Self.h

Go to the documentation of this file.

#ifndef   Self_h__
#define   Self_h__

#include <cstdlib>
#include <algorithm>

namespace meow {

#define DO_NOT_USE_SELF
#ifdef DO_NOT_USE_SELF

template<class Data>
class Self {
public:
  enum DuplicateType {
    COPY_FROM
  };
private:
  Data data_;
public:
  Self(                              )                 { }
  Self(Data const& d                 ): data_(d)       { }
  Self(Self const& b, DuplicateType d): data_(b.data_) { }
  Self(Self const& b);
  ~Self() { }
  Data const* operator->() const { return &data_; }
  Data      * operator->()       { return &data_; }
  Self& operator()() const { return *((Self*)this); }
  Self const& copyFrom(Self const& s) { data_ = s.data_; return *this; }
  Self const& referenceFrom(Self const& s) {
    return copyFrom(s);
  }
  Self const& duplicateFrom(Self const& s, DuplicateType t) {
    return copyFrom(s);
  }
  bool same(Self const& s) const { return false; }
  bool equal(Self const& s) const { return data_ == s.data_; }
  bool referenceLess(Self const& s) const { return (this < &s); }
  void operator=(Self const& a);
};

#else

template<class Data>
class Self {
public:
  enum DuplicateType {
    COPY_FROM,          
    REFERENCE_FROM      
  };
private:
  class Body {
  private:
    struct Kernel {
      Data*          data_;
      size_t      counter_;
      Body const*  master_;

      Kernel(Body const* master):
      data_(new Data( )), counter_(1), master_(master) {
      }

      Kernel(Body const* master, Data const& d):
      data_(new Data(d)), counter_(1), master_(master) {
      }

      ~Kernel() {
        delete data_;
      }
    };

    Kernel* pointer_;
    size_t  counter_;

    void clear() {
      --(pointer_->counter_);
      if (pointer_->counter_ <= 0) {
        delete pointer_;
      }
      else if (pointer_->master_ == this) {
        pointer_->master_ = NULL;
      }
    }
  public:
    Body(             ): pointer_(new Kernel(this   )), counter_(1) { }
    Body(Data const& d): pointer_(new Kernel(this, d)), counter_(1) { }
    Body(Body const& b): pointer_(b.pointer_         ), counter_(1) {
      ++(pointer_->counter_);
    }

    ~Body() {
      clear();
    }

    Body& copyFrom(Body const& b) {
      clear();
      pointer_ = b.pointer_;
      ++(pointer_->counter_);
      return *this;
    }

    Data const* access() const {
      return pointer_->data_;
    }

    Data* modify() {
      if (pointer_->counter_ > 1) {
        --(pointer_->counter_);
        Kernel* dupl = new Kernel(this, *pointer_->data_);
        if (pointer_->master_ == this) {
          std::swap(pointer_->data_, dupl->data_);
          pointer_->master_ = NULL;
        }
        pointer_ = dupl;
      }
      else if (pointer_->master_ == NULL) {
        pointer_->master_ = this;
      }
      return pointer_->data_;
    }

    int attach() {
      return ++counter_;
    }

    int detach() {
      return --counter_;
    }
  };

  Body* body_;

  void clear() {
    if (body_->detach() <= 0) {
      delete body_;
    }
  }
public:
  Self(): body_(new Body()) {
  }

  Self(Data const& d): body_(new Body(d)) {
  }

  Self(Self const& b, DuplicateType d) {
    switch(d) {
    case COPY_FROM:
      body_ = new Body(*b.body_);
      break;
    case REFERENCE_FROM:
      body_ = b.body_;
      body_->attach();
      break;
    }
  }

  Self(Self const& b);

  ~Self() {
    clear();
  }

  Data const* operator->() const {
    return body_->access();
  }

  Data* operator->() {
    return body_->modify();
  }

  Self& operator()() const {
    return *((Self*)this);
  }

  Self const& copyFrom(Self const& s) {
    if (body_->access() != s.body_->access()) {
      body_->copyFrom(*s.body_);
    }
    return *this;
  }

  Self const& referenceFrom(Self const& s) {
    if (body_ != s.body_) {
      clear();
      body_ = s.body_;
      body_->attach();
    }
    return *this;
  }

  Self const& duplicateFrom(Self const& s, DuplicateType t) {
    switch(t) {
    case COPY_FROM     : return      copyFrom(s);
    case REFERENCE_FROM: return referenceFrom(s);
    }
    return *this;
  }

  bool same(Self const& s) const {
    return (body_ == s.body_);
  }

  bool equal(Self const& s) const {
    if (same(s) || body_->access() == s.body_->access()) return true;
    return (*body_->access() == *s.body_->access());
  }

  bool referenceLess(Self const& s) const {
    return (body_ < s.body_);
  }

  void operator=(Self const& a);
};

#endif

} // meow

#endif // Self_h__