platform_global.h

#ifndef PLATFORM_GLOBAL_H
#define PLATFORM_GLOBAL_H
 
#include <QDebug>
#include <QFileInfo>
#include <QList>
#include <QMap>
#include <QMutex>
#include <QObject>
#include <QReadLocker>
#include <QReadWriteLock>
#include <QSettings>
#include <QString>
#include <QStringList>
#include <QtCore/qglobal.h>
#include <QThread>
#include <QVariant>
#include <QVarLengthArray>
#include <QWriteLocker>
#include <QDataStream>
 
 
 
#if QT_VERSION >= 0x050000
 
#ifdef Q_OS_WIN32
#ifndef Q_WS_WIN
#define Q_WS_WIN
#endif
#endif
 
#ifdef Q_OS_WIN64
#ifndef Q_WS_WIN
#define Q_WS_WIN
#endif
#endif
 
#endif
 
class Subscription;
 
typedef QVarLengthArray<QVariant> VremVArray;
typedef QList<QVariant> VremList;
typedef QVarLengthArray<Subscription *> VremSubArray;
 
#if defined(PLATFORM_LIBRARY)
#  define PLATFORMSHARED_EXPORT Q_DECL_EXPORT
#else
#  define PLATFORMSHARED_EXPORT Q_DECL_IMPORT
#endif
 
 
#if QT_VERSION >= 0x050500
#define STEAMVERSION  QDataStream::Qt_DefaultCompiledVersion
#else
#define STEAMVERSION  QDataStream::Qt_5_0
#endif
 
#include "definitions.h"
 
 
 
#define VSETTINGS() \
  QSettings settings( Definitions::GetApplicationPath(Definitions::GetApplicationName()),QSettings::IniFormat)
 
 
class Publication;
class PublicationRegistration;
 
 
PLATFORMSHARED_EXPORT Publication* CreatePublication(const QString name);
PLATFORMSHARED_EXPORT QStringList GetAllPublicationNames(void);
PLATFORMSHARED_EXPORT QStringList GetAllPossibleNames(void);
 
PLATFORMSHARED_EXPORT PublicationRegistration *InitCloudInstance(QObject *parent = 0);
PLATFORMSHARED_EXPORT PublicationRegistration *GetCloudInstance(void);
 
 
PLATFORMSHARED_EXPORT void MountLibraryInstance(int argc, char *argv[]);
PLATFORMSHARED_EXPORT void MountLibraryInstance(QStringList xargv, QStringList qargv);
PLATFORMSHARED_EXPORT void UnMountLibraryInstance();
 
 
class  PLATFORMSHARED_EXPORT RecursiveLock : public QReadWriteLock
{
public :
 
     RecursiveLock () : QReadWriteLock(QReadWriteLock::Recursive)
     {
 
     }
};
 
 
template<class T>
T VClear(void)
{
     T v = { { 0 }};
     return v;
}
 
 
 
template<class T>
class DLock
{
private :
     QMutex classLock;
     T Value;
public:
     DLock( T v)
     {
          Value = v;
     }
 
     DLock( )
     {
 
     }
     T operator=(const T &v)
     {
          QMutexLocker k (&classLock);
          Value = v;
          return v;
     }
 
     const T value(void)
     {
          QMutexLocker k (&classLock);
          T v;
          v = Value;
          return v;
     }
};
 
 
 
 
 
template<class T>
class DRWLock
{
private :
     RecursiveLock classLock;
     T Value;
public:
     DRWLock( T v)
     {
          Value = v;
     }
     DRWLock( )
     {
     }
 
     T operator=(const T &v)
     {
          classLock.lockForWrite();
          Value = v;
          classLock.unlock();
          return v;
     }
     const T value(void)
     {
          classLock.lockForRead();
          T v;
          v = Value;
          classLock.unlock();
          return v;
     }
};
 
 
 
template <class T>
 
 
struct TP {
      T p1;
      T p2;
      TP(void) : p1((T) 0), p2((T) 0)   {}
      TP( T v1, T v2) : p1(v1), p2(v2)  {}
 
 
friend bool Between ( TP<T> i1, TP<T> i2 )
      {
             T range1 = (i1.p1 + i1.p2) - (T)1;
             T range2 = (i2.p1 + i2.p2) - (T)1;
             if( (i2.p1 >= i1.p1 && i2.p1 <= range1) || (range2 >= i1.p1 && range2 <= range1))
                     return true;
             return false;
      }
};
 
 
template <class T>
class AUTOD
{
private :
      QMap<int,QList<T> > Channels;
 
public :
 
 
      void ClearAll( )
      {
             foreach ( QList<T>vlist, Channels.values() )
             {
                     foreach( T v, vlist)
                     {
                            delete v;
                     }
             }
      }
 
      void ClearAll( int uniqueId)
      {
 
             typename QMap<int,QList<T> >::iterator it;
             if( (it = Channels.find(uniqueId)) != Channels.end() )
             {
 
                     foreach( T v, it.value())
                     {
                            delete v;
                     }
                     Channels.erase(it);
             }
 
      }
 
      void Add(  int uniqueId, T v)
      {
             typename QMap<int,QList<T> >::iterator it;
             if ( (it = Channels.find(uniqueId)) != Channels.end() )
             {
                     it.push_back(v);
             }
             else {
                     QList<T> lst;
                     lst.push_back(v);
                     Channels.insert(uniqueId,lst);
             }
 
      }
 
 
      virtual ~AUTOD( )
      {
             ClearAll( );
      }
};
 
 
#endif // PLATFORM_GLOBAL_H