CTK/Libs/Core/ctkAbstractFactory.h

/*=========================================================================

  Library:   CTK
 
  Copyright (c) 2010  Kitware Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.commontk.org/LICENSE

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
=========================================================================*/

#ifndef __ctkAbstractFactory_h
#define __ctkAbstractFactory_h

// Qt includes
#include <QString>
#include <QHash>
#include <QSharedPointer>
#include <QStringList>

#ifdef _MSC_VER
  /// 4505: 'ctkAbstractFactoryItem<BaseClassType>::loadErrorString' :
  ///       unreferenced local function has been removed
# pragma warning(disable: 4505)
#endif

//----------------------------------------------------------------------------
/// ctkAbstractFactoryItem is the base class of factory items. They are
/// uniquely defined by a key and are responsible for creating/holding an
/// instance of a BaseClassType object.
template<typename BaseClassType>
class ctkAbstractFactoryItem
{
public:
  explicit ctkAbstractFactoryItem(const QString& key);
  virtual ~ctkAbstractFactoryItem(){}
  
  virtual QString loadErrorString()const;
  virtual bool load() = 0;
  
  BaseClassType* instantiate();
  bool instantiated()const;
  virtual void uninstantiate();
  
  QString key()const;
  
  void setVerbose(bool value);
  bool verbose()const;

protected:
  /// Must be reimplemented in subclasses to instanciate a BaseClassType*
  virtual BaseClassType* instanciator() = 0;
  BaseClassType* Instance;

private:
  QString Key;
  bool Verbose;
};

//----------------------------------------------------------------------------
/// ctkAbstractFactory is the base class of all the factory where items need
/// to be registered before being instantiated.
/// ctkAbstractFactory contains a collection of ctkAbstractFactoryItems that
/// are uniquely identifyed by a key. Subclasses of ctkAbstractFactory are
/// responsible for populating the list of ctkAbstractFactoryItems.
/// BaseClassType could be any type (most probably a QObject) 
template<typename BaseClassType>
class ctkAbstractFactory
{
public:
  /// 
  /// Constructor/Desctructor
  explicit ctkAbstractFactory();
  virtual ~ctkAbstractFactory();
  virtual void printAdditionalInfo();

  /// 
  /// Create an instance of the object. The item corresponding to the key
  /// should have been registered before.
  virtual BaseClassType * instantiate(const QString& itemKey);

  /// 
  /// Uninstanciate the object. Do nothing if the item given by the key has
  /// not be instantiated nor registered.
  void uninstantiate(const QString& itemKey);

  /// 
  /// Get list of all registered item keys.
  QStringList keys() const;

  /// 
  /// Register items with the factory
  /// Method provided for convenience - Should be overloaded in subclasse
  virtual void registerItems(){}

  /// Enabled verbose output
  /// Warning and error message will be printed to standard outputs
  void setVerbose(bool value);
  bool verbose()const;

protected:

  /// 
  /// Call the load method associated with the item.
  /// If succesfully loaded, add it to the internal map.
  bool registerItem(const QSharedPointer<ctkAbstractFactoryItem<BaseClassType> > & item);

  /// 
  /// Get a Factory item given its itemKey. Return 0 if any.
  ctkAbstractFactoryItem<BaseClassType> * item(const QString& itemKey)const;

  typedef typename QHash<QString, QSharedPointer<ctkAbstractFactoryItem<BaseClassType> > >::const_iterator ConstIterator;
  typedef typename QHash<QString, QSharedPointer<ctkAbstractFactoryItem<BaseClassType> > >::iterator       Iterator;

private:
  ctkAbstractFactory(const ctkAbstractFactory &); /// Not implemented
  void operator=(const ctkAbstractFactory&); /// Not implemented

  QHash<QString, QSharedPointer<ctkAbstractFactoryItem<BaseClassType> > > RegisteredItemMap;

  bool Verbose;
};

#include "ctkAbstractFactory.tpp"

#endif