BlobValue.h

Go to the documentation of this file.

#ifndef BLOBVALUE_H_
#define BLOBVALUE_H_

#include "data/BlobType.h"
#include "data/StrValue.h"

class DataWriter;
class ElementURI;
class RingBufferVoid;

class BlobValue : public StrValue
{
public:

    static size_t ElementSize( const BlobType& blobType )
    {
        return ELEMENT_SIZE[ blobType >= NOT_BLOB && blobType < BLOB_TYPE_COUNT ? blobType : NOT_BLOB ];
    }

    static const size_t ELEMENT_SIZE[BLOB_TYPE_COUNT];

    BlobValue( const ElementURI& elementUri );

    BlobValue( const void* bytes, size_t elements, const ElementURI& elementUri );

    BlobValue( const Unit& unit, const double* array, size_t elements, const ElementURI& elementUri );

    BlobValue( const Unit& unit, const float* array, size_t elements, const ElementURI& elementUri );

    BlobValue( const Unit& unit, const int* array, size_t elements, const ElementURI& elementUri );

    // set from  raw data
    void setFromRaw( const void* bytes, size_t elements );

    // set from a 1-d array (of double, float or int)
    template<typename T>
    void setFrom( const Unit& unit, const T* array, size_t elements );

    // set from a 2-d array (of double, float or int)
    template<typename T, size_t m, size_t n>
    void setFrom( const Unit& unit, const T( &array )[m][n] )
    {
        size_t length = m * n * ElementSize( blobType_ );
        value_.set( NULL, length );
        if( conversionNeeded<T>( unit ) )
        {
            for( size_t i = 0; i < m; ++i )
            {
                for( size_t j = 0; j < n; ++j )
                {
                    set( i * n + j, unit, array[i][j] );
                }
            }
        }
        else
        {
            length = n * ElementSize( blobType_ );
            for( size_t i = 0; i < m; ++i )
            {
                size_t offset = i * length;
                memcpy( ( char* )value_.cStr() + offset, ( const char* )( array[i] ), length );
            }
        }
    }

    // set from a 2-d array pointer (of double, float or int)
    template<typename T>
    void setFrom( const Unit& unit, const T** array, int m, int n );

    // set from a 3-d array (of double, float or int)
    template<typename T, size_t m, size_t n, size_t o>
    void setFrom( const Unit& unit, const T( &array )[m][n][o] )
    {
        size_t length = m * n * o * ElementSize( blobType_ );
        value_.set( NULL, length );
        if( conversionNeeded<T>( unit ) )
        {
            for( size_t i = 0; i < m; ++i )
            {
                for( size_t j = 0; j < n; ++j )
                {
                    for( size_t k = 0; k < o; ++k )
                    {
                        set( i * n * o + j * o + k, unit, array[i][j][k] );
                    }
                }
            }
        }
        else
        {
            length = o * ElementSize( blobType_ );
            for( size_t i = 0; i < m; ++i )
            {
                for( size_t j = 0; j < n; ++j )
                {
                    size_t offset = ( i * n + j ) * length;
                    memcpy( ( char* )value_.cStr() + offset, ( const char* )( array[i][j] ), length );
                }
            }
        }
    }

    // set from a 3-d array pointer (of double, float or int)
    template<typename T>
    void setFrom( const Unit& unit, const T*** array, int m, int n, int o );

    bool set( size_t index, const Unit& unit, double value );

    // copy to a 1-d array (of double, float or int), returns # of elements copied
    template<typename T>
    int copyTo( const Unit& unit, T* array, size_t elements );

    // copy to a 2-d array (of doubles, float, or int)
    template<typename T, size_t m, size_t n>
    int copyTo( const Unit& unit, T( &array )[m][n] )
    {
        size_t elements = m * n;
        if( elements > getElements() )
        {
            elements = getElements() / n * n;
        }
        if( conversionNeeded<T>( unit ) )
        {
            double value;
            for( unsigned int i = 0; i < elements / n; ++i )
            {
                for( unsigned int j = 0; j < elements / m; ++j )
                {
                    get( i * n + j, unit, value );
                    array[i][j] = value;
                }
            }
        }
        else
        {
            size_t length = n * sizeof( T );
            for( unsigned int i = 0; i < elements / n; ++i )
            {
                size_t offset = i * length;
                memcpy( ( char* )( array[i] ), value_.cStr() + offset, length );
            }
        }
        return elements;
    }

    // copy to a 2-d array pointer (of double, float or int), returns # of elements copied
    template<typename T>
    int copyTo( const Unit& unit, T** array, int m, int n );

    // copy to a 3-d array (of doubles, float, or int)
    template<typename T, size_t m, size_t n, size_t o>
    int copyTo( const Unit& unit, T( &array )[m][n][o] )
    {
        size_t elements = m * n * o;
        if( elements > getElements() )
        {
            elements = getElements() / n / o * n * o;
        }
        if( conversionNeeded<T>( unit ) )
        {
            double value;
            for( unsigned int i = 0; i < elements / n / o ; ++i )
            {
                for( unsigned int j = 0; j < n; ++j )
                {
                    for( unsigned int k = 0; k < o; ++k )
                    {
                        get( i * n * o + j * o + k, unit, value );
                        array[i][j][k] = value;
                    }
                }
            }
        }
        else
        {
            size_t length = o * sizeof( T );
            for( unsigned int i = 0; i < elements / n / o; ++i )
            {
                for( unsigned int j = 0; j < n; ++j )
                {
                    size_t offset = ( i * n + j ) * length;
                    memcpy( ( char* )( array[i][j] ), value_.cStr() + offset, length );
                }
            }
        }
        return elements;
    }

    // copy to a 3-d array pointer (of double, float or int), returns # of elements copied
    template<typename T>
    int copyTo( const Unit& unit, T*** array, int m, int n, int o );

    bool get( size_t index, const Unit& unit, double& value );

    size_t getElements()
    {
        return ElementSize( blobType_ ) == 0 ? 0 : value_.length() / ElementSize( blobType_ );
    }

    size_t getByteLength()
    {
        return value_.length();
    }

    void* getBytes()
    {
        return ( void* )value_.cStr();
    }

    // as a Str
    virtual Str toString( const Unit& unit ) const
    {
        return Str( value_.length(), 10 ) + " bytes of " + unit.getName();
    }

    BlobType getBlobType()
    {
        return blobType_;
    }

protected:

    friend class Blob_Test;

    // returns true if conversion needed
    template<typename T>
    bool conversionNeeded( const Unit& unit );

    template<typename T>
    void setElement( size_t index, T value, bool flip );

    template<typename T>
    void getElement( size_t index, T& value, bool flip );

    BlobType blobType_;


};

#endif /*BLOBVALUE_H_*/