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

Go to the documentation of this file.

/*
    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    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 3 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, see <http://www.gnu.org/licenses/>.

*/

#ifndef GENERIC_TYPE_HPP
#define GENERIC_TYPE_HPP

#include <stdexcept>
#include <cstdlib>
#include "log.hpp"


namespace isis
{
namespace data {template<typename TYPE> class ValueArray;}
namespace util
{
template<typename TYPE> class Value;

namespace _internal
{

class GenericValue
{
protected:
    template<typename T> T &m_cast_to() {
        LOG_IF( getTypeID() != T::staticID, Debug, error ) << "using " << getTypeName() << " at " << this << " as " << T::staticName() << " aborting ...";
        assert( getTypeID() == T::staticID );
        //      return *dynamic_cast<T *>( this );// @todo Mac doesn't like that (http://www.cocoabuilder.com/archive/xcode/247376-rtti-dynamic-cast-across-shared-module-boundaries.html)
        return *( reinterpret_cast<T *>( this ) );
    }
    template<typename T> const T &m_cast_to()const {
        LOG_IF( getTypeID() != T::staticID, Debug, error ) << "using " << getTypeName() << " at " << this << " as " << T::staticName() << " aborting ...";
        assert( getTypeID() == T::staticID );
        //      return *dynamic_cast<const T *>( this );// @todo Mac doesn't like that (http://www.cocoabuilder.com/archive/xcode/247376-rtti-dynamic-cast-across-shared-module-boundaries.html)
        return *( reinterpret_cast<const T *>( this ) );
    }

public:
    virtual std::string toString( bool labeled = false )const = 0;

    virtual std::string getTypeName()const = 0;

    virtual unsigned short getTypeID()const = 0;

    virtual bool isFloat()const = 0;

    virtual bool isInteger()const = 0;

    bool isSameType( const GenericValue &second )const;
    virtual ~GenericValue() {}
};

template<typename TYPE_TYPE> class GenericReference: protected boost::scoped_ptr<TYPE_TYPE>
{
    template<typename TT> friend class data::ValueArray; //allow Value and ValueArray to use the protected contructor below
    template<typename TT> friend class Value;
protected:
    //dont use this directly
    GenericReference( TYPE_TYPE *t ): boost::scoped_ptr<TYPE_TYPE>( t ) {}
public:
    TYPE_TYPE *operator->() const {return boost::scoped_ptr<TYPE_TYPE>::operator->();}
    TYPE_TYPE &operator*() const {return boost::scoped_ptr<TYPE_TYPE>::operator*();}
    GenericReference() {}
    GenericReference( const GenericReference &src ): boost::scoped_ptr<TYPE_TYPE>( NULL ) {
        operator=( src );
    }
    GenericReference( const TYPE_TYPE &src ): boost::scoped_ptr<TYPE_TYPE>( NULL ) {
        operator=( src );
    }
    GenericReference<TYPE_TYPE>& operator=( const GenericReference<TYPE_TYPE> &src ) {
        boost::scoped_ptr<TYPE_TYPE>::reset( src.isEmpty() ? 0 : src->clone() );
        return *this;
    }
    GenericReference<TYPE_TYPE>& operator=( const TYPE_TYPE &src ) {
        boost::scoped_ptr<TYPE_TYPE>::reset( src.clone() );
        return *this;
    }
    bool isEmpty()const {
        return boost::scoped_ptr<TYPE_TYPE>::get() == NULL;
    }
    const std::string toString( bool label = false )const {
        if ( isEmpty() )
            return std::string( "\xd8" ); //ASCII code empty set
        else
            return this->get()->toString( label );
    }
};

}
}
}
#endif // GENERIC_TYPE_HPP