Self.h

Go to the documentation of this file.

#ifndef   Self_h__
#define   Self_h__

#include <cstdlib>

namespace meow {

template<class Data>
class Self {
private:
  class Body {
  private:
    struct Kernel {
      Data    data_;
      int  counter_;
      Kernel() {
        counter_ = 1;
      }
      Kernel(Data const& data) {
        counter_ = 1;
        data_.copyFrom(data);
      }
    };
    Kernel *pointer_;
    int     counter_;
  public:
    Body() {
      counter_ = 1;
      pointer_ = new Kernel;
    }
    Body(Body const& b) {
      counter_ = 1;
      pointer_ = b.pointer_;
      pointer_->counter_++;
    }
    ~Body() {
      pointer_->counter_--;
      if (pointer_->counter_ <= 0) {
        delete pointer_;
      }
    }
    int attatch() { return ++counter_; }
    int detatch() { 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(Body* body) {
    if (body != NULL) {
      if (body->detatch() <= 0) {
        delete body;
      }
    }
  }
public:
  Self(bool create_body) {
    body_ = (create_body ? new Body() : NULL);
  }
  
  Self(Self const& b);
  
  ~Self() {
    clear(body_);
  }
  
  Data const* operator->() const {
    return body_->access();
  }
  
  Data* operator->() {
    return body_->modify();
  }
  
  Self& operator()() const {
    return *((Self*)this);
  }
  
  void copyFrom(Self const& s) {
    Body* old = body_;
    body_ = new Body(*(s.body_));
    clear(old);
  }
  
  void referenceFrom(Self const& s) {
    if (body_ != s.body_) {
      clear(body_);
      body_ = s.body_;
      body_->attatch();
    }
  }
  
  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()->equal(*(s.body_->access())));
  }
  
  bool referenceLess(Self const& s) const {
    return (body_ < s.body_);
  }
  
  void operator=(Self const& a);
};

} // meow

#endif // Self_h__