Fills the given array with the index of each bone's parent in the skeleton associated with the given action
434895
def getBoneHierarchy(self, action, unIndexArayCount):
        """"""

        fn = self.function_table.getBoneHierarchy
        pParentIndices = BoneIndex_t()
        result = fn(action, byref(pParentIndices), unIndexArayCount)
        return result, pParentIndices
491189
def fill_parentidid2obj_r1(self, id2obj_user, child_obj):
        """"""
        for higher_obj in self._getobjs_higher(child_obj):
            if higher_obj.item_id not in id2obj_user:
                id2obj_user[higher_obj.item_id] = higher_obj
                self.fill_parentidid2obj_r1(id2obj_user, higher_obj)
202127
protected void fillHeaders(JSONObject eachRow, List<String> joinFields, ActionType action) {
        if (action == ActionType.FIRST_CUT) {
            baseFieldNames.add("timestamp");
        } 
        if (eachRow != null) {
            if (isJoinType(action)) {
                Set<String> keysCopy = new LinkedHashSet<>(eachRow.keySet());
                keysCopy.removeAll(joinFields);
                baseFieldNames.addAll(keysCopy);
            } else {
                baseFieldNames.addAll(eachRow.keySet());
            }
        }
    }
1340226
function(obj, objDict) {
	    var parent = objDict[ obj.parentPath ];
	    if (parent) {
		if (parent.Substates == undefined)
		    parent.Substates = [];
		parent.Substates.push( obj );
	    }
	}
200664
private void loadPlanNodesFromJSONArrays(int stmtId, JSONArray jArray, Database db) {
        List<AbstractPlanNode> planNodes = new ArrayList<>();
        int size = jArray.length();

        try {
            for (int i = 0; i < size; i++) {
                JSONObject jobj = jArray.getJSONObject(i);
                String nodeTypeStr = jobj.getString("PLAN_NODE_TYPE");
                PlanNodeType nodeType = PlanNodeType.get(nodeTypeStr);
                AbstractPlanNode apn = nodeType.getPlanNodeClass().newInstance();
                apn.loadFromJSONObject(jobj, db);
                planNodes.add(apn);
            }

            //link children and parents
            for (int i = 0; i < size; i++) {
                JSONObject jobj = jArray.getJSONObject(i);
                if (jobj.has("CHILDREN_IDS")) {
                    AbstractPlanNode parent = planNodes.get(i);
                    JSONArray children = jobj.getJSONArray("CHILDREN_IDS");
                    for (int j = 0; j < children.length(); j++) {
                        AbstractPlanNode child = getNodeofId(children.getInt(j), planNodes);
                        parent.addAndLinkChild(child);
                    }
                }
            }
            m_planNodesListMap.put(stmtId,  planNodes);
        }
        catch (JSONException | InstantiationException | IllegalAccessException e) {
            System.err.println(e);
            e.printStackTrace();
        }
    }
1188164
function() {
			var parent = this.parent;
			var ix = parent.children.indexOf(this);
			var items = utils.flatten(arguments);
			spliceFn.apply(parent.children, [ix, 1].concat(items));
			
			// update parent
			items.forEach(function(item) {
				item.parent = parent;
			});
		}
345583
def getSkeletalBoneData(self, action, eTransformSpace, eMotionRange, unTransformArrayCount):
        """"""

        fn = self.function_table.getSkeletalBoneData
        pTransformArray = VRBoneTransform_t()
        result = fn(action, eTransformSpace, eMotionRange, byref(pTransformArray), unTransformArrayCount)
        return result, pTransformArray
1236760
public function toArrayParent($chaine_parent = 'parent_id', $chaine_id = 'id', array $indices = array(), $unset_indice = false)
    {
        $array = $this->toArray();

        $num = 0;
        $final = array();
        do {
            $is_present = false;
            foreach ($array as $key => $row) {
                if ($row[$chaine_parent] == $num) {
                    if (count($indices) > 0) {
                        $buffer = &$final;
                        foreach ($indices as $indice) {
                            if (isset($row[$indice])) {
                                $buffer = &$buffer[$row[$indice]];
                                if ($unset_indice) {
                                    unset($row[$indice]);
                                }
                            }
                        }
                        $buffer = $row;
                    } else {
                        $final[] = $row;
                    }
                    $num = $row[$chaine_id];
                    unset($array[$key]);
                    $is_present = true;
                    break;
                }
            }
        } while ($is_present);

        return $final;
    }
673407
@Override
    public void index(Class entityClazz, EntityMetadata m, Map<String, Object> values, Object parentId,
            Class parentClazz)
    {
        Set<String> indexNames = values.keySet();
        for (String idx_Name : indexNames)
        {
            Double value = (Double) values.get(idx_Name);
            Pipeline pipeLine = null;
            try
            {
                if (this.pipeLineOrConnection.getClass().isAssignableFrom(Jedis.class))
                {
                    pipeLine = ((Jedis) this.pipeLineOrConnection).pipelined();
                    pipeLine.zadd(idx_Name, value, parentId.toString());
                    // pipeLine.sync();
                }
                else
                {
                    ((Transaction) this.pipeLineOrConnection).zadd(idx_Name, value, parentId.toString());
                }
            }
            finally
            {
                if (pipeLine != null)
                {
                    pipeLine.sync();
                }
            }
        }

    }
