src/tools/values/vebLegacy.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_vebLegacy_h
#define ARMAGETRON_vebLegacy_h

#include "values/vCore.h"

class tConfItemBase;

namespace vValue {
namespace Expr {
namespace Bindings {
namespace Legacy {

template<typename T> class Callback : public Base {
public:
    typedef boost::shared_ptr<Base> (T::*cb_ptr)(void); 
private:
    cb_ptr m_value; 
    T *m_cockpit; 
public:
    Callback(cb_ptr value, T *hud); 
    Callback(Callback const &other); 

    void operator=(Callback const &other); 
    Base *copy(void) const;
    virtual ~Callback() { };

    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> Callback<T>::Callback(cb_ptr value, T *hud):
        Base(),
        m_value(value),
        m_cockpit(hud)
{ }

template<typename T> Callback<T>::Callback(Callback const &other):
        Base(other),
        m_value(other.m_value),
        m_cockpit(other.m_cockpit)
{ }

template<typename T> Base *Callback<T>::copy(void) const {
    return new Callback(*this);
}

template<typename T> void Callback<T>::operator=(Callback const &other) {
    this->Base::operator=(other);
    m_value=other.m_value;
    m_cockpit=other.m_cockpit;
}

template<typename T> Variant Callback<T>::GetValue() const {
    return (m_cockpit->*m_value)()->GetValue();
}

template<typename T> tString Callback<T>::GetString(Base const *other) const {
    return (m_cockpit->*m_value)()->GetString(other == 0 ? this : other);
}

template<typename T> int Callback<T>::GetInt(void) const {
    return (m_cockpit->*m_value)()->GetInt();
}

template<typename T> float Callback<T>::GetFloat(void) const {
    return (m_cockpit->*m_value)()->GetFloat();
}

template<typename T> bool Callback<T>::operator==(Base const &other) const { return *(m_cockpit->*m_value)() == other; }
template<typename T> bool Callback<T>::operator!=(Base const &other) const { return *(m_cockpit->*m_value)() != other; }
template<typename T> bool Callback<T>::operator>=(Base const &other) const { return *(m_cockpit->*m_value)() >= other; }
template<typename T> bool Callback<T>::operator<=(Base const &other) const { return *(m_cockpit->*m_value)() <= other; }
template<typename T> bool Callback<T>::operator> (Base const &other) const { return *(m_cockpit->*m_value)() >  other; }
template<typename T> bool Callback<T>::operator< (Base const &other) const { return *(m_cockpit->*m_value)() <  other; }

//TODO: Find a better solution for this, this is a bit slow.

class ConfItem : public Base {
    tConfItemBase *m_value; 
    tString Read() const; 
public:
    ConfItem(tString const &value); 
    ConfItem(ConfItem const &other); 
    void operator=(ConfItem const &other); 

    bool Good() const; 

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

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

}
}
}
}

#endif

---