include/ssm.hpp

Go to the documentation of this file.

#ifndef __SSM_HPP__
#define __SSM_HPP__

#include <iostream>
#include "ssm.h"

class SSMDummy
{
};


class SSMApiBase
{
protected:
    const char *streamName;                 
    int streamId;                               
    SSM_sid ssmId;                              
    bool isVerbose;                             
    bool isBlocking;                            
    void *mData;                                
    size_t mDataSize;                           
    void *mProperty;                            
    size_t mPropertySize;                       

    void init(  )
    {
        streamName = NULL;
        streamId = 0;
        ssmId = 0;
        isVerbose = true;
        isBlocking = false;
        timeId = -1;
        mData = NULL;
        mDataSize = 0;
        mProperty = NULL;
        mPropertySize = 0;
    }
    void init( const char *streamName, int streamId = 0 )
    {
        init(  );
        this->streamName = streamName;
        this->streamId = streamId;
    }
    

    void setStream( const char *streamName, int streamId = 0 )
    {
        this->streamName = streamName;
        this->streamId = streamId;
    }

public:
    SSM_tid timeId;                             
    ssmTimeT time;                              

    SSMApiBase(  )
    {
        init(  );
    }

    SSMApiBase( const char *streamName, int streamId = 0 )
    {
        init(  );
        setStream( streamName, streamId );
    }
    
    virtual ~SSMApiBase(){}

    bool isOpen(  ) const
    {
        return ( ssmId != 0 ? true : false );
    }
    bool isUpdate(  )
    {
        if( !isOpen(  ) )
        {
            return false;
        }
        return ( getTID_top( ssmId ) > timeId );
    }

    void setVerbose( bool verbose )
    {
        isVerbose = verbose;
    }
    
    void setBlocking( bool isBlocking )
    {
        this->isBlocking = isBlocking;
    }

    const char *getStreamName() const
    {
        return streamName;
    }
    const char *getSensorName() const
    {
        std::cerr << "SSMBase::getSensorName is old function. so please use get SSMBase::getStreamName()" << std::endl;
        return streamName;
    }
    
    int getStreamId() const
    {
        return streamId;
    }
    int getSensorId() const
    {
        std::cerr << "SSMBase::getSensorId is old function. so please use get SSMBase::getStreamId()" << std::endl;
        return streamId;
    }
    
    SSM_sid getSSMId() const
    {
        return ssmId;
    }
    
    void *data()
    {
        return mData;
    }
    
    size_t dataSize()
    {
        return mDataSize;
    }
    
    void *property()
    {
        return mProperty;
    }
    
    size_t propertySize()
    {
        return mPropertySize;
    }

    virtual size_t sharedSize(  )
    {
        return mDataSize;
    }
    
    bool create( double saveTime, double cycle )
    {
        if( !mDataSize )
        {
            std::cerr << "SSM::create() : data buffer of ''" << streamName << "', id = " << streamId << " is not allocked." << std::endl;
            return false;
        }

        ssmId = createSSM( streamName, streamId, sharedSize(  ), saveTime, cycle );
        if( ssmId == 0 )
        {
            if( isVerbose )
            {
                std::cerr << "SSM::create() : cannot create '" << streamName << "', id = " << streamId << std::endl;
            }
            return false;
        }
        return true;
    }

    bool create( const char *streamName, int streamId, double saveTime, double cycle )
    {
        setStream( streamName, streamId );
        return create( saveTime, cycle );
    }

    bool release(  )
    {
        return releaseSSM( &ssmId );
    }

    bool open( SSM_open_mode openMode = SSM_READ )
    {
        if( !mDataSize )
        {
            std::cerr << "SSM::open() : data buffer of '" << streamName << "', id = " << streamId << " is not allocked." << std::endl;
            return false;
        }
        ssmId = openSSM( streamName, streamId, openMode );
        if( ssmId == 0 )
        {
            if( isVerbose )
            {
                std::cerr << "SSM::open() : cannot open '" << streamName << "', id = " << streamId << std::endl;
            }
            return false;
        }
        return true;
    }

    bool open( const char *streamName, int streamId = 0, SSM_open_mode openMode = SSM_READ )
    {
        setStream( streamName, streamId );
        return open( openMode );
    }

