/home/ale/projects/ConfigML/inipat.h

Go to the documentation of this file.

#ifndef INIPAT_HEADER
#define INIPAT_HEADER
#include <strings.h>
#include "iostream"
#include "fstream"
//#include <string>
#include <vector>
#include <stack>

using namespace std;



class ConfigObj; // references itself

class TagInfo
{
   friend class ConfigObj;
   friend class TypeTagIs;
   friend class NameIs;
   unsigned int LineNo; 
   char* Tag; 
   void AssignTag(const char* Text); 
   public:
      TagInfo(unsigned int N, char* Text );
      TagInfo(const TagInfo& Other); 
      TagInfo(const TagInfo* Other);
      TagInfo& operator=(const TagInfo& Other);
      friend ostream& operator <<(ostream& Out, TagInfo& Info);
      
      friend ostream& operator <<(ostream& Out, const TagInfo* Info);

      inline const char* data()  { return Tag; };
      
      inline char* GetString()   { return Tag; };

      inline unsigned int GetLineNo()  { return LineNo; };

      ~TagInfo();
};

typedef vector<TagInfo*> TagVector; 
typedef vector<TagInfo*>::iterator TagIterator;
typedef vector<ConfigObj*> ConfigVector;
typedef vector<ConfigObj*>::iterator ConfigIterator;
typedef vector<ConfigObj*>::reverse_iterator ConfigRevIterator; 

class ConfigObj
{
   char* Name;
   unsigned int LineNo; 
   TagVector Params; 
   ConfigVector SubConfigs; 
   void AssignName(const char* N); 
   void KillParams(); 
   void KillConfigs(); 
   void CopyParams(const ConfigObj& Other);
   void CopyConfigs(const ConfigObj& Other);
   friend class TypeTagIs;
   friend class NameIs;
   public:
      ConfigObj(const char* N, unsigned int L);
      ConfigObj(const ConfigObj& Other);
      ConfigObj(const ConfigObj* Other);
      ConfigObj& operator=(const ConfigObj& Other);

      bool IsMyName(const char* N) const;
      
      ConfigIterator GetConfig(const char* N, unsigned int Index=0);

      ConfigIterator GetConfig(const char* N, const char* Param, const char* ValueOfParam);

      TagIterator GetTag(const char* N, unsigned int Index=0);

      
      inline TagInfo* GetTag(unsigned int Index){ if(Index < Params.size()) return  Params[Index]; else return NULL;};

      inline ConfigObj* GetConfig(unsigned int Index){ if(Index < SubConfigs.size()) return  SubConfigs[Index]; else return NULL;};

      
      inline unsigned int GetLineNo(){ return LineNo; };
      inline TagIterator TagsBegin() { return Params.begin(); };
      inline TagIterator TagsEnd(){ return Params.end(); };
      inline ConfigIterator ConfigBegin(){ return SubConfigs.begin(); };
      inline ConfigIterator ConfigEnd(){ return SubConfigs.end(); };
      inline ConfigRevIterator ConfigRbegin(){ return SubConfigs.rbegin(); };
      inline ConfigRevIterator ConfigRend(){ return SubConfigs.rend(); };

      TagIterator FindFirstTag(const char* ParamName);

      
      ConfigIterator FindFirstConfig(const char* ConfigName);

      

      ConfigIterator FindNextConfig(ConfigIterator& First);

      ConfigIterator FindNextConfig(ConfigIterator& First, const char* TwinTag);

      void Reverse();
      
      void Absorb(ConfigObj* Other );
      inline void Absorb(ConfigIterator Other ){ Absorb(*Other); };

      void Load(char* filename);
      
      ConfigStream& Load(ConfigStream& Input);

      ostream& Write(ostream& oStream, short TabShift=0);

      unsigned int CountParams(const char* Name=NULL);

      unsigned int CountConfigs(const char* Name=NULL);

      void Merge(const char* Name=NULL);

      void DropTwins(const char* Name, const char* TagName);

      inline bool empty()const {return ( Params.empty() && SubConfigs.empty() );}; 

      void Drop(TagInfo* Param); 
      void Drop(ConfigObj* C);  

      inline void Drop(TagIterator& it){ if(it!=Params.end()){ delete *it; Params.erase(it); } };
      
      inline void Drop(ConfigIterator& ci) { if(ci!=SubConfigs.end()){delete *ci; SubConfigs.erase(ci); } };

      inline void DropAll(){ KillParams(); KillConfigs(); };
      
      inline TagInfo* operator[](unsigned int i){ return Params[i]; };
      inline bool operator==(char* N){ return IsMyName(N); };

      ~ConfigObj();
};

char ValidateINI(char* filename);

bool strToBool(const char* text, bool NoMatch=false);

class TypeTagIs // if the Config Object has the tag with the name "Type" and the value TypName
{
   char* Value;
   bool check(ConfigObj* Subj);
   public:
      TypeTagIs(char* TypName);
      inline bool operator ()(ConfigIterator& Subj ){ return check(*Subj); };
      inline bool operator ()(ConfigRevIterator& Subj ){ return check(*Subj); };
       
      ~TypeTagIs();
};

class NameIs // name of the tag, or name of config object
{
   unsigned int Len;
   char* TagName;

   bool CheckTag(TagInfo* Subj);
   bool CheckConfig(ConfigObj* Subj);
   public:
      NameIs(char* TName);
      inline bool operator ()(TagIterator& Other ){ return CheckTag(*Other); };
      inline bool operator ()(ConfigIterator& Other ){ return CheckConfig(*Other); };
      inline bool operator ()(ConfigRevIterator& Other ){ return CheckConfig(*Other); };;
      
      ~NameIs();
};


#endif // INIPAT_HEADER

---