Move a group between archives
@param {Group} movingGroup The group to move
@param {Group|Archive} target The group to move to
@throws {Error} Throws if the remote type is not recognised
190064
function(movingGroup, target) {
        let targetArchive, groupDesc;
        if (target.type === "Archive") {
            // destination is an archive
            targetArchive = target;
            groupDesc = describe(movingGroup._getRemoteObject(), "0");
        } else if (target.type === "Group") {
            // destination is a group
            targetArchive = target._getArchive();
            groupDesc = describe(movingGroup._getRemoteObject(), target.getID());
        } else {
            throw new Error(`Unknown remote type: ${target.type}`);
        }
        // execute each command in the destination archive
        groupDesc.forEach(function(command) {
            targetArchive
                ._getWestley()
                .execute(command)
                .pad();
        });
        // delete
        movingGroup.delete(/* skip trash */ true);
    }
1071856
def move_to_group(self, items, new_group_id: int):
        
        group = self.rootItem.child(new_group_id)
        for item in items:
            group.appendChild(item)
        self.controller.refresh()
116653
function move(fs, a, b, method, cb) {
    var parentA = path.dirname(a);
    var parentB = path.dirname(b);
    var nameA = path.basename(a);
    var nameB = path.basename(b)

    fs.metadata(a)
    .then(function(metadata) {
        return this.metadata(b)
            .then(function(metadata) {
                throw fs.error('EEXIST', 'Cannot move because target path already exist: ' + b);
            }, function(err) {
                if (err.code === 'ENOENT') {
                    return this.mkdir(parentB);
                } else {
                    throw err;
                }
            });
    })
    .then(function() {
        return this._promise(method, a, b);
    })
    .done(function() {
        cb();
    }, function(err) {
        cb(err);
    });
}
923783
function copyAugment (target, src, keys) {
  for (let i = 0, l = keys.length; i < l; i++) {
    const key = keys[i]
    def(target, key, src[key])
  }
}
142315
public function moveDirs($source, $target, $dirs)
    {
        foreach ($dirs as $dir) {
            $this->moveDir($source, $target, $dir);
        }
    }
802627
function moveLeft( count ) {
    count = count || 1;
    const moveClasses = [
      CLASSES.MOVE_LEFT,
      CLASSES.MOVE_LEFT_2X,
      CLASSES.MOVE_LEFT_3X
    ];

    if ( count < 1 || count > moveClasses.length ) {
      throw new Error( 'MoveTransition: moveLeft count is out of range!' );
    }

    _baseTransition.applyClass( moveClasses[count - 1] );

    return this;
  }
1283659
def move_group_in_parent(self, group = None, index = None):
        
        
        if group is None or index is None:
            raise KPError("group and index must be set")
        elif type(group) is not v1Group or type(index) is not int:
            raise KPError("group must be a v1Group-instance and index "
                          "must be an integer.")
        elif group not in self.groups:
            raise KPError("Given group doesn't exist")
        elif index < 0 or index >= len(group.parent.children):
            raise KPError("index must be a valid index if group.parent.groups")
        else:
            group_at_index = group.parent.children[index]
            pos_in_parent = group.parent.children.index(group) 
            pos_in_groups = self.groups.index(group)
            pos_in_groups2 = self.groups.index(group_at_index)

            group.parent.children[index] = group
            group.parent.children[pos_in_parent] = group_at_index
            self.groups[pos_in_groups2] = group
            self.groups[pos_in_groups] = group_at_index
            if group.children:
                self._move_group_helper(group)
            if group_at_index.children:
                self._move_group_helper(group_at_index)
            group.last_mod = datetime.now().replace(microsecond=0)
            return True
1151324
function() {
        var distDir = this.readConfig('distDir');
        var packedDirName = this.readConfig('packedDirName');
        var archivePath = this.readConfig('archivePath');

        if (packedDirName) {
          packedDirName = path.join(archivePath, packedDirName);
          this.log('moving ' + distDir + ' to ' + packedDirName);

          this.distDir = packedDirName;
          return move(distDir, packedDirName);
        }

        return RSVP.resolve();
      }
695842
@Override
    public boolean accepts(Location origin, Archive originArchive,
                           Location target, Archive targetArchive) {
        if (findJDKInternals) {
            // accepts target that is JDK class but not exported
            Module module = targetArchive.getModule();
            return originArchive != targetArchive &&
                    isJDKInternalPackage(module, target.getPackageName());
        } else if (filterSameArchive) {
            // accepts origin and target that from different archive
            return originArchive != targetArchive;
        }
        return true;
    }
1217953
function (target, src) {
	for (var key in src) {
		if (src.hasOwnProperty(key)) {
			target[key] = src[key];
		}
	}
}
1032636
def move(self, group, cluster_ids=None):
        
        if isinstance(cluster_ids, string_types):
            logger.warn("The list of clusters should be a list of integers, "
                        "not a string.")
            return
        self.label('group', group, cluster_ids=cluster_ids)
691411
@Override
    public void exportTo(final OutputStream target) throws ArchiveExportException, IllegalArgumentException {
        // Precondition checks
        if (target == null) {
            throw new IllegalArgumentException("Target must be specified");
        }

        // Get Stream
        final InputStream in = this.exportAsInputStream();

        try {
            // Write out
            try {
                IOUtil.copy(in, target);
            } catch (final IOException e) {
                throw new ArchiveExportException("Error encountered in exporting archive to " + target, e);
            }
        } finally {
            // Close
            try {
                in.close();
            } catch (final IOException ioe) {
                // Just log
                log.warning("Could not close " + in + ": " + ioe);
            }
        }
    }
776315
public Actions moveToElement(WebElement target) {
    if (isBuildingActions()) {
      action.addAction(new MoveMouseAction(jsonMouse, (Locatable) target));
    }

    return moveInTicks(target, 0, 0);
  }
124343
private Result runOnGivenPartition(Query query, Target target) {
        try {
            return dispatchPartitionScanQueryOnOwnerMemberOnPartitionThread(
                    query, target.partitionId()).get();
        } catch (Throwable t) {
            throw rethrow(t);
        }
    }
1220028
public function move($target, $source)
    {
        $this->copy($target, $source);

        $this->delete($target);
    }
714834
public function applyBulkByGroupId( $column, $action, $target, $groupId ) {

		foreach( $target as $id ) {

			$model = $this->getById( $id );

			if( isset( $model ) && !$model->isTerminated() && $model->groupId == $groupId ) {

				$this->applyBulk( $model, $column, $action, $target );
			}
		}
	}
382132
def move(self, fromp, to):
		''' 
		'''
		frompp = get_pcs_path(fromp)
		top = get_pcs_path(to)
		pars = {
			'method' : 'move',
			'from' : frompp,
			'to' : top }

		self.pd("Remote moving: '{}' =mm=> '{}'".format(fromp, to))
		return self.__post(pcsurl + 'file', pars, self.__move_act)