When parsing an <LOD> node, set the range of values
Values must be in sequential order.
@param newRange
@param newCenter
344269
protected void set(float[] newRange, float[] newCenter) {
    this.range = new float[newRange.length];
    for (int i = 0; i < newRange.length; i++) {
      this.range[i] = newRange[i];
    }
    for (int i = 0; i < newCenter.length; i++) {
      this.center[i] = newCenter[i];
    }
    this.totalRange = newRange.length;
    this.currentRange = 0;
    this.active = true;
  }
1103954
public void setPosition(int newIndex) {

    //check NULL-Bitmap that indicate if field is null
    if ((buf[1 + (newIndex + 2) / 8] & (1 << ((newIndex + 2) % 8))) != 0) {
      this.lastValueNull = BIT_LAST_FIELD_NULL;
      return;
    }

    //if not must parse data until reading the desired field
    if (index != newIndex) {
      int internalPos = this.pos;
      if (index == -1 || index > newIndex) {
        //if there wasn't previous non-null read field, or if last field was after searched index,
        // position is set on first field position.
        index = 0;
        internalPos = 1 + (columnInformationLength + 9) / 8; // 0x00 header + NULL-Bitmap length
      } else {
        //start at previous non-null field position if was before searched index
        index++;
        internalPos += length;
      }

      for (; index <= newIndex; index++) {
        if ((buf[1 + (index + 2) / 8] & (1 << ((index + 2) % 8))) == 0) {
          if (index != newIndex) {
            //skip bytes
            switch (columnInformation[index].getColumnType()) {
              case BIGINT:
              case DOUBLE:
                internalPos += 8;
                break;

              case INTEGER:
              case MEDIUMINT:
              case FLOAT:
                internalPos += 4;
                break;

              case SMALLINT:
              case YEAR:
                internalPos += 2;
                break;

              case TINYINT:
                internalPos += 1;
                break;

              default:
                int type = this.buf[internalPos++] & 0xff;
                switch (type) {

                  case 251:
                    break;

                  case 252:
                    internalPos +=
                        2 + (0xffff & (((buf[internalPos] & 0xff) + ((buf[internalPos + 1] & 0xff)
                            << 8))));
                    break;

                  case 253:
                    internalPos += 3 + (0xffffff & ((buf[internalPos] & 0xff)
                        + ((buf[internalPos + 1] & 0xff) << 8)
                        + ((buf[internalPos + 2] & 0xff) << 16)));
                    break;

                  case 254:
                    internalPos += 8 + ((buf[internalPos] & 0xff)
                        + ((long) (buf[internalPos + 1] & 0xff) << 8)
                        + ((long) (buf[internalPos + 2] & 0xff) << 16)
                        + ((long) (buf[internalPos + 3] & 0xff) << 24)
                        + ((long) (buf[internalPos + 4] & 0xff) << 32)
                        + ((long) (buf[internalPos + 5] & 0xff) << 40)
                        + ((long) (buf[internalPos + 6] & 0xff) << 48)
                        + ((long) (buf[internalPos + 7] & 0xff) << 56));
                    break;

                  default:
                    internalPos += type;
                    break;
                }
                break;
            }
          } else {
            //read asked field position and length
            switch (columnInformation[index].getColumnType()) {
              case BIGINT:
              case DOUBLE:
                this.pos = internalPos;
                length = 8;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case INTEGER:
              case MEDIUMINT:
              case FLOAT:
                this.pos = internalPos;
                length = 4;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case SMALLINT:
              case YEAR:
                this.pos = internalPos;
                length = 2;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              case TINYINT:
                this.pos = internalPos;
                length = 1;
                this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                return;

              default:
                //field with variable length
                int type = this.buf[internalPos++] & 0xff;
                switch (type) {
                  case 251:
                    //null length field
                    //must never occur
                    //null value are set in NULL-Bitmap, not send with a null length indicator.
                    throw new IllegalStateException(
                        "null data is encoded in binary protocol but NULL-Bitmap is not set");

                  case 252:
                    //length is encoded on 3 bytes (0xfc header + 2 bytes indicating length)
                    length = 0xffff & ((buf[internalPos++] & 0xff)
                        + ((buf[internalPos++] & 0xff) << 8));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  case 253:
                    //length is encoded on 4 bytes (0xfd header + 3 bytes indicating length)
                    length = 0xffffff & ((buf[internalPos++] & 0xff)
                        + ((buf[internalPos++] & 0xff) << 8)
                        + ((buf[internalPos++] & 0xff) << 16));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  case 254:
                    //length is encoded on 9 bytes (0xfe header + 8 bytes indicating length)
                    length = (int) ((buf[internalPos++] & 0xff)
                        + ((long) (buf[internalPos++] & 0xff) << 8)
                        + ((long) (buf[internalPos++] & 0xff) << 16)
                        + ((long) (buf[internalPos++] & 0xff) << 24)
                        + ((long) (buf[internalPos++] & 0xff) << 32)
                        + ((long) (buf[internalPos++] & 0xff) << 40)
                        + ((long) (buf[internalPos++] & 0xff) << 48)
                        + ((long) (buf[internalPos++] & 0xff) << 56));
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                  default:
                    //length is encoded on 1 bytes (is then less than 251)
                    length = type;
                    this.pos = internalPos;
                    this.lastValueNull = BIT_LAST_FIELD_NOT_NULL;
                    return;

                }
            }
          }
        }
      }
    }
    this.lastValueNull = length == NULL_LENGTH ? BIT_LAST_FIELD_NULL : BIT_LAST_FIELD_NOT_NULL;
  }
