IPhreeqc.hpp

Go to the documentation of this file.

#ifndef INC_IPHREEQC_HPP
#define INC_IPHREEQC_HPP

#include <exception>
#include <list>
#include <vector>
#include <map>
#include <cstdarg>
#include "IPhreeqcCallbacks.h"      /* PFN_PRERUN_CALLBACK, PFN_POSTRUN_CALLBACK, PFN_CATCH_CALLBACK */
#include "Var.h"                    /* VRESULT */
#include "PHRQ_io.h"

#if defined(_WINDLL)
#define IPQ_DLL_EXPORT __declspec(dllexport)
#else
#define IPQ_DLL_EXPORT
#endif

class Phreeqc;
class IErrorReporter;
class CSelectedOutput;
class SelectedOutput;

class IPQ_DLL_EXPORT IPhreeqcStop : public std::exception 
{
public:
  virtual const char *what() const throw () {return "Failure in IPhreeqc\n";}
};

class IPQ_DLL_EXPORT IPhreeqc : public PHRQ_io
{
public:
        IPhreeqc(void);

        virtual ~IPhreeqc(void);

public:

        VRESULT                  AccumulateLine(const char *line);

        size_t                   AddError(const char* error_msg);

        size_t                   AddWarning(const char* warning_msg);

        void                     ClearAccumulatedLines(void);

        const std::string&       GetAccumulatedLines(void);

        const char*              GetComponent(int n);

        size_t                   GetComponentCount(void);

        int                      GetCurrentSelectedOutputUserNumber(void)const;

        const char*              GetDumpFileName(void)const;

        bool                     GetDumpFileOn(void)const;

        const char*              GetDumpString(void)const;

        const char*              GetDumpStringLine(int n);

        int                      GetDumpStringLineCount(void)const;

        bool                     GetDumpStringOn(void)const;

        const char*              GetErrorFileName(void)const;

        bool                     GetErrorFileOn(void)const;

        const char*              GetErrorString(void);

        const char*              GetErrorStringLine(int n);

        int                      GetErrorStringLineCount(void)const;

        bool                     GetErrorStringOn(void)const;

        int                      GetId(void)const;

        const char*              GetLogFileName(void)const;

        bool                     GetLogFileOn(void)const;

        const char*              GetLogString(void)const;

        const char*              GetLogStringLine(int n)const;

        int                      GetLogStringLineCount(void)const;

        bool                     GetLogStringOn(void)const;

        int                      GetNthSelectedOutputUserNumber(int n)const;

        const char*              GetOutputFileName(void)const;

        bool                     GetOutputFileOn(void)const;

        const char*              GetOutputString(void)const;

        const char*              GetOutputStringLine(int n)const;

        int                      GetOutputStringLineCount(void)const;

        bool                     GetOutputStringOn(void)const;

        int                      GetSelectedOutputColumnCount(void)const;

        int                      GetSelectedOutputCount(void)const;

        const char*              GetSelectedOutputFileName(void)const;

        bool                     GetSelectedOutputFileOn(void)const;

        int                      GetSelectedOutputRowCount(void)const;

        const char*              GetSelectedOutputString(void)const;

        const char*              GetSelectedOutputStringLine(int n);

        int                      GetSelectedOutputStringLineCount(void)const;

        bool                     GetSelectedOutputStringOn(void)const;

        VRESULT                  GetSelectedOutputValue(int row, int col, VAR* pVAR);

        VRESULT                  GetSelectedOutputValue2(int row, int col, int *vtype, double* dvalue, char* svalue, unsigned int svalue_length);

        static const char*       GetVersionString(void);

        const char*              GetWarningString(void);

        const char*              GetWarningStringLine(int n);

        int                      GetWarningStringLineCount(void)const;

        std::list< std::string > ListComponents(void);

        int                      LoadDatabase(const char* filename);

        int                      LoadDatabaseString(const char* input);

        void                     OutputAccumulatedLines(void);

        void                     OutputErrorString(void);

        void                     OutputWarningString(void);

        int                      RunAccumulated(void);

        int                      RunFile(const char* filename);

        int                      RunString(const char* input);

        void                     SetBasicCallback(double (*fcn)(double x1, double x2, const char *str, void *cookie), void * cookie1);

#ifdef IPHREEQC_NO_FORTRAN_MODULE
        void                     SetBasicFortranCallback(double (*fcn)(double *x1, double *x2, char *str, size_t l));
#else
        void                     SetBasicFortranCallback(double (*fcn)(double *x1, double *x2, const char *str, int l));
#endif

        VRESULT                  SetCurrentSelectedOutputUserNumber(int n);

        void                     SetDumpFileName(const char *filename);

