bond.h

/****************************************************************************************
                                          bond.h 
                                        ----------
    copyright            : (C) 2006 Jean-Luc Perret - Pierre Mahé
    email                : jean-luc.perret@unine.ch - pierre.mahe@ensmp.fr
 ***************************************************************************************/

/****************************************************************************************
 *                                                                                      *
 *      This program is free software; you can redistribute it and/or                   *
 *      modify it under the terms of the GNU Lesser General Public                      *
 *      License as published by the Free Software Foundation; either                    *
 *      version 2.1 of the License, or (at your option) any later version.              *
 *                                                                                      *
 *      This program is distributed in the hope that it will be useful,                 *
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of                  *
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU               *
 *      Lesser General Public License for more details.                                 *
 *                                                                                      *
 *      You should have received a copy of the GNU Lesser General Public                *
 *      License along with this library; if not, write to the Free Software             *
 *      Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA      *
 *                                                                                      *
 ****************************************************************************************/



#ifndef BOND_H
#define BOND_H

//#include<sstream>

#include "constant.h"
#include "datacontainer.h"
#include "atom.h"

#include <ring.h>


class Atom;

class Bond { //: public DataContainer  {  // bonds do not need to be a DataContainer

public:



        Bond();

        Bond(Atom* aSource, Atom* aTarget, int aLabel, int aPerretLabel = NAVALUE, int aBondStereo = 0,  int aBondNotUsed = 0, int aBondTopology = 0, int aBondReactionCenter = 0 );

        ~Bond();






        Atom* getTarget() throw( CError );

        bool hasTarget(){ if( target == NULL ){ return( false ); }else{ return( true ); }}

        Atom* getSource() throw( CError );

        bool hasSource(){ if( source == NULL ){ return( false ); }else{ return( true ); }}

        int getLabel(){ return(label);}

        int getPerretLabel(){
                return( perretLabel );
        }

        void setPerretLabel();


        void setKashimaPT(double aPt){ pt = aPt; }

        double getKashimaPT(){ return( pt ); }

        bool hasFlag(){ return flag; }

        void setFlag(){ flag = true; }

        void unsetFlag(){ flag = false; }

        bool hasFlagOriginal(){ return flagOriginal; }
        
        void setFlagOriginal(){ flagOriginal = true; }

        void unsetFlagOriginal(){ flagOriginal = false; }


        void addRing( Ring* aRing ){ if( !hasRing( aRing ) ){ rings.push_back( aRing ); } }

        bool hasRing( Ring* aRing );

        bool hasRing(){ if( numRings() > 0 ){ return( true ); }else{ return( false );};}
        
        int numRings(){ return( rings.size() ); }

        void setStereo( int a ){ stereo = a; }

        int getStereo(){ return( stereo ); }
        
        void setTopology( int a ){ topology = a; }

        int getTopology(){ return( topology ); }

        void setReactionCenter( int a ){ reactionCenter = a; }

        int getReactionCenter(){ return( reactionCenter ); }
        
        void setNotUsed( int a ){ notUsed = a; }

        int getNotUsed(){ return( notUsed ); }





        void reverse();

        Bond* getReverse() throw( CError );

        void hideToFrom();
        
        void restoreToFrom();






        string toString();

        string toStringShort();

        void describe();

        void describeShort();







        vector<Ring*>::iterator beginRing(){ return( rings.begin() );}
        vector<Ring*>::iterator endRing(){ return( rings.end() );}



        // ****************************** //
        // **** DEPRECATED FUNCTIONS **** //
        // ****************************** //

        //string toStringBFSVector();
        //Ring* getRingBFS( vector<Bond*>* toVisit, Bond* init = NULL );


private: // Private attributes

        Atom *source;

        Atom *target;

        int label;

        int perretLabel;

        int stereo;

        int notUsed;

        int topology;

        int reactionCenter;

        double pt;

        bool flag;

        bool flagOriginal;      
                                
        //map< string, Descriptor< Atom >* > atomDescriptors;

        //vector<Bond*> BFSVector;

        vector<Ring*> rings;


};

#endif

---