residue.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: residue.h,v 1.45 2005/10/23 12:02:20 oliver Exp $
//

#ifndef BALL_KERNEL_RESIDUE_H
#define BALL_KERNEL_RESIDUE_H

#ifndef BALL_KERNEL_FRAGMENT_H
# include <BALL/KERNEL/fragment.h>
#endif

#ifndef BALL_KERNEL_PDBATOMITERATOR_H
# include <BALL/KERNEL/PDBAtomIterator.h>
#endif

#ifndef BALL_KERNEL_RESIDUEITERATOR_H
# include <BALL/KERNEL/residueIterator.h>
#endif

 
#define BALL_RESIDUE_DEFAULT_ID               ""
#define BALL_RESIDUE_DEFAULT_INSERTION_CODE   ' '

namespace BALL 
{
  class Chain;
  class Protein;
  class SecondaryStructure;

  class BALL_EXPORT Residue
    : public Fragment
  {
    public:

    BALL_CREATE_DEEP(Residue)
  
    

    enum Property
    {
      PROPERTY__NON_STANDARD = Fragment::NUMBER_OF_PROPERTIES + 1,
      PROPERTY__AMINO_ACID,
      PROPERTY__WATER,
      PROPERTY__HAS_SSBOND,
      PROPERTY__C_TERMINAL,
      PROPERTY__N_TERMINAL,
      PROPERTY__CYCLIC,

      NUMBER_OF_PROPERTIES
    };

    enum FullNameType
    {
      NO_VARIANT_EXTENSIONS,
      ADD_VARIANT_EXTENSIONS,
      // Add the residue ID separated by a colon
      ADD_RESIDUE_ID,
      // Add the residue ID and the residue extension
      ADD_VARIANT_EXTENSIONS_AND_ID
    };



  
    Residue();
  
    Residue(const Residue& residue, bool deep = true);
  
    Residue
      (const String& name,
       const String& id = BALL_RESIDUE_DEFAULT_ID,
       char insertion_code = BALL_RESIDUE_DEFAULT_INSERTION_CODE);

    virtual ~Residue();

    virtual void clear();
  
    virtual void destroy();
  


    void persistentWrite(PersistenceManager& pm, const char* name = 0) const
      throw(Exception::GeneralException);

    void persistentRead(PersistenceManager& pm)
      throw(Exception::GeneralException);



    void set(const Residue& residue, bool deep = true);

    Residue& operator = (const Residue& residue);

    void get(Residue& residue, bool deep = true) const;

    void swap(Residue& residue);
  

    bool operator == (const Residue& residue) const;

    bool operator != (const Residue& residue) const;



    String getFullName(FullNameType type = ADD_VARIANT_EXTENSIONS) const;
    
    bool hasTorsionPhi() const;
  
    Angle getTorsionPhi() const;
    
    bool hasTorsionPsi() const;
  
    Angle getTorsionPsi() const;

    Protein* getProtein();

    const Protein* getProtein() const;

    Chain* getChain();

    const Chain* getChain() const;

    SecondaryStructure* getSecondaryStructure();

    const SecondaryStructure* getSecondaryStructure() const;

    PDBAtom* getPDBAtom(Position position);
  
    const PDBAtom* getPDBAtom(Position position) const;
  
    void setID(const String& id);

    const String& getID() const;

    void setInsertionCode(char insertion_code);

    char getInsertionCode() const;

    Size countPDBAtoms() const;

    void prepend(PDBAtom& atom);

    void append(PDBAtom& atom);

    void insert(PDBAtom& atom);

    void insertBefore(PDBAtom& atom, Composite& before);

    void insertAfter(PDBAtom& atom, Composite& after);

    bool remove(PDBAtom& atom);

    void spliceBefore(Residue& residue);

    void spliceAfter(Residue& residue);

    void splice(Residue& residue);



    bool isAminoAcid() const;
  
    bool isTerminal() const;
  
    bool isNTerminal() const;
  
    bool isCTerminal() const;



    virtual bool isValid() const;

    virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;


    // --- EXTERNAL ITERATORS 

    BALL_KERNEL_DEFINE_ITERATOR_CREATORS(PDBAtom)


    private:

    AtomContainer* getAtomContainer(Position position);
  
    const AtomContainer* getAtomContainer(Position position) const;
  
    Size countAtomContainers() const;

    void prepend(AtomContainer& atom_container);

    void append(AtomContainer& atom_container);

    void insert(AtomContainer& atom_container);

    void insertBefore(AtomContainer& atom_container, Composite& composite);

    void insertAfter(AtomContainer& atom_container, Composite& composite);

    void spliceBefore(AtomContainer& atom_container);

    void spliceAfter(AtomContainer& base_ragment);

    void splice(AtomContainer& AtomContainer);

    bool remove(AtomContainer& AtomContainer);

    bool isSuperAtomContainerOf(const AtomContainer& atom_container) const;

    BALL_KERNEL_DEFINE_ITERATOR_CREATORS(AtomContainer)

    // --- ATTRIBUTES

    String  id_;

    char    insertion_code_;
  };

  template <class ResidueContainerType>
  const Residue* getNTerminal(const ResidueContainerType& residue_container)
  {
    ResidueConstIterator res_it(residue_container.beginResidue());
    for (; res_it != residue_container.endResidue(); ++res_it)
    {
      if (res_it->isAminoAcid() == true)
      {
        return &(*res_it);
      }
    }

    return 0;
  }

  template <class ResidueContainerType>
  const Residue* getCTerminal(const ResidueContainerType& residue_container)
  {
    ResidueConstReverseIterator res_it(residue_container.rbeginResidue());
    for (; res_it != residue_container.rendResidue(); ++res_it)
    {
      // Look for the last residue marked as amino acid
      if (res_it->isAminoAcid() == true)
      {
        return &(*res_it);
      }
    }

    return 0;
  }

} // namespace BALL

#endif // BALL_KERNEL_RESIDUE_H