value.hpp

Go to the documentation of this file.

#pragma once 

//#include "config.h"
#include "global.hpp"
#include "sqlite/sqlite3.h"
#include <string>
#include <vector>
#include <utility>
#include <string>
#include <algorithm>
#include <memory>

using namespace std;

#ifdef _MSC_VER
#pragma warning( disable: 4521 4522 )  // multiple copy constructors and assignment operators specified
#endif

class   ValueBase;
class   ValueMex;
class   ValueSQL;
class   ValueSQLCol;
struct  tagNativeArray;


#define SQLITE_BLOBX 20   

HC_ASSERT( sizeof( sqlite3_int64 ) <= sizeof( long long ) );

class ValueBase
{
public:
    bool                m_isConst;          
    union
    {
      double            m_float;            
      sqlite3_int64     m_integer;          
      char*             m_text;             
      mxArray*          m_blob;             
      mxArray*          m_pcItem;           
      tagNativeArray*   m_array;            
      
      long long         m_largest_field;    
    };
    
    ~ValueBase()
    {
        // Class ValueBase manages no memory, so when object runs out of scope memory must have been freed
        // already or be const either.
        assert( m_isConst || !m_largest_field );
    }
    
// Only derived classes may create class instances
protected:
    
    ValueBase()
    : m_isConst(true),
      m_largest_field(0)
    {
    }
    
    ValueBase( const ValueBase& other )
    {
        m_isConst   = true;
        *this       = other;
    }
    
    ValueBase( ValueBase& other )
    {
        m_isConst       = true;
        *this           = other;
        other.m_isConst = true;   // taking ownership
    }
    
    ValueBase( ValueBase&& other )
    {
        m_isConst       = true;
        *this           = other;
        other.m_isConst = true;   // taking ownership
    }
    
    ValueBase& operator=( const ValueBase& other )
    {
        // checking self assignment
        if( this != &other )
        {
            assert( m_isConst || !m_largest_field );
            m_isConst       = true;
            m_largest_field = other.m_largest_field;
        }
        
        return *this;
    }
    
    ValueBase& operator=( ValueBase& other )
    {
        // checking self assignment
        if( this != &other )
        {
            assert( m_isConst || !m_largest_field );
            m_isConst       = other.m_isConst;
            m_largest_field = other.m_largest_field;

            other.m_isConst = true;   // taking ownership
        }
        
        return *this;
    }
    
    ValueBase& operator=( ValueBase&& other )
    {
        // checking self assignment
        if( this != &other )
        {
            assert( m_isConst || !m_largest_field );
            m_isConst       = other.m_isConst;
            m_largest_field = other.m_largest_field;

            other.m_isConst = true;   // taking ownership
        }
        
        return *this;
    }
};


class ValueMex : public ValueBase
{
public:
    typedef enum {
        TC_EMPTY = 0,       
        TC_SIMPLE,          
        TC_SIMPLE_VECTOR,   
        TC_SIMPLE_ARRAY,    
        TC_COMPLEX,         
        TC_UNSUPP = -1      
    } type_complexity_e;

    enum {
        LOGICAL_CLASS  = mxLOGICAL_CLASS,
        INT8_CLASS     = mxINT8_CLASS,
        UINT8_CLASS    = mxUINT8_CLASS,
        INT16_CLASS    = mxINT16_CLASS,
        INT32_CLASS    = mxINT32_CLASS,
        UINT16_CLASS   = mxUINT16_CLASS,
        UINT32_CLASS   = mxUINT32_CLASS,
        INT64_CLASS    = mxINT64_CLASS,
        DOUBLE_CLASS   = mxDOUBLE_CLASS,
        SINGLE_CLASS   = mxSINGLE_CLASS,
        CHAR_CLASS     = mxCHAR_CLASS,
    };
    
    
    ValueMex() : ValueBase()
    {
    }
    
    ValueMex( const ValueMex& other ) : ValueBase( other )
    {
    }
    
    ValueMex( ValueMex& other ) : ValueBase( other )
    {
    }
    
    ValueMex( ValueMex&& other ) : ValueBase( other )
    {
    }
    
