pointer.h

Go to the documentation of this file.

/*
 * pointer.h - smart pointer and array classes
 *
 * this file is part of PJFry library
 * Copyright 2011 Valery Yundin
 */
 
#ifndef QUL_POINTER_H
#  define QUL_POINTER_H
 
#  include <cstring>
#  include <memory>
 
class SRefCnt {
public:
  SRefCnt() : count( 0 ) {}
 
protected:
  int count;
};
 
template <typename T> class SPtr {
public:
  T*   operator->() const { return pObj; }
  bool operator==( const T* pobj ) const { return pobj == pObj; }
  bool operator!=( const T* pobj ) const { return pobj != pObj; }
 
  bool operator==( const SPtr<T>& spobj ) const { return spobj.pObj == pObj; }
  bool operator!=( const SPtr<T>& spobj ) const { return spobj.pObj != pObj; }
 
  SPtr( T* pobj = 0 ) : pObj( pobj ) {
    if ( pObj ) { pObj->count++; }
  }
  SPtr( const SPtr& ptr ) : pObj( ptr.pObj ) {
    if ( pObj ) { pObj->count++; }
  }
 
  SPtr& operator=( const SPtr& ptr ) {
    if ( this == &ptr ) { return *this; }
    if ( pObj && --( pObj->count ) == 0 ) { delete pObj; }
    if ( ( pObj = ptr.pObj ) ) { pObj->count++; }
    return *this;
  }
 
  ~SPtr() {
    if ( pObj && --( pObj->count ) == 0 ) { delete pObj; }
  }
 
private:
  T* pObj;
};
 
template <typename T, int N> class DArray;
// Iterator for DArray class
template <typename T, int N> class NIter {
  friend class DArray<T, N>;
 
public:
  inline T&     operator*() { return ptr[idx % N]; }
  inline T*     operator->() { return &ptr[idx % N]; }
  inline NIter& operator++() {
    idx++;
    return *this;
  }
  inline NIter& operator+=( int n ) {
    idx += n;
    return *this;
  }
 
  inline bool operator==( const NIter& iter ) { return idx == iter.idx && ptr == iter.ptr; }
  inline bool operator!=( const NIter& iter ) { return idx != iter.idx || ptr != iter.ptr; }
 
  NIter( T* begin, int last ) : ptr( begin ), idx( last ) {}
 
private:
  T*  ptr;
  int idx;
};
 
// DArray - static array with stack-like iterator
template <typename T, int N> class DArray {
public:
  DArray() : last( N ), len( 0 ) {}
 
  typedef NIter<T, N> iterator;
  iterator            begin() { return iterator( elems, last ); }
  iterator            end() { return iterator( elems, last + len ); }
 
  T& insert( const T& el ) {
    len         = ( len == N ? len : len + 1 );
    last        = ( ( last - 1 ) + N ) % N;
    elems[last] = el;
    return elems[last];
  }
 
#  ifdef USE_SMART_INSERT
  void remove( iterator& it ) {
    //       assert(it.ptr==elems);
    int i    = it.idx % N;
    elems[i] = T();
    if ( i >= last )
    {
      memmove( &elems[last + 1], &elems[last], ( i - last ) * sizeof( T ) );
      memset( &elems[last], 0, sizeof( T ) );
      last = ( last + 1 ) % N;
    }
    else
    {
      memmove( &elems[i], &elems[i + 1], ( last - i - 1 ) * sizeof( T ) );
      memset( &elems[last - 1], 0, sizeof( T ) );
    }
    len = len - 1;
  }
#  endif
 
  void reset() {
#  ifndef USE_DIRTY_RESET
    for ( int i = 0; i < len; i++ ) { elems[i] = T(); }
#  endif
    last = N;
    len  = 0;
  }
 
  static const int size = N;
  const T&         operator[]( const int idx ) const { return elems[idx]; }
  T&               operator[]( const int idx ) { return elems[idx]; }
 
private:
  T   elems[N];
  int last;
  int len;
};
 
// CArray - simple array with trivial iterator
template <typename T, int N> class CArray {
public:
  typedef std::auto_ptr<CArray> Ptr;
 
  CArray( T dval = T() ) {
    for ( iterator i = begin(); i != end(); ++i ) { *i = dval; }
  }
 
  typedef T* iterator;
  iterator   begin() { return &elems[0]; }
  iterator   end() { return &elems[N]; }
 
  static const int size = N;
 
  const T& operator[]( const int idx ) const { return elems[idx]; }
  T&       operator[]( const int idx ) { return elems[idx]; }
 
private:
  T elems[N];
};
 
#endif /* QUL_POINTER_H */
 
/*
class Test: public SRefCnt
{
  public:
    friend class SPtr<Test>;
    typedef SPtr<Test> Ptr;
 
    static Ptr create(int x) { return Ptr(new Test(x)); };
 
    ~Test() { };
 
  private:
    Test() { };
};
 
*/