---

Attributes.H

Go to the documentation of this file.

#ifndef _ATTRIBUTE_H
#define _ATTRIBUTE_H

#include <exception>
#include <Vector.H>
#include <string>

using namespace std;


namespace xchen
{

  class Attribute 
  {
      friend class Attributes;

      string id;
      char const* type;
      void* val;    

  public:
      Attribute(Attribute const&);
      Attribute& operator=(Attribute const&);
      

      template<typename T>
      Attribute(string const& name, T const&v) : id(name), type(typeid(T).name()), val(new T(v)) { }                
      Attribute(string const& name, type_info const& t) : id(name), type(t.name()), val(0)       { }                
      ~Attribute()                                                                               { deallocate(); }  
      
      template<typename T>
      void SetValue(T const& v) { if(strcmp(typeid(T).name(),type)) throw "Attributes::SetValue() type mismatch!\n"; if(!val)val = new T(); *(T*)val = v; } 
      void const* GetValue()                                          { return val; }
      bool operator<(Attribute const& rhs) const                      { return id < rhs.id; }
      
      friend istream& operator>> (istream& is, Attribute& a);                                    
      friend ostream& operator<< (ostream& os, Attribute const& a);
      
  private:
      Attribute(string const& name) : id(name), type(typeid(int).name()), val(0) { }             // used by Attributes class for searching.
      Attribute(string const& name, char*) { throw "Attribute(string const&, char*) disabled, use Attribute(string const&, string const&) instead.\n"; }

      void deallocate();
      void allocate(void* v);                                       // deallocate, allocate and init value if v!=0.
  };


  class Attributes
  {
  public:
      template<typename T>
      void Register(string const& id, T const&v);                     
      void Register(string const& id, type_info const& t);            

      Attribute& operator[](string const& id);
      
      void ReadFrom(int argc, char** argv);                           
      void ReadFrom(string const& str);                               
        
      friend istream& operator>> (istream& is, Attributes&);          
      friend ostream& operator<< (ostream& os, Attributes const&);
      
  private:
      set<Attribute> attr;
  };




  inline Attribute :: Attribute(Attribute const& rhs) : id(rhs.id), type(rhs.type), val(0)
  {
    allocate(rhs.val);
  }
  
  inline Attribute& Attribute :: operator=(Attribute const& rhs)
  {
    if(this != &rhs)
    {
      id = rhs.id;
      type = rhs.type;
      allocate(rhs.val);
    }
    return *this;
  }
  
  inline void  Attribute::deallocate()
  {
    if(!val) return;
    
    if     (! strcmp(type, typeid(char).name()) )      delete (char*)val;
    else if(! strcmp(type, typeid(int).name()) )       delete (int*)val;
    else if(! strcmp(type, typeid(double).name()) )    delete (double*)val;
    else if(! strcmp(type, typeid(dVector2D).name()) ) delete (dVector2D*)val;
    else if(! strcmp(type, typeid(dVector3D).name()) ) delete (dVector3D*)val;
    else if(! strcmp(type, typeid(dVector4D).name()) ) delete (dVector4D*)val;
    else if(! strcmp(type, typeid(dVector5D).name()) ) delete (dVector5D*)val;
    else if(! strcmp(type, typeid(iVector2D).name()) ) delete (iVector2D*)val;
    else if(! strcmp(type, typeid(iVector3D).name()) ) delete (iVector3D*)val;
    else if(! strcmp(type, typeid(iVector4D).name()) ) delete (iVector4D*)val;
    else if(! strcmp(type, typeid(iVector5D).name()) ) delete (iVector5D*)val;
    else if(! strcmp(type, typeid(string).name()) )    delete (string*)val;
    else { throw "supported attributes types are int, char, double, dVector[2-5]D, string\n"; }
  }
  

  inline void  Attribute::allocate(void *v)
  {
    if(!v) return;
    
    if     (! strcmp(type, typeid(char).name()) )      { delete (char*)val;      val = new char(*(char*)v); }      
    else if(! strcmp(type, typeid(int).name()) )       { delete (int*)val;       val = new int(*(int*)v); }       
    else if(! strcmp(type, typeid(double).name()) )    { delete (double*)val;    val = new double(*(double*)v); }    
    else if(! strcmp(type, typeid(dVector2D).name()) ) { delete (dVector2D*)val; val = new dVector2D(*(dVector2D*)v); } 
    else if(! strcmp(type, typeid(dVector3D).name()) ) { delete (dVector3D*)val; val = new dVector3D(*(dVector3D*)v); } 
    else if(! strcmp(type, typeid(dVector4D).name()) ) { delete (dVector4D*)val; val = new dVector4D(*(dVector4D*)v); } 
    else if(! strcmp(type, typeid(dVector5D).name()) ) { delete (dVector5D*)val; val = new dVector5D(*(dVector5D*)v); } 
    else if(! strcmp(type, typeid(iVector2D).name()) ) { delete (iVector2D*)val; val = new iVector2D(*(iVector2D*)v); } 
    else if(! strcmp(type, typeid(iVector3D).name()) ) { delete (iVector3D*)val; val = new iVector3D(*(iVector3D*)v); } 
    else if(! strcmp(type, typeid(iVector4D).name()) ) { delete (iVector4D*)val; val = new iVector4D(*(iVector4D*)v); } 
    else if(! strcmp(type, typeid(iVector5D).name()) ) { delete (iVector5D*)val; val = new iVector5D(*(iVector5D*)v); } 
    else if(! strcmp(type, typeid(string).name()) )    { delete (string*)val;    val = new string(*(string*)v); }    
    else { throw "supported attributes types are int, char, double, dVector[2-5]D, string\n"; }
  }



  inline void Attributes :: Register(string const& id, type_info const& t) 
  { 
    if(! attr.insert(Attribute(id, t)).second) 
      cerr << "Registration Attribute \"" << id << "\" failed: an attribute of the same id has already registered.\n"; 
  }

  template<typename T>
  inline void Attributes :: Register(string const& id, T const&v)                      
  { 
    pair<set<Attribute>::iterator, bool> result = attr.insert(Attribute(id, typeid(T)));
    if(!result.second)
      cerr << "Registration Attribute \"" << id << "\" failed: an attribute of the same id has already registered.\n"; 
    else  
    {
      ((Attribute&)(*result.first)).SetValue(v); 
    }
    
  }

  inline Attribute& Attributes :: operator[](string const& id)
  {
    set<Attribute>::iterator itr = attr.find(Attribute(id)); 
    if(itr == attr.end())
      throw "attribute " + id + " unregistered.\n";
    return (Attribute&)(*itr);
  }


  typedef Attributes CommandLineArguments;
}//end namespace xchen



#endif

---