Pipeline.h

Go to the documentation of this file.

#ifndef   Pipeline_H__
#define   Pipeline_H__

#include "Self.h"

#include <list>

namespace meow {

template<class Input, class Output, class Medium>
class Pipeline {
protected:
  typedef std::list<Medium const*>::const_iterator MediumPointerIteratorK;
private:
  struct Myself {
    struct MediumInfo {
      bool autoDel_;
      int  counter_;

      MediumInfo(bool ad): autoDel_(ad), counter_(1) {
      }
      ~MediumInfo() {
      }
    };

    std::list<Medium const*> pipe_;
    std::list<MediumInfo*  > info_;

    Myself() {
    }
    Myself(Myself const& b): pipe_(b.pipe_), info_(b.info_) {
      for (std::list<MediumInfo*>::iterator
           it = info_.begin(); it != info_.end(); ++it) {
        (*it).counter_ += 1;
      }
    }
    ~Myself() {
      std::list<MediumInfo*  >::iterator it = info_.begin();
      std::list<Medium const*>::iterator ip = pipe_.begin();
      for ( ; it != info_.end(); ++it, ++ip) {
        if ((*it).counter_ <= 0 && (*it).autoDel_ == true) {
          delete *ip;
        }
      }
    }

    bool frontAdd(Medium const* ptr, bool auto_delete) {
      pipe_.push_front(ptr);
      info_.push_front(new MediumInfo(auto_delete));
      return true;
    }

    bool backAdd(Medium const* ptr, bool auto_delete) {
      pipe_.push_back(ptr);
      info_.push_back(new MediumInfo(auto_delete));
      return true;
    }

    bool frontDel() {
      if (pipe_.empty()) return false;
      info_.front().counter_ -= 1;
      if (info_.front().autoDel_ && info_.front().counter_ <= 0) {
        delete pipe_.front();
      }
      pipe_.pop_front();
      return true;
    }

    bool backDel() {
      if (pipe_.empty()) return false;
      info_.back().counter_ -= 1;
      if (info_.back().autoDel_ && info_.back().counter_ <= 0) {
        delete pipe_.back();
      }
      pipe_.pop_back();
      return true;
    }
  };

  Self<Myself> const self;
protected:
  Pipeline(): self() {
  }

  Pipeline(Pipeline const& p): self(p.self(), COPY_FROM) {
  }

  Pipeline& copyFrom(Pipeline const& p) {
    self().copyFrom(p.self);
    return *this;
  }

  Pipeline& referenceFrom(Pipeline const& p) {
    self().referenceFrom(p.self);
  }

  Pipeline& operator=(Pipeline const& p) {
    return copyFrom(p);
  }

  std::list<Medium const*> const& pipe() const {
    return self->pipe_;
  }

public:
  virtual ~Pipeline() {
  }

  virtual Output goThrough(Input const& in) const = 0;

  virtual bool inversable() {
    return false;
  }

  virtual Input goThroughInv(Output const& in) const {
    return Input();
  }

  virtual bool frontAdd(Medium const* ptr, bool auto_delete) {
    return self()->frontAdd(ptr, auto_delete);
  }

  virtual bool backAdd(Medium const* ptr, bool auto_delete) {
    return self()->backAdd(ptr, auto_delete);
  }

  virtual bool frontDel() {
    return self()->frontDel();
  }

  virtual bool backDel() {
    return self()->backDel();
  }

  virtual size_t size() const {
    return self->pipe_.size();
  }

  virtual bool empty() const {
    return (size() == 0);
  }

  virtual Medium const* first() const {
    return self->pipe_.front().pointer_;
  }

  virtual Medium const* last() const {
    return self->pipe_.end().pointer_;
  }
};

} // meow

#endif // Pipeline_H__