ctrdiag.cpp

Go to the documentation of this file.

/**
 *  CTRDIAG - Generated CLib %Cantera interface library.
 *
 *  @file ctrdiag.cpp
 *
 *  Generated CLib API for Cantera's ReactionPathDiagram class.
 *
 *  This file was generated by sourcegen. It will be re-generated by the
 *  %Cantera build process. Do not manually edit.
 *
 *  @warning  This module is an experimental part of the %Cantera API and
 *      may be changed without notice.
 */
 
// This file is part of Cantera. See License.txt in the top-level directory or
// at https://cantera.org/license.txt for license and copyright information.
 
#include "clib_utils.h"
#include "cantera_clib/ctrdiag.h"
 
#include "cantera/base/stringUtils.h"
#include "cantera/kinetics/ReactionPath.h"
#include "cantera/kinetics/KineticsFactory.h"
#include "cantera/kinetics/InterfaceKinetics.h"
 
using namespace Cantera;
 
//! @cond
//! Cabinet type definitions will be ignored by Doxygen
 
// Define Cabinet<ReactionPathDiagram> (single-instance object)
typedef Cabinet<ReactionPathDiagram> ReactionPathDiagramCabinet;
template<> ReactionPathDiagramCabinet* ReactionPathDiagramCabinet::s_storage = 0;  // initialized here
 
typedef Cabinet<Kinetics> KineticsCabinet;
template<> KineticsCabinet* KineticsCabinet::s_storage;  // initialized elsewhere
 
//! @endcond
 
