include/partons/ModuleObjectFactory.h

0001 #ifndef MODULE_OBJECT_FACTORY_H
0002 #define MODULE_OBJECT_FACTORY_H
0003
0004 /**
0005  * @file ModuleObjectFactory.h
0006  * @author Bryan BERTHOU (SPhN / CEA Saclay)
0007  * @date July 02, 2015
0008  * @version 1.0
0009  */
0010
0011 #include <map>
0012 #include <string>
0013
0014 #include "ModuleObject.h"
0015 #include "ModuleObjectReference.h"
0016
0017 namespace PARTONS {
0018 class ActiveFlavorsThresholdsModule;
0019 class BaseObjectFactory;
0020 class DVCSScalesModule;
0021 class TCSScalesModule;
0022 class DVMPScalesModule;
0023 class GAM2ScalesModule;
0024 class CollinearDistributionEvolutionModule;
0025 class CollinearDistributionModule;
0026 class DDVCSConvolCoeffFunctionModule;
0027 class DDVCSObservable;
0028 class DDVCSProcessModule;
0029 class DDVCSScalesModule;
0030 class DDVCSXiConverterModule;
0031 class DVCSConvolCoeffFunctionModule;
0032 class DVCSObservable;
0033 class DVCSProcessModule;
0034 class DVCSScalesModule;
0035 class DVCSXiConverterModule;
0036 class DVMPConvolCoeffFunctionModule;
0037 class DVMPObservable;
0038 class DVMPProcessModule;
0039 class DVMPScalesModule;
0040 class DVMPXiConverterModule;
0041 class GPDEvolutionModule;
0042 class GPDModule;
0043 class GPDSubtractionConstantModule;
0044 class RunningAlphaStrongModule;
0045 class TCSConvolCoeffFunctionModule;
0046 class GAM2ConvolCoeffFunctionModule;
0047 class DVCSObservable;
0048 class DVCSProcessModule;
0049 class TCSObservable;
0050 class TCSProcessModule;
0051 class DVMPObservable;
0052 class DVMPProcessModule;
0053 //class GAM2Observable;
0054 class GAM2ProcessModule;
0055 class GPDEvolutionModule;
0056 class GPDModule;
0057 class CollinearDistributionEvolutionModule;
0058 class CollinearDistributionModule;
0059 class GPDSubtractionConstantModule;
0060 class ModuleObject;
0061 class RunningAlphaStrongModule;
0062 class DVCSXiConverterModule;
0063 class TCSObservable;
0064 class TCSProcessModule;
0065 class TCSScalesModule;
0066 class TCSXiConverterModule;
0067 class DVMPXiConverterModule;
0068 class GAM2XiConverterModule;
0069 } /* namespace PARTONS */
0070
0071 namespace PARTONS {
0072
0073 /**
0074  * @class ModuleObjectFactory
0075  *
0076  * @brief It's a specialization of the BaseObjectFactory to get intermediate abstract module class specialization to be able to use directly more sophisticated methods (like compute(...)).
0077  * It only casts BaseObject pointer to desired abstract module class type.
0078  */
0079 class ModuleObjectFactory: public BaseObject {
0080 public:
0081     /**
0082      * Default destructor.
0083      */
0084     virtual ~ModuleObjectFactory();
0085
0086     /**
0087      * Specialization of BaseObjectFactory::newBaseObject into a ModuleObject.
0088      * @param className Name of last child class.
0089      * @return ModuleObject pointer.
0090      */
0091     ModuleObject* newModuleObject(const std::string& className);
0092     /**
0093      * Specialization of BaseObjectFactory::newBaseObject into a ModuleObject.
0094      * @param classId Unique identifier of last child class.
0095      * @return ModuleObject pointer.
0096      */
0097     ModuleObject* newModuleObject(unsigned int classId);
0098
0099     /**
0100      * Clone module object.
0101      * @param pModuleObjectOrig Module object to be cloned.
0102      * @return Pointer to cloned object.
0103      */
0104     template<class T> T* cloneModuleObject(T* pModuleObjectOrig) {
0105
0106         T* pModuleObjectClone = pModuleObjectOrig->clone();
0107         store(pModuleObjectClone);
0108
0109         return pModuleObjectClone;
0110     }
0111
0112     /**
0113      * Specialization of ModuleObjectFactory::newModuleObject into a GPDEvolutionModule.
0114      * @param classId Unique identifier of last child class.
0115      * @return GPDEvolutionModule pointer.
0116      */
0117     GPDEvolutionModule* newGPDEvolutionModule(unsigned int classId);
0118     /**
0119      * Specialization of ModuleObjectFactory::newModuleObject into a GPDEvolutionModule.
0120      * @param className Name of last child class.
0121      * @return GPDEvolutionModule pointer.
0122      */
0123     GPDEvolutionModule* newGPDEvolutionModule(const std::string & className);
0124
0125     /**
0126      * Specialization of ModuleObjectFactory::newModuleObject into a GPDModule.
0127      * @param classId Unique identifier of last child class.
0128      * @return GPDModule pointer.
0129      */
0130     GPDModule* newGPDModule(unsigned int classId);
0131     /**
0132      * Specialization of ModuleObjectFactory::newModuleObject into a GPDModule.
0133      * @param className Name of last child class.
0134      * @return GPDModule pointer.
0135      */
0136     GPDModule* newGPDModule(const std::string &className);
0137
0138     /**
0139      * Specialization of ModuleObjectFactory::newModuleObject into a CollinearDistributionEvolutionModule.
0140      * @param classId Unique identifier of last child class.
0141      * @return CollinearDistributionEvolutionModule pointer.
0142      */
0143     CollinearDistributionEvolutionModule* newCollinearDistributionEvolutionModule(
0144             unsigned int classId);
0145     /**
0146      * Specialization of ModuleObjectFactory::newModuleObject into a CollinearDistributionEvolutionModule.
0147      * @param className Name of last child class.
0148      * @return CollinearDistributionEvolutionModule pointer.
0149      */
0150     CollinearDistributionEvolutionModule* newCollinearDistributionEvolutionModule(
0151             const std::string & className);
0152
0153     /**
0154      * Specialization of ModuleObjectFactory::newModuleObject into a CollinearDistributionModule.
0155      * @param classId Unique identifier of last child class.
0156      * @return CollinearDistributionModule pointer.
0157      */
0158     CollinearDistributionModule* newCollinearDistributionModule(
0159             unsigned int classId);
0160     /**
0161      * Specialization of ModuleObjectFactory::newModuleObject into a CollinearDistributionModule.
0162      * @param className Name of last child class.
0163      * @return CollinearDistributionModule pointer.
0164      */
0165     CollinearDistributionModule* newCollinearDistributionModule(
0166             const std::string &className);
0167
0168     /**
0169      * Specialization of ModuleObjectFactory::newModuleObject into a GPDSubtractionConstantModule.
0170      * @param classId Unique identifier of last child class.
0171      * @return GPDSubtractionConstantModule pointer.
0172      */
0173     GPDSubtractionConstantModule* newGPDSubtractionConstantModule(
0174             unsigned int classId);
0175     /**
0176      * Specialization of ModuleObjectFactory::newModuleObject into a GPDSubtractionConstantModule.
0177      * @param className Name of last child class.
0178      * @return GPDSubtractionConstantModule pointer.
0179      */
0180     GPDSubtractionConstantModule* newGPDSubtractionConstantModule(
0181             const std::string &className);
0182
0183     /**
0184      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSConvolCoeffFunctionModule.
0185      * @param classId Unique identifier of last child class.
0186      * @return DVCSConvolCoeffFunctionModule pointer.
0187      */
0188     DVCSConvolCoeffFunctionModule* newDVCSConvolCoeffFunctionModule(
0189             unsigned int classId);
0190     /**
0191      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSConvolCoeffFunctionModule.
0192      * @param className Name of last child class.
0193      * @return DVCSConvolCoeffFunctionModule pointer.
0194      */
0195     DVCSConvolCoeffFunctionModule* newDVCSConvolCoeffFunctionModule(
0196             const std::string &className);
0197
0198     /**
0199      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPConvolCoeffFunctionModule.
0200      * @param classId Unique identifier of last child class.
0201      * @return DVMPConvolCoeffFunctionModule pointer.
0202      */
0203     DVMPConvolCoeffFunctionModule* newDVMPConvolCoeffFunctionModule(
0204             unsigned int classId);
0205     /**
0206      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPConvolCoeffFunctionModule.
0207      * @param className Name of last child class.
0208      * @return DVMPConvolCoeffFunctionModule pointer.
0209      */
0210     DVMPConvolCoeffFunctionModule* newDVMPConvolCoeffFunctionModule(
0211             const std::string &className);
0212
0213     /**
0214      * Specialization of ModuleObjectFactory::newModuleObject into a TCSConvolCoeffFunctionModule.
0215      * @param classId Unique identifier of last child class.
0216      * @return TCSConvolCoeffFunctionModule pointer.
0217      */
0218     TCSConvolCoeffFunctionModule* newTCSConvolCoeffFunctionModule(
0219             unsigned int classId);
0220     /**
0221      * Specialization of ModuleObjectFactory::newModuleObject into a TCSConvolCoeffFunctionModule.
0222      * @param className Name of last child class.
0223      * @return TCSConvolCoeffFunctionModule pointer.
0224      */
0225     TCSConvolCoeffFunctionModule* newTCSConvolCoeffFunctionModule(
0226             const std::string &className);
0227
0228     /**
0229      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ConvolCoeffFunctionModule.
0230      * @param classId Unique identifier of last child class.
0231      * @return GAM2ConvolCoeffFunctionModule pointer.
0232      */
0233     GAM2ConvolCoeffFunctionModule* newGAM2ConvolCoeffFunctionModule(
0234             unsigned int classId);
0235     /**
0236      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ConvolCoeffFunctionModule.
0237      * @param className Name of last child class.
0238      * @return GAM2ConvolCoeffFunctionModule pointer.
0239      */
0240     GAM2ConvolCoeffFunctionModule* newGAM2ConvolCoeffFunctionModule(
0241             const std::string &className);
0242     /**
0243      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSConvolCoeffFunctionModule.
0244      * @param classId Unique identifier of last child class.
0245      * @return DDVCSConvolCoeffFunctionModule pointer.
0246      */
0247     DDVCSConvolCoeffFunctionModule* newDDVCSConvolCoeffFunctionModule(
0248             unsigned int classId);
0249     /**
0250      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSConvolCoeffFunctionModule.
0251      * @param className Name of last child class.
0252      * @return DDVCSConvolCoeffFunctionModule pointer.
0253      */
0254     DDVCSConvolCoeffFunctionModule* newDDVCSConvolCoeffFunctionModule(
0255             const std::string &className);
0256
0257     /**
0258      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSProcessModule.
0259      * @param classId Unique identifier of last child class.
0260      * @return DVCSProcessModule pointer.
0261      */
0262     DVCSProcessModule* newDVCSProcessModule(unsigned int classId);
0263     /**
0264      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSProcessModule.
0265      * @param className Name of last child class.
0266      * @return DVCSProcessModule pointer.
0267      */
0268     DVCSProcessModule* newDVCSProcessModule(const std::string & className);
0269
0270     /**
0271      * Specialization of ModuleObjectFactory::newModuleObject into a TCSProcessModule.
0272      * @param classId Unique identifier of last child class.
0273      * @return TCSProcessModule pointer.
0274      */
0275     TCSProcessModule* newTCSProcessModule(unsigned int classId);
0276     /**
0277      * Specialization of ModuleObjectFactory::newModuleObject into a TCSProcessModule.
0278      * @param className Name of last child class.
0279      * @return TCSProcessModule pointer.
0280      */
0281     TCSProcessModule* newTCSProcessModule(const std::string & className);
0282
0283     /**
0284      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPProcessModule.
0285      * @param classId Unique identifier of last child class.
0286      * @return DVMPProcessModule pointer.
0287      */
0288     DVMPProcessModule* newDVMPProcessModule(unsigned int classId);
0289     /**
0290      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPProcessModule.
0291      * @param className Name of last child class.
0292      * @return DVMPProcessModule pointer.
0293      */
0294     DVMPProcessModule* newDVMPProcessModule(const std::string & className);
0295
0296     /**
0297      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ProcessModule.
0298      * @param classId Unique identifier of last child class.
0299      * @return GAM2ProcessModule pointer.
0300      */
0301     GAM2ProcessModule* newGAM2ProcessModule(unsigned int classId);
0302     /**
0303      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ProcessModule.
0304      * @param className Name of last child class.
0305      * @return GAM2ProcessModule pointer.
0306      */
0307     GAM2ProcessModule* newGAM2ProcessModule(const std::string & className);
0308     /**
0309      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSProcessModule.
0310      * @param classId Unique identifier of last child class.
0311      * @return DDVCSProcessModule pointer.
0312      */
0313     DDVCSProcessModule* newDDVCSProcessModule(unsigned int classId);
0314     /**
0315      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSProcessModule.
0316      * @param className Name of last child class.
0317      * @return DDVCSProcessModule pointer.
0318      */
0319     DDVCSProcessModule* newDDVCSProcessModule(const std::string & className);
0320
0321     /**
0322      * Specialization of ModuleObjectFactory::newModuleObject into a RunningAlphaStrongModule.
0323      * @param classId Unique identifier of last child class.
0324      * @return RunningAlphaStrongModule pointer.
0325      */
0326     RunningAlphaStrongModule* newRunningAlphaStrongModule(unsigned int classId);
0327     /**
0328      * Specialization of ModuleObjectFactory::newModuleObject into a RunningAlphaStrongModule.
0329      * @param className Name of last child class.
0330      * @return RunningAlphaStrongModule pointer.
0331      */
0332     RunningAlphaStrongModule* newRunningAlphaStrongModule(
0333             const std::string & className);
0334
0335     /**
0336      * Specialization of ModuleObjectFactory::newModuleObject into a ActiveFlavorsThresholdsModule.
0337      * @param classId Unique identifier of last child class.
0338      * @return ActiveFlavorsThresholdsModule pointer.
0339      */
0340     ActiveFlavorsThresholdsModule* newActiveFlavorsThresholdsModule(
0341             unsigned int classId);
0342     /**
0343      * Specialization of ModuleObjectFactory::newModuleObject into a ActiveFlavorsModule.
0344      * @param className Name of last child class.
0345      * @return ActiveFlavorsModule pointer.
0346      */
0347     ActiveFlavorsThresholdsModule* newActiveFlavorsThresholdsModule(
0348             const std::string &className);
0349
0350     /**
0351      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSScalesModule.
0352      * @param classId Unique identifier of last child class.
0353      * @return DVCSScalesModule pointer.
0354      */
0355     DVCSScalesModule* newDVCSScalesModule(unsigned int classId);
0356     /**
0357      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSScalesModule.
0358      * @param className Name of last child class.
0359      * @return DVCSScalesModule pointer.
0360      */
0361     DVCSScalesModule* newDVCSScalesModule(const std::string &className);
0362
0363     /**
0364      * Specialization of ModuleObjectFactory::newModuleObject into a TCSScalesModule.
0365      * @param classId Unique identifier of last child class.
0366      * @return TCSScalesModule pointer.
0367      */
0368     TCSScalesModule* newTCSScalesModule(unsigned int classId);
0369     /**
0370      * Specialization of ModuleObjectFactory::newModuleObject into a TCSScalesModule.
0371      * @param className Name of last child class.
0372      * @return TCSScalesModule pointer.
0373      */
0374     TCSScalesModule* newTCSScalesModule(const std::string &className);
0375
0376     /**
0377      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPScalesModule.
0378      * @param classId Unique identifier of last child class.
0379      * @return DVMPScalesModule pointer.
0380      */
0381     DVMPScalesModule* newDVMPScalesModule(unsigned int classId);
0382     /**
0383      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPScalesModule.
0384      * @param className Name of last child class.
0385      * @return DVMPScalesModule pointer.
0386      */
0387     DVMPScalesModule* newDVMPScalesModule(const std::string &className);
0388
0389     /**
0390      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ScalesModule.
0391      * @param classId Unique identifier of last child class.
0392      * @return GAM2ScalesModule pointer.
0393      */
0394     GAM2ScalesModule* newGAM2ScalesModule(unsigned int classId);
0395     /**
0396      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2ScalesModule.
0397      * @param className Name of last child class.
0398      * @return GAM2ScalesModule pointer.
0399      */
0400     GAM2ScalesModule* newGAM2ScalesModule(const std::string &className);
0401     /**
0402      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSScalesModule.
0403      * @param classId Unique identifier of last child class.
0404      * @return DDVCSScalesModule pointer.
0405      */
0406     DDVCSScalesModule* newDDVCSScalesModule(unsigned int classId);
0407     /**
0408      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSScalesModule.
0409      * @param className Name of last child class.
0410      * @return DDVCSScalesModule pointer.
0411      */
0412     DDVCSScalesModule* newDDVCSScalesModule(const std::string &className);
0413
0414     /**
0415      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSXiConverterModule.
0416      * @param classId Unique identifier of last child class.
0417      * @return DVCSXiConverterModule pointer.
0418      */
0419     DVCSXiConverterModule* newDVCSXiConverterModule(unsigned int classId);
0420     /**
0421      * Specialization of ModuleObjectFactory::newModuleObject into a DVCSXiConverterModule.
0422      * @param className Name of last child class.
0423      * @return DVCSXiConverterModule pointer.
0424      */
0425     DVCSXiConverterModule* newDVCSXiConverterModule(
0426             const std::string &className);
0427
0428     /**
0429      * Specialization of ModuleObjectFactory::newModuleObject into a TCSXiConverterModule.
0430      * @param classId Unique identifier of last child class.
0431      * @return TCSXiConverterModule pointer.
0432      */
0433     TCSXiConverterModule* newTCSXiConverterModule(unsigned int classId);
0434     /**
0435      * Specialization of ModuleObjectFactory::newModuleObject into a TCSXiConverterModule.
0436      * @param className Name of last child class.
0437      * @return TCSXiConverterModule pointer.
0438      */
0439     TCSXiConverterModule* newTCSXiConverterModule(const std::string &className);
0440
0441     /**
0442      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPXiConverterModule.
0443      * @param classId Unique identifier of last child class.
0444      * @return DVMPXiConverterModule pointer.
0445      */
0446     DVMPXiConverterModule* newDVMPXiConverterModule(unsigned int classId);
0447     /**
0448      * Specialization of ModuleObjectFactory::newModuleObject into a DVMPXiConverterModule.
0449      * @param className Name of last child class.
0450      * @return DVMPXiConverterModule pointer.
0451      */
0452     DVMPXiConverterModule* newDVMPXiConverterModule(
0453             const std::string &className);
0454
0455     /**
0456      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSXiConverterModule.
0457      * @param classId Unique identifier of last child class.
0458      * @return DDVCSXiConverterModule pointer.
0459      */
0460     DDVCSXiConverterModule* newDDVCSXiConverterModule(unsigned int classId);
0461     /**
0462      * Specialization of ModuleObjectFactory::newModuleObject into a DDVCSXiConverterModule.
0463      * @param className Name of last child class.
0464      * @return DDVCSXiConverterModule pointer.
0465      */
0466     DDVCSXiConverterModule* newDDVCSXiConverterModule(
0467             const std::string &className);
0468
0469     /**
0470      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2XiConverterModule.
0471      * @param classId Unique identifier of last child class.
0472      * @return GAM2XiConverterModule pointer.
0473      */
0474     GAM2XiConverterModule* newGAM2XiConverterModule(unsigned int classId);
0475     /**
0476      * Specialization of ModuleObjectFactory::newModuleObject into a GAM2XiConverterModule.
0477      * @param className Name of last child class.
0478      * @return GAM2XiConverterModule pointer.
0479      */
0480     GAM2XiConverterModule* newGAM2XiConverterModule(
0481             const std::string &className);
0482
0483     /**
0484      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0485      * @param classId Unique identifier of last child class.
0486      * @return Observable pointer.
0487      */
0488     DVCSObservable* newDVCSObservable(unsigned int classId);
0489
0490     /**
0491      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0492      * @param className Name of last child class.
0493      * @return Observable pointer.
0494      */
0495     DVCSObservable* newDVCSObservable(const std::string & className);
0496
0497     /**
0498      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0499      * @param classId Unique identifier of last child class.
0500      * @return Observable pointer.
0501      */
0502     TCSObservable* newTCSObservable(unsigned int classId);
0503     /**
0504      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0505      * @param className Name of last child class.
0506      * @return Observable pointer.
0507      */
0508     TCSObservable* newTCSObservable(const std::string & className);
0509
0510     /**
0511      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0512      * @param classId Unique identifier of last child class.
0513      * @return Observable pointer.
0514      */
0515     DVMPObservable* newDVMPObservable(unsigned int classId);
0516
0517     /**
0518      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0519      * @param className Name of last child class.
0520      * @return Observable pointer.
0521      */
0522     DVMPObservable* newDVMPObservable(const std::string & className);
0523
0524     /**
0525      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0526      * @param classId Unique identifier of last child class.
0527      * @return Observable pointer.
0528      */
0529     DDVCSObservable* newDDVCSObservable(unsigned int classId);
0530
0531     /**
0532      * Specialization of ModuleObjectFactory::newModuleObject into a Observable.
0533      * @param className Name of last child class.
0534      * @return Observable pointer.
0535      */
0536     DDVCSObservable* newDDVCSObservable(const std::string & className);
0537
0538     /**
0539      * Method to update a pointer. Used to keep track of the modules and remove them when they become orphans (i.e. no pointer points to them).
0540      * @param pModuleObjectTarget The pointer to be modified.
0541      * @param pModuleObjectSource The pointer to be copied into the other. Or 0 if the target pointer is to be cleared.
0542      */
0543     void updateModulePointerReference(ModuleObject* pModuleObjectTarget,
0544             ModuleObject* pModuleObjectSource);
0545
0546     virtual std::string toString() const;
0547
0548 private:
0549     // To allow only Partons class to create a new instance of this class.
0550     // Used to avoid multiple singleton class and to avoid multithreading problem especially when getInstance() is called.
0551     // There is a bad behaviour with first instance initialization and mutex.
0552     friend class Partons;
0553
0554     /**
0555      * Private default constructor to ensure the creation of a single instance of the class, managed by Parton's class.
0556      *
0557      * @param pBaseObjectFactory
0558      */
0559     ModuleObjectFactory(BaseObjectFactory* pBaseObjectFactory);
0560
0561     BaseObjectFactory* m_pBaseObjectFactory; ///< Pointer to BaseObjectFactory to get cloned object's pointer.
0562
0563     /**
0564      * Store ModuleObject pointer created by the ModuleObjectFactory; used to handle references and life cycle of module pointer during execution of the program.
0565      */
0566     std::map<unsigned int, ModuleObjectReference*> m_instantiatedModuleObject;
0567
0568     /**
0569      * Store a new ModuleObjectReference from the provided ModuleObject pointer.
0570      *
0571      * @param pModuleObject
0572      */
0573     void store(ModuleObject* pModuleObject);
0574 };
0575
0576 } /* namespace PARTONS */
0577
0578 #endif /* MODULE_OBJECT_FACTORY_H */