src/tools/values/vCore.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************************

*/


#ifndef ARMAGETRON_vCore_h
#define ARMAGETRON_vCore_h

#include "tString.h"
#include <deque>
#include <iomanip>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>

namespace vValue {
namespace Expr {
namespace Core {
class Base;
}
}
namespace Type {
typedef boost::shared_ptr<Expr::Core::Base> BasePtr; 

typedef boost::variant<int, float, std::string> Variant;
typedef std::deque<BasePtr> arglist;
}
using namespace Type;

namespace Expr {
namespace Core {
class Base {
    int m_precision; 
    int m_minsize;   
    char m_fill;     
protected:
    template<typename T> inline tString Output(T value, Base const *other=0) const;
    //template<typename T> inline T VariantConvert(Variant const) const;
public:
    Base(int precision=1, int minsize=0, char fill='0'); 
    Base(Base const &other); 
    virtual ~Base() { };

    virtual Base *copy(void) const; 

    virtual int GetInt(void) const; 
    virtual float GetFloat(void) const; 
    virtual tString GetString(Base const *other=0) const; 
    virtual Variant GetValue(void) const; 

    template<class T> T Get() const;

    void SetPrecision(int precision); 
    void SetMinsize(int size); 
    void SetFill(char fill); 

    operator int() const { return GetInt(); }
    operator float() const { return GetFloat(); }
    operator tString() const { return GetString(); }

    virtual bool operator==(Base const &other) const; 
    virtual bool operator!=(Base const &other) const; 
    virtual bool operator>=(Base const &other) const; 
    virtual bool operator<=(Base const &other) const; 
    virtual bool operator> (Base const &other) const; 
    virtual bool operator< (Base const &other) const; 
};

template<typename T> inline tString Base::Output(T value, Base const *other) const {
    if (other==0) other=this;
    std::ostringstream buf("");
    buf << std::setfill(other->m_fill) << std::setw(other->m_minsize) << std::fixed << std::setprecision(other->m_precision) << value; return buf.str();
}

/*
template<typename T> inline T Base::VariantConvert(Variant v) const {
        if (T *ptr = boost::get<T>(v))
                return *ptr;
        std::stringstream stream("");
        stream << v;
        T i;
        stream >> i;
    return i;
}
*/

}
}
namespace Type {

class Set {
    BasePtr m_min; 
    BasePtr m_max; 
    BasePtr m_val; 
public:
    /*
    Set(Base *val = new Base,
        Base *min = new Base,
        Base *max = new Base); //!< Default constructor
    */
    Set(); 
    Set(BasePtr &val); 
    Set(BasePtr &val, BasePtr &min, BasePtr &max); 
    //    Set(BasePtr &val = BasePtr(), BasePtr &min = BasePtr(), BasePtr &max = BasePtr()); //!< Constructor using std::auto_ptr
    Set(const Set &other); 
    ~Set(); 
    void operator=(Set const &other); 
    Expr::Core::
    Base const &GetMin(void) const {return *m_min;} 
    Expr::Core::
    Base const &GetMax(void) const {return *m_max;} 
    Expr::Core::
    Base const &GetVal(void) const {return *m_val;} 
};
}
namespace Expr {
namespace Core {

template<typename T> class Number : public Base {
    T m_value; 
public:
    Number(T value); 
    Number(Base const &other); 
    /*
    Number(BaseExt const &other); //!< Copy constructor
    */
    virtual ~Number() { };

    Base *copy(void) const;

    virtual Variant GetValue(void) const; 
    virtual int GetInt(void) const; 
    virtual float GetFloat(void) const; 
    virtual tString GetString(Base const *other=0) const; 

    bool operator==(Base const &other) const;
    bool operator!=(Base const &other) const;
    bool operator>=(Base const &other) const;
    bool operator<=(Base const &other) const;
    bool operator> (Base const &other) const;
    bool operator< (Base const &other) const;
};

template<typename T> Number<T>::Number(T value):
        Base(),
        m_value(value)
{ }

template<typename T> Number<T>::Number(Base const &other):
        Base(other), // TODO: check if Base or BaseExt goes here
        m_value(static_cast<T>(other))
{ }

/*
template<typename T> Number<T>::Number(BaseExt const &other):
        BaseExt(other),
        m_value(static_cast<T>(other))
{ }
*/

// TODO: Changed from Number<T> * to Base*
template<typename T> Base *Number<T>::copy(void) const {
    return new Number(*this);
}

template<typename T> Variant Number<T>::GetValue(void) const {
    return static_cast<T>(m_value);
}

template<typename T> int Number<T>::GetInt(void) const {
    return static_cast<int>(m_value);
}

template<typename T> float Number<T>::GetFloat(void) const {
    return static_cast<float>(m_value);
}

template<typename T> tString Number<T>::GetString(Base const *other) const {
    return Output(m_value, other);
}

template<typename T> bool Number<T>::operator==(Base const &other) const {
    return m_value == static_cast<T>(other);
}
template<typename T> bool Number<T>::operator!=(Base const &other) const {
    return m_value != static_cast<T>(other);
}
template<typename T> bool Number<T>::operator>=(Base const &other) const {
    return m_value >= static_cast<T>(other);
}
template<typename T> bool Number<T>::operator<=(Base const &other) const {
    return m_value <= static_cast<T>(other);
}
template<typename T> bool Number<T>::operator> (Base const &other) const {
    return m_value > static_cast<T>(other);
}
template<typename T> bool Number<T>::operator< (Base const &other) const {
    return m_value < static_cast<T>(other);
}

typedef Number<float> Float;
typedef Number<int> Int;

class String : public Base {
    tString m_value; 
public:
    String(tString value); 
    String(char const *value); 
    String(Base const &other); 