extern "C" {
 
    int32_t rdiag_newReactionPathDiagram(int32_t kin, const char* element)
    {
        // constructor: shared_ptr<ReactionPathDiagram> newReactionPathDiagram(shared_ptr<Kinetics>, const string&)
        try {
            return ReactionPathDiagramCabinet::add(newReactionPathDiagram(KineticsCabinet::at(kin), element));
        } catch (...) {
            return handleAllExceptions(-2, ERR);
        }
    }
 
    int32_t rdiag_showDetails(int32_t handle)
    {
        // variable (getter): variable getter: show_details
        try {
            bool out = ReactionPathDiagramCabinet::at(handle)->show_details;
            return int(out);
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setShowDetails(int32_t handle, int32_t show_details)
    {
        // variable (setter): variable setter: show_details
        try {
            bool show_details_ = (show_details != 0);
            ReactionPathDiagramCabinet::at(handle)->show_details = show_details_;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double rdiag_threshold(int32_t handle)
    {
        // variable (getter): variable getter: threshold
        try {
            return ReactionPathDiagramCabinet::at(handle)->threshold;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setThreshold(int32_t handle, double threshold)
    {
        // variable (setter): variable setter: threshold
        try {
            ReactionPathDiagramCabinet::at(handle)->threshold = threshold;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double rdiag_boldThreshold(int32_t handle)
    {
        // variable (getter): variable getter: bold_min
        try {
            return ReactionPathDiagramCabinet::at(handle)->bold_min;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setBoldThreshold(int32_t handle, double bold_min)
    {
        // variable (setter): variable setter: bold_min
        try {
            ReactionPathDiagramCabinet::at(handle)->bold_min = bold_min;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double rdiag_normalThreshold(int32_t handle)
    {
        // variable (getter): variable getter: dashed_max
        try {
            return ReactionPathDiagramCabinet::at(handle)->dashed_max;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setNormalThreshold(int32_t handle, double dashed_max)
    {
        // variable (setter): variable setter: dashed_max
        try {
            ReactionPathDiagramCabinet::at(handle)->dashed_max = dashed_max;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    double rdiag_labelThreshold(int32_t handle)
    {
        // variable (getter): variable getter: label_min
        try {
            return ReactionPathDiagramCabinet::at(handle)->label_min;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setLabelThreshold(int32_t handle, double label_min)
    {
        // variable (setter): variable setter: label_min
        try {
            ReactionPathDiagramCabinet::at(handle)->label_min = label_min;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_boldColor(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: bold_color
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->bold_color;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setBoldColor(int32_t handle, const char* bold_color)
    {
        // variable (setter): variable setter: bold_color
        try {
            ReactionPathDiagramCabinet::at(handle)->bold_color = bold_color;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_normalColor(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: normal_color
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->normal_color;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setNormalColor(int32_t handle, const char* normal_color)
    {
        // variable (setter): variable setter: normal_color
        try {
            ReactionPathDiagramCabinet::at(handle)->normal_color = normal_color;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_dashedColor(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: dashed_color
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->dashed_color;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setDashedColor(int32_t handle, const char* dashed_color)
    {
        // variable (setter): variable setter: dashed_color
        try {
            ReactionPathDiagramCabinet::at(handle)->dashed_color = dashed_color;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_dotOptions(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: dot_options
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->dot_options;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setDotOptions(int32_t handle, const char* dot_options)
    {
        // variable (setter): variable setter: dot_options
        try {
            ReactionPathDiagramCabinet::at(handle)->dot_options = dot_options;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_font(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: m_font
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->m_font;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setFont(int32_t handle, const char* font)
    {
        // setter: void ReactionPathDiagram::setFont(const string&)
        try {
            ReactionPathDiagramCabinet::at(handle)->setFont(font);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double rdiag_scale(int32_t handle)
    {
        // variable (getter): variable getter: scale
        try {
            return ReactionPathDiagramCabinet::at(handle)->scale;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setScale(int32_t handle, double scale)
    {
        // variable (setter): variable setter: scale
        try {
            ReactionPathDiagramCabinet::at(handle)->scale = scale;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_flowType(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: const string ReactionPathDiagram::flowType()
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->flowType();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setFlowType(int32_t handle, const char* fType)
    {
        // setter: void ReactionPathDiagram::setFlowType(const string&)
        try {
            ReactionPathDiagramCabinet::at(handle)->setFlowType(fType);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    double rdiag_arrowWidth(int32_t handle)
    {
        // variable (getter): variable getter: arrow_width
        try {
            return ReactionPathDiagramCabinet::at(handle)->arrow_width;
        } catch (...) {
            return handleAllExceptions(DERR, DERR);
        }
    }
 
    int32_t rdiag_setArrowWidth(int32_t handle, double arrow_width)
    {
        // variable (setter): variable setter: arrow_width
        try {
            ReactionPathDiagramCabinet::at(handle)->arrow_width = arrow_width;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_title(int32_t handle, int32_t bufLen, char* buf)
    {
        // variable (getter): variable getter: title
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->title;
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_setTitle(int32_t handle, const char* title)
    {
        // variable (setter): variable setter: title
        try {
            ReactionPathDiagramCabinet::at(handle)->title = title;
            return 0;
        } catch (...) {
            return handleAllExceptions(ERR, ERR);
        }
    }
 
    int32_t rdiag_add(int32_t handle, int32_t d)
    {
        // setter: void ReactionPathDiagram::add(shared_ptr<ReactionPathDiagram>)
        try {
            ReactionPathDiagramCabinet::at(handle)->add(ReactionPathDiagramCabinet::at(d));
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_displayOnly(int32_t handle, int32_t k)
    {
        // setter: void ReactionPathDiagram::displayOnly(size_t)
        try {
            ReactionPathDiagramCabinet::at(handle)->displayOnly(k);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_getDot(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string ReactionPathDiagram::getDot()
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->getDot();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_getData(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string ReactionPathDiagram::getData()
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->getData();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_build(int32_t handle)
    {
        // method: void ReactionPathDiagram::build()
        try {
            ReactionPathDiagramCabinet::at(handle)->build();
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_getLog(int32_t handle, int32_t bufLen, char* buf)
    {
        // getter: string ReactionPathDiagram::getLog()
        try {
            string out = ReactionPathDiagramCabinet::at(handle)->getLog();
            copyString(out, buf, bufLen);
            return int(out.size()) + 1;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_findMajor(int32_t handle, double threshold, int32_t lda, int32_t aLen, double* a)
    {
        // method: void ReactionPathDiagram::findMajorPaths(double, size_t, double*)
        try {
            ReactionPathDiagramCabinet::at(handle)->findMajorPaths(threshold, lda, a);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_del(int32_t handle)
    {
        // destructor
        try {
            ReactionPathDiagramCabinet::del(handle);
            return 0;
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
    int32_t rdiag_cabinetSize()
    {
        // reserved CLib function: custom code
        try {
            // *************** begin custom code ***************
            return ReactionPathDiagramCabinet::size();
            // **************** end custom code ****************
        } catch (...) {
            return handleAllExceptions(-1, ERR);
        }
    }
 
} // extern "C"