shared_memory.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <set>

#include "timing.h"
#include "defines.h"

#if defined(__CYGWIN__) || defined(_WIN32)
#include <windows.h>
#else
#include <semaphore.h>
#endif

#define STAT_EX_SIZE 175
#define PLAY_EX_SIZE 2+6*SIMUL_TRACKS

namespace IPC {

  class statExchange {
    public:
      statExchange(char * _data);
      void now(long long int time);
      long long int now();
      void time(long time);
      long time();
      void lastSecond(long time);
      long lastSecond();
      void down(long long int bytes);
      long long int down();
      void up(long long int bytes);
      long long int up();
      void host(std::string name);
      std::string host();
      void streamName(std::string name);
      std::string streamName();
      void connector(std::string name);
      std::string connector();
      void crc(unsigned int sum);
      char getSync();
      void setSync(char s);
      unsigned int crc();
  private:
      char * data;
  };

  class semaphore {
    public:
      semaphore();
      semaphore(const char * name, int oflag, mode_t mode, unsigned int value);
      ~semaphore();
      operator bool() const;
      void open(const char * name, int oflag, mode_t mode = 0, unsigned int value = 0);
      int getVal() const;
      void post();
      void wait();
      bool tryWait();
      bool tryWaitOneSecond();
      void close();
      void unlink();
    private:
#if defined(__CYGWIN__) || defined(_WIN32)
      static SECURITY_ATTRIBUTES getSecurityAttributes();
      HANDLE mySem;
#else
      sem_t * mySem;
#endif
      std::string myName;
  };

  class semGuard {
    public:
      semGuard(semaphore * thisSemaphore);
      ~semGuard();
    private:
      semaphore * mySemaphore;
  };

  class sharedFile {
    public:
      sharedFile(std::string name_ = "", unsigned int len_ = 0, bool master_ = false, bool autoBackoff = true);
      sharedFile(const sharedFile & rhs);
      ~sharedFile();
      operator bool() const;
      void init(std::string name_, unsigned int len_, bool master_ =  false, bool autoBackoff = true);
      void operator =(sharedFile & rhs);
      bool operator < (const sharedFile & rhs) const {
        return name < rhs.name;
      }
      void close();
      void unmap();
      int handle;
      std::string name;
      long long int len;
      bool master;
      char * mapped;
  };

#if defined(__CYGWIN__) || defined(_WIN32)
  void preservePage(std::string);
  void releasePage(std::string);
#endif

#ifdef SHM_ENABLED
  class sharedPage {
  public:
    sharedPage(std::string name_ = "", unsigned int len_ = 0, bool master_ = false, bool autoBackoff = true);
    sharedPage(const sharedPage & rhs);
    ~sharedPage();
    operator bool() const;
    void init(std::string name_, unsigned int len_, bool master_ =  false, bool autoBackoff = true);
    void operator =(sharedPage & rhs);
    bool operator < (const sharedPage & rhs) const {
      return name < rhs.name;
    }
    void unmap();
    void close();
    #if defined(__CYGWIN__) || defined(_WIN32)
    HANDLE handle;
    #else
    int handle;
    #endif
    std::string name;
    long long int len;
    bool master;
    char * mapped;
  };
#else
  class sharedPage: public sharedFile {
    public:
      sharedPage(std::string name_ = "", unsigned int len_ = 0, bool master_ = false, bool autoBackoff = true);
      sharedPage(const sharedPage & rhs);
      ~sharedPage();
  };
#endif

  class sharedServer {
    public:
      sharedServer();
      sharedServer(std::string name, int len, bool withCounter = false);
      void init(std::string name, int len, bool withCounter = false);
      ~sharedServer();
      void parseEach(void (*callback)(char * data, size_t len, unsigned int id));
      operator bool() const;
      unsigned int amount;
    private:
      bool isInUse(unsigned int id);
      void newPage();
      void deletePage();
      std::string baseName;
      unsigned int payLen;
      std::set<sharedPage> myPages;
      semaphore mySemaphore;
      bool hasCounter;
  };

  class sharedClient {
    public:
      sharedClient();
      sharedClient(const sharedClient & rhs);
      sharedClient(std::string name, int len, bool withCounter = false);
      void operator = (const sharedClient & rhs);
      ~sharedClient();
      void write(char * data, int len);
      void finish();
      void keepAlive();
      char * getData();
    private:
      std::string baseName;
      sharedPage myPage;
      semaphore mySemaphore;
      int payLen;
      int offsetOnPage;
      bool hasCounter;
  };

  class userConnection {
    public:
      userConnection(char * _data);
      unsigned long getTrackId(size_t offset) const;
      void setTrackId(size_t offset, unsigned long trackId) const;
      unsigned long getKeynum(size_t offset) const;
      void setKeynum(size_t offset, unsigned long keynum);
    private:
      char * data;
  };
}