factory.h

Go to the documentation of this file.

//
// Copyright (c) 1999-2004 California Institute of Technology
// Copyright (c) 2004-2007 University of Southern California
// Rob Peters <rjpeters at usc dot edu>
//
// created: Sat Jun 26 23:40:55 1999
// commit: $Id: factory.h 10097 2007-08-07 19:08:27Z rjpeters $
// $HeadURL: file:///lab/rjpeters/svnrepo/code/trunk/groovx/src/rutz/factory.h $
//
// --------------------------------------------------------------------
//
// This file is part of GroovX.
//   [http://ilab.usc.edu/rjpeters/groovx/]
//
// GroovX is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// GroovX is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with GroovX; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//

#ifndef GROOVX_RUTZ_FACTORY_H_UTC20050626084020_DEFINED
#define GROOVX_RUTZ_FACTORY_H_UTC20050626084020_DEFINED

#include "rutz/assocarray.h"
#include "rutz/demangle.h"
#include "rutz/fileposition.h"
#include "rutz/mutex.h"
#include "rutz/shared_ptr.h"
#include "rutz/traits.h"

#include <typeinfo>

namespace rutz
{
  class fstring;


  template <class T>
  class creator_base
  {
  public:
    typedef T base_t;

    virtual ~creator_base() {}

    virtual creator_base* clone() const = 0;

    virtual base_t create() = 0;
  };



  template <class base_t, class derived_t>
  class creator_from_func : public rutz::creator_base<base_t>
  {
  public:
    typedef derived_t (*creator_func_t) ();

    creator_from_func(creator_func_t func) :
      rutz::creator_base<base_t>(), m_creator_func(func) {}

    virtual rutz::creator_base<base_t>* clone() const
    { return new creator_from_func<base_t, derived_t>(*this); }

    virtual base_t create() { return base_t(m_creator_func()); }

  private:
    creator_func_t m_creator_func;
  };


  class factory_fallback
  {
  public:
    factory_fallback() throw();

    virtual ~factory_fallback() throw();

    virtual void try_fallback(const rutz::fstring& key) const = 0;
  };

  class factory_base
  {
  public:
    typedef void (fallback_t)(const rutz::fstring&);

    factory_base() throw();

    virtual ~factory_base() throw();

    void set_fallback(rutz::shared_ptr<factory_fallback> f);

    void set_fallback(fallback_t* fptr);

    void try_fallback(const rutz::fstring& key) const;

  private:
    rutz::shared_ptr<factory_fallback> m_fallback;
  };



  template <class T>
  class factory
  {
  public:
    // typedefs

    typedef factory_base::fallback_t fallback_t;
    typedef T base_t;

  private:
    rutz::factory_base                               m_base;
    rutz::assoc_array<rutz::creator_base<base_t> >   m_map;
    mutable pthread_mutex_t                          m_mutex;

  protected:
    rutz::creator_base<base_t>*
    find_creator(const rutz::fstring& key) const
    {
      rutz::creator_base<base_t>* creator = 0;

      {
        GVX_MUTEX_LOCK(&m_mutex);
        creator = m_map.get_ptr_for_key(key);
      }

      if (creator == 0)
        {
          // note that we must call try_fallback() with our mutex
          // UN-locked because the intention is that the fallback
          // function will try do something to cause a new entry to be
          // inserted into this very factory object; that insertion
          // will require locking the mutex so if we have the mutex
          // locked here we will end up with a deadlock:
          m_base.try_fallback(key);

          {
            GVX_MUTEX_LOCK(&m_mutex);
            creator = m_map.get_ptr_for_key(key);
          }
        }

      return creator;
    }

  public:

    factory(const char* keydescr = "object type", bool nocase = false)
      : m_base(), m_map(keydescr, nocase), m_mutex()
    {
      pthread_mutex_init(&m_mutex, (pthread_mutexattr_t*) 0);
    }

    virtual ~factory() throw()
    {
      pthread_mutex_destroy(&m_mutex);
    }


    const char* register_creator(rutz::creator_base<base_t>* creator,
                                 const char* name)
    {
      GVX_MUTEX_LOCK(&m_mutex);

      m_map.set_ptr_for_key(name, creator);

      return name;
    }


    template <class derived_t>
    const char* register_creator(derived_t (*func) (),
                                 const char* key = 0)
    {
      GVX_MUTEX_LOCK(&m_mutex);

      if (key == 0)
        key = rutz::demangled_name
          (typeid(typename rutz::type_traits<derived_t>::pointee_t));

      m_map.set_ptr_for_key
        (key, new rutz::creator_from_func<base_t, derived_t>(func));

      return key;
    }


    void register_alias(const char* orig_key, const char* alias_key)
    {
      GVX_MUTEX_LOCK(&m_mutex);

      rutz::creator_base<base_t>* creator =
        m_map.get_ptr_for_key(orig_key);

      if (creator != 0)
        {
          m_map.set_ptr_for_key(alias_key, creator->clone());
        }
    }

    bool is_valid_key(const char* key) const
    {
      return (this->find_creator(key) != 0);
    }

    rutz::fstring get_known_keys(const char* sep) const
    {
      GVX_MUTEX_LOCK(&m_mutex);

      return m_map.get_known_keys(sep);
    }


    base_t new_object(const rutz::fstring& type) const
    {
      rutz::creator_base<base_t>* creator = this->find_creator(type);

      if (creator == 0) return base_t();

      return creator->create();
    }


    base_t new_checked_object(const rutz::fstring& type) const
    {
      rutz::creator_base<base_t>* creator = this->find_creator(type);

      if (creator == 0)
        {
          GVX_MUTEX_LOCK(&m_mutex);

          m_map.throw_for_key(type, SRC_POS);
        }

      return creator->create();
    }

    void set_fallback(rutz::shared_ptr<factory_fallback> f)
    {
      GVX_MUTEX_LOCK(&m_mutex);

      m_base.set_fallback(f);
    }

    void set_fallback(fallback_t* fptr)
    {
      GVX_MUTEX_LOCK(&m_mutex);

      m_base.set_fallback(fptr);
    }
  };

} // end namespace rutz


static const char __attribute__((used)) vcid_groovx_rutz_factory_h_utc20050626084020[] = "$Id: factory.h 10097 2007-08-07 19:08:27Z rjpeters $ $HeadURL: file:
#endif // !GROOVX_RUTZ_FACTORY_H_UTC20050626084020_DEFINED

---

The software described here is Copyright (c) 1998-2005, Rob Peters.
This page was generated Wed Dec 3 06:49:40 2008 by Doxygen version 1.5.5.