publicationregistration.h

#ifndef PUBLICATIONREGISTRATION_H
#define PUBLICATIONREGISTRATION_H
 
#include <platform_global.h>
#include <QObject>
#include <QMap>
#include <QString>
#include <QStringList>
#include <QWriteLocker>
#include <QReadWriteLock>
#include <QVariant>
#include <QUuid>
#include <qwatch.h>
 
class Publication;
class Subscription;
class Retain;
class QWidget;
 
class PLATFORMSHARED_EXPORT PublicationRegistration : public QObject
{
      Q_OBJECT
public :
    typedef enum:int { Owner, Local, NotEntered } LASTCHANCEMODE;
    QWatch errorLogger;
private:
 
 
      RecursiveLock  classLockPublications;
      RecursiveLock  uniques;
 
      QMap<QString,Publication *>systemsPublications;
      QMap<QString, QVariant> systemProperties;
 
      QMap<int,QStringList> remotePublications;
      QMap<QString, int> flashOffCopyRemoteNames;
      QMap<QString, QList<quint64>> forceGlobal;
      Retain *persistantRetention;
      QWidget *guiThread;
 
      quint64 uniqueIdDispatch;
 
      QMap <QString, LASTCHANCEMODE> LastChanceOwnership;
 
      QMap<QString, int> RelaysRequests;
      QMap<QString, void *> classRegistry;
 
      bool allowAutoConnectDaemon;
      bool allowRelays;
 
      QString  NodeName;
      QString  uuid;
 
public:
 
      explicit      PublicationRegistration(QObject *parent = nullptr);
 
      Publication*  CreatePublication(const QString name);
 
      QStringList   GetAllPublicationNames(void);
 
      QStringList   GetAllPossibleNames(void);
 
      QStringList   GetAllCurrentPublications(void);
 
      QStringList   GetAllGlobals(void);
 
      QMap<QString,QVariant> GetAllDescriptors(void);
 
      void AddDescription(QString name, QVariant desc);
      void RemoveDescription(QString name);
 
      QMap<QString, int>    GetAllPossibleNamesAndInstances();
 
      QMap<int,QStringList> GetAllRemotePublications(void);
 
 
      void ForceGlobal(QString name, quint64 id);
 
 
      void RemoveGlobal(QString name,quint64 id);
 
 
      void RequestRelay(QString name, bool flag = true);
 
      QStringList GetRelayRequests();
 
      void ReWriteGlobal(QString name,  LASTCHANCEMODE global );
 
      QMap<QString, PublicationRegistration::LASTCHANCEMODE> GetLastChance(void);
 
      PublicationRegistration::LASTCHANCEMODE TestLastChance(QString name );
 
 
      void AllowAutoConnectDaemon(bool allow = true);
      bool AutoConnectDaemon(void);
 
 
      void AddStorage( Retain *r);
 
      Retain *Storage (void );
 
 
      void SetGuiThread(QWidget *w);
 
      QWidget *GuiThread(void);
 
      void UseRetainedData( Subscription *subscription, VremVArray &va );
 
 
      void UseRetainedData( Subscription *subscription, QVariant va );
 
      void UserRemoveRetention( Subscription *subscriber);
 
 
 
    void setNodeName(QString name)
      {
          QReadLocker locker(&classLockPublications);
          NodeName = name;
      }
 
      QString getNodeName(void)
      {
          QReadLocker locker(&classLockPublications);
          return (NodeName);
      }
 
      void setUUID(QString name)
      {
          QReadLocker locker(&classLockPublications);
 
          uuid = name;
      }
 
      QString getUUID(void)
      {
          QReadLocker locker(&classLockPublications);
          if (uuid.isEmpty())
              uuid = QUuid::createUuid().toString();
          return (uuid);
      }
 
 
      QString getAlarmName()
      {
          return(getNodeName()+"Alarms");
      }
 
      QString getErrorName()
      {
          return(getNodeName()+"Error");
      }
 
      QString getMessagesName()
      {
          return(getNodeName()+"Messages");
      }
 
      QString getShitNotesName()
      {
          return(getNodeName()+"ShiftNotes");
      }
 
 
      quint64 UniqueID(void);
 
 
      template< class t >
      void RegisterProcessClass ( const QString name, t * dc)
      {
          QReadLocker locker(&classLockPublications);
          classRegistry.insert(name,dc);
          emit SignalNewClass(name, true);
      }
 
      void UnRegisterProcessClass ( const QString name)
      {
 
          QMap<QString, void *> ::iterator it;
          QReadLocker locker(&classLockPublications);
          if ( (it = classRegistry.find(name)) !=  classRegistry.end() )
          {
              classRegistry.erase(it);
              emit SignalNewClass(name, false);
          }
      }
 
 
      void *FindRegisteredClass(const QString name)
      {
          QMap<QString, void *>::iterator it;
          if( (it = classRegistry.find(name) ) != classRegistry.end() )
          {
              return it.value();
          }
          return nullptr;
      }
 
public slots :
 
      void slot_NewRemotePublication(int desc,  QString name);
 
      void slot_LostRemotePublication(int desc, QString name);
 
      void slot_LostRemoteDescriptor(int desc);
 
signals:
      void SignalNewPublication(QString name);
      void SignalLostPublication(QString name);
      void SignalNewPossiblePublication(QString name);
      void SignalLostPossiblePublication(QString name);
      void SignalNewRemotePublication(int desc, QString name );
      void SignalLostRemotePublication(int desc, QString name );
      void SignalLostRemoteDescriptor(int desc);
      void SignalGlobal(QString name, bool yes);
      void SignalRequestRelay(QString, int);
      void SignalNewClass(QString className , bool valid );
      void SignalDescriptorAdded(QString, QVariant);
      void SignalDescriptorLost(QString);
 
private slots:
      void slot_lostPublication(QString name);
 
 
};
 
#endif // PUBLICATIONREGISTRATION_H