shmem.h

Go to the documentation of this file.

#pragma once
 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include "safe_winsock.h"
#include <stdexcept>
 
namespace mlib {

class shmem_base
{
public:
  // constructors/destructor
  shmem_base ();
  shmem_base (const std::string& name, size_t size);
  virtual ~shmem_base ();
 
  // open/close
  virtual bool open (const std::string& name, size_t size);
  virtual bool close ();
 
  bool created () const
  {
    return mem_created;
  };
  bool is_opened () const
  {
    return mem != NULL;
  };
  size_t size () const
  {
    return sz;
  };
  const std::string& name () const
  {
    return name_;
  };
 
  // get/set function for read/write timeout
  void wtmo (DWORD msec)
  {
    wtmo_ = msec;
  };
  DWORD wtmo () const
  {
    return wtmo_;
  };
  void rtmo (DWORD msec)
  {
    rtmo_ = msec;
  };
  DWORD rtmo () const
  {
    return rtmo_;
  };
 
  // data access function
  virtual bool write (const void* data);
  virtual bool read (void* data);
 
protected:
  // Lock control
  bool rdlock ();
  void rdunlock ();
  bool wrlock ();
  void wrunlock ();
 
  // Unprotected data access functions. Use always together with lock control functions
  virtual void get (void* data);
  virtual void put (const void* data);
  void* dataptr () const
  {
    return mem;
  };
 
private:
#pragma pack(push, 1)
  struct syncblk
  {
    HANDLE wrex;   
    HANDLE rdgate; 
    DWORD wrid;    
    //    long rdreq;             ///< requesting readers
    LONG rc; 
    LONG wc; 
  };
#pragma pack(pop)
 
  std::string name_;
  LONG in_rdlock;
  LONG in_wrlock;
  bool mem_created;
  HANDLE file;
  HANDLE rdgate, wrex;
  DWORD rtmo_, wtmo_;
  size_t sz;
  struct syncblk* syn;
  void* mem;
};

template <class S, class B = shmem_base>
class shmem : public B
{
public:
  shmem ();
  shmem (const char* name);
  bool open (const char* name, size_t sz = sizeof (S));
  void operator>> (S& data);
  void operator<< (const S& data);
 
protected:
  S* dataptr () const
  {
    return (S*)B::dataptr ();
  };
 
  template <class S, class B>
  friend class lockr;
  template <class S, class B>
  friend class lockw;
};

template <class S, class B>
shmem<S, B>::shmem ()
  : B (){};

template <class S, class B>
shmem<S, B>::shmem (const char* name)
  : B (name, sizeof (S)){};

template <class S, class B>
bool shmem<S, B>::open (const char* name, size_t sz)
{
  return B::open (name, sz);
};

template <class S, class B>
void shmem<S, B>::operator>> (S& data)
{
  this->read (&data);
};

template <class S, class B>
void shmem<S, B>::operator<< (const S& data)
{
  this->write (&data);
};

 
template <class S, class B = shmem_base>
class lockr
{
public:
  lockr (shmem<S, B>& mem_);
  ~lockr ()
  {
    mem.rdunlock ();
  };
 
  const S* operator->()
  {
    return const_cast<const S*> (mem.dataptr ());
  };
  operator const S* ()
  {
    return const_cast<const S*> (mem.dataptr ());
  };
 
private:
  shmem<S, B>& mem;
};
 
template <class S, class B>
lockr<S, B>::lockr (shmem<S, B>& mem_)
  : mem (mem_)
{
  if (!mem.rdlock ())
    throw std::runtime_error ("rdlock failure");
}

 
template <class S, class B = shmem_base>
class lockw
{
public:
  lockw (shmem<S, B>& mem_);
  ~lockw ()
  {
    mem.wrunlock ();
  };
 
  S* operator->()
  {
    return mem.dataptr ();
  };
  operator S* ()
  {
    return mem.dataptr ();
  };
 
private:
  shmem<S, B>& mem;
};
 
template <class S, class B>
lockw<S, B>::lockw (shmem<S, B>& mem_)
  : mem (mem_)
{
  if (!mem.wrlock ())
    throw std::runtime_error ("wrlock failed");
};
 
} // namespace mlib