Share Library (C++)

/**
 * @file test1_string.cpp
 * @brief Share library - test1 (DummyString)
 * @author Kamil Dudka, xdudka00@gmail.com
 * @date 2007-05-15
 */
 
#include "sharelib.h"
 
#include <string.h>
#include <iostream>
#include <sstream>
 
namespace {
  const size_t MAX_DATA_SIZE = 1024*1024;
}
 
using namespace Share;
 
/**
 * The simplest string implementation supporting IPC
 */
class DummyString: public SharedObject {
  public:
    DummyString();
    ~DummyString();
 
    DummyString (const char *str) { operator=(str); }
    DummyString (const DummyString &str):
      SharedObject()
    {
      operator=(str);
    }
 
    /**
     * Deep copy
     */
    DummyString& operator= (const DummyString &str)
    {
      return operator= (str.c_str());
    }
 
    /**
     * @return Return C-string
     */
    const char* c_str() const
    {
      return static_cast<const char *>(data_);
    }
 
    /**
     * C-string assignment
     */
    DummyString& operator= (const char *);
 
  private:
    /**
     * Relocable pointer to internal string representation
     */
    RelocPtr<char> data_;
};
 
/**
 * Relocable pointer to DummyString type
 */
typedef RelocPtr<DummyString> PDummyString;
 
DummyString::DummyString()
{
  // Using SharedObject::alloc instead of ::operator new
  data_ = SharedObject::alloc (sizeof(char));
  *data_ = '\0';
}
 
DummyString::~DummyString()
{
  // Using SharedObject::free instead of ::operator delete
  SharedObject::free (data_);
}
 
DummyString& DummyString::operator= (const char *str)
{
  // Using SharedObject::free instead of ::operator delete
  SharedObject::free (data_);
 
  // Using SharedObject::alloc instead of ::operator new
  data_ = SharedObject::alloc (sizeof(char), strlen (str) + 1);
 
  strcpy (data_, str);
  return *this;
}
 
int main (int argc, char *argv[])
{
  try {
    if (argc <=1 || 0==strcmp (argv[1],"--help") || 0==strcmp (argv[1],"--usage")) {
      std::cout <<
        "Usage:\n"
        "  test1_string SEGMENT\n"
        "  test1_string SEGMENT POINTER\n";
      return 0;
    }
    std::string name;
    PDummyString pString;
    if (argc >= 2) {
      std::istringstream arg1 (argv[1]);
 
      // Read segment name
      if (!(arg1 >> name)) {
        std::cerr << "Invalid name of shared segment\n";
        return 1;
      }
    }
    else {
      std::cerr << "Missing name of shared segment\n";
      return 1;
    }
 
    if (argc >= 3) {
      std::istringstream arg2 (argv[2]);
      PDummyString::relative_pointer relPtr;
 
      // Read relative address
      if (!(arg2 >> relPtr)) {
        std::cerr << "Invalid pointer to DummyString object\n";
        return 1;
      }
 
      // Initialize pointer from relative address
      pString = PDummyString::fromRel (relPtr);
 
      // Attach existing shared segment
      ShareManager *manager = ShareManager::instance();
      manager-> attachSegment (name.c_str());
 
      // Work with shared object
      std::cout << pString->c_str() << std::endl;
 
      // Detach segment
      manager-> detachSegment();
    }
    else {
      // Create new shared segment
      ShareManager *manager = ShareManager::instance();
      manager-> createSegment (name.c_str(), MAX_DATA_SIZE);
 
      // Construct new shared object inside shared segment
      PDummyString pString = new DummyString;
      std::cout << "Name: " << name << std::endl;
      std::cout << "Address: " << pString.toRel() << std::endl;
      std::string line;
 
      // Read line after line and store it to shared object
      while (std::getline(std::cin, line)) {
        *pString = line.c_str();
      }
 
      // Destroy shared segment (delayed destruction)
      manager-> unlinkSegment();
      manager-> detachSegment();
    }
  }
  catch (ShareException e) {
    // Error handling
    std::cerr << "test1_string: " << e.message() << std::endl;
  }
}