PlaceUOffsetT prepends a UOffsetT to the Builder, without checking
        for space.
772079
def PlaceUOffsetT(self, x):
        
        N.enforce_number(x, N.UOffsetTFlags)
        self.head = self.head - N.UOffsetTFlags.bytewidth
        encode.Write(packer.uoffset, self.Bytes, self.Head(), x)
1061899
public synchronized void unuse() {
        assert(inUse);
        inUse = false;
        compiler = null;
        fileManager = null;
        fileManagerBase = null;
        smartFileManager = null;
        context = null;
        subTasks = null;
    }
485794
public T setStartOffset(long offset, TimeUnit units) {
    checkNotNull(units);

    this.startOffset = units.toMillis(offset);

    return getThis();
  }
906848
def detached(self, worker):
        """"""
        for wfb in self.attaching_workers + self.workers:
            if wfb.worker == worker:
                break
        else:
            log.msg("WEIRD: Builder.detached(%s) (%s)"
                    " not in attaching_workers(%s)"
                    " or workers(%s)" % (worker, worker.workername,
                                         self.attaching_workers,
                                         self.workers))
            return

        if wfb in self.attaching_workers:
            self.attaching_workers.remove(wfb)
        if wfb in self.workers:
            self.workers.remove(wfb)

        # inform the WorkerForBuilder that their worker went away
        wfb.detached()
381368
public BuildableType.Builder suppressUnchecked(Excerpt suppressUnchecked) {
    this.suppressUnchecked = Objects.requireNonNull(suppressUnchecked);
    _unsetProperties.remove(Property.SUPPRESS_UNCHECKED);
    return (BuildableType.Builder) this;
  }
1144498
Builder prepareNextPage()
  {
    int offset = this.offset + pageSize;
    validateOffset( offset );
    this.offset = offset;

    return builder;
  }
685853
function setOffsetRootToIndex(startIndex) {
            const loc = sourceCode.getLocFromIndex(startIndex)

            if (!offsets.has(loc.line)) {
                setOffsetToLoc(loc, 0, -1)
            }
        }
346638
public void markAsUnspent() {
        if (parent != null)
            if (log.isDebugEnabled()) log.debug("Un-marked {}:{} as spent by {}", getParentTransactionHash(), getIndex(), spentBy);
        else
            if (log.isDebugEnabled()) log.debug("Un-marked floating output as spent by {}", spentBy);
        availableForSpending = true;
        spentBy = null;
    }
775381
public void zeroOut() {
    for (long off = baseOffset; off < baseOffset + length * WIDTH; off += WIDTH) {
      Platform.putLong(baseObj, off, 0);
    }
  }
1199612
function(oThis, sProp, oValue, bNotifyLayout) {
		var bSuppressRerendering = !!oThis.getDomRef();
		oThis.setProperty(sProp, oValue, bSuppressRerendering);
		if (bSuppressRerendering && bNotifyLayout) {
			notifyLayoutOnChange(oThis, "CTRL_POS");
		}
		return bSuppressRerendering;
	}
260395
def PrependUOffsetTRelativeSlot(self, o, x, d):
        

        if x != d:
            self.PrependUOffsetTRelative(x)
            self.Slot(o)
763168
@Nonnull
	public static LByteSupplier byteSupplierFrom(Consumer<LByteSupplierBuilder> buildingFunction) {
		LByteSupplierBuilder builder = new LByteSupplierBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
751762
private void appendBranched(int startOffset, int pastEnd) {
        // Main tricky thing here is just replacing of linefeeds...
        if (mConvertLFs) {
            char[] inBuf = mBuffer;
            /* this will also unshare() and ensure there's room for at
             * least one more char
             */
            char[] outBuf = mBranchBuffer.getCurrentSegment();
            int outPtr = mBranchBuffer.getCurrentSegmentSize();

            // Pending \n to skip?
            if (mGotCR) {
                if (inBuf[startOffset] == '\n') {
                    ++startOffset;
                }
            }

            while (startOffset < pastEnd) {
                char c = inBuf[startOffset++];
                if (c == '\r') {
                    if (startOffset < pastEnd) {
                        if (inBuf[startOffset] == '\n') {
                            ++startOffset;
                        }
                    } else {
                        mGotCR = true;
                    }
                    c = '\n';
                }

                // Ok, let's add char to output:
                outBuf[outPtr++] = c;
                    
                // Need more room?
                if (outPtr >= outBuf.length) {
                    outBuf = mBranchBuffer.finishCurrentSegment();
                    outPtr = 0;
                }
            }

            mBranchBuffer.setCurrentLength(outPtr);
        } else {
            mBranchBuffer.append(mBuffer, startOffset, pastEnd-startOffset);
        }
    }
252788
def horz_offset(self, offset):
        
        self.get_or_add_xMode().val = ST_LayoutMode.FACTOR
        self.get_or_add_x().val = offset
728319
public void prepend(Object... aChunk) {
        for (int i = aChunk.length - 1; i >= 0; i--) {
            if (aChunk[i] instanceof String) {
                this.prepend((String) aChunk[i]);
            } else if (aChunk[i] instanceof SourceNode) {
                this.prepend((SourceNode) aChunk[i]);
            } else {
                throw new IllegalArgumentException();
            }
        }
    }
1331309
public void stopPublishingGeolocation()
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException, NotALeafNodeException {
        GeoLocation emptyGeolocation = new GeoLocation.Builder().build();
        getNode().publish(new PayloadItem<GeoLocation>(emptyGeolocation));
    }
306661
def unbuild_object(self, obj):
        
        logger.debug("Unbuilding %s" % obj)
        target_path = os.path.split(self.get_build_path(obj))[0]
        if self.fs.exists(target_path):
            logger.debug("Removing {}".format(target_path))
            self.fs.removetree(target_path)