Self.h

Go to the documentation of this file.

#ifndef   Self_h__
#define   Self_h__

#include <cstdlib>

namespace meow {

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

      Kernel(                ): data_(    ), counter_(1) { }
      Kernel(Data const& data): data_(data), counter_(1) { }
      ~Kernel() { }
    };

    Kernel* pointer_;
    int     counter_;
  public:
    Body(             ): pointer_(new Kernel( )), counter_(1) { }
    Body(Data const& d): pointer_(new Kernel(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;
    }
    void clear() {
      --(pointer_->counter_);
      if (pointer_->counter_ <= 0) {
        delete pointer_;
      }
    }
    int attach() { return ++counter_; }
    int detach() { return --counter_; }
    Data const* access() const {
      return &(pointer_->data_);
    }
    Data* modify() {
      if (pointer_->counter_ > 1) {
        --pointer_->counter_;
        pointer_ = new Kernel(pointer_->data_);
      }
      return &(pointer_->data_);
    }
  };

  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);
};

} // meow

#endif // Self_h__