    bool openWait( ssmTimeT timeOut = 0.0, SSM_open_mode openMode = SSM_READ )
    {
        if( !mDataSize )
            return false;

        bool ret, isVerbose;
        ssmTimeT start = gettimeSSM_real(  );

        isVerbose = this->isVerbose;
        this->isVerbose = false;

        ret = open( openMode );
        if( isVerbose && ( !ret ))
        {
            std::cerr << "SSM::openWait() : wait for stream '" << streamName << "', id = " << streamId << std::endl;
        }

        while( ( !ret ) && ( !sleepSSM( 1.0 ) ) && ( ( timeOut <= 0 ) || gettimeSSM_real(  ) - start < timeOut ) )
        {
            ret = open(  );
        }

        this->isVerbose = isVerbose;
        if( !ret )
            ret = open( openMode );
        return ret;
    }
    
    bool openWait( const char *streamName, int streamId = 0, ssmTimeT timeOut = 0.0, SSM_open_mode openMode = SSM_READ )
    {
        setStream( streamName, streamId );
        return openWait( timeOut, openMode );
    }

    bool close(  )
    {
        return closeSSM( &ssmId );
    }

    virtual bool write( ssmTimeT time = gettimeSSM(  ) )
    {
        if( !isOpen(  ) )
        {
            return false;
        }
        SSM_tid tid = writeSSM( ssmId, mData, time );
        if( tid >= 0 )
        {
            timeId = tid;
            this->time = time;
            return true;
        }
        return false;
    }
    virtual bool read( SSM_tid timeId = -1 )
    {
        if( !isOpen(  ) )
        {
            return false;
        }
        SSM_tid tid = readSSM( ssmId, mData, &time, timeId );
        if( tid >= 0 )
        {
            this->timeId = tid;
            return true;
        }
        return false;
    }

    bool readNext( int dt = 1 )
    {
        SSM_tid tid = getTID_bottom( ssmId ), rtid;
        if( timeId < 0 )
        {
            if( isBlocking )
                waitTID( ssmId, 0 );
            return read( -1 );
        }
        rtid = timeId + dt;
        if( rtid >= tid)
        {
            if( isBlocking )
                waitTID( ssmId, rtid );
            return read( rtid );
        }

        if( isVerbose )
            std::cerr << "SSM::readNext() : skipping read data  '" << streamName << "', id = " << streamId
                << " TID: "<< rtid << " -> " << tid << std::endl;
        return read( tid );
    }

    bool readBack( int dt = 1 )
    {
        return ( dt <= timeId ? read( timeId - dt ) : false );
    }

    bool readLast(  )
    {
        return read( -1 );
    }

    bool readNew(  )
    {
        if( isBlocking )
            waitTID( ssmId, timeId + 1 );
        return ( isUpdate(  ) ? read( -1 ) : false );
    }

    bool readTime( ssmTimeT time )
    {
        if( !isOpen(  ) )
        {
            return false;
        }
        SSM_tid tid = readSSM_time( ssmId, mData, time, &( this->time ) );
        if( tid >= 0 )
        {
            timeId = tid;
            return true;
        }
        return false;
    }
    
    bool setProperty(  )
    {
        if( mPropertySize > 0 )
            return static_cast < bool > ( set_propertySSM( streamName, streamId, mProperty, mPropertySize ) );
        else
            return false;
    }

    bool getProperty(  )
    {
        if( mPropertySize > 0 )
            return static_cast < bool > ( get_propertySSM( streamName, streamId, mProperty ) );
        else
            return false;
    }

    void setBuffer(void *data, size_t dataSize, void *property, size_t propertySize )
    {
        mData = data;
        mDataSize = dataSize;
        mProperty = property;
        mPropertySize = propertySize;
    }

};

template < typename T, typename P = SSMDummy > class SSMApi:public SSMApiBase
{
    void initApi()
    {
        SSMApiBase::setBuffer( &data, sizeof( T ), &property, sizeof( P ) );
    }

protected:
    void setBuffer(void *data, size_t dataSize, void *property, size_t propertySize );

public:
    T data;                                      
    P property;                                  

    SSMApi(  )
    {
        initApi();
    }
    
    SSMApi( const char *streamName, int streamId = 0 ) : SSMApiBase( streamName, streamId )
    {
        initApi();
    }
    
    ~SSMApi(  ){}
};

#endif                                          /* __SSM_HPP__ */