include/Factory.h

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 #ifndef _Factory_h_
  21 #define _Factory_h_
  22
  23 /**
  24  * @file Factory.h
  25  * @brief A generic object factory.
  26  * @author James Hogan <james@albanarts.com>
  27  */
  28
  29 #include "functionInfo.h"
  30
  31 #include <QHash>
  32
  33 /** A generic object factory.
  34  * Types can be registered to this class and then constructed using a key.
  35  */
  36 template <typename KEY, typename BASE, typename TUPLE>
  37 class Factory
  38 {
  39   public:
  40
  41     /*
  42      * Constructors + destructor
  43      */
  44
  45     /// Default constructor.
  46     Factory()
  47     : m_constructors()
  48     {
  49     }
  50
  51     /// Destructor.
  52     ~Factory()
  53     {
  54       foreach (BaseConstructor* constructor, m_constructors)
  55       {
  56         delete constructor;
  57       }
  58     }
  59
  60     /*
  61      * Type registration
  62      */
  63
  64     /** Add a type to the factory.
  65      * @param T Type to add.
  66      * @param key Identifier used to construct.
  67      */
  68     template <typename T>
  69     bool addType(const KEY& key)
  70     {
  71       typename ConstructorHash::const_iterator it = m_constructors.constFind(key);
  72       if (it == m_constructors.constEnd())
  73       {
  74         m_constructors[key] = new Constructor<T>();
  75         return true;
  76       }
  77       return false;
  78     }
  79
  80     /** Remove a type from the factory.
  81      * @param key Identifier used to construct.
  82      */
  83     bool removeType(const KEY& key)
  84     {
  85
  86       typename ConstructorHash::iterator it = m_constructors.find(key);
  87       if (it != m_constructors.end())
  88       {
  89         delete *it;
  90         m_constructors.erase(it);
  91         return true;
  92       }
  93       return false;
  94     }
  95
  96     /*
  97      * Construction
  98      */
  99
 100     BASE* construct(const KEY& key)
 101     {
 102       return constructFromPack(key, TUPLE::pack());
 103     }
 104     template <typename Param1>
 105     BASE* construct(const KEY& key, const Param1& param1)
 106     {
 107       return constructFromPack(key, TUPLE::pack(param1));
 108     }
 109     template <typename Param1, typename Param2>
 110     BASE* construct(const KEY& key, const Param1& param1, const Param2& param2)
 111     {
 112       return constructFromPack(key, TUPLE::pack(param1, param2));
 113     }
 114
 115     /** Construct a type using a pack of arguments.
 116      * @param key identifier of type to construct.
 117      * @param pack pack of arguments.
 118      */
 119     BASE* constructFromPack(const KEY& key, const typename TUPLE::Pack& pack)
 120     {
 121       typename ConstructorHash::const_iterator it = m_constructors.constFind(key);
 122       if (it != m_constructors.constEnd())
 123       {
 124         return (*it)->construct(pack);
 125       }
 126       else
 127       {
 128         return 0;
 129       }
 130     }
 131
 132     BASE* singleton(const KEY& key)
 133     {
 134       return singletonFromPack(key, TUPLE::pack());
 135     }
 136     template <typename Param1>
 137     BASE* singleton(const KEY& key, const Param1& param1)
 138     {
 139       return singletonFromPack(key, TUPLE::pack(param1));
 140     }
 141     template <typename Param1, typename Param2>
 142     BASE* singleton(const KEY& key, const Param1& param1, const Param2& param2)
 143     {
 144       return singletonFromPack(key, TUPLE::pack(param1, param2));
 145     }
 146
 147     /** Get a singleton of a type using a pack of arguments.
 148      * @param key identifier of type to construct.
 149      * @param pack pack of arguments.
 150      */
 151     BASE* singletonFromPack(const KEY& key, const typename TUPLE::Pack& pack)
 152     {
 153       typename ConstructorHash::const_iterator it = m_constructors.constFind(key);
 154       if (it != m_constructors.constEnd())
 155       {
 156         return (*it)->singleton(pack);
 157       }
 158       else
 159       {
 160         return 0;
 161       }
 162     }
 163
 164     /// Delete any existing singleton of a type.
 165     void deleteSingleton(const KEY& key)
 166     {
 167       typename ConstructorHash::const_iterator it = m_constructors.constFind(key);
 168       if (it != m_constructors.constEnd())
 169       {
 170         (*it)->deleteSingleton();
 171       }
 172     }
 173
 174     /// Delete all singletons.
 175     void deleteAllSingletons()
 176     {
 177       foreach (BaseConstructor* constructor, m_constructors)
 178       {
 179         constructor->deleteSingleton();
 180       }
 181     }
 182
 183   private:
 184
 185     /*
 186      * Types
 187      */
 188
 189     /// Base constructor class.
 190     class BaseConstructor
 191     {
 192       public:
 193         BaseConstructor()
 194         : m_singleton(0)
 195         {
 196         }
 197         virtual ~BaseConstructor()
 198         {
 199           delete m_singleton;
 200         }
 201         /// Construct an instance of a dervied type.
 202         virtual BASE* construct(const typename TUPLE::Pack& pack) const = 0;
 203         /// Get a singleton object, constructing if necessary.
 204         BASE* singleton(const typename TUPLE::Pack& pack)
 205         {
 206           if (0 == m_singleton)
 207           {
 208             m_singleton = construct(pack);
 209           }
 210           return m_singleton;
 211         }
 212         /// Delete singleton if it exists.
 213         void deleteSingleton()
 214         {
 215           delete m_singleton;
 216           m_singleton = 0;
 217         }
 218
 219       private:
 220         // No copy construction
 221         BaseConstructor(const BaseConstructor&);
 222
 223         BASE* m_singleton;
 224     };
 225
 226     /** Type specific generic constructor.
 227      * @param TYPE Type to construct.
 228      */
 229     template <typename TYPE>
 230     class Constructor : public BaseConstructor
 231     {
 232       public:
 233         virtual ~Constructor() {}
 234         virtual BASE* construct(const typename TUPLE::Pack& pack) const
 235         {
 236           return pack.template construct<TYPE>();
 237         }
 238     };
 239
 240     /// Hash of keys to constructors.
 241     typedef QHash<KEY, BaseConstructor*> ConstructorHash;
 242
 243     /*
 244      * Variables
 245      */
 246
 247     /// Constructors by key.
 248     ConstructorHash m_constructors;
 249 };
 250
 251 #endif // _Factory_h_
 252