        void                     SetDumpFileOn(bool bValue);

        void                     SetDumpStringOn(bool bValue);

        void                     SetErrorFileName(const char *filename);

        void                     SetErrorFileOn(bool bValue);

        void                     SetErrorStringOn(bool bValue);

        void                     SetLogFileName(const char *filename);

        void                     SetLogFileOn(bool bValue);

        void                     SetLogStringOn(bool bValue);

        void                     SetOutputFileName(const char *filename);

        void                     SetOutputFileOn(bool bValue);

        void                     SetOutputStringOn(bool bValue);

        void                     SetSelectedOutputFileName(const char *filename);

        void                     SetSelectedOutputFileOn(bool bValue);

        void                     SetSelectedOutputStringOn(bool bValue);

public:
        // overrides
        virtual void error_msg(const char *str, bool stop=false);
        virtual void log_msg(const char * str);
        virtual void output_msg(const char *str);
        virtual void punch_msg(const char *str);
        virtual void screen_msg(const char *str);
        virtual void warning_msg(const char *str);

        virtual void fpunchf(const char *name, const char *format, double d);
        virtual void fpunchf(const char *name, const char *format, char * d);
        virtual void fpunchf(const char *name, const char *format, int d);
        virtual void fpunchf_end_row(const char *format);

        virtual bool output_open(const char *file_name, std::ios_base::openmode mode = std::ios_base::out);
        virtual bool punch_open(const char *file_name, std::ios_base::openmode mode = std::ios_base::out, int n_user = 1);

protected:
        int EndRow(void);
        void AddSelectedOutput(const char* name, const char* format, va_list argptr);
        void UnLoadDatabase(void);

        void check_database(const char* sz_routine);
        int close_input_files(void);
        int close_output_files(void);
        void open_output_files(const char* sz_routine);

        void do_run(const char* sz_routine, std::istream* pis, PFN_PRERUN_CALLBACK pfn_pre, PFN_POSTRUN_CALLBACK pfn_post, void *cookie);

        void update_errors(void);

        int load_db(const char* filename);
        int load_db_str(const char* filename);
        int test_db(void);

        bool get_sel_out_file_on(int n)const;
        std::string sel_file_name(int n_user);

        std::string create_file_name(const char *prefix, const char *suffix);

        bool get_sel_out_string_on(int n)const;

protected:
#if defined(_MSC_VER)
/* disable warning C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2' */
#pragma warning(disable:4251)
#endif

        bool                       DatabaseLoaded;
        bool                       ClearAccumulated;
        bool                       UpdateComponents;
        std::map< int, bool >      SelectedOutputFileOnMap;

        bool                       OutputFileOn;

        bool                       LogFileOn;
        bool                       ErrorFileOn;
        bool                       DumpOn;

        bool                       DumpStringOn;

        bool                       OutputStringOn;
        std::string                OutputString;
        std::vector< std::string > OutputLines;

        bool                       LogStringOn;
        std::string                LogString;
        std::vector< std::string > LogLines;

        bool                       ErrorStringOn;
        IErrorReporter            *ErrorReporter;
        std::string                ErrorString;
        std::vector< std::string > ErrorLines;

        bool                       WarningStringOn;
        IErrorReporter            *WarningReporter;
        std::string                WarningString;
        std::vector< std::string > WarningLines;

        int                                           CurrentSelectedOutputUserNumber;
        std::map< int, CSelectedOutput* >             SelectedOutputMap;
        std::string                                   StringInput;

        std::string                DumpString;
        std::vector< std::string > DumpLines;

        std::list< std::string >   Components;

        std::map< int, std::string > SelectedOutputFileNameMap;

        std::string                OutputFileName;
        std::string                ErrorFileName;
        std::string                LogFileName;
        std::string                DumpFileName;

        std::map< int, bool >                         SelectedOutputStringOn;
        std::map< int, std::string >                  SelectedOutputStringMap;
        std::map< int, std::vector< std::string > >   SelectedOutputLinesMap;

protected:
        Phreeqc* PhreeqcPtr;
        FILE *input_file;
        FILE *database_file;

        friend class IPhreeqcLib;
        static std::map<size_t, IPhreeqc*> Instances;
        static size_t InstancesIndex;
        size_t Index;

        static std::string Version;

#if defined(_MSC_VER)
/* reset warning C4251 */
#pragma warning(default:4251)
#endif

#if defined(CPPUNIT)
        friend class TestIPhreeqc;
        friend class TestSelectedOutput;
#endif

private:
        IPhreeqc(const IPhreeqc&);

        IPhreeqc& operator=(const IPhreeqc&);
};

#endif // INC_IPHREEQC_HPP