/scr/tee1/isis/lib/Core/DataStorage/valuearray_base.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2010  reimer@cbs.mpg.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 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 TYPEPTRBASE_HPP
#define TYPEPTRBASE_HPP

#include "../CoreUtils/value_base.hpp"
#include "valuearray_converter.hpp"
#include "common.hpp"
#include <boost/mpl/if.hpp>
#include <boost/utility/enable_if.hpp>

namespace isis
{
namespace data
{
namespace _internal
{
class ConstValueAdapter: public util::ValueReference
{
public:
    typedef const util::ValueReference ( *Getter )( const void * );
    typedef void ( *Setter )( void *, const util::ValueBase & );
protected:
    const uint8_t *const p;
public:
    ConstValueAdapter( const uint8_t *const _p, Getter _getValueFunc );
    // to make some algorithms work
    bool operator==( const util::ValueReference &val )const;
    bool operator!=( const util::ValueReference &val )const;

    bool operator<( const util::ValueReference &val )const;
    bool operator>( const util::ValueReference &val )const;
};
class WritingValueAdapter: public ConstValueAdapter
{
    Setter setValueFunc;
public:
    WritingValueAdapter( uint8_t *const _p, Getter _getValueFunc, Setter _setValueFunc );
    WritingValueAdapter operator=( const util::ValueReference &val );
};

template<bool IS_CONST> class GenericValueIterator :
    public std::iterator < std::random_access_iterator_tag,
    typename boost::mpl::if_c<IS_CONST, ConstValueAdapter, WritingValueAdapter>::type,
    ptrdiff_t,
    typename boost::mpl::if_c<IS_CONST, ConstValueAdapter, WritingValueAdapter>::type,
    typename boost::mpl::if_c<IS_CONST, ConstValueAdapter, WritingValueAdapter>::type
    >
{
    typedef typename boost::mpl::if_c<IS_CONST, const uint8_t *, uint8_t *>::type ptr_type;
    ptr_type p, start; //we need the starting position for operator[]
    size_t byteSize;
    ConstValueAdapter::Getter getValueFunc;
    ConstValueAdapter::Setter setValueFunc;
    friend class GenericValueIterator<true>; //yes, I'm my own friend, sometimes :-) (enables the constructor below)
public:
    GenericValueIterator( const GenericValueIterator<false> &src ): //will become additional constructor from non const if this is const, otherwise overrride the default copy contructor
        p( src.p ), start( src.p ), byteSize( src.byteSize ), getValueFunc( src.getValueFunc ), setValueFunc( src.setValueFunc ) {}
    GenericValueIterator(): p( NULL ), start( p ), byteSize( 0 ), getValueFunc( NULL ), setValueFunc( NULL ) {}
    GenericValueIterator( ptr_type _p, ptr_type _start, size_t _byteSize, ConstValueAdapter::Getter _getValueFunc, ConstValueAdapter::Setter _setValueFunc ):
        p( _p ), start( _start ), byteSize( _byteSize ), getValueFunc( _getValueFunc ), setValueFunc( _setValueFunc )
    {}

    GenericValueIterator<IS_CONST>& operator++() {p += byteSize; return *this;}
    GenericValueIterator<IS_CONST>& operator--() {p -= byteSize; return *this;}

    GenericValueIterator<IS_CONST> operator++( int ) {GenericValueIterator<IS_CONST> tmp = *this; ++*this; return tmp;}
    GenericValueIterator<IS_CONST> operator--( int ) {GenericValueIterator<IS_CONST> tmp = *this; --*this; return tmp;}

    typename GenericValueIterator<IS_CONST>::reference operator*() const;
    typename GenericValueIterator<IS_CONST>::pointer  operator->() const {return operator*();}

    bool operator==( const GenericValueIterator<IS_CONST>& cmp )const {return p == cmp.p;}
    bool operator!=( const GenericValueIterator<IS_CONST>& cmp )const {return !( *this == cmp );}

    bool operator>( const GenericValueIterator<IS_CONST> &cmp )const {return p > cmp.p;}
    bool operator<( const GenericValueIterator<IS_CONST> &cmp )const {return p < cmp.p;}

    bool operator>=( const GenericValueIterator<IS_CONST> &cmp )const {return p >= cmp.p;}
    bool operator<=( const GenericValueIterator<IS_CONST> &cmp )const {return p <= cmp.p;}

    typename GenericValueIterator<IS_CONST>::difference_type operator-( const GenericValueIterator<IS_CONST> &cmp )const {return ( p - cmp.p ) / byteSize;}

    GenericValueIterator<IS_CONST> operator+( typename GenericValueIterator<IS_CONST>::difference_type n )const
    {return ( GenericValueIterator<IS_CONST>( *this ) += n );}
    GenericValueIterator<IS_CONST> operator-( typename GenericValueIterator<IS_CONST>::difference_type n )const
    {return ( GenericValueIterator<IS_CONST>( *this ) -= n );}


    GenericValueIterator<IS_CONST> &operator+=( typename GenericValueIterator<IS_CONST>::difference_type n )
    {p += ( n * byteSize ); return *this;}
    GenericValueIterator<IS_CONST> &operator-=( typename GenericValueIterator<IS_CONST>::difference_type n )
    {p -= ( n * byteSize ); return *this;}

    typename GenericValueIterator<IS_CONST>::reference operator[]( typename GenericValueIterator<IS_CONST>::difference_type n )const {
        //the book says it has to be the n-th elements of the whole object, so we have to start from what is hopefully the beginning
        return *( GenericValueIterator<IS_CONST>( start, start, byteSize, getValueFunc, setValueFunc ) += n );
    }

};
//specialise the dereferencing operators. They have to return (and create) different objects with different constructors
template<> GenericValueIterator<true>::reference GenericValueIterator<true>::operator*() const;
template<> GenericValueIterator<false>::reference GenericValueIterator<false>::operator*() const;

} //namespace _internal

class ValueArrayBase : public util::_internal::GenericValue
{
    friend class util::_internal::GenericReference<ValueArrayBase>;
    static const _internal::ValueArrayConverterMap &converters();
    scaling_pair getScaling( const scaling_pair &scale, unsigned short ID )const;
protected:
    size_t m_len;
    ValueArrayBase( size_t len = 0 );

