variables.hpp

/*
 * variables.hpp
 *
 * Created on: 1 Jul 2011
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek 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.
 *
 * Schnek 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 Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_VARIABLES_HPP_
#define SCHNEK_VARIABLES_HPP_

#include "types.hpp"
#include "../exception.hpp"
#include "../util/unique.hpp"

#include <list>
#include <map>
#include <string>
#include <memory>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#include <boost/variant.hpp>

#pragma GCC diagnostic pop

namespace schnek {

class BlockVariables;
typedef std::shared_ptr<BlockVariables> pBlockVariables;
typedef std::list<pBlockVariables> BlockVariablesList;

class Variable
{
  public:
    enum VariableTypeInfo {int_type, float_type, string_type};

    typedef ExpressionVariant ExpressionType;

  private:
    ExpressionType expression;
    ValueVariant var;
    VariableTypeInfo type;
    bool fixed;
    bool initialised;
    bool readonly;
    std::shared_ptr< Unique<Variable> > uniqueId;
  public:
    Variable(int value, bool initialised_ = true, bool readonly_ = false);
    Variable(double value, bool initialised_ = true, bool readonly_ = false);
    Variable(std::string value, bool initialised_ = true, bool readonly_ = false);
    Variable(pIntExpression expr, bool initialised_ = true, bool readonly_ = false);
    Variable(pFloatExpression expr, bool initialised_ = true, bool readonly_ = false);
    Variable(pStringExpression expr, bool initialised_ = true, bool readonly_ = false);

    Variable(const Variable &var);
    Variable &operator=(const Variable &var);

    VariableTypeInfo getType() {return type;}
    ValueVariant getValue() {return var;}
    const ExpressionVariant &getExpression() {return expression;}
    const ValueVariant &evaluateExpression();

    bool isConstant() {return fixed;}

    bool isReadOnly() {return readonly;}

    bool isInitialised() {return initialised;}

    /* Returns the id of the variable
     *
     * A unique id is created when a Variable is created with a value or an expression.
     * When one Variable is copied to another, either by the copy constructor or the assignement operator,
     * the id is copied as well.
     *
     * Thus, the id is not unique across all variables but is an id that identifies <strong>different</strong>
     * variables.
     */
    long getId() { return uniqueId->getId(); }

    const ValueVariant &evaluate() { if (!isConstant()) evaluateExpression(); return var; }
};

typedef std::shared_ptr<Variable> pVariable;
typedef std::list<pVariable> VariableList;
typedef std::map<std::string, pVariable> VariableMap;

class BlockVariables
{
  private:
    std::string name;
    std::string className;
    pBlockVariables parent;
    BlockVariablesList children;

    VariableMap vars;

    typedef std::map<std::string, pBlockVariables> BlockVariablesMap;
    typedef std::map<std::string, BlockVariablesList> BlockVariablesListMap;
    BlockVariablesMap childrenByName;
    BlockVariablesListMap childrenByClassName;

    bool exists(std::list<std::string> path, bool upward);

    pVariable getVariable(std::list<std::string> path, bool upward);
  public:
    BlockVariables(std::string name_, std::string className_, pBlockVariables parent_)
        : name(name_), className(className_), parent(parent_)
    {}

    bool exists(std::string name);

    pVariable getVariable(std::string name);

    bool addVariable(std::string name, pVariable variable);

    bool addChild(pBlockVariables child);

    std::string getBlockName() { return name; }
    std::string getClassName() { return className; }
    pBlockVariables getParent() { return parent; }
    const BlockVariablesList& getChildren() { return children; }

    const VariableMap& getVariables() { return vars; }
};

class VariableStorage
{
  private:
    pBlockVariables root;
    pBlockVariables cursor;
  public:
    VariableStorage() {}
    VariableStorage(std::string name, std::string classname);
    VariableStorage(const VariableStorage& storage)
      : root(storage.root), cursor(storage.cursor) {}

    void resetCursor();

    void cursorUp();

    void addVariable(std::string name, pVariable variable);

    pBlockVariables createBlock(std::string name, std::string classname);

    pBlockVariables getRootBlock() { return root; }
    pBlockVariables getCurrentBlock() { return cursor; }
};

} // namespace

#endif // SCHNEK_VARIABLES_HPP_