Append copies of the values from another array

@param highLowContainer other array
@param startingIndex starting index in the other array
@param end last index array in the other array
191979
protected void appendCopy(PointableRoaringArray highLowContainer, int startingIndex, int end) {
    extendArray(end - startingIndex);
    for (int i = startingIndex; i < end; ++i) {
      this.keys[this.size] = highLowContainer.getKeyAtIndex(i);
      this.values[this.size] = highLowContainer.getContainerAtIndex(i).clone();
      this.size++;
    }
  }
1010981
protected void appendCopiesUntil(PointableRoaringArray highLowContainer, short stoppingKey) {
    final int stopKey = toIntUnsigned(stoppingKey);
    MappeableContainerPointer cp = highLowContainer.getContainerPointer();
    while (cp.hasContainer()) {
      if (toIntUnsigned(cp.key()) >= stopKey) {
        break;
      }
      extendArray(1);
      this.keys[this.size] = cp.key();
      this.values[this.size] = cp.getContainer().clone();
      this.size++;
      cp.advance();
    }
  }
396753
private synchronized void initializeListOfPreviousContainers() {
    if (this.previousContainers == null) {
      final List<Container> yarnPrevContainers =
          this.registration.getRegistration().getContainersFromPreviousAttempts();

      // If it's still null, create an empty list to indicate that it's not a restart.
      if (yarnPrevContainers == null) {
        this.previousContainers = Collections.unmodifiableSet(new HashSet<Container>());
      } else {
        this.previousContainers = Collections.unmodifiableSet(new HashSet<>(yarnPrevContainers));
      }

      yarnContainerManager.onContainersRecovered(this.previousContainers);
    }
  }
1304321
protected void fill(int fromIndex, int endIndex) {
        fromIndex = fromIndex == -1 ? 0 : fromIndex;
        endIndex = endIndex == -1 || endIndex > this.timeSeries.length ? this.timeSeries.length : endIndex;

        final T val;
        if (applyZero()) {
            val = zero();
        } else {
            val = null;
        }

        // set the values
        for (int i = fromIndex; i < endIndex; i++) {
            set(i, val);
        }
    }
194285
private List<Integer> getRowIds(final int startIndex, final int endIndex) {
		// If the table is sorted, we may require a mapping for table row index <--> data model index.
		int[] rowIndexMapping = getComponentModel().rowIndexMapping;

		// Check if sort mapping needs updating
		if (isSorted() && rowIndexMapping != null && rowIndexMapping.length != getDataModel().
				getRowCount()) {
			rowIndexMapping = getDataModel().sort(getSortColumnIndex(), isSortAscending());
			getOrCreateComponentModel().rowIndexMapping = rowIndexMapping;
		}

		if (rowIndexMapping == null) {
			// No mapping, return from startIndex to endIndex
			return new RowIdList(startIndex, endIndex);
		} else {
			List<Integer> rowIds = new ArrayList<>(endIndex - startIndex + 1);

			for (int i = startIndex; i <= endIndex; i++) {
				rowIds.add(rowIndexMapping[i]);
			}

			return rowIds;
		}

	}
200934
public static List<UserCustomColumn> createRequiredColumns(int startingIndex) {

		List<UserCustomColumn> columns = new ArrayList<>();
		columns.add(createBaseIdColumn(startingIndex++));
		columns.add(createRelatedIdColumn(startingIndex++));

		return columns;
	}
1215723
private void dataBufferAppend(char[] ch, int start, int length) {
        dataBuffer = (char[]) extendArray(dataBuffer, dataBuffer.length,
                dataBufferPos + length);

        System.arraycopy(ch, start, dataBuffer, dataBufferPos, length);
        dataBufferPos += length;
    }
1010670
public StrBuilder insert(int index, CharSequence csq, int start, int end) {
		if (csq == null) {
			csq = "null";
		}
		final int csqLen = csq.length();
		if (start > csqLen) {
			return this;
		}
		if (start < 0) {
			start = 0;
		}
		if (end > csqLen) {
			end = csqLen;
		}
		if (start >= end) {
			return this;
		}
		if (index < 0) {
			index = 0;
		}

		final int length = end - start;
		moveDataAfterIndex(index, length);
		for (int i = start, j = this.position; i < end; i++, j++) {
			value[j] = csq.charAt(i);
		}
		this.position = Math.max(this.position, index) + length;
		return this;
	}
894894
@Override
    public IAtomContainer containerFromPermutation(int[] permutation) {
        try {
            IAtomContainer permutedContainer = (IAtomContainer) atomContainer.clone();
            IAtom[] atoms = new IAtom[atomContainer.getAtomCount()];
            for (int i = 0; i < atomContainer.getAtomCount(); i++) {
                atoms[permutation[i]] = permutedContainer.getAtom(i);
            }
            permutedContainer.setAtoms(atoms);
            return permutedContainer;
        } catch (CloneNotSupportedException c) {
            return null;
        }
    }
484282
protected void append(String v, int start, int end) {
        try {
            writer.write(v, start, end - start);
        } catch (Exception e) {
            throw MwsUtl.wrap(e);
        }
    }