    ValueMex& operator=( const ValueMex& other )
    {
        ValueBase::operator=( other );
        return *this;
    }
    
    ValueMex& operator=( ValueMex& other )
    {
        ValueBase::operator=( other );
        return *this;
    }
    
    ValueMex& operator=( ValueMex&& other )
    {
        ValueBase::operator=( other );
        return *this;
    }
    
    explicit
    ValueMex( const mxArray* pcItem )
    {
        m_isConst = true;
        m_pcItem  = const_cast<mxArray*>(pcItem);
    }
    
   
    ValueMex( mwIndex m, mwIndex n, int clsid = mxDOUBLE_CLASS )
    {
        m_pcItem  = mxCreateNumericMatrix( m, n, (mxClassID)clsid, mxREAL );
        m_isConst = false;
    }


    ValueMex& Adopt( bool doAdopt = true )
    {
        m_isConst = !doAdopt;
        return *this;
    }


    static
    ValueMex CreateCellMatrix( int m, int n )
    {
        return ValueMex( mxCreateCellMatrix( m, n ) ).Adopt();
    }


    static
    ValueMex CreateDoubleScalar( double value )
    {
        return ValueMex( mxCreateDoubleScalar( value ) ).Adopt();
    }


    static
    ValueMex CreateString( const char* str )
    {
        return ValueMex( mxCreateString( str ) ).Adopt();
    }

    
    void Destroy()
    {
        if( !m_isConst && m_pcItem )
        {
            // Workaround to avoid MATLAB crash with persistent arrays ("Case 02098404", Lucas Lebert, MathWorks Technical Support Department 
            mxArray* tmp = m_pcItem;
            m_pcItem = NULL;
            mxDestroyArray( m_pcItem );
        }
    }

    
    inline
    const mxArray* Item() const
    {
        return const_cast<const mxArray*>( m_pcItem );
    }


    inline
    mxArray* Item()
    {
        return m_pcItem;
    }


    inline
    ValueMex Duplicate() const
    {
        return ValueMex( m_pcItem ? mxDuplicateArray( m_pcItem ) : NULL ).Adopt();
    }


    inline
    mxArray* Detach()
    {
        assert( !m_isConst );
        mxArray* pcItem = m_pcItem;
        m_largest_field = 0;
        return pcItem;
    }


    inline
    size_t GetM() const
    {
        return mxGetM(m_pcItem);
    }
    
    inline
    size_t GetN() const
    {
        return mxGetN(m_pcItem);
    }
    
    inline
    bool IsEmpty() const
    {
        return !m_pcItem || mxIsEmpty( m_pcItem );
    }

    inline
    bool IsCell() const
    {
        return m_pcItem ? mxIsCell( m_pcItem ) : false;
    }

    inline
    bool IsComplex() const
    {
        return m_pcItem ? mxIsComplex( m_pcItem ) : false;
    }

    inline
    bool IsScalar() const
    {
        return NumElements() == 1;
    }

    inline
    bool IsStruct() const
    {
        return mxIsStruct( m_pcItem );
    }

    inline
    bool IsVector() const
    {
        return NumDims() == 2 && min( GetM(), GetN() ) == 1;
    }
    
    inline
    bool IsDoubleClass() const
    {
        return mxDOUBLE_CLASS == ClassID();
    }

    inline
    bool IsFunctionHandle() const
    {
        return mxFUNCTION_CLASS == ClassID();
    }

    inline
    size_t NumElements() const
    {
        return m_pcItem ? mxGetNumberOfElements( m_pcItem ) : 0;
    }
    
    inline
    size_t ByElement() const
    {
        return m_pcItem ? mxGetElementSize( m_pcItem ) : 0;
    }
    
    inline
    int NumDims() const
    {
        return m_pcItem ? mxGetNumberOfDimensions( m_pcItem ) : 0;
    }
      
    inline
    size_t ByData() const
    {
       return NumElements() * ByElement();
    }
    
    inline
    mxClassID ClassID() const
    {
        return m_pcItem ? mxGetClassID( m_pcItem ) : mxUNKNOWN_CLASS;
    }

