Makes combinations recursively of all possible mobile Hydrogen positions.
@param taken positions taken by hydrogen
@param combinations combinations made so far
@param skeleton container to work on
@param totalMobHydrCount
@param mobHydrAttachPositions
775264
private void combineHydrogenPositions(List<Integer> taken, List<List<Integer>> combinations,
            IAtomContainer skeleton, int totalMobHydrCount, List<Integer> mobHydrAttachPositions) {
        if (taken.size() != totalMobHydrCount) {
            for (int i = 0; i < mobHydrAttachPositions.size(); i++) {
                int pos = mobHydrAttachPositions.get(i);
                IAtom atom = findAtomByPosition(skeleton, pos);
                int conn = getConnectivity(atom, skeleton);
                int hCnt = 0;
                for (int t : taken)
                    if (t == pos) hCnt++;
                if (atom.getValency() - atom.getFormalCharge() > (hCnt + conn)) {
                    taken.add(pos);
                    combineHydrogenPositions(taken, combinations, skeleton, totalMobHydrCount, mobHydrAttachPositions);
                    taken.remove(taken.size() - 1);
                }
            }
        } else {
            List<Integer> addList = new ArrayList<Integer>(taken.size());
            addList.addAll(taken);
            Collections.sort(addList);
            if (!combinations.contains(addList)) {
                combinations.add(addList);
            }
        }
    }
841486
private void addModels(final Key<Model>[] newModels) {
    int before = leaderboard().getModelCount();
    leaderboard().addModels(newModels);
    int after = leaderboard().getModelCount();
    modelCount.addAndGet(after - before);
  }
485690
public void setContainers(java.util.Collection<Container> containers) {
        if (containers == null) {
            this.containers = null;
            return;
        }

        this.containers = new java.util.ArrayList<Container>(containers);
    }
644833
@Override
  public void updatePosition(float verticalDragOffset) {
    int right = getViewRightPosition(verticalDragOffset);
    int left = right - layoutParams.width;
    int top = getView().getTop();
    int bottom = top + layoutParams.height;

    getView().layout(left, top, right, bottom);
  }
536457
public void merge(RunResults runResults) {
        for (RootMethodRunResult srcResult : runResults.rootMethodRunResults) {
            if (getRunResultByRootMethodKey(srcResult.getRootMethodKey()) != null) {
                throw new RuntimeException(String.format(
                        "not supported: root method %s is called multi times", srcResult.getRootMethodKey()));
            }
            addRootMethodRunResults(srcResult);
        }
    }
808560
protected void associateBatched(Collection owners, Collection children)
    {
        ObjectReferenceDescriptor ord = getObjectReferenceDescriptor();
        ClassDescriptor cld = getOwnerClassDescriptor();
        Object owner;
        Object relatedObject;
        Object fkValues[];
        Identity id;
        PersistenceBroker pb = getBroker();
        PersistentField field = ord.getPersistentField();
        Class topLevelClass = pb.getTopLevelClass(ord.getItemClass());
        HashMap childrenMap = new HashMap(children.size());


        for (Iterator it = children.iterator(); it.hasNext(); )
        {
            relatedObject = it.next();
            childrenMap.put(pb.serviceIdentity().buildIdentity(relatedObject), relatedObject);
        }

        for (Iterator it = owners.iterator(); it.hasNext(); )
        {
            owner = it.next();
            fkValues = ord.getForeignKeyValues(owner,cld);
            if (isNull(fkValues))
            {
                field.set(owner, null);
                continue;
            }
            id = pb.serviceIdentity().buildIdentity(null, topLevelClass, fkValues);
            relatedObject = childrenMap.get(id);
            field.set(owner, relatedObject);
        }
    }
1173599
public void setJobs(java.util.Collection<ThirdPartyJob> jobs) {
        if (jobs == null) {
            this.jobs = null;
            return;
        }

        this.jobs = new java.util.ArrayList<ThirdPartyJob>(jobs);
    }
477489
public static void mergeInstances(Map<TriangulationPoint, TriangulationPoint> uniquePts, List<TriangulationPoint> ptList) {
        for(int idPoint = 0; idPoint < ptList.size(); idPoint++) {
            TriangulationPoint pt = ptList.get(idPoint);
            TriangulationPoint uniquePt = uniquePts.get(pt);
            if(uniquePt == null) {
                uniquePts.put(pt, pt);
            } else {
                // Duplicate point
                ptList.set(idPoint, uniquePt);
            }
        }
    }
