---

env.h

Go to the documentation of this file.

#ifndef DV_UTIL_ENV_H
#define DV_UTIL_ENV_H
// $Id: env.h,v 1.8 2002/10/20 13:19:22 dvermeir Exp $
#include <string>
#include <stdexcept>
#include <iostream>
#include <map>
#include <list>
#include <vector>
#include <iterator>
#include <dvutil/tostring.h>
#include <dvutil/props.h>
#include "noconst.h"

namespace Dv {
namespace Util {
class Env {
public:
  class Exception: public std::runtime_error {
  public:
    static const std::string NAME;
    Exception(const std::string& msg): std::runtime_error(NAME + ": " + msg) {}
  };

  Env();
  Env(const Env& e);
  Env(std::istream& is) throw (Exception);
  Env(const std::string& fn) throw (Exception);

  ~Env();

  class iterator;


  const std::string& svalue() const throw (Exception);
  std::string& slvalue() throw (Exception);

  template<typename T> 
  operator T() const throw (Exception) {
    typename noconst<T>::mutable_type t;
    if (!Dv::Util::fromstring(t,svalue()))
      throw Exception(svalue() + ": cannot convert");
    return t;
    }

  template<typename T> 
  operator T*() const throw (Exception) { 
    throw Exception(svalue() + ": cannot convert fo T*");
    return 0; }

  operator const char*() const throw (Exception) { 
    return svalue().c_str();
    }

  operator const std::string&() const throw (Exception) { return svalue(); }
  operator std::string&() throw (Exception) { return slvalue(); }

  bool defined() const { return box_ != 0; }

  enum Type { NIL ,
              STRING , 
              MAP ,
              ARRAY 
              };
  Type type() const;

  static const char* type_s(Type t);

  bool is_string() const { return type() == STRING; }
  bool is_array() const { return type() == ARRAY; }
  bool is_map() const { return type() == MAP; }
  
  static const Env& nil();

  Env& operator[](int i) throw (Exception);
  const Env& operator()(int i) const throw (Exception);

  Env& operator[](const std::string& s) throw (Exception);
  const Env& operator()(const std::string& s) const throw (Exception);

  template<typename T>
  Env& operator=(const T& t) { 
        if (this!=&nil())
          slvalue() = Dv::Util::tostring(t);
        return *this;
        }

  Env& operator=(const std::string& s);

  Env& operator=(const Env& e);

  Env& clear() { return *this = nil(); }
  Env& merge(const Env& e);

  size_t size() const;

  template<typename T>
  bool
  operator==(const T& t) const {
  return static_cast<T>(*this) == t;
  }

  bool
  operator==(const std::string& s) const {
  return svalue() == s;
  }

  bool
  operator==(const Env& e) const;

  template<typename T>
  bool
  operator!=(const T& t) const {
  return ! (*this == t);
  }

  const Env& substitute(std::ostream& os, std::istream& is) const throw (Exception);

  const Env& substitute(std::string& out, const std::string& ins) const throw (Exception);


  std::ostream& print(std::ostream& os, const std::string& prefix = "") const;

  Env& read_key(const std::string& s) throw (Exception);
  static bool explode(const std::string& index, std::vector<std::string>& keys);

  class Display {
  public:
    Display(const Env& e);
    Display(const Display& d);
    size_t size() const { return envs_.size(); }
    const Env* top() const { return envs_.front(); }
    Display& push(const std::string& key);
    Display& pop();
    const Env* operator()(const std::string& key) const;
    const Env* operator()(const std::vector<std::string>& keys) const;
    Display& expand(const std::vector<std::string>& keys);
    void substitute(std::ostream& os, std::istream& is) const throw (Exception);
    std::ostream& print(std::ostream& os) const;
  private:
    std::list<const Env*> envs_;
    std::list<std::string> names_;
  };

  const Env* access(const std::string& key) const;
  // const Env* access(const std::vector<std::string>& keys, size_t i = 0 ) const;

