var_map.h

#ifndef SCIL_VAR_MAP_H
#define SCIL_VAR_MAP_H

#include<scil/variable.h>
#include<scil/row.h>
#include<map>

namespace SCIL {

template<class A>
class scil_map {
  public:

  virtual
  row& operator()(const A&)=0;

  virtual ~scil_map() {};
};

template<class A>
class var_map : public scil_map<A> {
  private:

  std::map<A, var> AV;

 public:

  var_map() { };

  const
  var operator[](const A& a) const {
    /*{\Marrop returns a proxy to the enrty of |a|. If the proxy class is 
      used as rvalue, |inf(a)| is returned. If the proxy class is used as a
      lvalue with right-hand-side $v$, |set(a,v)| is called.}*/
    return AV[a];
  };

  var& operator[](const A& a) {
    return AV[a];
  };

  row& operator()(const A& a) {
    row* r=new row(AV[a]);
    return *r;
  };

  virtual
  ~var_map() {};
};

template<class A, class B>
  class var_map2 : public std::map<A, var_map<B> > {
};

template<class A>
class row_map : public scil_map<A> {
  private:

  std::map<A, row> AV;

 public:

  row_map() { };

  const
  row operator[](const A& a) const {
    /*{\Marrop returns a proxy to the enrty of |a|. If the proxy class is 
      used as rvalue, |inf(a)| is returned. If the proxy class is used as a
      lvalue with right-hand-side $v$, |set(a,v)| is called.}*/
    std::cout<<"hisd\n";
    return AV[a];
  };

  row& operator[](const A& a) {
    return AV[a];
  };

  row& operator()(const A& a) {
    return AV[a];
  };

  //FIXME virtual destructor
  virtual
  ~row_map() {};
};

template<class A, class B>
  class row_map2 : public std::map<A, row_map<B> > {
};

}

#endif

---