shmem.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This file is part of MLIB project. See LICENSE file for full license terms.
*/

 
#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;
  bool is_opened () const;
  size_t size () const;
 
  const std::string& name () const;
 
  // get/set function for read/write timeout
  void wtmo (DWORD msec);
  DWORD wtmo () const;
  void rtmo (DWORD msec);
  DWORD rtmo () const;
 
  // data access function
  virtual bool write (const void* data);
  virtual bool read (void* data);
 
protected:
  // Lock control
  virtual bool rdlock ();
  virtual void rdunlock ();
  virtual bool wrlock ();
  virtual void wrunlock ();

  void get (void* data) const;
  void put (const void* data);
  const void* dataptr () const;
  void* dataptr ();
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:
  const S* dataptr () const;
  S* 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 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");
};
 
//---------------------------------------------------------------------------

inline 
bool shmem_base::created () const
{
  return mem_created;
}

inline 
bool shmem_base::is_opened () const
{
  return mem != NULL;
}

inline 
size_t shmem_base::size () const
{
  return sz;
}

inline 
const std::string& shmem_base::name () const
{
  return name_;
}

inline 
void shmem_base::wtmo (DWORD msec)
{
  wtmo_ = msec;
}

inline
DWORD shmem_base::wtmo () const
{
  return wtmo_;
}

inline
void shmem_base::rtmo (DWORD msec)
{
  rtmo_ = msec;
}

inline
DWORD shmem_base::rtmo () const
{
  return rtmo_;
}

inline
void shmem_base::put (const void* data)
{
  memcpy (dataptr (), data, size ());
}

inline
void shmem_base::get (void* data) const
{
  memcpy (data, dataptr (), size ());
}

inline
const void* shmem_base::dataptr () const
{
  return mem;
}

inline
void* shmem_base::dataptr ()
{
  return mem;
}

template <class S, class B>
const S* shmem<S, B>::dataptr () const
{
  return (const S*)B::dataptr ();
}

template <class S, class B>
S* shmem<S, B>::dataptr ()
{
  return (S*)B::dataptr ();
}
 
} // namespace mlib