DriverSet.h

Go to the documentation of this file.

/*
 * DriverSet.h
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef DRIVERSET_H_
#define DRIVERSET_H_

#include <HSEP/DriverLib.h>
#include <HSEP/Array.h>

#define TYPENAME_LEN 256

namespace HSEP {

    class BaseDriverSet {
        string aFactoryName;
        virtual void _addLibrary(const char* pTypeName,string& pFilePath, string& pFactoryName) = 0;
    protected:
        virtual void unload() = 0;
    public:

        BaseDriverSet(string& pFactoryNameRef) {
            aFactoryName = string(pFactoryNameRef); // take care with stolen references
        } // constructor

        BaseDriverSet(const char* pFactoryNamePtr) {
            aFactoryName = string(pFactoryNamePtr);
        } // constructor


        virtual ~BaseDriverSet() {
        } // destructor

        bool load(string& pPathRef,string& pPrefixRef);

    }; // BaseDriverSet class

    template <class Type>
    class DriverSet : public BaseDriverSet {
    public:
        typedef DriverLib<Type>             DriverLibType;       
        typedef Dictionary< DriverLibType>  DriverLibDictionary; 
        typedef function<void ( string& pKey, DriverLibType* pValue)> ForEachWorker; 
    protected:
        DriverLibDictionary aDriverLibCollection;

        void _addLibrary(const char* pTypeNamePtr,string& pFilePathRef,string& pFactoryNameRef) {

            DriverLibType* vLibraryPtr = new DriverLibType(pFilePathRef,pFactoryNameRef);
            if (vLibraryPtr->valid()) {
                aDriverLibCollection.put(pTypeNamePtr,vLibraryPtr);
            } // if (vLibraryPtr->isValid())

        } // _addLibrary

    public:
        DriverSet(string& pFactoryNameRef) : BaseDriverSet(pFactoryNameRef) {
        }

        DriverSet(const char* pFactoryNamePtr) : BaseDriverSet(pFactoryNamePtr) {
        }

        virtual ~DriverSet() {
            //
            // This is not necessary because the system
            // releases all the resources automatcially
            //
            //          unload();
        }

        void unload() {
            aDriverLibCollection.clear();
        } // unload

        bool has(
            string& pSetNameRef,
            string& pItemNameRef
        ) {
            bool vResult = false;

            if (aDriverLibCollection.has(pSetNameRef)) {

                DriverLibType* vDriverLibPtr = aDriverLibCollection.ptr(pSetNameRef);

                if (nullptr != vDriverLibPtr) {
                    vResult = vDriverLibPtr->has(pItemNameRef);
                }
            }
            return vResult;

        } // has

        Type* ptr(string& pSetNameRef,string& pItemNameRef) {

            Type* vItemPtr = nullptr;
            DriverLibType* vDriverLibPtr;

            vDriverLibPtr = aDriverLibCollection.ptr(pSetNameRef);

            if (nullptr != vDriverLibPtr) {
                vItemPtr = vDriverLibPtr->getItemPtr(pItemNameRef); // could return nullptr;
            }
            return vItemPtr;

        } // ptr

        Type* ptr(const char* pSetNamePtr, const char* pItemNamePtr) {
            string vSetName(pSetNamePtr);
            string vItemName(pItemNamePtr);
            return ptr(vSetName,vItemName);
        }

        void forEach(ForEachWorker pWorker) {
            aDriverLibCollection.forEach(pWorker);
        } // forEach

        void info(StringArray& pItems) {
            aDriverLibCollection.forEach([&](string& xKey, DriverLibType* xDriverLib) {
                pItems.push("Library ["+xKey+"] : "+xDriverLib->infoRef());
            });
        } // info

    }; // DriverSet

} // HSEP namespace

#endif /* DRIVERSET_H_ */