sharelib/sharelib.h

Go to the documentation of this file.

#ifndef SHARELIB_H
#define SHARELIB_H

#ifdef _WIN32
  // Export symbols to .dll while using MS C++ compiler
# define SHARE_EXPORT __declspec(dllexport)
#else
  // There is no need to declare export on Linux
# define SHARE_EXPORT
#endif

#include <new>            // Import std::bad_alloc exception
#include <memory>         // Import std::allocator
#include <iterator>       // Import std::random_access_iterator_tag
#include <functional>
#include <stddef.h>       // Import base set of system types (like size_t, ptrdiff_t, ...)

namespace Share {
  template <bool> struct ERROR_CTAssert_failed__Unexpected_sizeof_char;
  template <> struct ERROR_CTAssert_failed__Unexpected_sizeof_char<true> { };

  class ShareException: public std::bad_alloc {
    public:
      SHARE_EXPORT ShareException (const char *message);

      SHARE_EXPORT ~ShareException () throw ();

      SHARE_EXPORT ShareException (const ShareException &);

      SHARE_EXPORT const char* message() const;

    private:
      void operator= (const ShareException &);
      char *message_;
  };

  class Relocator {
    public:
      typedef void* absolute_pointer;                 
      typedef const void* absolute_const_pointer;     
      typedef size_t relative_pointer;                
      typedef const size_t relative_const_pointer;    

      static relative_pointer absToRel (absolute_pointer abs, absolute_pointer base) {
        ERROR_CTAssert_failed__Unexpected_sizeof_char<sizeof(char)==1>();
        return
          (abs) ?
          static_cast<char *> (abs) - static_cast<char *> (base) :
          0;
       }

      static relative_const_pointer absToRel (absolute_const_pointer abs, absolute_pointer base) {
        return absToRel (const_cast<absolute_pointer>(abs), base);
      }

      static absolute_pointer relToAbs (relative_pointer rel, absolute_pointer base) {
        ERROR_CTAssert_failed__Unexpected_sizeof_char<sizeof(char)==1>();
        return
          (rel) ?
          static_cast<char *> (base) + rel :
          0;
      }

    private:
      Relocator ();
  };

  template <class T> struct TReference {
    typedef T& reference;                       
    typedef const T& const_reference;           
  };

  template <> struct TReference<void> {
    typedef void reference;                     
    typedef void const_reference;               
  };

  template <> struct TReference<const void> {
    typedef void reference;                     
    typedef void const_reference;               
  };

  template <class T> struct TVoidPointer {
    typedef void* void_pointer;                 
    typedef const void* const_void_pointer;     
  };

  template <class T> struct TVoidPointer<const T> {
    typedef const void* void_pointer;           
    typedef const void* const_void_pointer;     
  };

  class SharedSegment;          // Platform-independent shared segment representation
  class SegmentHeader;          // Object placed at begin of each shared segment

  class ShareManager {
    public:
      typedef Relocator::relative_pointer relative_pointer;               
      typedef Relocator::relative_const_pointer relative_const_pointer;   

      SHARE_EXPORT static ShareManager* instance();

      SHARE_EXPORT static void destroySelf();

      SHARE_EXPORT void createSegment (const char *name, size_t size) throw (ShareException);

      SHARE_EXPORT void attachSegment (const char *name) throw (ShareException);

      SHARE_EXPORT void detachSegment () throw ();

      SHARE_EXPORT void unlinkSegment () throw ();

      SHARE_EXPORT const char* name ();

      relative_pointer absToRel (void *abs) {
        return Relocator::absToRel (abs, atAddr_);
      }

      relative_const_pointer absToRel (const void *abs) {
        return Relocator::absToRel (abs, atAddr_);
      }

      template <class T> relative_pointer absToRel (T *abs) {
        typedef typename TVoidPointer<T>::void_pointer void_pointer;
        return absToRel(static_cast<void_pointer> (abs));
      }

      void* relToAbs (relative_pointer rel) {
        return Relocator::relToAbs (rel, atAddr_);
      }

      SHARE_EXPORT void* alloc (size_t size) throw (ShareException);

      void* alloc (size_t size, size_t count) throw (ShareException) {
        return this-> alloc (size * count);
      }

      SHARE_EXPORT void free (void *addr) throw ();

      void free (void *addr, size_t) throw () {
        this-> free (addr);
      }

      SHARE_EXPORT size_t available ();

    protected:
      SHARE_EXPORT void initDebugMode (SharedSegment *segment);

      SHARE_EXPORT void destroySegment ();

      friend class SharedSegmentWrapper;

