dynamic_library_processor.hpp

#ifndef CPPAD_CG_DYNAMIC_LIBRARY_PROCESSOR_INCLUDED
#define CPPAD_CG_DYNAMIC_LIBRARY_PROCESSOR_INCLUDED
/* --------------------------------------------------------------------------
 *  CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
 *    Copyright (C) 2013 Ciengis
 *    Copyright (C) 2020 Joao Leal
 *
 *  CppADCodeGen is distributed under multiple licenses:
 *
 *   - Eclipse Public License Version 1.0 (EPL1), and
 *   - GNU General Public License Version 3 (GPL3).
 *
 *  EPL1 terms and conditions can be found in the file "epl-v10.txt", while
 *  terms and conditions for the GPL3 can be found in the file "gpl3.txt".
 * ----------------------------------------------------------------------------
 * Author: Joao Leal
 */

namespace CppAD {
namespace cg {

template<class Base>
class DynamicModelLibraryProcessor : public ModelLibraryProcessor<Base> {
protected:
    std::string _libraryName;
    std::unique_ptr<const std::string> _customLibExtension;
    std::map<std::string, std::string> _options;
public:

    inline explicit DynamicModelLibraryProcessor(ModelLibraryCSourceGen <Base>& modelLibGen,
                                                 std::string libraryName = "cppad_cg_model") :
            ModelLibraryProcessor<Base>(modelLibGen),
            _libraryName(std::move(libraryName)) {
    }

    virtual ~DynamicModelLibraryProcessor() = default;

    inline const std::string& getLibraryName() const {
        return _libraryName;
    }

    inline void setLibraryName(const std::string& libraryName) {
        CPPADCG_ASSERT_KNOWN(!libraryName.empty(), "Library name cannot be empty")

        _libraryName = libraryName;
    }

    inline const std::string* getCustomLibraryExtension() const {
        return _customLibExtension.get();
    }

    inline void setCustomLibraryExtension(const std::string& libraryExtension) {
        _customLibExtension.reset(new std::string(libraryExtension));
    }

    inline void removeCustomLibraryExtension() {
        _customLibExtension.reset();
    }

    inline std::map<std::string, std::string>& getOptions() {
        return _options;
    }

    inline const std::map<std::string, std::string>& getOptions() const {
        return _options;
    }

    std::unique_ptr<DynamicLib<Base>> createDynamicLibrary(CCompiler<Base>& compiler,
                                                           bool loadLib = true) {
        // backup output format so that it can be restored
        OStreamConfigRestore coutb(std::cout);

        this->modelLibraryHelper_->startingJob("", JobTimer::DYNAMIC_MODEL_LIBRARY);

        const std::map<std::string, ModelCSourceGen < Base>*>&models = this->modelLibraryHelper_->getModels();
        try {
            for (const auto& p : models) {
                const std::map<std::string, std::string>& modelSources = this->getSources(*p.second);

                this->modelLibraryHelper_->startingJob("", JobTimer::COMPILING_FOR_MODEL);
                compiler.compileSources(modelSources, true, this->modelLibraryHelper_);
                this->modelLibraryHelper_->finishedJob();
            }

            const std::map<std::string, std::string>& sources = this->getLibrarySources();
            compiler.compileSources(sources, true, this->modelLibraryHelper_);

            const std::map<std::string, std::string>& customSource = this->modelLibraryHelper_->getCustomSources();
            compiler.compileSources(customSource, true, this->modelLibraryHelper_);

            std::string libname = _libraryName;
            if (_customLibExtension != nullptr)
                libname += *_customLibExtension;
            else
                libname += system::SystemInfo<>::DYNAMIC_LIB_EXTENSION;

            compiler.buildDynamic(libname, this->modelLibraryHelper_);

        } catch (...) {
            compiler.cleanup();
            throw;
        }
        compiler.cleanup();

        this->modelLibraryHelper_->finishedJob();

        if (loadLib)
            return loadDynamicLibrary();
        else
            return std::unique_ptr<DynamicLib<Base>> (nullptr);
    }

    void createStaticLibrary(CCompiler <Base>& compiler,
                             Archiver& ar,
                             bool posIndepCode) {
        // backup output format so that it can be restored
        OStreamConfigRestore coutb(std::cout);

        this->modelLibraryHelper_->startingJob("", JobTimer::STATIC_MODEL_LIBRARY);

        const std::map<std::string, ModelCSourceGen<Base>*>& models = this->modelLibraryHelper_->getModels();
        try {
            for (const auto& p : models) {
                const std::map<std::string, std::string>& modelSources = this->getSources(*p.second);

                this->modelLibraryHelper_->startingJob("", JobTimer::COMPILING_FOR_MODEL);
                compiler.compileSources(modelSources, posIndepCode, this->modelLibraryHelper_);
                this->modelLibraryHelper_->finishedJob();
            }

            const std::map<std::string, std::string>& sources = this->getLibrarySources();
            compiler.compileSources(sources, posIndepCode, this->modelLibraryHelper_);

            const std::map<std::string, std::string>& customSource = this->modelLibraryHelper_->getCustomSources();
            compiler.compileSources(customSource, posIndepCode, this->modelLibraryHelper_);

            std::string libname = _libraryName;
            if (_customLibExtension != nullptr)
                libname += *_customLibExtension;
            else
                libname += system::SystemInfo<>::STATIC_LIB_EXTENSION;

            ar.create(libname, compiler.getObjectFiles(), this->modelLibraryHelper_);
        } catch (...) {
            compiler.cleanup();
            throw;
        }
        compiler.cleanup();

        this->modelLibraryHelper_->finishedJob();
    }


protected:

    virtual std::unique_ptr<DynamicLib<Base>> loadDynamicLibrary();

};

} // END cg namespace
} // END CppAD namespace

#endif