connectorSequence.hh

 
#ifndef ConnectorSequence_hh
#define ConnectorSequence_hh
 
#include "connector.hh"
#include "toolbox/sequence.hh"
 
namespace concepts {
 
  // ************************************************** Sequence<const Key*> **
 
  template<>
  class Sequence<const Key*> : public BaseSequence<const Key*> {
  public:
    Sequence() : BaseSequence<const Key*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<const Key*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<uint> key() const;
  };
 
  // ******************************************* Sequence<const Connector0*> **
 
  template<>
  class Sequence<const Connector0*> : 
    public BaseSequence<const Connector0*> {
  public:
    Sequence() : BaseSequence<const Connector0*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<const Connector0*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
  };
 
  // ************************************************* Sequence<Connector0*> **
 
  template<>
  class Sequence<Connector0*> : public BaseSequence<Connector0*> {
  public:
    Sequence() : BaseSequence<Connector0*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<Connector0*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
  };
 
  // ******************************************* Sequence<const Connector1*> **
 
  template<>
  class Sequence<const Connector1*> : 
    public BaseSequence<const Connector1*> {
  public:
    Sequence() : BaseSequence<const Connector1*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<const Connector1*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
    Sequence<Connector0*> vertex(uint i) const;
    Sequence<const Connector1*> child(uint i) const;
  };
 
  // ************************************************* Sequence<Connector1*> **
 
  template<>
  class Sequence<Connector1*> : public BaseSequence<Connector1*> {
  public:
    Sequence() : BaseSequence<Connector1*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<Connector1*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
    Sequence<Connector0*> vertex(uint i) const;
    Sequence<const Connector1*> child(uint i) const;
  };
 
  // ******************************************* Sequence<const Connector2*> **
 
  template<>
  class Sequence<const Connector2*> : 
    public BaseSequence<const Connector2*> {
  public:
    Sequence() : BaseSequence<const Connector2*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<const Connector2*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
    Sequence<Connector0*> vertex(uint i) const;
    Sequence<Connector1*> edge(uint i) const;
    Sequence<const Connector2*> child(uint i) const;
  };
 
  // ************************************************* Sequence<Connector2*> **
 
  template<>
  class Sequence<Connector2*> : public BaseSequence<Connector2*> {
  public:
    Sequence() : BaseSequence<Connector2*>() {}
    template<class F>
    Sequence(const F& seq) : BaseSequence<Connector2*>(seq) {}
    virtual ~Sequence() {}
 
    Sequence<const Key*> key() const;
    Sequence<Connector0*> vertex(uint i) const;
    Sequence<Connector1*> edge(uint i) const;
    Sequence<const Connector2*> child(uint i) const;
  };
 
  // ********************************************************* allConnectors **
  
  template<class F, class G>
  Sequence<G*> allConnectors(const F& cntr, G* (F::*fun)(uint) const) {
    Sequence<G*> seq;
    G* cntri;  // connectors inside cntr
    uint i = 0;
    while ((cntri = (cntr.*fun)(i++)) != 0) seq.push_back(cntri);
    return seq;
  }
 
} // namespace concepts
 
#endif // ConnectorSequence_hh