import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
/**
 * Build the operation.
 *
 * @return the operation
 */
public Operation build() {
    Extent extent = clipboard;
    if (!transform.isIdentity()) {
        extent = new BlockTransformExtent(extent, transform, targetWorldData.getBlockRegistry());
    }
    ForwardExtentCopy copy = new ForwardExtentCopy(extent, clipboard.getRegion(), clipboard.getOrigin(), targetExtent, to);
    copy.setTransform(transform);
    copy.setCopyEntities(!ignoreEntities);
    copy.setCopyBiomes((!ignoreBiomes) && (!(clipboard instanceof BlockArrayClipboard) || ((BlockArrayClipboard) clipboard).IMP.hasBiomes()));
    if (this.canApply != null) {
        copy.setFilterFunction(this.canApply);
    }
    if (targetExtent instanceof EditSession) {
        Mask sourceMask = ((EditSession) targetExtent).getSourceMask();
        if (sourceMask != null) {
            new MaskTraverser(sourceMask).reset(extent);
            copy.setSourceMask(sourceMask);
            ((EditSession) targetExtent).setSourceMask(null);
        }
    }
    if (ignoreAirBlocks) {
        copy.setSourceMask(new ExistingBlockMask(clipboard));
    }
    return copy;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
public final
@Nullable
Operation commit() {
    Operation ours = commitBefore();
    Operation other = extent.commit();
    if (ours != null && other != null) {
        return new OperationQueue(ours, other);
    } else if (ours != null) {
        return ours;
    } else if (other != null) {
        return other;
    } else {
        return null;
    }
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public static void pasteWithWE(Player p, File f) throws DataException {
	SpongePlayer sp = SpongeWorldEdit.inst().wrapPlayer(p);
	SpongeWorld ws = SpongeWorldEdit.inst().getWorld(p.getWorld());
	
	LocalSession session = SpongeWorldEdit.inst().getSession(p);
	
	Closer closer = Closer.create();
	try {
		ClipboardFormat format = ClipboardFormat.findByAlias("schematic");
		FileInputStream fis = closer.register(new FileInputStream(f));
	    BufferedInputStream bis = closer.register(new BufferedInputStream(fis));
	    ClipboardReader reader = format.getReader(bis);
	    		    
	    WorldData worldData = ws.getWorldData();
	    Clipboard clipboard = reader.read(ws.getWorldData());
	    session.setClipboard(new ClipboardHolder(clipboard, worldData));
	    
	    ClipboardHolder holder = session.getClipboard();
	    
	    Operation op = holder.createPaste(session.createEditSession(sp), ws.getWorldData()).to(session.getPlacementPosition(sp)).build();
	    Operations.completeLegacy(op);
	} catch (IOException | MaxChangedBlocksException | EmptyClipboardException | IncompleteRegionException e) {
		e.printStackTrace();
	}		
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
private static Operation runOperation(Operation operation, RunContext context) {
  Operation next = operation;
  while (next != null && context.shouldContinue()) {
    try {
      next = next.resume(context);
    } catch (WorldEditException e) {
      e.printStackTrace();
      return null;
    }
  }

  if (next != null) {
    return next;
  } else {
    return null;
  }
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public Integer execute(ICancelabeEditSession editSession) throws MaxChangedBlocksException {
    try {
        ClipboardReader reader = ClipboardFormat.SCHEMATIC.getReader(new FileInputStream(file));
        WorldData worldData = bukkitWorld.getWorldData();
        Clipboard clipboard = reader.read(worldData);
        ClipboardHolder holder = new ClipboardHolder(clipboard, worldData);
        editSession.enableQueue();
        editSession.setFastMode(true);
        Vector to = new Vector(origin.getBlockX(), origin.getBlockY(), origin.getBlockZ());
        final Operation operation = holder
                .createPaste(editSession, worldData)
                .to(to)
                .ignoreAirBlocks(true)
                .build();
        Operations.completeBlindly(operation);
        editSession.flushQueue();
    } catch (IOException e) {
        log.log(Level.WARNING, "Error trying to paste " + file, e);
    }
    return 32768;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public Integer execute(CancelabeEditSession editSession) throws MaxChangedBlocksException {
    try {
        ClipboardReader reader = ClipboardFormat.SCHEMATIC.getReader(new FileInputStream(file));
        WorldData worldData = bukkitWorld.getWorldData();
        Clipboard clipboard = reader.read(worldData);
        ClipboardHolder holder = new ClipboardHolder(clipboard, worldData);
        editSession.enableQueue();
        editSession.setFastMode(true);
        Vector to = new Vector(origin.getBlockX(), origin.getBlockY(), origin.getBlockZ());
        final Operation operation = holder
                .createPaste(editSession, worldData)
                .to(to)
                .ignoreAirBlocks(true)
                .build();
        Operations.completeBlindly(operation);
        editSession.flushQueue();
    } catch (IOException e) {
        log.log(Level.WARNING, "Error trying to paste " + file, e);
    }
    return 0;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public Integer execute(CancelabeEditSession editSession) throws MaxChangedBlocksException {
    try {
        ClipboardReader reader = ClipboardFormat.SCHEMATIC.getReader(new FileInputStream(file));
        WorldData worldData = bukkitWorld.getWorldData();
        Clipboard clipboard = reader.read(worldData);
        ClipboardHolder holder = new ClipboardHolder(clipboard, worldData);
        editSession.enableQueue();
        editSession.setFastMode(true);
        Vector to = new Vector(origin.getBlockX(), origin.getBlockY(), origin.getBlockZ());
        final Operation operation = holder
                .createPaste(editSession, worldData)
                .to(to)
                .ignoreAirBlocks(true)
                .build();
        Operations.completeBlindly(operation);
        editSession.flushQueue();
    } catch (IOException e) {
        log.log(Level.WARNING, "Error trying to paste " + file, e);
    }
    return 32768;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
public void regenerate(Floor floor, EditSession session, RegenerationCause cause) {
	Clipboard clipboard = floor.getClipboard();
	
	Region region = clipboard.getRegion();
	World world = region.getWorld();
	WorldData data = world.getWorldData();
	
	ClipboardHolder holder = new ClipboardHolder(clipboard, data);
	
	Operation pasteOperation = holder.createPaste(session, data)
			.to(region.getMinimumPoint())
			.ignoreAirBlocks(true)
			.build();
	
	try {
		Operations.complete(pasteOperation);
	} catch (WorldEditException e) {
		throw new RuntimeException(e);
	}
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
@Deprecated
public void generate(EditSession session) {
	Region region = floorClipboard.getRegion();
	World world = region.getWorld();
	WorldData data = world.getWorldData();
	
	ClipboardHolder holder = new ClipboardHolder(floorClipboard, data);
	
	Operation pasteOperation = holder.createPaste(session, data)
			.to(region.getMinimumPoint())
			.ignoreAirBlocks(true)
			.build();
	
	try {
		Operations.complete(pasteOperation);
	} catch (WorldEditException e) {
		throw new RuntimeException(e);
	}
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
protected int pasteBlocks(Vector target, Vector offset, double angle) throws MaxChangedBlocksException {
    RoundedTransform transform = new RoundedTransform(new AffineTransform()
            .translate(offset)
            .rotateY(angle));
    if (!this.transform.isIdentity()) {
        transform = transform.combine(this.transform);
    }
    if (!originalTransform.isIdentity()) {
        transform = transform.combine(originalTransform);
    }

    // Pasting
    Clipboard clipboard = clipboardHolder.getClipboard();
    clipboard.setOrigin(center.subtract(centerOffset).round());
    clipboardHolder.setTransform(transform);

    Vector functionOffset = target.subtract(clipboard.getOrigin());
    final int offX = functionOffset.getBlockX();
    final int offY = functionOffset.getBlockY();
    final int offZ = functionOffset.getBlockZ();

    Operation operation = clipboardHolder
            .createPaste(editSession, editSession.getWorldData())
            .to(target)
            .ignoreAirBlocks(true)
            .filter(v -> buffer.add(v.getBlockX() + offX, v.getBlockY() + offY, v.getBlockZ() + offZ))
            .build();
    Operations.completeLegacy(operation);

    // Cleanup
    clipboardHolder.setTransform(originalTransform);
    clipboard.setOrigin(originalOrigin);

    return operation instanceof ForwardExtentCopy ? ((ForwardExtentCopy) operation).getAffected() : 0;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
public Operation resume(final RunContext run) throws WorldEditException {
    while (this.iterator.hasNext()) {
        if (this.function.apply(this.iterator.next())) {
            affected++;
        }
    }
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
/**
 * Create an operation to copy from the original clipboard to the given extent.
 *
 * @param target the target
 * @return the operation
 */
public Operation copyTo(Extent target) {
    BlockTransformExtent extent = new BlockTransformExtent(original, transform, worldData.getBlockRegistry());
    ForwardExtentCopy copy = new ForwardExtentCopy(extent, original.getRegion(), original.getOrigin(), target, original.getOrigin());
    copy.setTransform(transform);
    return copy;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public SelectionCommand(CommandExecutor<Contextual<? extends Operation>> delegate, String permission) {
    checkNotNull(delegate, "delegate");
    checkNotNull(permission, "permission");
    this.delegate = delegate;
    this.permission = permission;
    addParameter(delegate);
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
public Operation commit() {
    flush();
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Nullable
@Override
public Operation commit() {
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
protected Operation commitBefore() {
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Nullable
public Operation commit() {
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
public Operation resume(RunContext run) throws WorldEditException {
    NodePair current;
    Node from;
    Node adjacent;
    MutableBlockVector mutable = new MutableBlockVector();
    Vector mutable2 = new Vector();
    int countAdd, countAttempt;
    IntegerTrio[] dirs = getIntDirections();

    for (int layer = 0; !queue.isEmpty(); layer++) {
        current = queue.poll();
        from = current.to;
        hashQueue.remove(from);
        if (visited.containsKey(from)) {
            continue;
        }
        mutable.mutX(from.getX());
        mutable.mutY(from.getY());
        mutable.mutZ(from.getZ());
        function.apply(mutable);
        countAdd = 0;
        countAttempt = 0;
        for (IntegerTrio direction : dirs) {
            mutable2.mutX(from.getX() + direction.x);
            mutable2.mutY(from.getY() + direction.y);
            mutable2.mutZ(from.getZ() + direction.z);
            if (isVisitable(mutable, mutable2)) {
                adjacent = new Node(mutable2.getBlockX(), mutable2.getBlockY(), mutable2.getBlockZ());
                if ((current.from == null || !adjacent.equals(current.from))) {
                    AtomicInteger adjacentCount = visited.get(adjacent);
                    if (adjacentCount == null) {
                        if (countAdd++ < maxBranch) {
                            if (!hashQueue.contains(adjacent)) {
                                if (current.depth == maxDepth) {
                                    countAttempt++;
                                } else {
                                    hashQueue.add(adjacent);
                                    queue.addFirst(new NodePair(from, adjacent, current.depth + 1));
                                }
                            } else {
                                countAttempt++;
                            }
                        } else {
                            countAttempt++;
                        }
                    } else if (adjacentCount.decrementAndGet() == 0) {
                        visited.remove(adjacent);
                    } else if (hashQueue.contains(adjacent)) {
                        countAttempt++;
                    }
                }
            }
        }
        if (countAttempt > 0) {
            visited.put(from, new AtomicInteger(countAttempt));
        }
        affected++;
    }
    return null;
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Nullable
@Override
default Operation commit() {
    return getQueue().commit();
}
 

import com.sk89q.worldedit.function.operation.Operation; //导入依赖的package包/类
@Override
@Nullable
public Operation commit() {
    return parent.commit();
}