typed_blobs.hpp

Go to the documentation of this file.

#pragma once 

//#include "config.h"
//#include "global.hpp"
#include "utils.hpp"

#ifdef _WIN32
  #define GCC_PACKED_STRUCT
  #pragma pack(1)
#else
  #define GCC_PACKED_STRUCT __attribute__((packed))
#endif
  
#if !defined( MATLAB_MEX_FILE )
    typedef enum 
    {
        mxUNKNOWN_CLASS = 0,
        mxCELL_CLASS,
        mxSTRUCT_CLASS,
        mxLOGICAL_CLASS,
        mxCHAR_CLASS,
        mxVOID_CLASS,
        mxDOUBLE_CLASS,
        mxSINGLE_CLASS,
        mxINT8_CLASS,
        mxUINT8_CLASS,
        mxINT16_CLASS,
        mxUINT16_CLASS,
        mxINT32_CLASS,
        mxUINT32_CLASS,
        mxINT64_CLASS,
        mxUINT64_CLASS,
        mxFUNCTION_CLASS,
        mxOPAQUE_CLASS,
        mxOBJECT_CLASS
    } mxClassID;

    typedef size_t  mwSize;

    #define mxGetClassID(x) mxUINT8_CLASS
#endif


#define TBH_MAGIC_MAXLEN      14
#define TBH_PLATFORM_MAXLEN   11
#define TBH_COMPRID_MAXLEN    12
#define TBH_ENDIAN_MAXLEN      2

extern const char  TBH_MAGIC[];     
extern       char  TBH_platform[];  
extern       char  TBH_endian[];    

#ifdef MAIN_MODULE

/* Implementations */

static int typed_blobs_mode = 0; 

namespace old_version { int check_compatibility(void); };

void typed_blobs_init()
{
    mxArray *plhs[3] = {0};
    
    assert( old_version::check_compatibility() );
    
#if defined( MATLAB_MEX_FILE)
    if( 0 == mexCallMATLAB( 3, plhs, 0, NULL, "computer" ) )
    {
        mxGetString( plhs[0], TBH_platform, TBH_PLATFORM_MAXLEN );
        mxGetString( plhs[2], TBH_endian, TBH_ENDIAN_MAXLEN );

        ::utils_destroy_array( plhs[0] );
        ::utils_destroy_array( plhs[1] );
        ::utils_destroy_array( plhs[2] );
    }
#else
#endif
}

void typed_blobs_mode_set( int mode )
{
    typed_blobs_mode = (mode != 0);
}

int typed_blobs_mode_on()
{
    return typed_blobs_mode;
}

/*static*/ const char  TBH_MAGIC[TBH_MAGIC_MAXLEN]         = "mkSQLite.tbh\0"; 
/*static*/       char  TBH_platform[TBH_PLATFORM_MAXLEN]   = {0};              
/*static*/       char  TBH_endian[TBH_ENDIAN_MAXLEN]       = {0};              

#endif

struct GCC_PACKED_STRUCT TypedBLOBHeaderBase 
{
  char    m_magic[TBH_MAGIC_MAXLEN];        
  int16_t m_ver;                            
  int32_t m_clsid;                          
  char    m_platform[TBH_PLATFORM_MAXLEN];  
  char    m_endian;                         
  
  void init( mxClassID clsid )
  {
    strcpy( m_magic,    TBH_MAGIC );
    strcpy( m_platform, TBH_platform );
    
    m_ver       = (int16_t)sizeof( *this ); // Header size used as version number
    m_clsid     = (int32_t)clsid;           // MATLABs class ID
    m_endian    = TBH_endian[0];            // First letter only ('L'ittle or 'B'ig)
  }
  
  bool validMagic()
  {
    return 0 == _strnicmp( m_magic, TBH_MAGIC, TBH_MAGIC_MAXLEN );
  }
  
  static
  bool validClsid( mxClassID clsid )
  {
    switch( clsid )
    {
      // standard types can be stored in any typed blob
      case mxLOGICAL_CLASS:
      case    mxCHAR_CLASS:
      case  mxDOUBLE_CLASS:
      case  mxSINGLE_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:
        return true;
      default:
        // no other types supported so far
        return false;
    }
  }
  

  static
  bool validClsid( const mxArray* pItem )
  {
    return pItem && validClsid( mxGetClassID( pItem ) );
  }
  
  
  bool validClsid()
  {
    return validClsid( (mxClassID)m_clsid );
  }
  
  
  bool validPlatform()
  {
    return TBH_endian[0] == m_endian && 0 == _strnicmp( TBH_platform, m_platform, TBH_PLATFORM_MAXLEN );
  }
  
  
#if defined( MATLAB_MEX_FILE )
  static
  size_t getDataSize( const mxArray* pItem )
  {
    size_t data_size = 0;
    
    if( pItem )
    {
      size_t szElement   = mxGetElementSize( pItem );
      size_t cntElements = mxGetNumberOfElements( pItem );
      
      data_size = szElement * cntElements;
    }
    
    return data_size;
  }
#endif
};


struct GCC_PACKED_STRUCT TypedBLOBHeaderCompressed : public TypedBLOBHeaderBase 
{
  char m_compression[12];

  void init( mxClassID clsid )
  {
    TypedBLOBHeaderBase::init( clsid );
    setCompressor( "" );
  }

