Fills the given buffer with the name of the bone at the given index in the skeleton associated with the given action
767893
def getBoneName(self, action, nBoneIndex, pchBoneName, unNameBufferSize):
        """"""

        fn = self.function_table.getBoneName
        result = fn(action, nBoneIndex, pchBoneName, unNameBufferSize)
        return result
369904
private void addToIndex(Map<String, String> param) throws Exception {
        String doc = writeUpdateString(param);
        addToBuffer(doc);
    }
877315
private void updateIndexTermTargetName(final IndexTerm indexterm) {
        final int targetSize = indexterm.getTargetList().size();
        final int subtermSize = indexterm.getSubTerms().size();

        for (int i = 0; i<targetSize; i++) {
            final IndexTermTarget target = indexterm.getTargetList().get(i);
            final String uri = target.getTargetURI();
            final int indexOfSharp = uri.lastIndexOf(SHARP);
            final String fragment = (indexOfSharp == -1 || uri.endsWith(SHARP))?
                    null:
                        uri.substring(indexOfSharp + 1);
            if (fragment != null && titleMap.containsKey(fragment)) {
                target.setTargetName(titleMap.get(fragment));
            } else {
                target.setTargetName(defaultTitle);
            }
        }

        for (int i = 0; i<subtermSize; i++) {
            final IndexTerm subterm = indexterm.getSubTerms().get(i);
            updateIndexTermTargetName(subterm);
        }
    }
564721
public void sendIndexToBuffer(String index, Map<String, List<String>> fields) {
		String doc = pyUtils.solrDocument(fields);
		addToBuffer(index, doc);
	}
725617
private void setIndex() {
		int DataCounter, PBASCounter, PLOCCounter, PCONCounter, NumRecords, indexBase;
		byte[] RecNameArray = new byte[4];
		String RecName;

		DataCounter = 0;
		PBASCounter = 0;
		PLOCCounter = 0;
		PCONCounter = 0;

		indexBase = getIntAt(absIndexBase + macJunk);
		NumRecords = getIntAt(absIndexBase - 8 + macJunk);

		for (int record = 0; record <= NumRecords - 1; record++) {
			getSubArray(RecNameArray, (indexBase + (record * 28)));
			RecName = new String(RecNameArray);
			if (RecName.equals("FWO_"))
				FWO = indexBase + (record * 28) + 20;
			if (RecName.equals("DATA")) {
				++DataCounter;
				if (DataCounter == 9)
					DATA9 = indexBase + (record * 28) + 20;
				if (DataCounter == 10)
					DATA10 = indexBase + (record * 28) + 20;
				if (DataCounter == 11)
					DATA11 = indexBase + (record * 28) + 20;
				if (DataCounter == 12)
					DATA12 = indexBase + (record * 28) + 20;
			}
			if (RecName.equals("PBAS")) {
				++PBASCounter;
				if (PBASCounter == 2)
					PBAS2 = indexBase + (record * 28) + 20;
			}
			if (RecName.equals("PLOC")) {
				++PLOCCounter;
				if (PLOCCounter == 2)
					PLOC = indexBase + (record * 28) + 20;
			}
			if (RecName.equals("PCON")) {
				++PCONCounter;
				if (PCONCounter == 2)
					PCON = indexBase + (record * 28) + 20;
			}

		} //next record
		traceLength = getIntAt(DATA12 - 8);
		seqLength = getIntAt(PBAS2 - 4);
		PLOC = getIntAt(PLOC) + macJunk;
		DATA9 = getIntAt(DATA9) + macJunk;
		DATA10 = getIntAt(DATA10) + macJunk;
		DATA11 = getIntAt(DATA11) + macJunk;
		DATA12 = getIntAt(DATA12) + macJunk;
		PBAS2 = getIntAt(PBAS2) + macJunk;
		PCON = getIntAt(PCON) + macJunk;
	}
586214
@SuppressWarnings("unchecked")
	public static <T> T[] insert(T[] buffer, int index, T... newElements) {
		return (T[]) insert((Object)buffer, index, newElements);
	}
442050
void append(final MultiIndex.Action action) throws IOException
   {
      initOut();
      out.write(action.toString() + "\n");
      entryCount++;
   }
230523
function () {
		var ikConstraints = this.ikConstraints;
		var ikConstraintsCount = ikConstraints.length;

		var arrayCount = ikConstraintsCount + 1;
		var boneCache = this.boneCache;
		if (boneCache.length > arrayCount) boneCache.length = arrayCount;
		for (var i = 0, n = boneCache.length; i < n; i++)
			boneCache[i].length = 0;
		while (boneCache.length < arrayCount)
			boneCache[boneCache.length] = [];

		var nonIkBones = boneCache[0];
		var bones = this.bones;

		outer:
		for (var i = 0, n = bones.length; i < n; i++) {
			var bone = bones[i];
			var current = bone;
			do {
				for (var ii = 0; ii < ikConstraintsCount; ii++) {
					var ikConstraint = ikConstraints[ii];
					var parent = ikConstraint.bones[0];
					var child= ikConstraint.bones[ikConstraint.bones.length - 1];
					while (true) {
						if (current == child) {
							boneCache[ii].push(bone);
							boneCache[ii + 1].push(bone);
							continue outer;
						}
						if (child == parent) break;
						child = child.parent;
					}
				}
				current = current.parent;
			} while (current);
			nonIkBones[nonIkBones.length] = bone;
		}
	}
