subscription.h

#ifndef SUBSCRIPTION_H
#define SUBSCRIPTION_H
/*
*
* $LastChangedDate: 2022-04-25 15:05:33 -0400 (Mon, 25 Apr 2022) $
*   $LastChangedBy: ed $
*        $Revision: 3190 $
*          $Author: ed $
*             $URL: svn+ssh://svn.vremsoft.com/var/share/svn/tags/platfom3.4.3/platformlib/subscription.h $
*              $Id: subscription.h 3190 2022-04-25 19:05:33Z ed $
*           edc@vremsoft.com
*
*       19
*
*             *** 2014<c> ***
*
*
*/
#include <QObject>
 
#include "platform_global.h"
#include "publication.h"
#include "memoryheap.h"
#include "algo.h"
#include <QString>
#include <QList>
#include <QVariantList>
 
 
#include <QStringList>
#include <QDataStream>
 
class Publication;
 
 
class  PLATFORMSHARED_EXPORT Subscription : public QObject
{
      Q_OBJECT
 
public:
      typedef  enum { EventOnly = 0, CacheData = 1 } StorageType ;
 
private :
      Publication *publication;
      MemoryHeap   storeRoom;
      bool         needUpdate;
      QString      nameOfPublication;
      QVariant     userdata;
      quint64      ourId;
      bool         owner;
 
private slots:
      void  SlotUpdateHasOccured( qint16 index, qint16 count, QVariant src );
      void  SlotDataResetHasOccured(  qint16 count, QVariant src  );
      void  SlotHasSubscriberConnectedEvent(int connections)
      {
         Q_UNUSED(connections)
         emit SignalEventIamTheLastSubscription();
      }
 
public:
 
      Subscription(QString name, QObject *parent = nullptr);
 
      virtual ~Subscription();
 
      virtual MemoryHeap &getMemoryHeap();
 
      virtual int getSize();
 
      virtual Publication *getPublication(void)
      {
         return publication;
      }
 
      virtual void PeerConnect()
      {
 
      }
      virtual void setUserData( QVariant UserInfo)
      {
         userdata = UserInfo;
      }
 
      virtual QVariant userData( )
      {
         return userdata;
      }
 
      virtual void UserResetEventOccured(  qint16 count, QVariant src)
      {
          Q_UNUSED(count)
          Q_UNUSED(src)
      }
 
      virtual void UserEventOccured(qint16 index, qint16 count, QVariant src)
      {
          Q_UNUSED(index)
          Q_UNUSED(count)
          Q_UNUSED(src)
      }
 
      virtual void ResetArray( const VremVArray values, QVariant src = "local" )
      {
          getPublication()->resetArray(values,src);
      }
 
      virtual void Update( const QVariant value, int index = 0, QVariant src = "local" )
      {
          getPublication()->insertVariant(index, value, src);
      }
      virtual void Update( const VremVArray values, int index = 0, QVariant src = "local" )
      {
         getPublication()->insertArray(index,values,src);
      }
 
      virtual bool isResident()
      {
          return false;
      }
 
      virtual bool isOwner()
      {
          return owner;
      }
 
      virtual void Update( const VremList values, int index = 0, QVariant src = "local" )
      {
         if( values.size())
         {
            VremVArray v( values.size());
            int i;
            for( i = 0; i < v.size() && i < values.size(); ++i)
                v[i] = values[i];
            getPublication()->insertArray(index,v,src);
         }
      }
 
      void SetPublisherProperty(QVariant property);
 
      QVariant GetPublisherPropery(void);
 
      void SetPublisherPropertyDescription(QString desc);
 
      QString GetPublisherProperyDescription(void);
 
      virtual void Update( const QStringList values, int index = 0, QVariant src = "local" )
      {
          if( values.size())
          {
              VremVArray v( values.size());
              int i;
              for( i = 0; i < v.size() && i < values.size(); ++i)
                  v[i] = values[i];
              getPublication()->insertArray(index,v,src);
          }
      }
 
      virtual VremVArray RequestValues(int index = 0, int count = 1)
      {
            return getMemoryHeap().getArray(index,count);
      }
 
 
      virtual QVariant getSnglValue( int index = 0)
      {
            VremVArray i1 = RequestValues(index,1);
            if( i1.size() )
            {
          return i1[0];
            }
            return QVariant();
      }
 
      virtual VremVArray RequestAllValues(int index = 0)
      {
         return getMemoryHeap().getArray(index,0);
      }
 
      virtual void Repeat( QVariant v, int count, int index = 0 );
 
      QString const text(void)
      {
          return nameOfPublication;
      }
 
      void ForceGlobal(void);
      void RemoveGlobal(void);
 
signals:
     void SignalEventDataReset(  qint16 count, QVariant src);
     void SignalEventOccured(qint16 index, qint16 count, QVariant src);
     void SignalEventIamTheLastSubscription();
     void SignalNamedEventOccured(QString name, qint16 index, qint16 count, QVariant src);
     void SignalUserDataEventOccured(QVariant udata, qint16 index, qint16 count, QVariant src);
 
public slots:
 
private slots :
    void  SlotPeerConnect();
 
};
 
#endif // SUBSCRIPTION_H