  void setCompressor( const char* strCompressorType )
  {
    strncpy( m_compression, strCompressorType, sizeof( m_compression ) );
  }
  
  const char* getCompressor()
  {
    return m_compression;
  }
  
  bool validCompression()
  {
    return 1;
  }
};


template< typename HeaderBaseType >
struct GCC_PACKED_STRUCT TBHData : public HeaderBaseType
{
  int32_t m_nDims[1];  

  void init( mxClassID clsid, mwSize nDims, const mwSize* pSize )
  {
    HeaderBaseType::init( clsid );
    HeaderBaseType::m_ver = sizeof( *this );
    
    assert( nDims >= 0 );
    assert( !nDims || pSize );
    
    m_nDims[0] = nDims;
    for( int i = 0; i < (int)nDims; i++ )
    {
      m_nDims[i+1] = (int32_t)pSize[i];
    }
  }
  
  
  void init( const mxArray* pItem )
  {
    assert( pItem );
    mxClassID clsid = mxGetClassID( pItem );
    mwSize nDims = mxGetNumberOfDimensions( pItem );
    const mwSize* dimensions = mxGetDimensions( pItem );
    
    init( clsid, nDims, dimensions );
  }
  
  
  bool validVer()
  {
      return sizeof(*this) == (size_t)HeaderBaseType::m_ver;
  }
  
  
  void* getData( mwSize nDims )
  {
    return (void*)&m_nDims[ nDims + 1 ];
  }
  
  
  void* getData()
  {
    return getData( m_nDims[0] );
  }
  
  
  static
  size_t dataOffset( mwSize nDims )
  {
    //return offsetof( TBHData, m_nDims[nDims+1] ); /* doesn't work on linux gcc 4.1.2 */
    TBHData* p = (TBHData*)1024; // p must be something other than 0, due to compiler checking
    return (char*)&p->m_nDims[nDims+1] - (char*)p;
  }
  
  
  size_t dataOffset()
  {
    return dataOffset( m_nDims[0] );
  }
  
  
  size_t getDataSize()
  {
    return utils_elbytes( (mxClassID)HeaderBaseType::m_clsid );
  }
  
  
  mxArray* createNumericArray( bool doCopyData )
  {
    mwSize nDims = m_nDims[0];
    mwSize* dimensions = new mwSize[nDims];
    mxArray* pItem = NULL;
    mxClassID clsid = (mxClassID)HeaderBaseType::m_clsid;
    
    for( int i = 0; i < (int)nDims; i++ )
    {
      dimensions[i] = (mwSize)m_nDims[i+1];
    }
    
    pItem = mxCreateNumericArray( nDims, dimensions, clsid, mxREAL );
    delete[] dimensions;
    
    // copy hosted item data into numeric array
    if( pItem && doCopyData )
    {
      memcpy( mxGetData( pItem ), getData(), TypedBLOBHeaderBase::getDataSize( pItem ) );
    }
    
    return pItem;
  }
  
private: 
  TBHData();
  TBHData( const TBHData& );
  TBHData& operator=( const TBHData& );
};

typedef TBHData<TypedBLOBHeaderBase>       TypedBLOBHeaderV1;  
typedef TBHData<TypedBLOBHeaderCompressed> TypedBLOBHeaderV2;  


namespace old_version {
    /* Store type and dimensions of MATLAB vectors/arrays in BLOBs */
    static const char TBH_MAGIC[] = "mkSQLite.tbh";  
    static char TBH_platform[11]    = {0};           
    static char TBH_endian[2]       = {0};           

    // typed BLOB header agreement
    // native and free of matlab types, to provide data sharing with other applications

#ifdef _WIN32
#pragma pack( push )
#pragma pack()
#endif

    typedef struct 
    {
      char magic[sizeof(TBH_MAGIC)];  
      int16_t ver;                    
      int32_t clsid;                  
      char platform[11];              
      char endian;                    
      int32_t sizeDims[1];            
    } TypedBLOBHeader;

#ifdef _WIN32
#pragma pack( pop )
#endif

#define TBH_DATA(tbh)            ((void*)&tbh->sizeDims[tbh->sizeDims[0]+1])
#define TBH_DATA_OFFSET(nDims)   ((ptrdiff_t)&((TypedBLOBHeader*) 0)->sizeDims[nDims+1])

    int check_compatibility()
    {
        TypedBLOBHeaderV1*  tbh1         = (TypedBLOBHeaderV1*)1024;
        TypedBLOBHeader*    old_struct   = (TypedBLOBHeader*)1024;

        if(     (void*)&tbh1->m_ver          == (void*)&old_struct->ver
            &&  (void*)&tbh1->m_clsid        == (void*)&old_struct->clsid
            &&  (void*)&tbh1->m_platform[0]  == (void*)&old_struct->platform[0]
            &&  (void*)&tbh1->m_endian       == (void*)&old_struct->endian
            &&  (void*)&tbh1->m_nDims        == (void*)&old_struct->sizeDims
            &&   TBH_DATA_OFFSET(2)          == TypedBLOBHeaderV1::dataOffset(2) )
        {
            return 1;
        } 
        else 
        {
            return 0;
        }
    }

#undef TBH_DATA
#undef TBH_DATA_OFFSET
};