    Base *copy(void) const;
    virtual ~String() { };

    virtual Variant GetValue(void) const; 
    virtual tString GetString(Base const *other=0) const;

    bool operator==(Base const &other) const;
    bool operator!=(Base const &other) const;
    bool operator>=(Base const &other) const;
    bool operator<=(Base const &other) const;
    bool operator> (Base const &other) const;
    bool operator< (Base const &other) const;
};

class UnaryOp : public Base {
protected:
    BasePtr m_value; 
public:
    UnaryOp(BasePtr value); 
    UnaryOp(UnaryOp const &other); 
    virtual Base *copy(void) const; 
};

#define DeclStdUnaryOp(classname)       \
class classname : public UnaryOp {      \
public: \
    classname(BasePtr value) : UnaryOp(value) {}; \
    classname(UnaryOp const &other) : UnaryOp(other) {}; \
    virtual Variant GetValue(void) const; \
    virtual Base *copy(void) const; \
};

class BinaryOp : public Base {
protected:
    BasePtr m_lvalue; 
    BasePtr m_rvalue; 
public:
    BinaryOp(BasePtr lvalue, BasePtr rvalue); 
    BinaryOp(BinaryOp const &other); 
    virtual Base *copy(void) const; 
};

#define DeclStdBinaryOp(classname)      \
class classname : public BinaryOp {     \
public: \
    classname(BasePtr lvalue, BasePtr rvalue) : BinaryOp(lvalue, rvalue) {}; \
    classname(BinaryOp const &other) : BinaryOp(other) {}; \
    virtual Variant GetValue(void) const; \
    virtual Base *copy(void) const; \
};

}
using namespace Core;
}

template<typename C> class Creator {
public:
    static Expr::Base *create() {
        return new C();
    }
    template<typename T> static Expr::Base *create(T t) {
        return new C(t);
    }
    template<typename T, typename U> static Expr::Base *create(T t, U u) {
        return new C(t, u);
    }
    template<typename T, typename U, typename V> static Expr::Base *create(T t, U u, V v) {
        return new C(t, u, v);
    }
    template<typename T, typename U, typename V, typename W> static Expr::Base *create(T t, U u, V v, W w) {
        return new C(t, u, v, w);
    }
    template<typename T, typename U, typename V, typename W, typename X> static Expr::Base *create(T t, U u, V v, W w, X x) {
        return new C(t, u, v, w, x);
    }
};


using namespace Type;
}

#endif

---