---

prop_registry.hh

Go to the documentation of this file.

/*
 *  File:       cucu.c
 *              $Id: prop_registry.hh,v 1.4 2002/06/26 20:49:47 alec Exp $
 *
 *  Author:     Alec Panoviciu (alecu@email.com)
 *
 *  Comments:
 *
 *  Revision history:
 *
 *  $Log: prop_registry.hh,v $
 *  Revision 1.4  2002/06/26 20:49:47  alec
 *  g++ 3.x happy
 *
 *  Revision 1.3  2002/06/23 23:29:33  alec
 *  profile-based optimization stuff
 *
 *  Revision 1.2  2002/04/29 09:34:10  alec
 *  scanner ptree building compiles
 *
 */

/* 
  Copyright (C) 2002 Alexandru Panoviciu (alecu@email.com)

  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; either version 2 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */


#ifndef __PROP_REGISTRY_HH__
#define __PROP_REGISTRY_HH__

#include <string>
#include <vector>
#include <exception>
#include <typeinfo>
#include <map>
using namespace std;

#include "debug.h"


class PropRegistry
{
public:
  
  class PropData
  {
  public:

    enum {k_string, k_bool, k_int, k_float, k_undef} tag;

    vector<string> s;
    vector<bool> b;
    vector<int> i;
    vector<float> f;

    PropData () : tag(k_undef) {}
    
    PropData (const PropData &o) :
      tag(o.tag), s(o.s), b(o.b), i(o.i), f(o.f)
    {}

    PropData& operator = (const PropData &o)
    {
      if (this  == &o) return *this;
      tag = o.tag;
      s = o.s;
      b = o.b;
      i = o.i;
      f = o.f;
    }


    explicit PropData (const char *s_) :
      tag(k_string), s(1, string(s_))
    {}
    
    explicit PropData (const string &s_) :
      tag(k_string), s(1, s_)
    {}

    explicit PropData (const vector<string> &s_) :
      tag(k_string), s(s_)
    {}

    explicit PropData (const bool b_) :
      tag(k_bool), b(1, b_)
    {}

    explicit PropData (const vector<bool> &b_) :
      tag(k_bool), b(b_)
    {}
    
    explicit PropData (const int i_) :
      tag(k_int), i(1, i_)
    {}

    explicit PropData (const vector<int> &i_) :
      tag(k_int), i(i_)
    {}
    
    explicit PropData (const float f_) :
      tag(k_float), f(1, f_)
    {}

    explicit PropData (const vector<float> &f_) :
      tag(k_float), f(f_)
    {}

    PropData& operator = (const char *s_)
    {
      return *this = PropData(s_);
    }

    PropData& operator = (const string &s_)
    {
      return *this = PropData(s_);
    }

    PropData& operator = (const bool b_)
    {
      return *this = PropData(b_);
    }

    PropData& operator = (const vector<bool> &b_)
    {
      return *this = PropData(b_);
    }

    PropData& operator = (const int i_)
    {
      return *this = PropData(i_);
    }

    PropData& operator = (const vector<int> &i_)
    {
      return *this = PropData(i_);
    }

    PropData& operator = (const float f_)
    {
      return *this = PropData(f_);
    }

    PropData& operator = (const vector<float> &f_)
    {
      return *this = PropData(f_);
    }

    operator string () throw (bad_cast)
    {
      if ((tag != k_string) || (s.size() != 1)) throw bad_cast();
      return s[0];
    }

    operator vector<string>& () throw (bad_cast)
    {
      if (tag != k_string) throw bad_cast();
      return s;
    }

    operator bool () throw (bad_cast)
    {
      if ((tag != k_bool) || (b.size() != 1)) throw bad_cast();
      return b[0];
    }

    operator vector<bool>& () throw (bad_cast)
    {
      if (tag != k_bool) throw bad_cast();
      return b;
    }

    operator int () throw (bad_cast)
    {
      if ((tag != k_int) || (i.size() != 1)) throw bad_cast();
      return i[0];
    }

    operator vector<int>& () throw (bad_cast)
    {
      if (tag != k_int) throw bad_cast();
      return i;
    }

    operator float () throw (bad_cast)
    {
      if ((tag != k_float) || (i.size() != 1)) throw bad_cast();
      return f[0];
    }

    operator vector<float>& () throw (bad_cast)
    {
      if (tag != k_float) throw bad_cast();
      return f;
    }

    PropData& operator << (const PropData &o) throw (bad_cast);

    PropData& operator << (const string &o) throw (bad_cast)
    {
      return *this << PropData(o);
    }
    
    PropData& operator << (const int &o) throw (bad_cast)
    {
      return *this << PropData(o);
    }
    
    PropData& operator << (const float &o) throw (bad_cast)
    {
      return *this << PropData(o);
    }
    
    PropData& operator << (const bool &o) throw (bad_cast)
    {
      return *this << PropData(o);
    }

    PropData& operator << (const char *o) throw (bad_cast)
    {
      return *this << PropData(o);
    }

  };
    
  bool contains (const string &key) const
  {
    return data.find(key) != data.end();
  }

  bool empty () const
  {
    return data.empty();
  }

  typedef map<string, PropData, less<string> > StorageType;

  typedef StorageType::iterator iterator;
  typedef StorageType::const_iterator const_iterator;

  iterator begin ()
  {
    return data.begin();
  }

  iterator end ()
  {
    return data.end();
  }

  const_iterator begin () const
  {
    return data.begin();
  }

  const_iterator end () const
  {
    return data.end();
  }

  PropData& operator [] (const string &key)
  {
    return data[key];
  }

private:

  StorageType data;

};


inline string operator + (const string &a, PropRegistry::PropData &b)
{
  return a + (string) b;
}

inline int operator + (const int &a, PropRegistry::PropData &b)
{
  return a + (int) b;
}

inline bool operator + (const bool &a, PropRegistry::PropData &b)
{
  return a + (bool) b;
}

inline float operator + (const float &a, PropRegistry::PropData &b)
{
  return a + (float) b;
}


inline string operator + (PropRegistry::PropData &b, const string &a)
{
  return a + (string) b;
}

inline int operator + (PropRegistry::PropData &b, const int &a)
{
  return a + (int) b;
}

inline bool operator + (PropRegistry::PropData &b, const bool &a)
{
  return a + (bool) b;
}

inline float operator + (PropRegistry::PropData &b, const float &a)
{
  return a + (float) b;
}


ostream& operator << (ostream &os, const PropRegistry::PropData &o);

ostream& operator << (ostream &os, const PropRegistry  &o);

ostream& operator >> (ostream &os, PropRegistry::PropData &o);

ostream& operator >> (ostream &os, PropRegistry &o);


#endif /* #ifndef __PROP_REGISTRY_HH__ */

---