/scr/tee1/isis/lib/Core/CoreUtils/value.hpp

Go to the documentation of this file.

//
// C++ Interface: type
//
// Description:
//
//
// Author: Enrico Reimer<reimer@cbs.mpg.de>, (C) 2009
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef ISISTYPE_HPP
#define ISISTYPE_HPP

#include "value_base.hpp"

#include <string>
#include <functional>
#include <boost/type_traits/is_float.hpp>
#include <boost/type_traits/is_integral.hpp>

namespace isis
{
namespace util
{

template<class TYPE > class Value;

API_EXCLUDE_BEGIN
namespace _internal
{

template<typename T, bool isNumber> class type_compare
{
public:
    type_compare() {} // c++11 says we need a user defined constructor here
    bool operator()( const util::Value<T> &/*first*/, const ValueBase &/*second*/ )const {
        LOG( Debug, error ) << "comparison of " << util::Value<T>::staticName() << " is not supportet";
        return false;
    }
};

template<typename T> class type_compare<T, true>
{
protected:
    virtual bool posOverflow( const util::Value<T> &/*first*/, const util::Value<T> &/*second*/ )const {return false;} //default to false
    virtual bool negOverflow( const util::Value<T> &/*first*/, const util::Value<T> &/*second*/ )const {return false;} //default to false
    virtual bool inRange( const util::Value<T> &/*first*/, const util::Value<T> &/*second*/ )const {return false;} //default to false
public:
    bool operator()( const util::Value<T> &first, const ValueBase &second )const {
        // ask second for a converter from itself to Value<T>
        const ValueBase::Converter conv = second.getConverterTo( util::Value<T>::staticID );

        if ( conv ) {
            //try to convert second into T and handle results
            util::Value<T> buff;

            switch ( conv->convert( second, buff ) ) {
            case boost::numeric::cPosOverflow:
                LOG( Debug, info ) << "Positive overflow when converting " << second.toString( true ) << " to " << util::Value<T>::staticName() << ".";
                return posOverflow( first, buff );
            case boost::numeric::cNegOverflow:
                LOG( Debug, info ) << "Negative overflow when converting " << second.toString( true ) << " to " << util::Value<T>::staticName() << ".";
                return negOverflow( first, buff );
            case boost::numeric::cInRange:
                return inRange( first, buff );
            }
        } else {
            LOG( Debug, error ) << "No conversion of " << second.getTypeName() << " to " << util::Value<T>::staticName() << " available";
            return false;
        }

        return false;
    }
    type_compare() {} // c++11 says we need a user defined constructor here
    virtual ~type_compare() {}
};

template<typename T, bool isNumber> class type_less : public type_compare<T, isNumber>
{
public: // c++11 says we need a user defined constructor here
    type_less() {}
};// we are going to specialize this for numeric T below
template<typename T, bool isNumber> class type_greater : public type_compare<T, isNumber>
{
public: // c++11 says we need a user defined constructor here
    type_greater() {}
};
template<typename T, bool isNumber> class type_eq : public type_compare<T, isNumber>
{
protected:
    bool inRange( const util::Value<T> &first, const util::Value<T> &second )const {
        return static_cast<const T &>( first ) == static_cast<const T &>( second );
    }
public: // c++11 says we need a user defined constructor here
    type_eq() {}
};

template<typename T> class type_less<T, true> : public type_compare<T, true>
{
protected:
    bool posOverflow( const util::Value<T> &/*first*/, const util::Value<T> &/*second*/ )const {
        return true; //getting an positive overflow when trying to convert second into T, obviously means first is less
    }
    bool inRange( const util::Value<T> &first, const util::Value<T> &second )const {
        return static_cast<const T &>( first ) < static_cast<const T &>( second );
    }
public: // c++11 says we need a user defined constructor here
    type_less() {}
};

template<typename T> class type_greater<T, true> : public type_compare<T, true>
{
protected:
    bool negOverflow( const util::Value<T> &/*first*/, const util::Value<T> &/*second*/ )const {
        return true; //getting an negative overflow when trying to convert second into T, obviously means first is greater
    }
    bool inRange( const util::Value<T> &first, const util::Value<T> &second )const {
        return static_cast<const T &>( first ) > static_cast<const T &>( second );
    }
public: // c++11 says we need a user defined constructor here
    type_greater() {}
};

}
API_EXCLUDE_END

template<typename TYPE> class Value: public ValueBase
{
    TYPE m_val;
    static const char m_typeName[];
protected:
    ValueBase *clone() const {
        return new Value<TYPE>( *this );
    }
public:
    static const unsigned short staticID = _internal::TypeID<TYPE>::value;
    Value(): m_val() {
        BOOST_STATIC_ASSERT( staticID < 0xFF );
        checkType<TYPE>();
    }
    template<typename T> Value( const T &value ) {
        m_val = _internal::__cast_to<TYPE>()( this, value );
        BOOST_STATIC_ASSERT( staticID < 0xFF );
        checkType<TYPE>();
    }
    std::string toString( bool labeled = false )const {
        std::string ret;
        Reference ref = copyByID( Value<std::string>::staticID );

        if ( ref.isEmpty() ) {
            LOG( Debug, warning ) << "Automatic conversion of " << *this << " to string failed. Falling back to boost::lexical_cast<std::string>";
            ret = boost::lexical_cast<std::string>( m_val );
        } else {
            ret = ref->castTo<std::string>();
        }

        if ( labeled )ret += "(" + staticName() + ")";

        return ret;
    }

    std::string getTypeName()const {return staticName();}
    unsigned short getTypeID()const {return staticID;}
    bool isFloat() const {return boost::is_float< TYPE >::value;}
    bool isInteger() const {return boost::is_integral< TYPE >::value;}

    virtual bool operator==( const ValueBase &second )const {
        if ( second.is<TYPE>() ) {
            return m_val == second.castTo<TYPE>();
        } else
            return  false;
    }

    static std::string staticName() {return m_typeName;}

    operator const TYPE &()const {return m_val;}

    operator TYPE &() {return m_val;}

    bool gt( const ValueBase &ref )const {
        static const _internal::type_greater<TYPE, boost::is_arithmetic<TYPE>::value > greater;
        return greater.operator()( *this, ref );
    }

    bool lt( const ValueBase &ref )const {
        static const _internal::type_less<TYPE, boost::is_arithmetic<TYPE>::value > less;
        return less( *this, ref );
    }

    bool eq( const ValueBase &ref )const {
        static const _internal::type_eq<TYPE, boost::is_arithmetic<TYPE>::value > equal;
        return equal( *this, ref );
    }

    virtual ~Value() {}
};

template<typename T> const util::Value<T>& ValueBase::castToType() const
{
    checkType<T>();
    return m_cast_to<util::Value<T> >();
}
template<typename T> const T &ValueBase::castTo() const
{
    const util::Value<T> &ret = castToType<T>();
    return ret.operator const T & ();
}
template<typename T> util::Value<T>& ValueBase::castToType()
{
    checkType<T>();
    return m_cast_to<util::Value<T> >();
}
template<typename T> T &ValueBase::castTo()
{
    util::Value<T> &ret = castToType<T>();
    return ret.operator T & ();
}

template<typename T> bool ValueBase::is()const
{
    checkType<T>();
    return getTypeID() == util::Value<T>::staticID;
}

}
}

#endif //DATATYPE_INC