egs_object_factory.h

Go to the documentation of this file.

/*
###############################################################################
#
#  EGSnrc egs++ object factory headers
#  Copyright (C) 2015 National Research Council Canada
#
#  This file is part of EGSnrc.
#
#  EGSnrc is free software: you can redistribute it and/or modify it under
#  the terms of the GNU Affero General Public License as published by the
#  Free Software Foundation, either version 3 of the License, or (at your
#  option) any later version.
#
#  EGSnrc 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 Affero General Public License for
#  more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with EGSnrc. If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
#
#  Author:          Iwan Kawrakow, 2005
#
#  Contributors:    Reid Townson
#
###############################################################################
*/
 
 
#ifndef EGS_OBJECT_FACTORY_
#define EGS_OBJECT_FACTORY_
 
#include "egs_libconfig.h"
#include "egs_functions.h"
 
#include <string>
#include <vector>
#include <typeinfo>
using namespace std;
 
class EGS_Input;
class EGS_ObjectFactory;
 
class EGS_EXPORT EGS_Object {
 
public:
 
    EGS_Object(const string &Name = "", EGS_ObjectFactory *f = 0);
 
    EGS_Object(EGS_Input *inp, EGS_ObjectFactory *f = 0);
    virtual ~EGS_Object();
 
    const string &getObjectName() const {
        return name;
    };
 
    void setObjectName(const string &Name) {
        name = Name;
    };
 
    const string &getObjectType() const {
        return otype;
    };
 
    virtual EGS_Object *createObject(EGS_Input *inp) {
        (void)inp;
        return 0;
    };
 
    static string getUniqueName(const EGS_Object *o = 0);
 
    void setName(EGS_Input *inp);
 
    inline int ref() {
        return ++nref;
    };
    inline int deref() {
        return --nref;
    };
    void setFactory(EGS_ObjectFactory *f);
 
    static void deleteObject(EGS_Object *o) {
        if (!o) {
            return;
        }
        if (!o->deref()) {
            delete o;
        }
    };
 
protected:
 
    string  name;    
    string  otype;   
    int     nref;    
    EGS_ObjectFactory *factory; 
 
};
 
class EGS_Library;
 
class EGS_EXPORT EGS_ObjectFactory {
 
public:
 
    EGS_ObjectFactory(const string &dsoPath, int where=0);
 
    virtual ~EGS_ObjectFactory();
 
    virtual void addKnownObject(EGS_Object *o) {
        if (o) {
            o->ref();
            known_objects.push_back(o);
        }
    };
 
    virtual EGS_Object *createSingleObject(EGS_Input *inp,
                                           const char *funcname = 0, bool unique = true);
 
    EGS_Object *createObjects(EGS_Input *inp, const string &section_delimeter,
                              const string &object_delimeter, const string &select_key,
                              const char *funcname = 0, bool unique = true);
 
    bool haveObject(const EGS_Object *o) const;
 
    EGS_Object *getObject(const string &Name);
 
    EGS_Object *takeObject(const string &Name);
 
    void removeObject(EGS_Object *o);
 
    virtual bool addObject(EGS_Object *o, bool unique = true);
 
    void addKnownTypeId(const char *typeid_name);
 
    int  nObjects() const {
        return objects.size();
    };
 
    EGS_Object *getObject(size_t j) {
        return j<objects.size() ? objects[j] : 0;
    };
 
protected:
 
    vector<EGS_Library *> libs;          
    vector<EGS_Object *>  known_objects; 
    vector<EGS_Object *>  objects;       
    vector<string>        known_typeids; 
    string dso_path;                     
 
};
 
template <class T>
class EGS_EXPORT EGS_TypedObjectFactory : public EGS_ObjectFactory {
 
public:
 
    EGS_TypedObjectFactory(const string &dsoPath, const string &type,
                           int where=0) :
        EGS_ObjectFactory(dsoPath,where), otype(type) {};
    ~EGS_TypedObjectFactory() {};
 
    bool isKnownTypeId(EGS_Object *o) const {
        for (int j=0; j<known_typeids.size(); j++) {
            if (known_typeids[j] == typeid(*o).name()) {
                return true;
            }
        }
        return false;
    };
 
    bool isMyObjectType(EGS_Object *o, const char *func) {
        if (!o) {
            return false;
        }
        T *t = dynamic_cast<T *>(o);
        bool res;
        if (t) {
            res = true;
        }
        else {
            res = isKnownTypeId(o);
        }
        if (!res && func) egsWarning("EGS_TypedObjectFactory::%s:\n"
                                         "  dynamic_cast to %s fails for object of type %s\n"
                                         "  This object's typeid is also not in the list of know typeids\n",
                                         func,otype.c_str(),o->getObjectType().c_str());
        return res;
    };
 
    void addKnownObject(EGS_Object *o) {
        if (isMyObjectType(o,"addKnownObject()")) {
            EGS_ObjectFactory::addKnownObject(o);
        }
        EGS_ObjectFactory::addKnownObject(o);
    };
 
    EGS_Object *createSingleObject(EGS_Input *i,
                                   const char *fname = 0, bool u = true) {
        EGS_Object *o = EGS_ObjectFactory::createSingleObject(i,fname,u);
        if (o) {
            if (!isMyObjectType(o,"createSingleObject()")) {
                delete o;
                o = 0;
            }
        }
        return o;
    };
 
    bool addObject(EGS_Object *o, bool unique = true) {
        if (!isMyObjectType(o,"addObject()")) {
            return false;
        }
        return EGS_ObjectFactory::addObject(o,unique);
    };
 
private:
 
    string   otype;
 
};
 
#endif