57140
@Override
  final protected void addRange(int left, int right, int additionalId,
      long additionalRef, Integer id, Long ref) {
    String key = left + "_" + right;
    if (index.containsKey(key)) {
      index.get(key).addIdAndRef(id, ref, additionalId, additionalRef);
    } else {
      root = addRange(root, left, right, additionalId, additionalRef, id, ref);
      root.color = MtasRBTreeNode.BLACK;
    }
  }
1102045
public final boolean setChildAt(BinaryTreeZone zone, N newChild) {
		switch (zone) {
		case LEFT:
			return setLeftChild(newChild);
		case RIGHT:
			return setRightChild(newChild);
		default:
			throw new IndexOutOfBoundsException();
		}
	}
384512
@Override
    public void setCenter(LatLong latLong) {
        synchronized (this) {
            setCenterInternal(latLong.latitude, latLong.longitude);
        }
        notifyObservers();
    }
1304338
public static Range<RowPosition> makeRowRange(Token left, Token right, IPartitioner partitioner)
    {
        return new Range<RowPosition>(left.maxKeyBound(partitioner), right.maxKeyBound(partitioner), partitioner);
    }
130022
@Override
	public void setCenter(double x, double y, double z) {
		this.cx = x;
		this.cy = y;
		this.cz = z;
	}
996141
public static <C extends Comparable> RangeTree<C> create(final Iterable<Range<C>> ranges) {
        return new CenteredRangeTree<C>(ranges);
    }
1179639
function isRangeInTable(opts: Options, node: Node, range: Range): boolean {
    const { startKey, endKey } = range;
    const startPosition = TablePosition.create(opts, node, startKey);
    const endPosition = TablePosition.create(opts, node, endKey);

    // Only handle events in tables
    if (!startPosition.isInTable() || !endPosition.isInTable()) {
        return false;
    }

    // Inside the same table
    return startPosition.table === endPosition.table;
}
1155682
@Override
	public void setCenter(Point3D center) {
		this.cx = center.getX();
		this.cy = center.getY();
		this.cz = center.getZ();
	}
1131883
public boolean setChildAt(QuadTreeZone zone, N newChild) {
		switch (zone) {
		case NORTH_WEST:
			return setFirstChild(newChild);
		case NORTH_EAST:
			return setSecondChild(newChild);
		case SOUTH_WEST:
			return setThirdChild(newChild);
		case SOUTH_EAST:
			return setFourthChild(newChild);
		default:
		}
		return false;
	}
152789
public void setRangesOnIndexedValues(java.util.Collection<ObjectAttributeRange> rangesOnIndexedValues) {
        if (rangesOnIndexedValues == null) {
            this.rangesOnIndexedValues = null;
            return;
        }

        this.rangesOnIndexedValues = new java.util.ArrayList<ObjectAttributeRange>(rangesOnIndexedValues);
    }
1001134
private void depthFirstSearch(final Range<C> query, final Node node, final List<Range<C>> result, final Set<Node> visited) {
        if (node == null || visited.contains(node) || query.isEmpty()) {
            return;
        }
        if (node.left() != null && Ranges.isLessThan(query, node.center())) {
            depthFirstSearch(query, node.left(), result, visited);
        }
        else if (node.right() != null && Ranges.isGreaterThan(query, node.center())) {
            depthFirstSearch(query, node.right(), result, visited);
        }
        if (Ranges.isGreaterThan(query, node.center())) {
            for (Range<C> range : node.overlapByUpperEndpoint()) {
                if (Ranges.intersect(range, query)) {
                    result.add(range);
                }
                if (Ranges.isGreaterThan(query, range.upperEndpoint())) {
                    break;
                }
            }
        }
        else if (Ranges.isLessThan(query, node.center())) {
            for (Range<C> range : node.overlapByLowerEndpoint()) {
                if (Ranges.intersect(range, query)) {
                    result.add(range);
                }
                if (Ranges.isLessThan(query, range.lowerEndpoint())) {
                    break;
                }
            }
        }
        else {
            result.addAll(node.overlapByLowerEndpoint());
        }
        visited.add(node);
    }
1267164
TokenRange range(Node begin, JavaToken end) {
        if (storeTokens) {
            return new TokenRange(begin.getTokenRange().get().getBegin(), end);
        }
        return null;
    }
770232
public void setCenterCoordsRelativeToParent(int x, int y) {

        Style style = getElement().getStyle();
        style.setLeft(x - 10, Unit.PX);
        style.setTop(y - 10, Unit.PX);
    }
603166
function(node) {
      var range = rangy.createRange(this.doc);

      range.setStartAfter(node);
      range.setEndAfter(node);
      return this.setSelection(range);
    }
719611
public void setRegionOrder(java.util.Collection<String> regionOrder) {
        if (regionOrder == null) {
            this.regionOrder = null;
            return;
        }

        this.regionOrder = new com.amazonaws.internal.SdkInternalList<String>(regionOrder);
    }