variable.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// 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 3 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, see <http://www.gnu.org/licenses/>.
#ifndef __VARIABLE_HH
# define __VARIABLE_HH

# include "pattern.hh"
# include <memory>
# include <stack>
# include "../lists/listable.hh"

namespace aurelia {

  template <typename T>
  struct variable {
  private:
    std::shared_ptr<std::stack<std::auto_ptr<T> > > value;

  public:

    variable(): value(new std::stack<std::auto_ptr<T> >()) {
      value->push(std::auto_ptr<T>(NULL));
    }

    variable(const variable& v): value(v.value) {
    }

    variable(const T& v): value(new std::stack<std::auto_ptr<T> >()) {
      value->push(std::auto_ptr<T>(new T(v)));
    }

    void push() const {
      value->push(std::auto_ptr<T>(NULL));
    }

    void pop() const {
      value->pop();
    }

    bool has_value() const {
      return value->top().get() != NULL;
    }

    const T& operator*() const {
      if (!has_value())
        throw failure();
      return *(value->top());
    }

    const T& operator=(const T& c) {
      if (has_value()) {
        if (c != *(value->top()))
          throw failure();
        return *(value->top());
      }
      value->top().reset(new T(c));
      return *(value->top());
    }

    void reset() const {
      value->top().release();
      value->top().reset(NULL);
    }

  };

  template <typename T>
  struct pattern_model<variable<T> > {
    struct model {
      typedef variable<T> type;
      typedef T build_type;
    };
  };

  template <typename T>
  struct listable_model<variable<T> > {
    struct model {
      typedef variable<T> type;
    };
  };

}

#endif