731026
@SuppressWarnings("unchecked")
   void indexAdded(String name, int numDocs)
   {
      if (numDocs < 0)
      {
         throw new IllegalArgumentException("numDocs must be positive");
      }
      // multiple threads may enter this method:
      // - the background thread of this IndexMerger, when it replaces indexes
      //   after a successful merge
      // - a regular thread that updates the workspace
      //
      // therefore we have to synchronize this block
      synchronized (lock)
      {
         // initially create buckets
         if (indexBuckets.size() == 0)
         {
            long lower = 0;
            long upper = minMergeDocs;
            while (upper < maxMergeDocs)
            {
               indexBuckets.add(new IndexBucket(lower, upper, true));
               lower = upper + 1;
               upper *= mergeFactor;
            }
            // one with upper = maxMergeDocs
            indexBuckets.add(new IndexBucket(lower, maxMergeDocs, false));
            // and another one as overflow, just in case...
            indexBuckets.add(new IndexBucket(maxMergeDocs + 1, Long.MAX_VALUE, false));
         }

         // put index in bucket
         IndexBucket bucket = (IndexBucket)indexBuckets.get(indexBuckets.size() - 1);
         for (int i = 0; i < indexBuckets.size(); i++)
         {
            bucket = (IndexBucket)indexBuckets.get(i);
            if (bucket.fits(numDocs))
            {
               break;
            }
         }
         bucket.add(new Index(name, numDocs));

         if (log.isDebugEnabled())
         {
            log.debug("index added: name=" + name + ", numDocs=" + numDocs);
         }

         // if bucket does not allow merge, we don't have to continue
         if (!bucket.allowsMerge())
         {
            return;
         }

         // check if we need a merge
         if (bucket.size() >= mergeFactor)
         {
            long targetMergeDocs = bucket.upper;
            targetMergeDocs = Math.min(targetMergeDocs * mergeFactor, maxMergeDocs);
            // sum up docs in bucket
            List<Index> indexesToMerge = new ArrayList<Index>();
            int mergeDocs = 0;
            for (Iterator<Index> it = bucket.iterator(); it.hasNext() && mergeDocs <= targetMergeDocs;)
            {
               indexesToMerge.add(it.next());
            }
            if (indexesToMerge.size() > 2)
            {
               // found merge
               Index[] idxs = (Index[])indexesToMerge.toArray(new Index[indexesToMerge.size()]);
               bucket.removeAll(indexesToMerge);
               if (log.isDebugEnabled())
               {
                  log.debug("requesting merge for " + indexesToMerge);
               }
               mergeTasks.add(new Merge(idxs));
               log.debug("merge queue now contains " + mergeTasks.size() + " tasks.");
            }
         }
      }
   }
327347
function BlockData(index, buf, cb, count) {
  this.index = index;
  this.buf = buf;
  this.cb = cb;
  this.count = count | 0;
}
527827
public void insert(@NonNull T object, int index) {
        synchronized (mLock) {
            mObjects.add(index, object);
            notifyItemInserted(index);
        }
    }
405871
static String constructIndexName(String indexName, int indexRollsPerDay, Date date) {
        if (indexRollsPerDay > 0) {
            ZonedDateTime zdt = ZonedDateTime.ofInstant(date.toInstant(), ZoneId.of("UTC"));

            int minutesPerRoll = 1440 / indexRollsPerDay;
            int minutesElapsedSinceStartOfDay = zdt.getHour() * 60 + zdt.getMinute();
            int nthRoll = minutesElapsedSinceStartOfDay  / minutesPerRoll;
            String retval = String.format("%s-%s.%04d", indexName, zdt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")), nthRoll);
            logger.debug("constructIndexName from rolls per day = {} gives: {}", indexRollsPerDay, retval);
            return retval;
        } else {
            return indexName;
        }
    }
1031952
public void fillVMIndex(TIntIntHashMap index, int p) {
        for (Node n : scope) {
            for (VM v : parent.getRunningVMs(n)) {
                index.put(v.id(), p);
            }
            for (VM v : parent.getSleepingVMs(n)) {
                index.put(v.id(), p);
            }
        }
        for (VM v : ready) {
            index.put(v.id(), p);
        }
    }
424890
def append(index, str)
      check_index(index)
      window = @session.request(:nvim_get_current_win)
      cursor = window.cursor

      set_lines(index, index, true, [*str.split($/)])
      window.set_cursor(cursor)
      str
    end
378015
def __save(self, b):
        '''
            
        '''
        newbufferidx = (self.__bufferidx + len(b))
        self.__buffer[self.__bufferidx:newbufferidx] = b
        #update buffer index
        self.__bufferidx = newbufferidx
888140
protected void updateName(TreeElement parentNode, int index)
    {
        setName(getNodeName(parentNode, index));
        TreeElement[] children = getChildren();
        for (int i = 0; i < children.length; i++) {
            children[i].updateName(this, i);
        }
    }
935947
private int mapIndexToAction(int index) {
    if (index < buttonCount) {
      int count = -1;
      for (int x = 0; x < MAX_BUTTON_COUNT; x++) {
        if (fields[x]) {
          count++;
        }
        if (count == index) {
          return x;
        }
      }
    }
    return -1;
  }