1318779
public void setContainers(java.util.Collection<ContainerDefinition> containers) {
        if (containers == null) {
            this.containers = null;
            return;
        }

        this.containers = new java.util.ArrayList<ContainerDefinition>(containers);
    }
201254
def update_positions(self, positions):
        '''
        '''
        sphs_verts = self.sphs_verts_radii.copy()
        sphs_verts += positions.reshape(self.n_spheres, 1, 3)

        self.tr.update_vertices(sphs_verts)
        self.poslist = positions
510211
public void setContainers(java.util.Collection<ModelPackageContainerDefinition> containers) {
        if (containers == null) {
            this.containers = null;
            return;
        }

        this.containers = new java.util.ArrayList<ModelPackageContainerDefinition>(containers);
    }
391026
private Set<String> findReachableNodes(CmsAppCategoryNode rootNode, HashSet<String> reachableNodes) {

        reachableNodes.add(rootNode.getCategory().getId());
        for (CmsAppCategoryNode child : rootNode.getChildren()) {
            findReachableNodes(child, reachableNodes);
        }
        return reachableNodes;
    }
711350
public void setCombiners( List<TupleCombiner> combiners)
    {
    combiners_ = new ArrayList<TupleCombiner>();
    if( combiners != null)
      {
      combiners_.addAll( combiners);
      }
    }
185542
Collection<Point2d[]> getCoordinates(IAtomContainer mol) {
        try {
            // create the library key to lookup an entry, we also store
            // the canonical out ordering
            int n = mol.getAtomCount();
            int[] ordering = new int[n];
            String smiles = cansmi(mol, ordering);

            final Collection<Point2d[]> coordSet = templateMap.get(smiles);
            final List<Point2d[]> orderedCoordSet = new ArrayList<>(coordSet.size());

            for (Point2d[] coords : coordSet) {
                Point2d[] orderedCoords = new Point2d[coords.length];
                for (int i = 0; i < n; i++) {
                    orderedCoords[i] = new Point2d(coords[ordering[i]]);
                }
                orderedCoordSet.add(orderedCoords);
            }
            return Collections.unmodifiableList(orderedCoordSet);
        } catch (CDKException e) {
            return Collections.emptyList();
        }
    }
643591
public void setFromPoints(Point2D[] points) {
		if (points == null || points.length == 0) {
			setEmpty();
			return;
		}

		Point2D pt = points[0];
		setCoords(pt.x, pt.y);
		for (int i = 1; i < points.length; i++) {
			Point2D pt2d = points[i];
			mergeNE(pt2d.x, pt2d.y);
		}
	}
236409
public void setId3Insertions(java.util.Collection<Id3Insertion> id3Insertions) {
        if (id3Insertions == null) {
            this.id3Insertions = null;
            return;
        }

        this.id3Insertions = new java.util.ArrayList<Id3Insertion>(id3Insertions);
    }
49725
public void add(int position) {
    if (mtasPositionType.equals(POSITION_SINGLE)) {
      if (position != mtasPositionStart) {
        if (position == (mtasPositionStart + 1)) {
          mtasPositionType = POSITION_RANGE;
          mtasPositionEnd = position;
        } else if (position == (mtasPositionStart - 1)) {
          mtasPositionType = POSITION_RANGE;
          mtasPositionEnd = mtasPositionStart;
          mtasPositionStart = position;
        } else {
          mtasPositionType = POSITION_SET;
          SortedSet<Integer> list = new TreeSet<>();
          list.add(position);
          list.add(mtasPositionStart);
          mtasPositionList = ArrayUtils
              .toPrimitive(list.toArray(new Integer[list.size()]));
          mtasPositionStart = list.first();
          mtasPositionEnd = list.last();
        }
      }
    } else {
      SortedSet<Integer> list = new TreeSet<>();
      if (mtasPositionType.equals(POSITION_RANGE)) {
        mtasPositionType = POSITION_SET;
        for (int i = mtasPositionStart; i <= mtasPositionEnd; i++) {
          list.add(i);
        }
        list.add(position);
      } else if (mtasPositionType.equals(POSITION_SET)) {
        for (int p : mtasPositionList) {
          list.add(p);
        }
        list.add(position);
      }
      mtasPositionList = ArrayUtils
          .toPrimitive(list.toArray(new Integer[list.size()]));
      mtasPositionStart = list.first();
      mtasPositionEnd = list.last();
      if (list.size() == (1 + mtasPositionEnd - mtasPositionStart)) {
        mtasPositionType = POSITION_RANGE;
        mtasPositionList = null;
      }
    }
  }