    private:
      static ShareManager *instance_;                   
      SharedSegment *segment_;                          
      SegmentHeader *atAddr_;                           

    private:
      ShareManager ();
      ~ShareManager ();
      ShareManager (const ShareManager&);               
      ShareManager& operator= (const ShareManager&);    
  };

  class SharedObject {
  public:
    static void* operator new (size_t size) throw (ShareException)
    {
      return alloc(size);
    }

    static void* operator new[] (size_t size) throw (ShareException)
    {
      return alloc(size);
    }

    static void operator delete (void *addr, size_t) throw ()
    {
      free (addr);
    }

    static void operator delete[] (void *addr, size_t) throw()
    {
      free (addr);
    }

    static void* alloc (size_t size) throw (ShareException)
    {
      return ShareManager::instance()-> alloc (size);
    }

    static void* alloc (size_t size, size_t count) throw (ShareException) {
      return alloc (size * count);
    }

    static void free (void *addr) throw ()
    {
      ShareManager::instance()-> free (addr);
    }

  protected:
    SharedObject () { }           
    ~SharedObject () { }          
  };

  template <class T> class RelocPtr: public SharedObject {
    public:
      typedef T value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef T* pointer;
      typedef const T* const_pointer;
      typedef typename TVoidPointer<T>::void_pointer void_pointer;                  
      typedef typename TVoidPointer<T>::const_void_pointer const_void_pointer;      
      typedef typename TReference<T>::reference reference;                          
      typedef typename TReference<T>::const_reference const_reference;              
      typedef typename Relocator::relative_pointer relative_pointer;                
      typedef typename Relocator::relative_const_pointer relative_const_pointer;    

      typedef std::random_access_iterator_tag iterator_category;

      RelocPtr ():
        rel_ (0)
      {
      }

      RelocPtr (void_pointer abs):
        rel_ (ShareManager::instance()-> absToRel (abs))
      {
      }

      RelocPtr (void_pointer abs, void *base):
        rel_ (Relocator::absToRel (abs, base))
      {
      }

      RelocPtr (const RelocPtr &src):
        SharedObject(),
        rel_ (src.rel_)
      {
      }

      RelocPtr& operator= (const RelocPtr &src) {
        rel_= src.rel_;
        return *this;
      }

      RelocPtr& operator= (void_pointer abs) {
        rel_= ShareManager::instance()-> absToRel (abs);
        return *this;
      }

      pointer operator-> () const {
        return static_cast <T *> (ShareManager::instance()-> relToAbs (rel_));
      }

      operator pointer () const {
        return operator-> ();
      }

      reference operator[] (size_type i) {
        RelocPtr<T> tmp (*this);
        tmp+= i;
        return *(tmp.operator->());
      }

      relative_pointer toRel () const {
        return rel_;
      }

      static RelocPtr<T> fromRel (relative_pointer rel) {
        RelocPtr<T> tmp;
        tmp.rel_= rel;
        return tmp;
      }

      RelocPtr& operator++ () {
        rel_+= sizeof(T);
        return *this;
      }
      RelocPtr& operator-- () {
        rel_-= sizeof(T);
        return *this;
      }

      RelocPtr& operator+= (difference_type count) {
        rel_+= count * sizeof(T);
        return *this;
      }

      RelocPtr& operator-= (difference_type count) {
        rel_-= count * sizeof(T);
        return *this;
      }

    private:
      relative_pointer rel_;   
  };

  template <class T> RelocPtr<T> operator++ (RelocPtr<T> &ptr, int)
  {
    RelocPtr<T> tmp(ptr);
    ++ptr;
    return tmp;
  }

  template <class T> RelocPtr<T> operator-- (RelocPtr<T> &ptr, int)
  {
    RelocPtr<T> tmp(ptr);
    --ptr;
    return tmp;
  }

  template <class T> ptrdiff_t operator- (RelocPtr<T> &a, RelocPtr<T> &b)
  {
    return (a.toRel()-b.toRel())/sizeof(T);
  }

  template <class T> RelocPtr<T> operator+ (RelocPtr<T> ptr, ptrdiff_t diff)
  {
    ptr+= diff;
    return ptr;
  }

  template <class T> RelocPtr<T> operator- (RelocPtr<T> ptr, ptrdiff_t diff)
  {
    ptr-= diff;
    return ptr;
  }

