base.h

Go to the documentation of this file.

/**********************************************************************
base.h - Base classes to build a graph
 
Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.
 
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 General Public License for more details.
***********************************************************************/

#ifndef OB_BASE_H
#define OB_BASE_H

#include "babelconfig.h"

#include <vector>
#include <map>

#if HAVE_IOSTREAM
#include <iostream>
#elif HAVE_IOSTREAM_H
#include <iostream.h>
#endif

namespace OpenBabel
{

class OBBase;
class OBNodeBase;
class OBEdgeBase;
class OBGraphBase;

class OBAPI OBBase
{
public:
    virtual ~OBBase()
    {}
    ; //NF
    virtual OBBase* DoTransformations(const std::map<std::string,std::string>*pOptions)
    {
        return this;
    } //NF Base type does nothing
    static const char* ClassDescription()
    {
        return "";
    } //NF

};

class OBAPI OBNodeBase : public OBBase
{
protected:
    unsigned short int  _idx;
    OBGraphBase        *_parent;
    std::vector<OBEdgeBase*> _vbond;

public:
    bool Visit;

    OBNodeBase()
    {
        Visit = false;
    }
    virtual ~OBNodeBase()
    {}
    virtual unsigned int  GetIdx()                   const
    {
        return(_idx);
    }
    void                  SetIdx(int idx)
    {
        _idx = idx;
    }
    virtual OBGraphBase  *GetParent()
    {
        return(_parent);
    }
    void                  SetParent(OBGraphBase*);
    void                  AddEdge(OBEdgeBase *b)
    {
        _vbond.push_back(b);
    }
    virtual unsigned int  GetValence()               const
    {
        return(_vbond.size());
    }
    OBNodeBase           *BeginNbr(std::vector<OBEdgeBase*>::iterator&);
    OBNodeBase           *NextNbr(std::vector<OBEdgeBase*>::iterator&);
    OBEdgeBase           *Begin(std::vector<OBEdgeBase*>::iterator&);
    OBEdgeBase           *Next(std::vector<OBEdgeBase*>::iterator&);
    virtual bool          IsConnected(OBNodeBase*);

    void Error(int f)
    {
        std::cerr << "atom vf called = " << f << std::endl;
    }
    virtual int           GetFormalCharge()          const
    {
        ((OBNodeBase*)this)->Error(1);
        return(0);
    }
    virtual unsigned int  ExplicitHydrogenCount()    const
    {
        ((OBNodeBase*)this)->Error(22);
        return(0);
    }
    virtual unsigned int  ImplicitHydrogenCount()    const
    {
        ((OBNodeBase*)this)->Error(22);
        return(0);
    }
    virtual unsigned int  GetImplicitValence()       const
    {
        ((OBNodeBase*)this)->Error(3);
        return(0);
    }
    virtual unsigned int  GetHvyValence()            const
    {
        ((OBNodeBase*)this)->Error(4);
        return(0);
    }
    virtual unsigned int  KBOSum()                const
    {
        ((OBNodeBase*)this)->Error(5);
        return(0);
    }
    virtual unsigned int  GetHyb()                   const
    {
        ((OBNodeBase*)this)->Error(6);
        return(0);
    }
    virtual unsigned int  MemberOfRingCount()        const
    {
        ((OBNodeBase*)this)->Error(7);
        return(0);
    }
    virtual unsigned int  GetAtomicNum()                         const
    {
        ((OBNodeBase*)this)->Error(8);
        return(0);
    }
    virtual void          SetMatch(OBNodeBase*)
    {}
    virtual void          SetAromatic()
    {}
    virtual bool          IsInRingSize(int)          const
    {
        ((OBNodeBase*)this)->Error(9);
        return(false);
    }
    virtual bool          IsAromatic()               const
    {
        ((OBNodeBase*)this)->Error(10);
        return(false);
    }
    virtual bool          IsInRing()                 const
    {
        ((OBNodeBase*)this)->Error(11);
        return(false);
    }
    virtual bool          Eval(OBNodeBase*)          const
    {
        ((OBNodeBase*)this)->Error(12);
        return(false);
    }
    virtual OBNodeBase   *GetMatch()
    {
        ((OBNodeBase*)this)->Error(13);
        return(NULL);
    }
};

class OBAPI OBEdgeBase : public OBBase
{
protected:
    unsigned short int _idx;
    OBNodeBase        *_bgn;     
    OBNodeBase        *_end;     

    OBGraphBase       *_parent;
public:
    bool Visit;

