base.h

Go to the documentation of this file.

/**********************************************************************
base.h - Base class for OpenBabel objects

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

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 <openbabel/babelconfig.h>

#include <vector>
#include <map>
#include <string>
#include <iostream>
#include <openbabel/tokenst.h>

#ifdef UNUSED
#elif (__GNUC__ == 4)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif

namespace OpenBabel
{

 //Forward declaration of the base class for OBMol OBReaction, OBAtom, etc.
 //Declaration later in this file.
class OBBase;
class OBConversion; //used only as pointer

 OBAPI std::string OBReleaseVersion();

 namespace OBGenericDataType
 {
 enum
 {
 UndefinedData = 0,

 PairData = 1,

 EnergyData = 2,

 CommentData = 3,

 ConformerData = 4,

 ExternalBondData = 5,

 RotamerList = 6,

 VirtualBondData = 7,

 RingData = 8,

 TorsionData = 9,

 AngleData = 10,

 SerialNums = 11,

 UnitCell = 12,

 SpinData = 13,

 ChargeData = 14,

 SymmetryData = 15,

 // 16 - Value unused, formerly ChiralData

 OccupationData = 17,

 DensityData = 18,

 ElectronicData = 19,

 VibrationData = 20,

 RotationData = 21,

 NuclearData = 22,

 SetData = 23,

 GridData = 24,

 VectorData = 25,

 MatrixData = 26,

 StereoData = 27,

 DOSData = 28,

 ElectronicTransitionData = 29,

 // space for up to 2^14 more entries...

 CustomData0 = 16384,
 CustomData1 = 16385,
 CustomData2 = 16386,
 CustomData3 = 16387,
 CustomData4 = 16388,
 CustomData5 = 16389,
 CustomData6 = 16390,
 CustomData7 = 16391,
 CustomData8 = 16392,
 CustomData9 = 16393,
 CustomData10 = 16394,
 CustomData11 = 16395,
 CustomData12 = 16396,
 CustomData13 = 16397,
 CustomData14 = 16398,
 CustomData15 = 16399
 };
 } // end namespace
 enum DataOrigin {
 any, 
 fileformatInput, 
 userInput, 
 perceived, 
 external, 
 local 
 };

 // Class introduction in generic.cpp
 // This base class declaration has no dependence on mol.h
 class OBAPI OBGenericData
 {
 protected:
 std::string _attr; 
 unsigned int _type; 
 DataOrigin _source;
 public:
 OBGenericData(const std::string attr = "undefined",
 const unsigned int type = OBGenericDataType::UndefinedData,
 const DataOrigin source = any);
 //Use default copy constructor and assignment operators
 //OBGenericData(const OBGenericData&);

 /* Virtual constructors added. see
 http://www.parashift.com/c++-faq-lite/abcs.html#faq-22.5
 to allow copying given only a base class OBGenericData pointer.
 It may be necessary to cast the return pointer to the derived class
 type, since we are doing without Covariant Return Types
 http://www.parashift.com/c++-faq-lite/virtual-functions.html#faq-20.8

 A derived class may return NULL if copying is inappropriate */
 virtual OBGenericData* Clone(OBBase* /*parent*/) const
 { return NULL; }
 virtual ~OBGenericData() {}
 //Use default copy constructor and assignment operators
 //OBGenericData& operator=(const OBGenericData &src);

 void SetAttribute(const std::string &v)
 { _attr = v; }
 void SetOrigin(const DataOrigin s) { _source = s; }
 virtual const std::string &GetAttribute() const
 { return(_attr); }
 unsigned int GetDataType() const
 { return(_type); }
 virtual const std::string &GetValue() const
 { return _attr; }
 virtual DataOrigin GetOrigin() const
 { return _source; }
 };

 typedef std::vector<OBGenericData*>::iterator OBDataIterator;

 // introduction in base.cpp
 class OBAPI OBBase
 {
 public:
 virtual ~OBBase()
 {
 if (!_vdata.empty())
 {
 std::vector<OBGenericData*>::iterator m;
 for (m = _vdata.begin();m != _vdata.end();m++)
 delete *m;
 _vdata.clear();
 }
 }

 virtual bool Clear();

 virtual OBBase* DoTransformations(const std::map<std::string,std::string>* /*pOptions*/,
 OBConversion* /*pConv*/)
 {
 return this;
 }

 static const char* ClassDescription()
 {
 return "";
 }

 template< class T >
 T* CastAndClear(bool clear=true)
 {
 T* pOb = dynamic_cast<T*>(this);
 if(pOb && clear)// Clear only if this is of target class
 Clear();
 return pOb;
 }

 //Currently no title data member in base class.
 virtual const char *GetTitle(bool UNUSED(replaceNewlines) = true) const { return "";}
 virtual void SetTitle(const char *) {}


 bool HasData(const std::string &);
 bool HasData(const char *);
 bool HasData(const unsigned int type);
 void DeleteData(unsigned int type);
 void DeleteData(OBGenericData*);
 void DeleteData(std::vector<OBGenericData*>&);
 bool DeleteData(const std::string& s);
 void SetData(OBGenericData *d)
 {
 if(d) _vdata.push_back(d);
 }
 void CloneData(OBGenericData *d);
 size_t DataSize() const
 { return(_vdata.size()); }
 OBGenericData *GetData(const unsigned int type);
 OBGenericData *GetData(const std::string&);
 OBGenericData *GetData(const char *);
 std::vector<OBGenericData*> GetAllData(const unsigned int type);
 std::vector<OBGenericData*> &GetData() { return(_vdata); }
 std::vector<OBGenericData*> GetData(DataOrigin source);
 OBDataIterator BeginData()
 { return(_vdata.begin()); }
 OBDataIterator EndData()
 { return(_vdata.end()); }
 protected:
 std::vector<OBGenericData*> _vdata; 

 };

} //namespace OpenBabel

#endif // OB_BASE_H