797964
public int newBufferStartsAt(int iTargetPosition, GridList gridList)
    {
//**NOTE** This can be improved by moving any overlapping records in the old buffer to the new buffer
    // Discard the entire current buffer
        if (gridList != null)
            this.moveBufferToAccessList(gridList);
        for (int index = m_iCurrentRecordStart; index < m_iCurrentRecordEnd; index++)
        {
            int iArrayIndex = this.bufferToArrayIndex(index);
            Object bookmark = m_aCurrentRecord[iArrayIndex];
            m_aCurrentRecord[iArrayIndex] = gEmptyCell;
            if (!gridList.inRecordList(index))
                if ((bookmark != null) && (bookmark != gEmptyCell))
                    this.freeElement(bookmark);
        }
        m_iCurrentRecordStart = iTargetPosition;
        m_iCurrentRecordEnd = iTargetPosition;  // No records in buffer!
        return this.bufferToArrayIndex(iTargetPosition);
    }
32932
@Override
  public MappeableContainer not(final int firstOfRange, final int lastOfRange) {
    // TODO: may need to convert to a RunContainer
    // TODO: this can be optimized for performance
    if (firstOfRange >= lastOfRange) {
      return clone(); // empty range
    }

    // determine the span of array indices to be affected
    int startIndex = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) firstOfRange);
    if (startIndex < 0) {
      startIndex = -startIndex - 1;
    }
    int lastIndex =
        BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (lastOfRange - 1));
    if (lastIndex < 0) {
      lastIndex = -lastIndex - 2;
    }
    final int currentValuesInRange = lastIndex - startIndex + 1;
    final int spanToBeFlipped = lastOfRange - firstOfRange;
    final int newValuesInRange = spanToBeFlipped - currentValuesInRange;
    final int cardinalityChange = newValuesInRange - currentValuesInRange;
    final int newCardinality = cardinality + cardinalityChange;

    if (newCardinality > DEFAULT_MAX_SIZE) {
      return toBitmapContainer().not(firstOfRange, lastOfRange);
    }

    final MappeableArrayContainer answer = new MappeableArrayContainer(newCardinality);
    if (!BufferUtil.isBackedBySimpleArray(answer.content)) {
      throw new RuntimeException("Should not happen. Internal bug.");
    }
    short[] sarray = answer.content.array();

    for (int i = 0; i < startIndex; ++i) {
      // copy stuff before the active area
      sarray[i] = content.get(i);
    }

    int outPos = startIndex;
    int inPos = startIndex; // item at inPos always >= valInRange

    int valInRange = firstOfRange;
    for (; valInRange < lastOfRange && inPos <= lastIndex; ++valInRange) {
      if ((short) valInRange != content.get(inPos)) {
        sarray[outPos++] = (short) valInRange;
      } else {
        ++inPos;
      }
    }

    for (; valInRange < lastOfRange; ++valInRange) {
      answer.content.put(outPos++, (short) valInRange);
    }

    // content after the active range
    for (int i = lastIndex + 1; i < cardinality; ++i) {
      answer.content.put(outPos++, content.get(i));
    }
    answer.cardinality = newCardinality;
    return answer;
  }
76858
public void appendHitRange(int start, int end) {
		hits.add(new Range(start, end));
		ranges = null;//キャッシュをクリア
	}
505171
public static ListDouble limit(final ListDouble data, final int start, final int end) {
        return new ListDouble() {

            @Override
            public double getDouble(int index) {
                return data.getDouble(index + start);
            }

            @Override
            public int size() {
                return end - start;
            }
        };
    }
855689
public void add(int start, int end) {
    mtasOffsetStart = Math.min(mtasOffsetStart, start);
    mtasOffsetEnd = Math.max(mtasOffsetEnd, end);
  }
1373222
private WsByteBuffer[] marshallAddedHeaders(WsByteBuffer[] inBuffers, int index) {
        WsByteBuffer[] buffers = inBuffers;
        buffers[index] = allocateBuffer(this.outgoingHdrBufferSize);
        for (HeaderElement elem = this.hdrSequence; null != elem; elem = elem.nextSequence) {
            if (elem.wasAdded()) {
                buffers = marshallHeader(buffers, elem);
            }
        }
        // add second EOL
        buffers = putBytes(BNFHeaders.EOL, buffers);
        buffers = flushCache(buffers);
        // flip the last buffer now that we're done
        buffers[buffers.length - 1].flip();
        return buffers;
    }
1039659
function (startIndex, endIndex) {
                if (_.isUndefined(startIndex)) {
                    startIndex = Number.MAX_VALUE;
                }
                if (_.isUndefined(endIndex)) {
                    endIndex = -1;
                }
                var renderer;
                // release unused renderer
                for (var index in this.$activeRenderer) {
                    if (this.$activeRenderer.hasOwnProperty(index) && (index < startIndex || index > endIndex)) {
                        // render not in use
                        renderer = this.$activeRenderer[index];
                        if (renderer) {
                            renderer.set({
                                $index: null,
                                $dataItem: null
                            });

                            renderer.remove();

                            this.$availableRenderer.push(renderer);
                        }

                        delete this.$activeRenderer[index];
                    }
                }
            }