    type_complexity_e Complexity( bool bCanSerialize = false ) const
    {
        if( IsEmpty() ) return TC_EMPTY;

        switch( ClassID() )
        {
            case  mxDOUBLE_CLASS:
            case  mxSINGLE_CLASS:
                if( mxIsComplex( m_pcItem ) )
                {
                    return TC_COMPLEX;
                }
                /* fallthrough */
            case mxLOGICAL_CLASS:
            case    mxINT8_CLASS:
            case   mxUINT8_CLASS:
            case   mxINT16_CLASS:
            case  mxUINT16_CLASS:
            case   mxINT32_CLASS:
            case  mxUINT32_CLASS:
            case   mxINT64_CLASS:
            case  mxUINT64_CLASS:
                if( IsScalar() ) return TC_SIMPLE;
                return IsVector() ? TC_SIMPLE_VECTOR : TC_SIMPLE_ARRAY;
            case    mxCHAR_CLASS:
                return ( IsScalar() || IsVector() ) ? TC_SIMPLE : TC_SIMPLE_ARRAY;
            case mxUNKNOWN_CLASS:
                // serialized data is marked as "unknown" type by mksqlite
                return bCanSerialize ? TC_COMPLEX : TC_UNSUPP;
            case  mxSTRUCT_CLASS:
            case    mxCELL_CLASS:
                return TC_COMPLEX;
            default:
                return TC_UNSUPP;
        }
    }
    
    inline
    void* Data() const
    {
        return !IsEmpty() ? mxGetData( m_pcItem ) : NULL;
    }
    
    char *GetString( bool flagUTF = false, const char* format = NULL ) const
    {
                size_t      count;
                char*       result          = NULL;
                mxArray*    new_string      = NULL;
        const   mxArray*    org_string      = m_pcItem;
        
        // reformat original string with MATLAB function "sprintf" into new string
        if( format )
        {
            mxArray* args[2] = { mxCreateString( format ), const_cast<mxArray*>(org_string) };

            mexCallMATLAB( 1, &new_string, 2, args, "sprintf" );
            mxDestroyArray( args[0] );  // destroy format string
            
            org_string = new_string; // Override (but don't free!) org_string
        }
        
        // get character stream from original string (MATLAB array)
        if( org_string )
        {
            char* temp = mxArrayToString( org_string );  // Handles multibyte strings, too
            
            // Copy string with own memory management
            if( temp )
            {
                count  = strlen( temp ) + 1;
                result = (char*) MEM_ALLOC( count, sizeof(char) );
                
                if( result )
                {
                    memcpy( result, temp, count );
                }
                
                mxFree( temp );
            }
        }

        // reformatted string is no longer needed
        ::utils_destroy_array( new_string );

        // try to retrieve the character stream
        if( !result )
        {
            // free memory and return with error
            mexErrMsgTxt( getLocaleMsg( MSG_CANTCOPYSTRING ) );
        }
        
        // convert to UFT
        if( flagUTF )
        {
            char *buffer = NULL;
            int buflen;

            /* get only the buffer size needed */
            buflen = utils_latin2utf( (unsigned char*)result, (unsigned char*)buffer );
            buffer = (char*) MEM_ALLOC( buflen, sizeof(char) );

            if( !buffer )
            {
                ::utils_free_ptr( result ); // Needless due to mexErrMsgTxt(), but clean
                mexErrMsgTxt( getLocaleMsg( MSG_CANTCOPYSTRING ) );
            }

            /* encode string to utf now */
            ::utils_latin2utf( (unsigned char*)result, (unsigned char*)buffer );

            ::utils_free_ptr( result );

            result = buffer;
        }

        return result;
    }
    
    
    char* GetEncString() const
    {
        return GetString( g_convertUTF8 ? true : false );
    }


