dae_var_info.hpp

#ifndef CPPAD_CG_DAE_VAR_INFO_INCLUDED
#define CPPAD_CG_DAE_VAR_INFO_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 {

class DaeVarInfo {
private:
    size_t id_;
    int antiDerivative_;
    int derivative_;
    bool integratedDependent_;
    bool integratedVariable_;
    std::string name_;
    int originalIndex_;
    int order_;
    int originalAntiDerivative_;
public:

    inline DaeVarInfo(const std::string& name = "",
                      size_t id = 0) :
        id_(id),
        antiDerivative_(-1),
        derivative_(-1),
        integratedDependent_(true),
        integratedVariable_(false),
        name_(name),
        originalIndex_(-1),
        order_(0),
        originalAntiDerivative_(-1) {
    }

    inline DaeVarInfo(int derivativeOf,
                      const std::string& name = "",
                      size_t id = 0) :
        id_(id),
        antiDerivative_(derivativeOf),
        derivative_(-1),
        integratedDependent_(true),
        integratedVariable_(false),
        name_(name),
        originalIndex_(-1),
        order_(0),
        originalAntiDerivative_(-1) {
    }

    inline size_t getId() const {
        return id_;
    }

    inline void setId(size_t id) {
        id_ = id;
    }

    inline int getAntiDerivative() const {
        return antiDerivative_;
    }

    inline void setAntiDerivative(int derivativeOf) {
        antiDerivative_ = derivativeOf;
    }

    inline int getDerivative() const {
        return derivative_;
    }

    inline void setDerivative(int derivative) {
        derivative_ = derivative;
    }

    inline bool isFunctionOfIntegrated() const {
        return integratedDependent_;
    }

    inline void makeConstant() {
        integratedVariable_ = false;
        integratedDependent_ = false;
        antiDerivative_ = -1;
        order_ = -1;
        originalAntiDerivative_ = -1;
    }

    inline void makeIntegratedVariable() {
        integratedVariable_ = true;
        integratedDependent_ = false;
        antiDerivative_ = -1;
        order_ = -1;
        originalAntiDerivative_ = -1;
    }

    inline bool isIntegratedVariable() const {
        return integratedVariable_;
    }

    inline const std::string& getName() const {
        return name_;
    }

    inline void setName(const std::string& name) {
        name_ = name;
    }

    inline int getOriginalIndex() const {
        return originalIndex_;
    }

    inline void setOriginalIndex(int originalIndex) {
        originalIndex_ = originalIndex;
    }

    inline int getOriginalAntiDerivative() const {
        return originalAntiDerivative_;
    }

    inline void setOriginalAntiDerivative(int originalAntiDerivative) {
        originalAntiDerivative_ = originalAntiDerivative;
    }

    inline int getOrder() const {
        return order_;
    }

    inline void setOrder(int order) {
        order_ = order;
    }

    inline void printInfo(std::ostream& out = std::cout) const {
        out << name_ << ":\n";
        if (antiDerivative_ >= 0)
            out << " derivative-of: " << antiDerivative_ << "\n";
        if (derivative_ >= 0)
            out << " derivative: " << derivative_ << "\n";
        if (integratedDependent_)
            out << " integrated dependent\n";
        else if (integratedVariable_)
            out << " integrated variable\n";
        out.flush();
    }

    inline virtual ~DaeVarInfo() {
    }
};

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

#endif