    virtual ValueArrayBase *clone()const = 0;

public:
    typedef _internal::GenericValueIterator<false> value_iterator;
    typedef _internal::GenericValueIterator<true> const_value_iterator;
    typedef value_iterator value_reference;
    typedef const_value_iterator const_value_reference;
    class DelProxy : public boost::shared_ptr<const void>
    {
    public:
        DelProxy( const ValueArrayBase &master );
        void operator()( const void *at );
    };

    virtual boost::shared_ptr<const void> getRawAddress( size_t offset = 0 )const = 0;

    virtual boost::shared_ptr<void> getRawAddress( size_t offset = 0 ) = 0;

    virtual value_iterator beginGeneric() = 0;
    value_iterator endGeneric();
    virtual const_value_iterator beginGeneric()const = 0;
    const_value_iterator endGeneric()const;

    typedef util::_internal::GenericReference<ValueArrayBase> Reference;
    typedef _internal::ValueArrayConverterMap::mapped_type::mapped_type Converter;

    template<typename T> bool is()const;

    const Converter &getConverterTo( unsigned short ID )const;

    template<typename T> const ValueArray<T>& castToValueArray() const {
        return m_cast_to<ValueArray<T> >();
    }

    template<typename T> ValueArray<T>& castToValueArray() {
        return m_cast_to<ValueArray<T> >();
    }

    size_t getLength()const;

    virtual std::vector<Reference> splice( size_t size )const = 0;

    virtual scaling_pair getScalingTo( unsigned short typeID, autoscaleOption scaleopt = autoscale )const = 0;
    virtual scaling_pair getScalingTo( unsigned short typeID, const std::pair<util::ValueReference, util::ValueReference> &minmax, autoscaleOption scaleopt = autoscale )const;

    Reference copyByID( unsigned short ID = 0, scaling_pair scaling = scaling_pair() ) const;

    bool copyTo( isis::data::ValueArrayBase &dst, scaling_pair scaling = scaling_pair() )const;

    template<typename T> bool copyToMem( T *dst, size_t len, scaling_pair scaling = scaling_pair() )const {
        ValueArray<T> cont( dst, len, typename ValueArray<T>::NonDeleter() );
        return copyTo( cont, scaling );
    }

    template<typename T> bool copyFromMem( const T *const src, size_t len, scaling_pair scaling = scaling_pair() ) {
        ValueArray<T> cont( const_cast<T *>( src ), len, typename ValueArray<T>::NonDeleter() ); //its ok - we're no going to change it
        return cont.copyTo( *this, scaling );
    }

    static Reference createByID( unsigned short ID, size_t len );

    template<typename T> ValueArray<T> copyAs( scaling_pair scaling = scaling_pair() )const {
        Reference erg = copyByID( ValueArray<T>::staticID, scaling );
        return erg.isEmpty() ? ValueArray<T>( 0 ) : erg->castToValueArray<T>();
    }

    ValueArrayBase::Reference  convertByID( unsigned short ID, scaling_pair scaling = scaling_pair() );


    template<typename T> ValueArray<T> as( scaling_pair scaling = scaling_pair() ) {
        Reference erg = convertByID( ValueArray<T>::staticID, scaling );
        return erg.isEmpty() ? ValueArray<T>( 0 ) : erg->castToValueArray<T>();
    }

    ValueArrayBase::Reference cloneToNew( size_t length )const;

    virtual size_t bytesPerElem()const = 0;

    virtual ~ValueArrayBase();

    void copyRange( size_t start, size_t end, ValueArrayBase &dst, size_t dst_start )const;

    size_t useCount()const;

    virtual std::pair<util::ValueReference, util::ValueReference> getMinMax()const = 0;

    size_t compare( size_t start, size_t end, const ValueArrayBase &dst, size_t dst_start )const;
    
    virtual void endianSwap()=0;
};


typedef ValueArrayBase::Reference ValueArrayReference;

}
}

#endif // TYPEPTRBASE_HPP