Registry.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2004 - 2016 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Util/units/Registry.h
 
#ifndef __Registry_h
#define __Registry_h
 
#include "ReferenceTo.h"
 
#include <vector>
#include <iostream>
 
namespace Registry {
 
  template<class Parent> class List;

  template<class Parent>
  class Entry : public Reference::Able
  {
    public:
 
    friend class List<Parent>;

    Parent* get () const { return instance; }

    Entry () { instance = 0; }

    virtual ~Entry () { if (instance) delete instance; }
    
  protected:

    void register_child (Parent* _instance) 
    {
      List<Parent>& registry = List<Parent>::get_registry();
 
      if (List<Parent>::verbose)
        std::cerr << "Registry::Entry<Parent>::register_child"
          " instance=" << _instance << " registry=" << &registry <<
          " size=" << registry.size() + 1 << std::endl;
 
      instance = _instance;
      registry.add (this);
    }

    virtual Parent* create () const = 0;
 
  private:
    Parent* instance;
  };

  template<class Parent>
  class List : public Reference::Able
  {
 
    friend class Entry<Parent>;
 
  public:

    template<class Child> class Instances;

    template<class Child> class Enter;
  
    template<class Child, class Argument> class Unary;

    unsigned size () const { return entries.size(); }

    Parent* operator[] (unsigned i) const { return entries[i]->get(); }

    void erase (unsigned i) { entries.erase( entries.begin() + i ); }

    auto begin() const -> typename std::vector<Reference::To<Entry<Parent>>>::const_iterator { return entries.begin(); }
    auto end() const -> typename std::vector<Reference::To<Entry<Parent>>>::const_iterator { return entries.end(); }

    Parent* create (unsigned i) const { return entries[i]->create(); }

    static bool verbose;

    static List& get_registry()
    { if (!registry) { auto_delete = registry = new List; } return *registry; }
 
  protected:

    void add (Entry<Parent>* entry) { entries.push_back (entry); }

    std::vector< Reference::To< Entry<Parent> > > entries;

    static List* registry;

    static Reference::To<List> auto_delete;
  };
 
  template<class Parent>
  template<class Child>
  class List<Parent>::Instances
  {
  public:
    static unsigned get_instances () { return instances; }
    static void add_instance () { instances++; }
  private:
    static unsigned instances;
  };

  template<class Parent>
  template<class Child>
  class List<Parent>::Enter : public Entry<Parent>
  {
  public:
    Enter () 
    { 
      if (Instances<Child>::get_instances() == 0)
        this->register_child (new Child);
      Instances<Child>::add_instance();
    }
 
  protected:
    Parent* create () const { return new Child; }
  };
  
  template<class Parent>
  template<class Child, class Argument>
  class List<Parent>::Unary : public Entry<Parent>
  {
  public:

    Unary (const Argument& arg)
    { 
      argument = arg;
      if (Instances<Child>::get_instances() == 0)
        this->register_child( new Child(arg) );
      Instances<Child>::add_instance();
    }
  protected:
    Parent* create () const { return new Child(argument); }
    Argument argument;
  };
 
 
}
 
template<class Parent> 
template<class Child>
unsigned Registry::List<Parent>::Instances<Child>::instances = 0;
 
template<class Parent>
bool Registry::List<Parent>::verbose = false;
 
template<class Parent>
Registry::List<Parent>* Registry::List<Parent>::registry = 0;
 
template<class Parent>
Reference::To< Registry::List<Parent> > Registry::List<Parent>::auto_delete;
 
#endif