    int GetInt( int errval = 0 ) const
    {
        if( !IsEmpty() )
        {
            switch( ClassID() )
            {
                case mxINT8_CLASS  :  return (int) *( (int8_t*)   Data() );
                case mxUINT8_CLASS :  return (int) *( (uint8_t*)  Data() );
                case mxINT16_CLASS :  return (int) *( (int16_t*)  Data() );
                case mxUINT16_CLASS:  return (int) *( (uint16_t*) Data() );
                case mxINT32_CLASS :  return (int) *( (int32_t*)  Data() );
                case mxUINT32_CLASS:  return (int) *( (uint32_t*) Data() );
                case mxSINGLE_CLASS:  return (int) *( (float*)    Data() );
                case mxDOUBLE_CLASS:  return (int) *( (double*)   Data() );
                case mxLOGICAL_CLASS: return (int) mxIsLogicalScalarTrue( m_pcItem );

                default: 
                    assert( false );
                    return errval;
            }
        }

        return errval;
    }
    
    sqlite3_int64 GetInt64( int errval = 0 ) const
    {
        if( !IsEmpty() )
        {
            switch( ClassID() )
            {
                case mxINT64_CLASS : return *( (sqlite3_int64*)  Data() );

                default: 
                    assert( false );
                    return (sqlite3_int64) errval;
            }
        }

        return errval;
    }
    
    double GetScalar() const
    {
        return IsScalar() ? mxGetScalar( m_pcItem ) : DBL_NAN;
    }

    const mxArray* GetField( int n, const char* name ) const
    {
        mxArray* result = NULL;
        
        if( m_pcItem )
        {
            result = mxGetField( m_pcItem, n, name );

            if( !result )
            {
                // MATLAB bug? For implicit non-initialized structure members mxGetField()
                // returns NULL.
                // ( Thx Knut Voigtlaender for pointing that out )
                // Workaround: Check if struct has requested field
                if( mxGetFieldNumber( m_pcItem, name ) >= 0 )
                {
                    // Create and return an empty array in this case
                    // (MATLAB destroys it automatically when exitting MEX function)
                    result = mxCreateNumericMatrix( 0, 1, mxDOUBLE_CLASS, mxREAL );
                }
            }
        }
        return result;
    }


    void SetCell( int i, const mxArray* cell )
    {
        if( m_pcItem )
        {
            mxSetCell( m_pcItem, i, const_cast<mxArray*>(cell) );
        }
    }


    void MakePersistent()
    {
        if( m_pcItem )
        {
            mexMakeArrayPersistent( m_pcItem );
            m_isConst = false;
        }
    }


    void Throw()
    {
        if( !IsEmpty() && mxIsClass( m_pcItem, "MException" ) )
        {
            mxArray* exception = Detach();
            mexCallMATLAB( 0, NULL, 1, &exception, "throw" );
        }

    }


    void Call( ValueMex* lhs, ValueMex* exception )
    {
        assert( IsCell() && !IsEmpty() );

        mxArray* _lhs       = NULL;  // Function return value
        mxArray** prhs      = (mxArray**)Data();  // Function handle and arguments
        mxArray* _exception = mexCallMATLABWithTrap( 1, &_lhs, (int)NumElements(), prhs, "feval" );

        // Function returned results?
        if( _lhs )
        {
            *lhs = ValueMex( _lhs ).Adopt();
            _lhs = NULL;
        }

        // An exception occured?
        if( _exception )
        {
            *exception = ValueMex( _exception ).Adopt();
            _exception = NULL;
        }

        // Cleanup
        
        if( _lhs )
        {
            mxDestroyArray( _lhs );
        }

        if( _exception )
        {
            mxDestroyArray( _exception );
        }
    }
};


class ValueSQL : public ValueBase
{
public:
    int    m_typeID;    
    size_t m_blobsize;  
  
    ~ValueSQL()
    {
        Destroy();
    }

    ValueSQL()
    {
        m_blobsize = 0;
        m_typeID   = SQLITE_NULL;
    }
    
    ValueSQL( const ValueSQL& other ) : ValueBase( other )
    {
        m_typeID   = other.m_typeID;
        m_blobsize = other.m_blobsize;
    }
    
    ValueSQL( ValueSQL& other ) : ValueBase( other )
    {
        m_typeID   = other.m_typeID;
        m_blobsize = other.m_blobsize;
    }
    
