Adds a ChemSequence to this container.

@param  chemSequence  The chemSequence to be added to this container
@see                  #chemSequences
421945
@Override
    public void addChemSequence(IChemSequence chemSequence) {
        if (chemSequenceCount + 1 >= chemSequences.length) {
            growChemSequenceArray();
        }
        chemSequences[chemSequenceCount] = chemSequence;
        chemSequenceCount++;
    }
508691
public void add(StatementRank rank, Resource subject) {
		if (this.bestRank == rank) {
			subjects.add(subject);
		} else if(bestRank == StatementRank.NORMAL && rank == StatementRank.PREFERRED) {
			//We found a preferred statement
			subjects.clear();
			bestRank = StatementRank.PREFERRED;
			subjects.add(subject);
		}
	}
1228603
public void setInitialSequence(int[] sequence) {
    if(models != null){
      for(int i = 0; i < models.length; i++)
        models[i].setInitialSequence(sequence);
      return;
    }
    model1.setInitialSequence(sequence);
    model2.setInitialSequence(sequence);
  }
483706
public void add(S sequence) {
        int start = currentEnd;
        this.sequence.add(sequence);
        suffix = new Suffix<>(currentEnd, currentEnd, this.sequence);
        activePoint.setPosition(root, null, 0);
        extendTree(start, this.sequence.getLength());
    }
609370
@Override
    public void addChemModel(IChemModel chemModel) {
        if (chemModelCount + 1 >= chemModels.length) {
            growChemModelArray();
        }
        chemModels[chemModelCount] = chemModel;
        chemModelCount++;
    }
217620
public void add(VerifierComponent descr) {

        if ( subSolver != null ) {
            subSolver.add( descr );
        } else {
            if ( type == OperatorDescrType.AND ) {
                if ( possibilityLists.isEmpty() ) {
                    possibilityLists.add( new HashSet<VerifierComponent>() );
                }
                for ( Set<VerifierComponent> set : possibilityLists ) {
                    set.add( descr );
                }
            } else if ( type == OperatorDescrType.OR ) {
                Set<VerifierComponent> set = new HashSet<VerifierComponent>();
                set.add( descr );
                possibilityLists.add( set );
            }
        }
    }
227401
protected function _addSequence(Sequence $sequence)
    {
        $namespaceName = $sequence->getNamespaceName();
        $seqName       = $sequence->getFullQualifiedName($this->getName());

        if (isset($this->_sequences[$seqName])) {
            throw SchemaException::sequenceAlreadyExists($seqName);
        }

        if ($namespaceName !== null
            && ! $sequence->isInDefaultNamespace($this->getName())
            && ! $this->hasNamespace($namespaceName)) {
            $this->createNamespace($namespaceName);
        }

        $this->_sequences[$seqName] = $sequence;
    }
242912
public function addSequence(Sequence $sequence)
    {
        if ($this->hasSequence($sequence->getName())) {
            throw SchemaException::schemaSequenceAlreadyExists($this->getName(), $sequence->getName());
        }

        $this->sequences[$sequence->getName()] = $sequence;
    }
690601
public void addRequirement(Requirement requirement) throws GreenPepperServerException
    {
        if(requirements.contains(requirement) || requirementNameExists(requirement.getName()))
            throw new GreenPepperServerException( GreenPepperServerErrorKey.REQUIREMENT_ALREADY_EXISTS, "Requirement already exists");

        requirement.setRepository(this);
        requirements.add(requirement);
    }
1263125
public static void writeProteinSequence(OutputStream outputStream,
			Collection<ProteinSequence> proteinSequences) throws Exception {

		GenbankWriter<ProteinSequence, AminoAcidCompound> genbankWriter = new GenbankWriter<ProteinSequence, AminoAcidCompound>(
				outputStream,
				proteinSequences,
				new GenericGenbankHeaderFormat<ProteinSequence, AminoAcidCompound>());
		genbankWriter.process();

	}
1140997
private Statements createSequencesStatements(Iterable<Sequence> sequences) {
		Statements statements = new Statements();
		for ( Sequence sequence : sequences ) {
			addSequence( statements, sequence );
		}
		return statements;
	}
1226058
@Override
    public Object mapSequence(Object sequence) {
        List<?> list = (List<?>) sequence;
        List<Object> ret = new ArrayList<>();
        for (Object o : list)
            ret.add(map(o));
        return ret;
    }
1267797
public static int getAtomCount(IChemSequence sequence) {
        int count = 0;
        for (int i = 0; i < sequence.getChemModelCount(); i++) {
            count += ChemModelManipulator.getAtomCount(sequence.getChemModel(i));
        }
        return count;
    }
1233116
public static void writeProteinSequence(OutputStream outputStream,
			Collection<ProteinSequence> proteinSequences) throws Exception {

		FastaWriter<ProteinSequence, AminoAcidCompound> fastaWriter = new FastaWriter<ProteinSequence, AminoAcidCompound>(
				outputStream, proteinSequences,
				new GenericFastaHeaderFormat<ProteinSequence, AminoAcidCompound>());
		fastaWriter.process();

	}
1004714
@Override
    public void addAtomContainer(IAtomContainer atomContainer, double multiplier) {
        if (atomContainerCount + 1 >= atomContainers.length) {
            growAtomContainerArray();
        }
        atomContainer.addListener(this);
        atomContainers[atomContainerCount] = atomContainer;
        multipliers[atomContainerCount] = multiplier;
        atomContainerCount++;
        notifyChanged();
    }
1075912
public void insertSequence(final List<Group> groups) {
    if (groups != null && !groups.isEmpty() && !sequenceMap.containsValue(groups)) {
      sequenceMap.put(groups.get(0).getSequence(), groups);
    }
  }
195926
@Override
    public Iterable<IChemSequence> chemSequences() {
        return new Iterable<IChemSequence>() {

            @Override
            public Iterator<IChemSequence> iterator() {
                return new ChemSequenceIterator();
            }
        };
    }