memoryatom.h

#ifndef MEMORYATOM_H
#define MEMORYATOM_H
 
#include <QObject>
#include <QVarLengthArray>
#include <QReadWriteLock>
#include <QVariant>
#include <QtGlobal>
 
#include <platform_global.h>
#include <memoryheap.h>
 
 
class PLATFORMSHARED_EXPORT  MemoryAtom : public QObject
{
     Q_OBJECT
 
private :
    RecursiveLock  classLock;
    void unlock()
    {
        classLock.unlock();
    }
    void lockForWrite()
    {
        classLock.lockForWrite();
    }
    void lockForRead()
    {
        classLock.lockForRead();
    }
protected :
     MemoryHeap  storeRoom;
 
public:
    explicit MemoryAtom(QObject *parent = 0);
 
    VremVArray getArray()
    {
        VremVArray i1;
 
        lockForRead();
 
        i1 = storeRoom.getArray();
        unlock();
        return i1;
    }
 
    VremVArray  getArray(int index, int count )
    {
        VremVArray ibv;
        lockForRead();
        ibv = storeRoom.getArray(index, count);
 
        unlock();
        return ibv;
    }
 
    int insertVariant(int index, QVariant i1, QVariant src = "local" )
    {
 
        qint16   _count;
         _count = 0;
 
        lockForWrite();
        storeRoom.insertVariant(index, i1);
        _count = 1;
 
        unlock();
        if (receivers(SIGNAL(SignalUpdateHasOccured(qint16, qint16, QVariant ))) > 0)
          emit SignalUpdateHasOccured(index, _count, src );
 
        return _count;
    }
 
    int insertArray(int index, const VremVArray &i1, QVariant src = "local" )
    {
         lockForWrite();
         storeRoom.insertArray(index, i1);
         unlock();
         if (receivers(SIGNAL(SignalUpdateHasOccured(qint16, qint16, QVariant ))) > 0)
              emit SignalUpdateHasOccured(index, i1.size(), src );
 
         return i1.size();
    }
 
 
    void resetArray(const VremVArray &i1, QVariant src = "local")
    {
        classLock.lockForWrite();
        storeRoom.clear();
        storeRoom.insertArray(0, i1);
        classLock.unlock();
        if (receivers(SIGNAL(SignalDataResetHasOccured( qint16, QVariant ))) > 0)
          emit SignalDataResetHasOccured( i1.size(), src );
    }
 
    void clear(QVariant src = "local")
    {
        classLock.lockForWrite();
        storeRoom.clear();
        classLock.unlock();
        if (receivers(SIGNAL(SignalUpdateHasOccured(qint16, qint16, QVariant ))) > 0)
          emit SignalUpdateHasOccured(0, 0, src );
    }
 
 
    int getSize(void)
    {
        int size;
        lockForRead();
        size = storeRoom.size();
        unlock();
        return size;
    }
 
 
    MemoryAtom &operator=( MemoryAtom &i1 )
    {
        qint16 index, count;
        index = count = 0;
 
        lockForWrite();
 
        i1.lockForRead();
        storeRoom = i1.storeRoom;
        i1.unlock();
        count = (qint16 )storeRoom.size();
        unlock();
        if (receivers(SIGNAL(SignalUpdateHasOccured(qint16, qint16, QVariant ))) > 0)
             emit SignalUpdateHasOccured(index, count, "local" );
        return *this;
    }
 
    MemoryAtom &operator=( VremVArray &i1 )
    {
        qint16 index, count;
        index = count = 0;
 
        lockForWrite();
        storeRoom = i1;
        count = storeRoom.size();
        unlock();
        if (receivers(SIGNAL(SignalUpdateHasOccured(qint16, qint16, QVariant ))) > 0)
             emit SignalUpdateHasOccured(index, count, "local" );
        return *this;
    }
 
 
signals:
     void  SignalUpdateHasOccured( qint16 index, qint16 count, QVariant srcOfUpdate );
     void  SignalDataResetHasOccured( qint16 count, QVariant srcOfUpdate );
 
 
 
public slots:
 
 
};
 
 
 
 
 
#endif // MEMORYATOM_H