/* lazy initialization of sublists
546620
public synchronized final void ensureReferencesLoaded() throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "ensureReferencesLoaded");

        _references();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "ensureReferencesLoaded");
    }
696820
private static void initArrayList(ArrayList al, String str) {
		StringTokenizer strTknr = new StringTokenizer(str, "|");
		while (strTknr.hasMoreTokens()) {
			al.add(strTknr.nextToken());
		}
	}
92758
def _init_subtokens_from_list(self, subtoken_strings):
        """"""
        # we remember the maximum length of any subtoken to avoid having to
        # check arbitrarily long strings.
        self._all_subtoken_strings = set([s for s in subtoken_strings if s])
        self._max_subtoken_len = max([len(s) for s in subtoken_strings])
1035000
private static synchronized void lazyInit(InputStream inStream) {
		if (registry==null) {

			registry = 	new HashSet<ProteinModification>();
			byId = new HashMap<String, ProteinModification>();
			byResidId = new HashMap<String, Set<ProteinModification>>();
			byPsimodId = new HashMap<String, Set<ProteinModification>>();
			byPdbccId = new HashMap<String, Set<ProteinModification>>();
			byKeyword = new HashMap<String, Set<ProteinModification>>();
			byComponent = new HashMap<Component, Set<ProteinModification>>();
			byCategory = new EnumMap<ModificationCategory, Set<ProteinModification>>(
					ModificationCategory.class);
			for (ModificationCategory cat:ModificationCategory.values()) {
				byCategory.put(cat, new HashSet<ProteinModification>());
			}
			byOccurrenceType = new EnumMap<ModificationOccurrenceType, Set<ProteinModification>>(
					ModificationOccurrenceType.class);
			for (ModificationOccurrenceType occ:ModificationOccurrenceType.values()) {
				byOccurrenceType.put(occ, new HashSet<ProteinModification>());
			}
			registerCommonProteinModifications(inStream);
		}
	}
1151383
@Override
	public void init(NamedList args) {
		super.init(args);
		// init components
		searchStatus = new MtasSolrComponentStatus(this);
		searchVersion = new MtasSolrComponentVersion(this);
		searchDocument = new MtasSolrComponentDocument(this);
		searchKwic = new MtasSolrComponentKwic(this);
		searchList = new MtasSolrComponentList(this);
		searchGroup = new MtasSolrComponentGroup(this);
		searchTermvector = new MtasSolrComponentTermvector(this);
		searchPrefix = new MtasSolrComponentPrefix(this);
		searchStats = new MtasSolrComponentStats(this);
		searchFacet = new MtasSolrComponentFacet(this);
		searchCollection = new MtasSolrComponentCollection(this);
		// init collection
		String collectionCacheDirectory = null;
		Long collectionLifetime = null;
		Integer collectionMaximumNumber = null;
		Integer collectionMaximumOverflow = null;
		if (args.get(CONFIG_COLLECTION_CACHE_DIRECTORY) != null
				&& args.get(CONFIG_COLLECTION_CACHE_DIRECTORY) instanceof String) {
			collectionCacheDirectory = (String) args.get(CONFIG_COLLECTION_CACHE_DIRECTORY);
		} else {
			log.error("no " + CONFIG_COLLECTION_CACHE_DIRECTORY + " defined for " + this.getClass().getSimpleName());
		}
		if (args.get(CONFIG_COLLECTION_LIFETIME) != null && args.get(CONFIG_COLLECTION_LIFETIME) instanceof Long) {
			collectionLifetime = (Long) args.get(CONFIG_COLLECTION_LIFETIME);
		} else {
			log.error("no " + CONFIG_COLLECTION_LIFETIME + " defined for " + this.getClass().getSimpleName());
		}
		if (args.get(CONFIG_COLLECTION_MAXIMUM_NUMBER) != null
				&& args.get(CONFIG_COLLECTION_MAXIMUM_NUMBER) instanceof Integer) {
			collectionMaximumNumber = (Integer) args.get(CONFIG_COLLECTION_MAXIMUM_NUMBER);
		} else {
			log.error("no " + CONFIG_COLLECTION_MAXIMUM_NUMBER + " defined for " + this.getClass().getSimpleName());
		}
		if (args.get(CONFIG_COLLECTION_MAXIMUM_OVERFLOW) != null
				&& args.get(CONFIG_COLLECTION_MAXIMUM_OVERFLOW) instanceof Integer) {
			collectionMaximumNumber = (Integer) args.get(CONFIG_COLLECTION_MAXIMUM_OVERFLOW);
		} else {
			log.error("no " + CONFIG_COLLECTION_MAXIMUM_OVERFLOW + " defined for " + this.getClass().getSimpleName());
		}
		collectionCache = new MtasSolrCollectionCache(collectionCacheDirectory, collectionLifetime,
				collectionMaximumNumber, collectionMaximumOverflow);
	}
124394
private void load(final String[] subFiles) {
		for (int i = 0; i < subFiles.length; i++) {
			load(subFiles[i]);
		}
	}
349276
public static int[] init(final int[] indexes) {
		for (int i = 0; i < indexes.length; ++i) {
			indexes[i] = i;
		}
		return indexes;
	}
818620
function M(list, assimilateSublists) {
    var self = this, idx = 0;
    if (list)
      for (var i = 0, len = list.length; i < len; i++) {
        var item = list[i];
        if (assimilateSublists && isList(item))
          for (var j = 0, len2 = item.length; j < len2; j++)
            self[idx++] = item[j];
        else
          self[idx++] = item;
      }
    else
      self[idx++] = assimilateSublists;

    self['length'] = idx;
    self['_'] = true;
  }
1057057
private void convertMultipleListsToFastList()
    {
        FastList<MithraFastList<E>> localLists = this.lists;
        if (localLists.size() > 1)
        {
            final MithraFastList<E> newList = new MithraFastList<E>(this.size());

            for (int i = 0; i < localLists.size(); i++)
            {
                newList.addAll(localLists.get(i));
            }
            FastList<MithraFastList<E>> newLists = new FastList<MithraFastList<E>>(2);
            newLists.add(newList);
            this.lists = newLists;
        }
    }
1350077
void init()
    {
        view.set(new View(
                         ImmutableList.of(new Memtable(cfstore)),
                         ImmutableList.<Memtable>of(),
                         Collections.<SSTableReader, SSTableReader>emptyMap(),
                         Collections.<SSTableReader>emptySet(),
                         Collections.<SSTableReader>emptySet(),
                         SSTableIntervalTree.empty()));
    }
975232
void init( DMatrixSparseCSC A ) {
        this.A = A;
        this.m = A.numRows;
        this.n = A.numCols;

        this.next = 0;
        this.head = m;
        this.tail = m + n;
        this.nque = m + 2*n;

        if( parent.length < n || leftmost.length < m) {
            parent = new int[n];
            post = new int[n];
            pinv = new int[m+n];
            countsR = new int[n];
            leftmost = new int[m];
        }
        gwork.reshape(m+3*n);
    }
244387
@Override
    public List<R> subList(int fromIndex, int toIndex) {
        List<R> r = new ArrayList<>();
        Iterator<R> itr = iterator();
        hudson.util.Iterators.skip(itr, fromIndex);
        for (int i=toIndex-fromIndex; i>0; i--) {
            r.add(itr.next());
        }
        return r;
    }
952479
@Override
    public void initialize(InputSplit split) throws IOException, InterruptedException {
        if (split instanceof ListStringSplit) {
            ListStringSplit listStringSplit = (ListStringSplit) split;
            delimitedData = listStringSplit.getData();
            dataIter = delimitedData.iterator();
        } else {
            throw new IllegalArgumentException("Illegal type of input split " + split.getClass().getName());
        }
    }
625329
public static <T> List<T> subList(List<T> input, int startIndex, int count) {
        int fromIndex = startIndex - 1;
        int toIndex = fromIndex + count;
        if (toIndex >= input.size()) {
            toIndex = input.size();
        }
        if (fromIndex >= toIndex) {
            return Collections.emptyList();
        }
        return input.subList(fromIndex, toIndex);
    }
1040666
protected void lazyor(final ImmutableRoaringBitmap x2) {
    int pos1 = 0, pos2 = 0;
    int length1 = highLowContainer.size();
    final int length2 = x2.highLowContainer.size();
    main: if (pos1 < length1 && pos2 < length2) {
      short s1 = highLowContainer.getKeyAtIndex(pos1);
      short s2 = x2.highLowContainer.getKeyAtIndex(pos2);

      while (true) {
        if (s1 == s2) {
          getMappeableRoaringArray().setContainerAtIndex(pos1, highLowContainer
              .getContainerAtIndex(pos1).lazyIOR(x2.highLowContainer.getContainerAtIndex(pos2)));
          pos1++;
          pos2++;
          if ((pos1 == length1) || (pos2 == length2)) {
            break main;
          }
          s1 = highLowContainer.getKeyAtIndex(pos1);
          s2 = x2.highLowContainer.getKeyAtIndex(pos2);
        } else if (Util.compareUnsigned(s1, s2) < 0) { // s1 < s2
          pos1++;
          if (pos1 == length1) {
            break main;
          }
          s1 = highLowContainer.getKeyAtIndex(pos1);
        } else { // s1 > s2
          getMappeableRoaringArray().insertNewKeyValueAt(pos1, s2,
              x2.highLowContainer.getContainerAtIndex(pos2).clone());
          pos1++;
          length1++;
          pos2++;
          if (pos2 == length2) {
            break main;
          }
          s2 = x2.highLowContainer.getKeyAtIndex(pos2);
        }
      }
    }
    if (pos1 == length1) {
      getMappeableRoaringArray().appendCopy(x2.highLowContainer, pos2, length2);
    }
  }
1202481
@Override
    public List<T> subList(int arg0, int arg1) {
        while ( allResults.size() < arg1 && nextResultsAvailable() ) {
            moveNextResults();
        }
        
        return Collections.unmodifiableList(allResults.subList(arg0, arg1));
    }
961475
def initialize(self):
        """"""
        self._lb = [b[0] for b in self.bounds]  # can be done more efficiently?
        self._ub = [b[1] for b in self.bounds]