1013019
void add(int index, IonValueLite child)
        throws ContainedValueException, NullPointerException
    {
        if ((index < 0) || (index > get_child_count()))
        {
            throw new IndexOutOfBoundsException();
        }
        checkForLock();
        validateNewChild(child);

        add_child(index, child);
        patch_elements_helper(index + 1);

        assert((index >= 0)
               && (index < get_child_count())
               && (child == get_child(index))
               && (child._elementid() == index));
    }
1267654
function buildNodeHierachy( nodeId, parentObject, json, allNodes, skins ) {

			var node = allNodes[ nodeId ];
			var nodeDef = json.nodes[ nodeId ];

			// build skeleton here as well

			if ( nodeDef.skin !== undefined ) {

				var meshes = node.isGroup === true ? node.children : [ node ];

				for ( var i = 0, il = meshes.length; i < il; i ++ ) {

					var mesh = meshes[ i ];
					var skinEntry = skins[ nodeDef.skin ];

					var bones = [];
					var boneInverses = [];

					for ( var j = 0, jl = skinEntry.joints.length; j < jl; j ++ ) {

						var jointId = skinEntry.joints[ j ];
						var jointNode = allNodes[ jointId ];

						if ( jointNode ) {

							bones.push( jointNode );

							var mat = new THREE.Matrix4();

							if ( skinEntry.inverseBindMatrices !== undefined ) {

								mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );

							}

							boneInverses.push( mat );

						} else {

							console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', jointId );

						}

					}

					mesh.bind( new THREE.Skeleton( bones, boneInverses ), mesh.matrixWorld );

				}

			}

			// build node hierachy

			parentObject.add( node );

			if ( nodeDef.children ) {

				var children = nodeDef.children;

				for ( var i = 0, il = children.length; i < il; i ++ ) {

					var child = children[ i ];
					buildNodeHierachy( child, node, json, allNodes, skins );

				}

			}

		}
931908
public void fit(INDArray x) {
        this.data = x;
        for(int i = 0; i < numTrees; i++) {
            RPTree tree = new RPTree(data.columns(),maxSize,similarityFunction);
            tree.buildTree(x);
            trees.add(tree);
        }
    }
865566
@Override
	@SuppressWarnings("unchecked")
	protected void updateMongoInfo(JSONArray tmpMongoDetailArray) {
		for (Object obj : tmpMongoDetailArray) {
			JSONObject dataMainObj = (JSONObject) obj;

			Scope scope = new Scope();

			removeExistingEntity(getJSONString(dataMainObj, "_oid"));

			// collectorId
			scope.setCollectorId(
					featureCollectorRepository.findByName(FeatureCollectorConstants.VERSIONONE).getId());

			// ID;
			scope.setpId(getJSONString(dataMainObj, "_oid"));

			// name;
			scope.setName(getJSONString(dataMainObj, "Name"));

			// beginDate;
			scope.setBeginDate(getJSONString(dataMainObj, "BeginDate"));

			// endDate;
			scope.setEndDate(getJSONString(dataMainObj, "EndDate"));

			// changeDate;
			scope.setChangeDate(getJSONString(dataMainObj, "ChangeDate"));

			// assetState;
			scope.setAssetState(getJSONString(dataMainObj, "AssetState"));

			// isDeleted;
			scope.setIsDeleted(getJSONString(dataMainObj, "IsDeleted"));

			// path;
			String projPath = scope.getName();
			List<String> projList = (List<String>) dataMainObj.get("ParentAndUp.Name");
			if (!CollectionUtils.isEmpty(projList)) {
				for (String proj : projList) {
					projPath = proj + "-->" + projPath;
				}
				projPath = "All-->" + projPath;
			} else {
				projPath = "All-->" + projPath;
			}
			scope.setProjectPath(sanitizeResponse(projPath));

			projectRepo.save(scope);
		}
	}
175262
public void setArray(final int parameterIndex, final Array x) 
        throws SQLException {

        setParam(parameterIndex, acolyte.jdbc.ParameterMetaData.Array, x);
    }
1140141
function insert (parent, children) {
  if (!parent || !children) {
    return
  }
  let nodes = Array.prototype.slice.call(children)
  if (nodes.length === 0) {
    nodes.push(children)
  }
  for (let i = 0; i < nodes.length; i++) {
    if (this.contains(nodes[i], parent)) {
      continue
    }
    if (nodes[i] !== parent && parent.appendChild) {
      parent.appendChild(nodes[i])
    }
  }
}
450536
def _fill_array_from_list(the_list, the_array):
        """"""
        for i, val in enumerate(the_list):
            the_array[i] = val
        return the_array
573990
function _appendActionToUpdaters(node, actionMap) {
  if (node.members && node.members.static.length) {
    node.members.static = node.members.static.map(nd => _appendActionToUpdaters(nd, actionMap));
  }

  const updater = node.name;

  const action = Object.values(actionMap)
    .find(action => action.updaters.find(up => up.name === updater));

  if (!action) {
    return node;
  }
  const actionName = action.name;

  const mdContent = `
  * __Action__: [${BT}${actionName}${BT}](../actions/actions.md#${actionName.toLowerCase()})
  `;

  return _appendListToDescription(node, mdContent);
}