src/tools/values/vCore.cpp

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.

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

*/

#include <boost/lexical_cast.hpp>

#include "vCore.h"

namespace vValue {
namespace Expr {
namespace Core {

Base::Base(int precision, int minsize, char fill):
        m_precision(precision),
        m_minsize(minsize),
        m_fill(fill)
{}

Base::Base(Base const &other) :
        m_precision(other.m_precision),
        m_minsize(other.m_minsize),
        m_fill(other.m_fill)
{ }

void Base::SetPrecision(int precision) {
    m_precision = precision;
}

void Base::SetMinsize(int minsize) {
    m_minsize = minsize;
}

void Base::SetFill(char fill) {
    m_fill = fill;
}

Variant
Base::GetValue(void) const {
    //std::cerr << "WARNING: Base::GetValue called!" << std::endl;
    return std::string("");
}
template<> Variant Base::Get<Variant>() const { return GetValue(); }

int Base::GetInt(void) const {
    try {
        return boost::lexical_cast<int>(GetValue());
    }
    catch(boost::bad_lexical_cast &)
    {
        return 0;
    }
}
template<> int     Base::Get<int    >() const { return GetInt(); }

float Base::GetFloat(void) const {
    try {
        return boost::lexical_cast<float>(GetValue());
    }
    catch(boost::bad_lexical_cast &)
    {
        return 0.0;
    }
}
template<> float   Base::Get<float  >() const { return GetFloat(); }

tString Base::GetString(Base const *other) const {
    Variant v = GetValue();
    if (tString *iptr = boost::get<tString>(&v))
            return *iptr;
    return Output(v, other);
}
template<> tString Base::Get<tString>() const { return GetString(); }

Base *Base::copy(void) const {
    return new Base();
}

bool Base::operator==(Base const &other) const { return false; }
bool Base::operator!=(Base const &other) const { return true;  }
bool Base::operator>=(Base const &other) const { return false; }
bool Base::operator<=(Base const &other) const { return false; }
bool Base::operator> (Base const &other) const { return false; }
bool Base::operator< (Base const &other) const { return false; }

}
}
namespace Type {

Set::Set() : 
        m_min(new Expr::Base()),
        m_max(new Expr::Base()),
        m_val(new Expr::Base())
{}

Set::Set(BasePtr &val) : 
        m_min(new Expr::Base()),
        m_max(new Expr::Base()),
        m_val(val)
{}

Set::Set(BasePtr &val, BasePtr &min, BasePtr &max) : 
        m_min(min),
        m_max(max),
        m_val(val)
{}

Set::Set(Set const &other) :
        m_min(other.m_min),
        m_max(other.m_max),
        m_val(other.m_val)
{}

Set::~Set() {
}

void Set::operator=(Set const &other) {
    if(this != &other) {
        m_min = BasePtr(other.GetMin().copy());
        m_max = BasePtr(other.GetMax().copy());
        m_val = BasePtr(other.GetVal().copy());
    }
}

}
namespace Expr {
namespace Core {

String::String(tString value):
        m_value(value)
{ }

String::String(char const *value):
        m_value(tString(value))
{ }

String::String(Base const &other):
        Base(other),
        m_value(other.GetString())
{ }

Base *String::copy(void) const {
    return new String(*this);
}

Variant String::GetValue() const {
    return GetString();
}

tString String::GetString(Base const *other) const {
    return Output(m_value, other);
}

bool String::operator==(Base const &other) const { return m_value == static_cast<tString>(other); }
bool String::operator!=(Base const &other) const { return m_value !=  static_cast<tString>(other); }
bool String::operator>=(Base const &other) const { return m_value >=  static_cast<tString>(other); }
bool String::operator<=(Base const &other) const { return m_value <=  static_cast<tString>(other); }
bool String::operator> (Base const &other) const { return m_value >   static_cast<tString>(other); }
bool String::operator< (Base const &other) const { return m_value <   static_cast<tString>(other); }


UnaryOp::UnaryOp(BasePtr value) :
        m_value(value    )
{ }

UnaryOp::UnaryOp(UnaryOp const &other) :
        Base (other         ),
        m_value(other.m_value->copy())
{ }

Base *UnaryOp::copy(void) const {
    return new UnaryOp(*this);
}

BinaryOp::BinaryOp(BasePtr lvalue, BasePtr rvalue) :
        m_lvalue(lvalue    ),
        m_rvalue(rvalue    )
{ }

BinaryOp::BinaryOp(BinaryOp const &other) :
        Base (other         ),
        m_lvalue(other.m_lvalue->copy()),
        m_rvalue(other.m_rvalue->copy())
{ }

Base *BinaryOp::copy(void) const {
    return new BinaryOp(*this);
}

}
}
}

---