  template <class T> class Allocator {
    public:
      typedef T value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef RelocPtr<T> pointer;                
      typedef RelocPtr<const T> const_pointer;    
      typedef T& reference;
      typedef const T& const_reference;

      Allocator() throw() { }

      ~Allocator() throw() { }

      template <class U> Allocator (const Allocator<U>&) throw() { }

      template <class U>
      struct rebind {
        typedef Allocator<U> other;
      };

      pointer address (reference obj) const {
        return &obj;
      }

      const_pointer address (const_reference obj) const {
        return &obj;
      }

      pointer allocate (size_type count) {
        return pointer (static_cast<T*>(ShareManager::instance()-> alloc (sizeof(T), count)));
      }

      void deallocate (pointer addr, size_type count) {
        ShareManager::instance()-> free (addr, count);
      }

      void construct (pointer p, const T& val) {
        ::new(p) T(val);
      }

      void destroy (pointer p) {
        p->~T();
      }

      size_type max_size () const throw() {
        return 
          (ShareManager::instance()-> available())
          /sizeof(T);
      }
  };
  template <class T1, class T2> bool operator== (const Allocator<T1>&, const Allocator<T2>&) throw() { return true; }
  template <class T1, class T2> bool operator!= (const Allocator<T1>&, const Allocator<T2>&) throw() { return false; }

  // Patch for Microsoft C++ compiler
#ifdef _WIN32
  template <> void Allocator<char>::destroy(Allocator<char>::pointer) { }
#endif // _WIN32

  template <
    class TItem,
    class TAllocator = std::allocator<TItem>
    >
  class Vector {
      static const size_t allocBase2Exp = 4;

      static const size_t allocDownFactor2Exp = 2;

      typedef typename TAllocator::size_type size_type;
      typedef typename TAllocator::difference_type difference_type;
      typedef typename TAllocator::pointer pointer;
      typedef typename TAllocator::const_pointer const_pointer;
      typedef typename TAllocator::reference reference;
      typedef typename TAllocator::const_reference const_reference;

    public:
      typedef pointer iterator;                   
      typedef const_pointer const_iterator;       

      Vector():
        size_ (0),
        capacity_ (0),
        data_ (0)
      {
        lowLevelResize(0);
      }

      Vector (size_type size):
        size_ (0),
        capacity_ (0),
        data_ (0)
      {
        lowLevelResize(size);
        size_ = size;
      }

      Vector (const Vector &other):
        size_ (0),
        capacity_ (0),
        data_ (0)
      {
        operator= (other);
      }

      Vector& operator= (const Vector &other) {
        size_type newSize = other.size();
        lowLevelResize(newSize);
        size_ = newSize;
        TItem *s1 = begin();
        const TItem *s2 = other.begin();
        const TItem *s2end = other.end();
        for (; s2!=s2end; s1++, s2++)
          alloc_.construct (s1, *s2);

        return *this;
      }

      ~Vector() {
        TItem *pEnd = end();
        for (TItem *i=begin(); i!=pEnd; i++)
          alloc_.destroy (i);
        alloc_.deallocate (data_, capacity_);
      }

      reference operator[] (size_type index) {
        return data_[index];
      }

      const_reference operator[] (size_type index) const {
        return data_[index];
      }

      bool operator== (const Vector &other) const {
        const TItem *s1 = begin();
        const TItem *s2 = other.begin();
        for (; s1!=end() && s2!=other.end(); s1++, s2++)
          if (*s1 != *s2)
            return false;
        return
          s1 == end() &&
          s2 == other.end();
      }

      bool operator!= (const Vector &other) const {
        return !operator== (other);
      }

      iterator begin() {
        return data_;
      }

      iterator end() {
        return data_ + static_cast<difference_type> (size_);
      }

      const_iterator begin() const {
        return static_cast<const_iterator>(data_);
      }

      const_iterator end() const {
        return static_cast<const_iterator>(data_ + static_cast<difference_type>(size_));
      }

      void clear() {
        for (TItem *i=begin(); i!=end(); i++)
          alloc_.destroy (i);
        lowLevelResize(0);
        size_ = 0;
      }

      bool empty() const {
        return size_==0;
      }

      void push_back (const_reference item) {
        lowLevelResize (size_ + 1, true);
        alloc_.construct (this + static_cast<difference_type>(size_), item);
        size_ ++;
      }

      void pop_back() {
        lowLevelResize(size_ - 1, true);
        size_ --;
      }

      size_type size() const {
        return size_;
      }

      void resize (size_type newSize, const_reference val= TItem()) {
        lowLevelResize(newSize, true);
        for (; size_ < newSize; size_++)
          data_[size_] = val;

        size_ = newSize;
      }

    private:
      TAllocator alloc_;
      size_type size_;
      size_type capacity_;
      iterator data_;

      void lowLevelCopy (TItem *dest, const TItem *src, size_type count) {
        for (size_type i=0; i<count; i++, dest++, src++)
          *dest = *src;
      }