    OBEdgeBase()
    {
        Visit = false;
        _bgn = _end = NULL;
    }
    OBEdgeBase(OBNodeBase *bgn,OBNodeBase *end)
    {}
    virtual ~OBEdgeBase()
    {}

    virtual OBGraphBase* GetParent()
    {
        return(_parent);
    }
    void SetParent(OBGraphBase*);
    unsigned int GetIdx()
    {
        return(_idx);
    }
    void SetIdx(int idx)
    {
        _idx = idx;
    }
    void SetBgn(OBNodeBase *n)
    {
        _bgn = n;
    }
    void SetEnd(OBNodeBase *n)
    {
        _end = n;
    }
    void SwapEnds()
    {
        std::swap(_bgn,_end);
    }
    OBNodeBase *GetBgn()
    {
        return(_bgn);
    }
    OBNodeBase *GetEnd()
    {
        return(_end);
    }

    void Error(int f)
    {
        std::cerr << "bond vf err = " << f << std::endl;
    }
    virtual void SetClosure()
    {}
    virtual bool IsAromatic()      const
    {
        ((OBEdgeBase*)this)->Error(1);
        return(false);
    }
    virtual bool IsInRing()        const
    {
        ((OBEdgeBase*)this)->Error(2);
        return(false);
    }
    virtual bool IsClosure()
    {
        ((OBEdgeBase*)this)->Error(3);
        return(false);
    }
    virtual bool Eval(OBEdgeBase*)
    {
        ((OBEdgeBase*)this)->Error(4);
        return(false);
    }
    virtual unsigned int  GetBO()  const
    {
        ((OBEdgeBase*)this)->Error(5);
        return(0);
    }
};

class OBAPI OBGraphBase : public OBBase
{
protected:
    bool                 _vlock;
    std::vector<OBNodeBase*>  _vatom;
    std::vector<OBEdgeBase*>  _vbond;
public:
    OBGraphBase()
    {
        _vlock = false;
        _vatom.clear();
        _vbond.clear();
    }
    OBGraphBase(const OBGraphBase &src) : OBBase() { }
    virtual     ~OBGraphBase()          { }
    unsigned int NumNodes()
    {
        return(_vatom.empty() ? 0 : _vatom.size());
    }
    unsigned int NumEdges()
    {
        return(_vbond.empty() ? 0 : _vbond.size());
    }
    void        ResetVisitFlags();
    bool        SetVisitLock(bool);
    bool        GetVisitLock()
    {
        return(_vlock);
    }
    OBNodeBase *Begin(std::vector<OBNodeBase*>::iterator&);
    OBNodeBase *Next(std::vector<OBNodeBase*>::iterator&);
    OBEdgeBase *Begin(std::vector<OBEdgeBase*>::iterator&);
    OBEdgeBase *Next(std::vector<OBEdgeBase*>::iterator&);
        
/*The following (placeholder) routines removed to avoid finding solution to
iterators being illegally returned as NULL
    //substructure search functions
    virtual bool SingleMatch()                  const
    {
        return(false);
    }
    virtual void SetSingleMatch(bool)
    {}
    virtual bool FinishedMatch()                const
    {
        return(false);
    }
    virtual void SetFinishedMatch(bool)
    {}
    virtual void ClearMatches()
    {}
    virtual void PushBack(std::vector<OBNodeBase*>&)
    {}
    virtual void PrepForMatch()
    {}
        virtual std::vector<std::pair<OBNodeBase*,std::vector<OBEdgeBase*> > >::iterator BgnMatch()
    {
        return((std::vector<std::pair<OBNodeBase*,std::vector<OBEdgeBase*> > >::iterator) NULL);
    }
    virtual std::vector<std::pair<OBNodeBase*,std::vector<OBEdgeBase*> > >::iterator EndMatch()
    {
        return((std::vector<std::pair<OBNodeBase*,std::vector<OBEdgeBase*> > >::iterator) NULL);
    }
        virtual OBNodeBase *GetFirstSeed()
    {
        return((OBNodeBase*)NULL);
    }
    bool Match(OBGraphBase &,bool singleMatch=false);
    bool Match(OBGraphBase &,
               std::vector<std::pair<OBNodeBase*,std::vector<OBEdgeBase*> > >::iterator,
               std::vector<OBEdgeBase*>::iterator);
*/
};

} //namespace OpenBabel

#endif // OB_BASE_H

---

This file is part of the documentation for Open Babel, version 2.0.2.

Documentation copyright © 1998-2005, the Open Babel Developers.
Open Babel is hosted by:
Generated on Thu Nov 30 20:18:00 2006 by  1.5.1.