    ValueSQL( ValueSQL&& other ) : ValueBase( other )
    {
        m_typeID   = other.m_typeID;
        m_blobsize = other.m_blobsize;
    }
    
    ValueSQL& operator=( const ValueSQL& other )
    {
        ValueBase::operator=(other);
        m_typeID      = other.m_typeID;
        m_blobsize    = other.m_blobsize;
        return *this;
    }

    ValueSQL& operator=( ValueSQL& other )
    {
        ValueBase::operator=(other);
        m_typeID      = other.m_typeID;
        m_blobsize    = other.m_blobsize;
        return *this;
    }

    ValueSQL& operator=( ValueSQL&& other )
    {
        ValueBase::operator=(other);
        m_typeID      = other.m_typeID;
        m_blobsize    = other.m_blobsize;
        return *this;
    }

    explicit
    ValueSQL( double dValue )
    {
        m_float   = dValue;
        m_typeID  = SQLITE_FLOAT;
    }
    
    explicit
    ValueSQL( sqlite3_int64 iValue )
    {
        m_integer = iValue;
        m_typeID  = SQLITE_INTEGER;
    }
    
    explicit
    ValueSQL( const char* txtValue )
    {
        m_text    = const_cast<char*>(txtValue);
        m_typeID  = SQLITE_TEXT;
    }
    
    explicit
    ValueSQL( char* txtValue )
    {
        m_text    = txtValue;
        m_typeID  = SQLITE_TEXT;
    }
    
    explicit
    ValueSQL( char* blobValue, size_t size )
    {
        m_isConst     = false;
        m_text        = blobValue;
        m_blobsize    = size;
        m_typeID      = SQLITE_BLOBX;
    }
    
    explicit
    ValueSQL( const mxArray* blobValue )
    {
        m_blob    = const_cast<mxArray*>(blobValue);
        m_typeID  = SQLITE_BLOB;
    }

    explicit
    ValueSQL( mxArray* blobValue )
    {
        m_isConst = false;
        m_blob    = blobValue;
        m_typeID  = SQLITE_BLOB;
    }


    void* Detach()
    {
        assert( m_text && ( m_typeID == SQLITE_TEXT || m_typeID == SQLITE_BLOB || m_typeID == SQLITE_BLOBX ) );
        m_isConst = true;
        return (void*)m_text;
    }

    void Destroy()
    {
        extern void blob_free( void** pBlob );  /* sql_builtin_functions.hpp */
        
        if( !m_isConst )
        {
            if( m_typeID == SQLITE_TEXT && m_text )
            {
                ::utils_free_ptr( m_text );
                m_text = NULL;
            }
            
            if( m_typeID == SQLITE_BLOBX && m_text )
            {
                blob_free( (void**)&m_text );
            }
            
            if( m_typeID == SQLITE_BLOB && m_blob )
            {
                mxDestroyArray( m_blob );
                m_blob = NULL;
            }
        }
        
        m_typeID = SQLITE_NULL;
    }
};


class ValueSQLCol
{
private:
    ValueSQLCol();
    
public:
    string m_col_name;  
    string m_name;      
    bool   m_isAnyType; 
    
    typedef pair<string,string>    StringPair;
    typedef vector<StringPair>     StringPairList;  

    vector<ValueSQL>  m_any;    
    vector<double>    m_float;  
    
    ValueSQLCol( StringPair name )
    : m_col_name(name.first)/*SQL*/, m_name(name.second)/*MATLAB*/, m_isAnyType(false)
    {
    }
    
    ~ValueSQLCol()
    {
        for( int i = 0; i < (int)m_any.size(); i++ )
        {
            m_any[i].Destroy();
        }
    }

    void Destroy( int row )
    {
        if( m_isAnyType && row < (int)m_any.size() )
        {
            m_any[row].Destroy();
        }
    }
    
    size_t size()
    {
        return m_isAnyType ? m_any.size() : m_float.size();
    }
    
    const ValueSQL operator[]( int index )
    {
        return m_isAnyType ? const_cast<const ValueSQL&>(m_any[index]) : ValueSQL( m_float[index] );
    }
    