      void lowLevelResize (size_type newSize, bool bCopyContent=false) {
        static const size_type allocBaseSize = 1 << allocBase2Exp;
        if (newSize < allocBaseSize)
          newSize = allocBaseSize;

        if (
            newSize <= capacity_ &&
            newSize >= (capacity_ >> allocDownFactor2Exp)
            )
          return;

        for (capacity_= allocBaseSize; capacity_<newSize; capacity_<<=1);
        TItem *newBlock = alloc_.allocate (capacity_);

        if (data_) {
          if (bCopyContent)
            lowLevelCopy (newBlock, static_cast<const_iterator>(data_), size_);

          alloc_.deallocate (data_, size_);
        }

        data_ = newBlock;
      }
  };

  template <class TAllocator = std::allocator<char> >
  class String {
      typedef char TItem;
      typedef Vector<TItem, TAllocator> TContainer;
      typedef typename TAllocator::size_type size_type;
      typedef typename TAllocator::difference_type difference_type;
      typedef typename TAllocator::pointer pointer;
      typedef typename TAllocator::const_pointer const_pointer;
      typedef typename TAllocator::reference reference;
      typedef typename TAllocator::const_reference const_reference;

    public:
      typedef typename TContainer::iterator iterator;                   
      typedef typename TContainer::const_iterator const_iterator;       

      String():
        array_ (1, '\0')
      {
      }

      String (size_type size, const_reference val):
        array_ (size+1, val)
      {
        array_ [size] = '\0';
      }

      String (const TItem *sz):
        array_ (szLength (sz)+1)
      {
        TItem *i = array_.begin();
        for (; *sz; sz++, i++)
          *i = *sz;
        *i = '\0';
      }

      String (const String &other):
        array_ (other.array_)
      {
      }

      String& operator= (const TItem *sz) {
        array_.resize (szLength (sz)+1);
        TItem *i = array_.begin();
        for (; *sz; sz++, i++)
          *i = *sz;
        *i = '\0';

        return *this;
      }

      String& operator= (const String &other) {
        array_ = other.array_;
        return *this;
      }

      reference operator[] (size_type index) {
        return array_[index];
      }

      const_reference operator[] (size_type index) const {
        return array_[index];
      }

      iterator begin() {
        return array_.begin();
      }

      iterator end() {
        return array_.end()-1;
      }

      const_iterator begin() const {
        return array_.begin();
      }

      const_iterator end() const {
        return array_.end()-1;
      }

      int compare (const String &other) const {
        const TItem *s1 = begin();
        const TItem *s2 = other.begin();
        const TItem *s1end = end();
        const TItem *s2end = other.end();
        for (; s1!=s1end && s2!=s2end; s1++, s2++) {
          if (*s1 < *s2)
            return -1;
          else if (*s1 > *s2)
            return 1;
        }
        if (s1 != end())
          return 1;
        else if (s2 != other.end())
          return -1;
        else
          return 0;
      }
      bool operator== (const String<TAllocator> &other) const { return 0==compare (other); }
      bool operator!= (const String<TAllocator> &other) const { return 0!=compare (other); }
      bool operator<= (const String<TAllocator> &other) const { return 0>=compare (other); }
      bool operator>= (const String<TAllocator> &other) const { return 0<=compare (other); }
      bool operator<  (const String<TAllocator> &other) const { return 0> compare (other); }
      bool operator>  (const String<TAllocator> &other) const { return 0< compare (other); }

      void append (const TItem *);

      void clear() {
        array_.clear();
      }

      bool empty() const {
        return array_.empty();
      }

      size_type length() const {
        return array_.size();
      }

      const TItem* c_str() const {
        return array_.begin();
      }

    private:
      TContainer array_;
      TAllocator alloc_;

    private:
      static size_type szLength (const TItem *sz) {
        int len = 0;
        while (*sz)
          len++, sz++;
        return len;
      }
  };

  template <class A> String<A> operator+ (String<A> s1, const String<A> &s2)
  {
    s1.append (s2);
    return s1;
  }

  template <
    class TFirst,
    class TSecond
    >
  struct Pair {
    TFirst first;
    TSecond second;
  };

  template <
    class TKey,
    class TValue,
    class TAllocator = std::allocator< Pair<TKey, TValue> >
    >
  class Map {
      static const size_t defaultHtSize = 1 << 12;

      typedef Pair<TKey, TValue> TData;
      typedef TData& TData_reference;
      typedef const TData* TData_const_pointer;
      typedef size_t size_type;
      typedef typename TAllocator::template rebind<Map>::other TMapAllocator;
      typedef typename TMapAllocator::const_pointer TMap_const_pointer;

