variable_name_generator.hpp

#ifndef CPPAD_CG_VARIABLE_NAME_GENERATOR_INCLUDED
#define CPPAD_CG_VARIABLE_NAME_GENERATOR_INCLUDED
/* --------------------------------------------------------------------------
 *  CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
 *    Copyright (C) 2012 Ciengis
 *
 *  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 {

typedef struct FuncArgument {
    std::string name;
    bool array;

    inline FuncArgument() :
        array(false) {
    }

    inline FuncArgument(const std::string& nam, bool a = true) :
        name(nam),
        array(a) {
    }
} FuncArgument;

template<class Base>
class VariableNameGenerator {
protected:
    std::vector<FuncArgument> _dependent;
    std::vector<FuncArgument> _independent;
    std::vector<FuncArgument> _temporary;
public:

    virtual const std::vector<FuncArgument>& getDependent() const {
        return _dependent;
    }

    virtual const std::vector<FuncArgument>& getIndependent() const {
        return _independent;
    }

    virtual const std::vector<FuncArgument>& getTemporary() const {
        return _temporary;
    }

    virtual size_t getMinTemporaryVariableID() const = 0;

    virtual size_t getMaxTemporaryVariableID() const = 0;

    virtual size_t getMaxTemporaryArrayVariableID() const = 0;

    virtual size_t getMaxTemporarySparseArrayVariableID() const = 0;

    virtual std::string generateDependent(size_t index) = 0;

    virtual std::string generateIndependent(const OperationNode<Base>& variable,
                                            size_t id) = 0;

    virtual std::string generateTemporary(const OperationNode<Base>& variable,
                                          size_t id) = 0;

    virtual std::string generateTemporaryArray(const OperationNode<Base>& variable,
                                               size_t id) = 0;

    virtual std::string generateTemporarySparseArray(const OperationNode<Base>& variable,
                                                     size_t id) = 0;

    virtual std::string generateIndexedDependent(const OperationNode<Base>& var,
                                                 size_t id,
                                                 const IndexPattern& ip) = 0;

    virtual std::string generateIndexedIndependent(const OperationNode<Base>& var,
                                                   size_t id,
                                                   const IndexPattern& ip) = 0;

    virtual void setTemporaryVariableID(size_t minTempID,
                                        size_t maxTempID,
                                        size_t maxTempArrayID,
                                        size_t maxTempSparseArrayID) = 0;

    virtual const std::string& getIndependentArrayName(const OperationNode<Base>& indep,
                                                       size_t id) = 0;

    virtual size_t getIndependentArrayIndex(const OperationNode<Base>& indep,
                                            size_t id) = 0;

    virtual bool isConsecutiveInIndepArray(const OperationNode<Base>& indepFirst,
                                           size_t idFirst,
                                           const OperationNode<Base>& indepSecond,
                                           size_t idSecond) = 0;

    virtual bool isInSameIndependentArray(const OperationNode<Base>& indep1,
                                          size_t id1,
                                          const OperationNode<Base>& indep2,
                                          size_t id2) = 0;

    virtual const std::string& getTemporaryVarArrayName(const OperationNode<Base>& var,
                                                        size_t id) = 0;

    virtual size_t getTemporaryVarArrayIndex(const OperationNode<Base>& var,
                                             size_t id) = 0;

    virtual bool isConsecutiveInTemporaryVarArray(const OperationNode<Base>& varFirst,
                                                  size_t idFirst,
                                                  const OperationNode<Base>& varSecond,
                                                  size_t idSecond) = 0;

    virtual bool isInSameTemporaryVarArray(const OperationNode<Base>& var1,
                                           size_t id1,
                                           const OperationNode<Base>& var2,
                                           size_t id2) = 0;

    virtual void customFunctionVariableDeclarations(std::ostream& out) {
    }

    virtual void prepareCustomFunctionVariables(std::ostream& out) {
    }

    virtual void finalizeCustomFunctionVariables(std::ostream& out) {
    }

    inline virtual ~VariableNameGenerator() {
    }
};

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

#endif