  Env& read(std::istream& is) throw (Dv::Util::Env::Exception);

protected:

  class SBox;
  class MBox;
  class ABox;

  class Box {
  public:
    class iterator {
    public:
      typedef std::map<std::string,const Env*>::iterator::value_type value_type;
      virtual iterator& operator++();
      virtual value_type operator*() const;
      virtual bool equal(const iterator* i) const;
    };

    Type type() const;

    virtual iterator* begin() const throw (Exception);
    virtual iterator* end() const throw (Exception);

    operator std::string&() throw (Exception) { return slvalue(); }
    operator const std::string&() const throw (Exception) { return svalue(); }

    virtual const std::string& svalue() const throw (Exception);
    virtual std::string& slvalue() throw (Exception);

    virtual Env* operator[](int i) throw (Exception);
    virtual const Env* operator()(int i) const throw (Exception);

    virtual Env* operator[](const std::string& s) throw (Exception);
    virtual const Env* operator()(const std::string& s) const throw (Exception);
    virtual ~Box();
  };

public:
  class iterator {
  public:
    typedef Box::iterator::value_type value_type;
    iterator(Box::iterator* it): it_(it) {}
    ~iterator() { delete it_; }
    iterator& operator++() { ++*it_; return *this; }
    value_type operator*() const;
    bool operator==(const iterator& i) const { 
      return ( it_ == i.it_ ? true : it_->equal(i.it_) ); }
    bool operator!=(const iterator& i) const { return ! (*this == i); }
  private:
    Box::iterator*      it_;
  };

  iterator begin() const;
  iterator end() const;

protected:

  class SBox: public Box {
  public:
    virtual const std::string& svalue() const throw (Exception) { return s_; }
    virtual std::string& slvalue() throw (Exception) { return s_; }
  private:
    std::string s_;
  };

  class MBox: public Box {
  public:
    typedef std::map<std::string, Env*> Map;

    class iterator: public Box::iterator {
    public:
      iterator(Map::const_iterator it): it_(it) {}
      iterator& operator++() { ++it_; return *this; }
      value_type operator*() const { return *it_; }
      bool equal(const Box::iterator* i) const;
    private:
      Map::const_iterator it_;
    };

    iterator* begin() const throw (Exception) { return new iterator(m_.begin()); }
    iterator* end() const throw (Exception) { return new iterator(m_.end()); }

    MBox();
    ~MBox();

    size_t size() const { return m_.size(); }
    Env* operator[](const std::string& s) throw (Exception);
    const Env* operator()(const std::string& s) const throw (Exception);
  private:
    Map m_;
  };

  class ABox: public Box {
  public:
    typedef std::vector<Env*> Vector;

    class iterator: public Box::iterator {
    public:
      iterator(Vector::const_iterator it, const Vector* v);
      iterator& operator++() { ++it_; return *this; }
      value_type operator*() const;
      bool equal(const Box::iterator* i) const;
    private:
      Vector::const_iterator it_;
      const Vector* const v_;
    };

    iterator* begin() const throw (Exception) { return new iterator(a_.begin(), &a_); }
    iterator* end() const throw (Exception) { return new iterator(a_.end(), &a_); }

    ABox(size_t size);
    ~ABox();
    size_t size() const { return a_.size(); }
    Env* operator[](int i) throw (Exception);
    const Env* operator()(int i) const throw (Exception);
  private:
    Vector a_;
  };


private:
  Box*  box_;
};

}}

namespace std {
std::ostream&
operator<<(std::ostream& os, const Dv::Util::Env& e);
std::istream&
operator>>(std::istream& is, Dv::Util::Env& e) throw (Dv::Util::Env::Exception);

inline std::ostream&
operator<<(std::ostream& os, const Dv::Util::Env::Display& d) {
return d.print(os);
}
}
#endif

---

dvenv-0.2.2

[20 October, 2002]