    public:
      Map (size_type htSize= defaultHtSize):
        htSize_ (htSize)
      {
        htArray_ = pItemAlloc_.allocate (htSize_);
        for (size_type i=0; i<htSize_; i++)
          htArray_[i]=0;
      }

    private:
      struct Item;
      typedef typename TAllocator::template rebind<Item>::other TItemAllocator;
      typedef typename TItemAllocator::pointer TItem_pointer;
      typedef typename TItemAllocator::const_pointer TItem_const_pointer;
      typedef typename TItemAllocator::reference TItem_reference;
      struct Item {
        TData data;
        TItem_pointer next;
      };
      typedef typename TAllocator::template rebind<TItem_pointer>::other TPItemAllocator;
      typedef typename TPItemAllocator::pointer TPItem_pointer;

    public:
      class const_iterator {
        public:
          const_iterator():
            hTable_ (0),
            hashIndex_ (0),
            item_ (0)
          {
          }

          TData_const_pointer operator->() {
            if (!item_)
              return 0;
            else
              return &(item_-> data);
          }

          operator TData_const_pointer() {
            return operator->();
          }

          const_iterator& operator ++() {
            if (item_)
              item_ = item_-> next;

            if (!item_) {
              for (
                  hashIndex_++;
                  hashIndex_ < hTable_->htSize_ && hTable_->htArray_[hashIndex_] == 0;
                  hashIndex_ ++);

              if (hashIndex_ < hTable_->htSize_)
                item_ = hTable_-> htArray_ [hashIndex_];
            }

            return *this;
          }

          const_iterator operator ++(int) {
            const_iterator tmp = *this;
            operator ++();
            return tmp;
          }

          bool operator== (const const_iterator &other) {
            return
              hTable_ == other.hTable_ &&
              item_ == other.item_;
          }

          bool operator!= (const const_iterator &other) {
            return !operator== (other);
          }

        private:
          const_iterator (TMap_const_pointer ht, size_type hashIndex, TItem_const_pointer item):
            hTable_ (ht),
            hashIndex_ (hashIndex),
            item_ (item)
          {
          }

        private:
          TMap_const_pointer hTable_;
          size_type hashIndex_;
          TItem_const_pointer item_;
          friend class Map;
      };  // (class const_iterator)

      ~Map() {
        clear();
        pItemAlloc_.deallocate (htArray_, htSize_);
      }

      void clear() {
        TItem_pointer *ppCurrent = htArray_;
        for (size_type hashIndex=0; hashIndex<htSize_; hashIndex++, ppCurrent++) {
          Item *pCurrent = *ppCurrent;
          while (pCurrent) {
            Item *pNext = pCurrent->next;
            itemAlloc_.destroy (pCurrent);
            itemAlloc_.deallocate (pCurrent, 1);
            pCurrent = pNext;
          }
          *ppCurrent = 0;
        }
      }

      const_iterator find (const TKey &key) {
        size_type hashIndex = hashFunction (key);
        TItem_pointer pCurrent = htArray_ [hashIndex];

        while (pCurrent && pCurrent->data.first != key)
          pCurrent = pCurrent->next;

        return const_iterator (this, hashIndex, pCurrent);
      }

      TValue& operator[] (const TKey &key) {
        size_type hashIndex = hashFunction (key);
        typedef typename TItemAllocator::difference_type TDiff;
        TItem_pointer *ppCurrent = htArray_ + static_cast<TDiff>(hashIndex);

        for (; *ppCurrent; ppCurrent = &((*ppCurrent)-> next)) {
          TData_reference current = (*ppCurrent)-> data;
          if (current.first == key)
            return current.second;
        }

        Item item = {
          { key, TValue() },
          0
        };

        *ppCurrent = itemAlloc_.allocate (1);
        itemAlloc_.construct (*ppCurrent, item);

        return (*ppCurrent)->data.second;
      }

      const_iterator begin() const {
        const_iterator iter (this, 0, 0);
        iter++;
        return iter;
      }

      const_iterator end() const {
        return const_iterator (this, 0, 0);
      }

    private:
      size_t htSize_;
      TPItem_pointer htArray_;
      TItemAllocator itemAlloc_;
      TPItemAllocator pItemAlloc_;

      template<class T> size_t hashFunction (const T &key) {
        typedef typename T::const_iterator Iterator;
        Iterator i= key.begin();
        unsigned int h=0;
        for (; i != key.end(); i++) {
          unsigned char p = static_cast<unsigned char> (*i);
          h = 31*h + p;
        }
        return h % htSize_;
      }
  };
}

#endif // SHARELIB_H

---