Share Library (C++)

/**
 * @file SegmentHeader.cpp
 * @brief Object placed at begin of each shared segment
 * @author Kamil Dudka, xdudka00@gmail.com
 * @date 2007-05-15
 * @ingroup backend
 */
 
#include "SegmentHeader.h"
#include <string.h>
 
using namespace Share;
 
namespace {
  // Prefix added to shared segment name to create mutex name
  const char *szMutexPrefix = "SHMutex/";
 
  /**
   * @param name Name of shared segment
   * @return Return legth of mutex name
   */
  inline size_t mutexNameLength (const char *name) {
    return
      strlen (szMutexPrefix) +
      strlen (name) +
      1;
  }
 
  /**
   * @param allocator Alreae initialized allocator. It will be used to allocate memory for mutex name.
   * @param name Name of shared segment
   * @return Return pointer to mutex name (allocated inside shared segment).
   */
  inline SegmentHeader::TStringZ mutexNameInitializer (TSegmentAllocator &allocator, const char *name) {
    SegmentHeader::TStringZ mutexName = allocator.alloc (mutexNameLength (name));
    strcpy (mutexName, szMutexPrefix);
    strcat (mutexName, name);
    return mutexName;
  }
}
 
SegmentHeader::SegmentHeader (const char *name, size_t dataSize):
  allocator_ (
      this,
      sizeof(SegmentHeader),
      alignmenter (mutexNameLength(name)) + alignmenter (dataSize)
      ),
  mutexName_ (mutexNameInitializer (allocator_, name)),
  mutex_ (mutexName_)
{
}
 
size_t SegmentHeader::sizeNeeded (const char *name, size_t dataSize)
{
  return
    alignmenter (sizeof (SegmentHeader)) +
    alignmenter (mutexNameLength (name)) +
    alignmenter (dataSize);
}
 
void* SegmentHeader::alloc (size_t size) throw (ShareException)
{
  MutexLock lock (&mutex_);
  return allocator_.alloc (size);
}
 
void SegmentHeader::free (void *addr) throw ()
{
  MutexLock lock (&mutex_);
  allocator_.free (addr);
}
 
size_t SegmentHeader::size()
{
  MutexLock lock (&mutex_);
  return allocator_.size();
}
 
size_t SegmentHeader::available()
{
  MutexLock lock (&mutex_);
  return allocator_.available();
}
 
void SegmentHeader::notifyAttach()
{
  MutexLock lock (&mutex_);
  refCounter_.notifyAttach();
}
 
void SegmentHeader::notifyDetach()
{
  MutexLock lock (&mutex_);
  refCounter_.notifyDetach();
}
 
int SegmentHeader::refCount()
{
  MutexLock lock (&mutex_);
  return refCounter_.refCount();
}
 
void SegmentHeader::unlink()
{
  MutexLock lock (&mutex_);
  refCounter_.unlink();
}
 
bool SegmentHeader::isUnlinked()
{
  MutexLock lock (&mutex_);
  return refCounter_.isUnlinked();
}
 
bool SegmentHeader::shouldBeDestroyed()
{
  MutexLock lock (&mutex_);
  return refCounter_.shouldBeDestroyed();
}