---

/home/slang/XVision2/src/Pipes/Dependency.h

# ifndef __dependency_h
# define __dependency_h

// This class (partly) helps booking the dependency relationship in the 
// pipe graph. Actually the dependencis can be viewed as directed edges
// in the graph.
// The following code is not guarenteed to work on multi-derived classes, 
// since a re-interpret cast will have to be used.
// And semaphores must be added if used under multithread settings

class DependencyUnit {
 protected:
  struct Node {
    DependencyUnit ** dependency ;
    Node * next ;

    Node( DependencyUnit ** u, Node * n = 0 ) : dependency(u), next(n) {}
    ~Node() { delete next ; }
  } *head, **tail ;

  // Functions in the following 'protected' section are supposed to be 
  // overridden.
 protected:

  // This must be overridden, to return a new copy of the object itself.
  // In smalltalk this can be done solely in the parent class, 
  // e.g. ^new (self class), but in C++ I can't figure out a way doing
  // so without the help of the derived class.

  virtual DependencyUnit * duplicate(void) const = 0 ;
    // e.g. { return new ClassName(*this) ; }
    // Here ClassName is the name of the derived class.
    // Be sure that dependency is correctly set up.

  // This may be overridden, to set dependencies (i.e. via addDependency()).
  // However, be sure to call it as well as in all constructors of the 
  // derived class when appropriate, since overriding functions will not be
  // calls during construction of the base class.
  
  virtual void setDependency(void) {}

 private:

  DependencyUnit * replica ;
  bool copying ;

  void precopy(void);
  void docopy(void);
  void postcopy(void);

 public:

  // This is the deep copy function using overridden duplicate.
  // It's not supposed to be overridden in most cases.

  virtual DependencyUnit * copy(void);

 public:

  DependencyUnit() : 
    head(0), tail(&head), replica(0), copying(false) { setDependency(); }
  DependencyUnit(const DependencyUnit& u ) : // no default copy constructor
    head(0), tail(&head), replica(0), copying(false) { setDependency(); }

  void addDependency( DependencyUnit ** u ) 
    { *tail = new Node(u,0); tail = &((*tail)->next); }
  void removeDependency( DependencyUnit ** u );
  void removeAllDependency(void) { delete head ; head = 0 ; tail = &head ; }
  virtual ~DependencyUnit() { removeAllDependency(); }
};


# endif //__dependency_h

---