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

Go to the documentation of this file.

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

#ifndef ISISTYPE_BASE_HPP
#define ISISTYPE_BASE_HPP

#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/lexical_cast.hpp>

#include "types.hpp"
#include "value_converter.hpp"
#include "generic_value.hpp"
#include "common.hpp"


namespace isis
{
namespace util
{
API_EXCLUDE_BEGIN
namespace _internal
{
template<typename TYPE> struct __cast_to {
    template<typename SOURCE> TYPE operator()( Value<TYPE>*, const SOURCE &value ) {
        return boost::lexical_cast<TYPE>( value ); //generic version types are different - so do lexical cast
    }
    TYPE operator()( Value<TYPE>*, const TYPE &value ) {
        return value; //special version types are same - so just return the value
    }
};
template<> struct __cast_to<uint8_t> { // we cannot lexical_cast to uint8_t - we'll get "characters" (1 => '1' == 49)
    template<typename SOURCE> uint8_t operator()( Value<uint8_t>*, const SOURCE &value ) {
        // lexical cast to unsigned short
        const unsigned short val = boost::lexical_cast<unsigned short>( value );

        // have to check by hand because the lexical cast will only check against unsigned short
        if( val > std::numeric_limits<uint8_t>::max() ) {
            throw boost::bad_lexical_cast( typeid( SOURCE ), typeid( uint8_t ) );
        }

        // and then static_cast to uint8_t
        return static_cast<uint8_t>( val );
    }
    uint8_t operator()( Value<uint8_t> *, const uint8_t &value ) {
        return value; //special version types are same - so just return the value
    }
};
}
API_EXCLUDE_END

/*
 * This is the mostly abstract base class for all scalar values (see types.hpp).
 * Additionally, there's the ValueArrayBase containing the more complex data handling stuff with abstract values.
 * Both are derived from GenericValue containing the description of the actual value type.
 */

class ValueBase : public _internal::GenericValue
{
    static const _internal::ValueConverterMap &converters();
    friend class _internal::GenericReference<ValueBase>;
protected:
    virtual ValueBase *clone()const = 0;
public:
    typedef _internal::GenericReference<ValueBase> Reference;
    typedef _internal::ValueConverterMap::mapped_type::mapped_type Converter;

    template<typename T> bool is()const;

    const Converter &getConverterTo( unsigned short ID )const;

    static bool convert( const ValueBase &from, ValueBase &to );

    template<class T> T as()const {
        if( is<T>() )
            return castTo<T>();

        Reference ret = copyByID( Value<T>::staticID );

        if ( ret.isEmpty() ) {
            LOG( Debug, error )
                    << "Interpretation of " << toString( true ) << " as " << Value<T>::staticName()
                    << " failed. Returning " << Value<T>().toString() << ".";
            return T();
        } else
            return ret->castTo<T>();
    }

    template<typename T> const Value<T>& castToType() const;

    template<typename T> const T &castTo() const;

    template<typename T> Value<T>& castToType();

    template<typename T> T &castTo();

    virtual bool operator==( const ValueBase &second )const = 0;

    Reference copyByID( unsigned short ID ) const;

    bool fitsInto( unsigned short ID ) const;

    virtual ~ValueBase();

    virtual bool gt( const ValueBase &ref )const = 0;
    virtual bool lt( const ValueBase &ref )const = 0;
    virtual bool eq( const ValueBase &ref )const = 0;
};


typedef ValueBase::Reference ValueReference;

}
}

namespace std
{
template<typename charT, typename traits> basic_ostream<charT, traits>&
operator<<( basic_ostream<charT, traits> &out, const isis::util::_internal::GenericValue &s )
{
    return out << s.toString();
}
template<typename charT, typename traits, typename TYPE_TYPE> basic_ostream<charT, traits>&
operator<<( basic_ostream<charT, traits> &out, const isis::util::_internal::GenericReference<TYPE_TYPE> &s )
{
    return out << s.toString( true );
}
}

#endif //ISISTYPE_BASE_HPP