bond.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: bond.h,v 1.46 2005/12/23 17:01:47 amoll Exp $
//

#ifndef BALL_KERNEL_BOND_H
#define BALL_KERNEL_BOND_H

#ifndef BALL_CONCEPT_PROPERTY_H
# include <BALL/CONCEPT/property.h>
#endif

#ifndef BALL_CONCEPT_COMPOSITE_H
# include <BALL/CONCEPT/composite.h>
#endif

#ifndef BALL_CONCEPT_ATOMCONTAINER_H
# include <BALL/KERNEL/atomContainer.h>
#endif

#define BALL_BOND_DEFAULT_FIRST_ATOM    0
#define BALL_BOND_DEFAULT_SECOND_ATOM   0
#define BALL_BOND_DEFAULT_NAME          ""
#define BALL_BOND_DEFAULT_ORDER         ORDER__UNKNOWN
#define BALL_BOND_DEFAULT_TYPE          TYPE__UNKNOWN


namespace BALL
{
  class Atom;
  class Fragment;
  class System;

  class BALL_EXPORT Bond
    : public Composite,
      public PropertyManager
  {
    public:

    friend class Atom;

    BALL_CREATE_DEEP(Bond)

    

    class BALL_EXPORT NotBound
      : public Exception::GeneralException
    {
      public:
      NotBound(const char* file, int line);
    };


    typedef short Order;
    typedef short Type;



    enum BondOrder
    {
      ORDER__UNKNOWN        = 0,
      ORDER__SINGLE         = 1,
      ORDER__DOUBLE         = 2,
      ORDER__TRIPLE         = 3,
      ORDER__QUADRUPLE      = 4,
      ORDER__AROMATIC       = 5,
      ORDER__ANY            = 6,
      NUMBER_OF_BOND_ORDERS
    };

    enum BondType
    {
      TYPE__UNKNOWN           = 0,
      TYPE__COVALENT          = 1,
      TYPE__HYDROGEN          = 2,
      TYPE__DISULPHIDE_BRIDGE = 3,
      TYPE__SALT_BRIDGE       = 4,
      TYPE__PEPTIDE           = 5,
      NUMBER_OF_BOND_TYPES
    };

    enum Property
    {
      IS_AROMATIC = 0,
      NUMBER_OF_PROPERTIES
    };


    Bond();

    Bond(const Bond& bond, bool deep = true);

    Bond(const String& name, Atom& first, Atom& second, Order order = BALL_BOND_DEFAULT_ORDER,
         Type type = BALL_BOND_DEFAULT_TYPE)
      throw(Exception::TooManyBonds);

    static Bond* createBond(Bond& bond, Atom& first, Atom& second)
      throw(Exception::TooManyBonds);

    virtual ~Bond();

    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 finalize()
      throw(Exception::GeneralException);


    bool operator == (const Bond& bond) const;

    bool operator != (const Bond& bond) const;


    Bond& operator = (const Bond& bond);

    void swap(Bond& bond);


    void setFirstAtom(Atom* atom);
    void setSecondAtom(Atom* atom);

    const Atom* getFirstAtom() const;

    const Atom* getSecondAtom() const;

    Atom* getPartner(const Atom& atom) const;

    void setName(const String& name);

    const String& getName() const;

    void setOrder(Order bond_order);

    Order getOrder() const;

    bool isAromatic() const;

    void setType(Type bond_type);

    Type getType() const;

    float getLength() const throw(NotBound);

    const Atom* getBoundAtom(const Atom& atom) const;

    Atom* getBoundAtom(const Atom& atom);


    bool isBondOf(const Atom& atom) const;

    bool isBound() const;

    bool isInterBond() const;

    bool isInterBondOf(const AtomContainer& atom_container) const;

    bool isIntraBond() const;

    bool isIntraBondOf(const AtomContainer& atom_container) const;



    virtual bool isValid() const;

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

    protected:


    // First atom of the bond (bond owner)
    Atom*   first_;

    // Second atom
    Atom*   second_;

    // Bond name
    String  name_;

    // Bond order
    Order   bond_order_;

    // Bond type
    Type    bond_type_;

    private:

    void arrangeBonds_();
    void clear_();
  };

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/KERNEL/bond.iC>
# endif
} // namespace BALL

#endif // BALL_KERNEL_BOND_H