Factory.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */

#ifndef _Factory_H_
#define _Factory_H_

#include "FactoryException.h"

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include <map>
#include <vector>

namespace hippodraw {

template < class Type > class Factory
{
private:

  Factory ( const Factory< Type > & );

protected:

  std::map < std::string, Type * > m_types;

  mutable std::vector< std::string > m_names;

  Factory ( );

  virtual ~Factory();

 public:

  void add ( Type * );

  void remove ( const std::string & name );

  bool exists ( const std::string & name ) const;

  Type * prototype ( const std::string & name ) const;

  Type * create ( const std::string & name );

  const std::vector< std::string > & names () const;

};

template < class Type >
Factory < Type >::Factory ( )
{
}

template< class Type >
Factory<Type>::~Factory ()
{
  typename std::map < std::string, Type * > ::iterator first
          = m_types.begin();
  for ( ; first != m_types.end(); ++first ) {
    delete first->second;
  }

  m_types.clear ();
}

template< class Type >
void Factory<Type>::add ( Type * obj )
{
  const std::string & name = obj->name ();
  m_types[name] = obj;
}

template < class Type >
void
Factory < Type >::
remove ( const std::string & name )
{
  typename std::map < std::string, Type * > ::iterator it
    = m_types.find ( name );
  if ( it != m_types.end () ) {
    m_types.erase ( it );
  }
}

template < class Type >
bool Factory < Type>::
exists ( const std::string & name ) const
{
  // Don't use map::operator[]() to find the name, as it will create
  // one if it doesn't exist.
  typename std::map< std::string, Type * >::const_iterator it 
    = m_types.find ( name );

  return it != m_types.end ();
}


template< class Type >
Type * Factory<Type>::prototype ( const std::string & name ) const
{
  // Don't use map::operator[]() to find the name, as it will create
  // one if it doesn't exist.
  typename std::map< std::string, Type * >::const_iterator it 
    = m_types.find ( name );
  if ( it == m_types.end () ) throw FactoryException ( name );

  return it->second;
}

template< class Type >
Type * Factory<Type>::create ( const std::string & name )
{
  Type * obj = prototype ( name );
  if ( obj == 0 ) {
    return 0;
  }
  return obj->clone ();
}

template< class Type >
const std::vector< std::string > & Factory<Type>::names () const
{
  m_names.clear ();
  typename std::map <std::string, Type *>::const_iterator it 
    = m_types.begin ();
  for ( ; it != m_types.end (); ++it ) {
    m_names.push_back ( it->first );
  }

  return m_names;
}

} // namespace hippodraw

#endif // _Factory_H_

---