    void swapToAnyType()
    {
        if( !m_isAnyType )
        {
            assert( !m_any.size() );
            
            // convert each element to ValueSQL type
            for( int i = 0; i < (int)m_float.size(); i++ )
            {
                m_any.push_back( ValueSQL(m_float[i]) );
            }

            // clear old value vector (double types) and flag new column type
            m_float.clear();
            m_isAnyType = true;
        }
    }
    
    void append( double value )
    {
        if( m_isAnyType )
        {
            m_any.push_back( ValueSQL(value) );
        }
        else
        {
            m_float.push_back( value );
        }
    }
    
    void append( sqlite3_int64 value )
    {
        /* Test if integer value can be represented as double type */
        double    dVal  = (double)(value);
        long long llVal = (sqlite3_int64) dVal;

        if( llVal == value )
        {
            // double type is equivalent, and thus preferred
            append( dVal );
        }
        else
        {
            swapToAnyType();
            m_any.push_back( ValueSQL(value) );
        }
    }
    
    void append( const char* value )
    {
        swapToAnyType();
        m_any.push_back( ValueSQL(value) );
    }

    void append( char* value )
    {
        swapToAnyType();
        m_any.push_back( ValueSQL(value) );
    }

    void append( const mxArray* value )
    {
        swapToAnyType();
        m_any.push_back( ValueSQL(value) );
    }
    
    void append( mxArray* value )
    {
        swapToAnyType();
        m_any.push_back( ValueSQL(value) );
    }
    
    void append( const ValueSQL& item )
    {
        switch( item.m_typeID )
        {
          case SQLITE_FLOAT:
            append( item.m_float );
            return;
            
          case SQLITE_INTEGER:
            append( item.m_integer );
            return;
            
          case SQLITE_NULL:
            if( g_NULLasNaN )
            {
                append( DBL_NAN );
            }
            else
            {
                swapToAnyType();
                m_any.push_back( ValueSQL() );
            }
            return;
            
          case SQLITE_TEXT:
          case SQLITE_BLOB:
            swapToAnyType();
            m_any.push_back( item );
            break;
            
          default:
            assert( false );
            break;
        }
    }
    
    void append( ValueSQL& item )
    {
        switch( item.m_typeID )
        {
          case SQLITE_FLOAT:
          case SQLITE_INTEGER:
          case SQLITE_NULL:
              append( (const ValueSQL&)item );
              break;
          case SQLITE_TEXT:
          case SQLITE_BLOB:
            swapToAnyType();
            m_any.push_back( ValueSQL(item) );
            break;
            
          default:
            assert( false );
            break;
        }
    }
};

struct tagNativeArray
{
    size_t          m_elBytes;      
    size_t          m_dims[1];      
    
    tagNativeArray()
    : m_elBytes(0)
    {
        m_dims[0] = 0;
    }

    static
    tagNativeArray* CreateArray( size_t nDims, size_t dims[], int typeID )
    {
        tagNativeArray* pThis   = NULL;
        size_t          elBytes = utils_elbytes( (mxClassID)typeID );
        size_t          memBytes;
        
        size_t nElements = 0;
        
        if( nDims )
        {
            nElements = dims[0];
            for( int i = 1; i < (int)nDims; i++ )
            {
                nElements *= dims[i];
            }
        }
        
        memBytes = sizeof(tagNativeArray) +
                   sizeof(dims[0]) * nDims +
                   nElements * elBytes;
        
        pThis = (tagNativeArray*)MEM_ALLOC( memBytes, 1 );
        
        if( pThis )
        {
            pThis->m_elBytes    = elBytes;
            pThis->m_dims[0]    = nDims;
            
            for( int i = 0; i < (int)nDims; i++ )
            {
                pThis->m_dims[i+1] = dims[i];
            }
        }
        
        return pThis;
    }
    
    static
    tagNativeArray* CreateMatrix( size_t m, size_t n, int typeID )
    {
        size_t dims[] = {m, n};
        return CreateArray( 2, dims, typeID );
    }
    
    static
    void FreeArray( tagNativeArray* pNativeArray )
    {
        MEM_FREE( pNativeArray );
    }
};