passes all tests on win32; before changing to multiple instances

git-svn-id: svn://136.177.114.72/svn_GW/IPhreeqc/branches/class@4201 1feff8c3-07ed-0310-ac33-dd36852eb9cd

IPhreeqc.hpp

@@ -1,138 +0,0 @@
-#ifndef _INC_IPHREEQC_HPP
-#define _INC_IPHREEQC_HPP
-
-#include "Phreeqc.h"                /* Phreeqc */
-#include "IPhreeqcCallbacks.h"      /* PFN_PRERUN_CALLBACK, PFN_POSTRUN_CALLBACK, PFN_CATCH_CALLBACK */
-#include "Var.h"                    /* VRESULT */
-#include "SelectedOutput.hxx"
-
-
-class IErrorReporter;
-
-struct PhreeqcStop{};
-
-class IPhreeqc : public Phreeqc
-{
-public:
-	IPhreeqc(void);
-	~IPhreeqc(void);
-
-public:
-	int LoadDatabase(const char* filename);
-	int LoadDatabaseString(const char* input);
-
-	void UnLoadDatabase(void);
-
-	void OutputLastError(void);
-
-	const char* GetLastErrorString(void);
-	const char* GetLastWarningString(void);
-	const char* GetDumpString(void);
-
-	int GetDumpLineCount(void)const;
-	const char* GetDumpLine(int n);
-
-	int GetErrorLineCount(void)const;
-	const char* GetErrorLine(int n);
-
-	std::list< std::string > ListComponents(void);
-
-	VRESULT AccumulateLine(const char *line);
-
-	bool GetDumpOn(void)const;
-	void SetDumpOn(bool bValue);
-
-	bool GetDumpStringOn(void)const;
-	void SetDumpStringOn(bool bValue);
-
-	bool GetErrorOn(void)const;
-	void SetErrorOn(bool bValue);
-
-	bool GetLogOn(void)const;
-	void SetLogOn(bool bValue);
-
-	bool GetOutputOn(void)const;
-	void SetOutputOn(bool bValue);
-
-	bool GetSelectedOutputOn(void)const;
-	void SetSelectedOutputOn(bool bValue);
-
-	int RunAccumulated(void);
-	int RunFile(const char* filename);
-	int RunString(const char* input);
-
-	int GetSelectedOutputRowCount(void)const;
-	int GetSelectedOutputColumnCount(void)const;
-	VRESULT GetSelectedOutputValue(int row, int col, VAR* pVAR);
-
-	void OutputLines(void);
-
-	size_t AddError(const char* error_msg);
-	size_t AddWarning(const char* warning_msg);	
-
-	const std::string& GetAccumulatedLines(void);
-	void ClearAccumulatedLines(void);
-
-	// Singleton for library
-	static IPhreeqc* LibraryInstance(void);
-	static int Create(void);
-	static void Destroy(int n);
-
-	// Callbacks
-	//
-
-	// IPhreeqc.cpp
-	static int handler(const int action, const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args);
-	int output_handler(const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args);
-	int open_handler(const int type, const char *file_name/*, void *cookie*/);
-
-	// module_files.c
-	static int module_handler(const int action, const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args);
-	int module_isopen_handler(const int type);
-	int module_open_handler(const int type, const char *file_name);
-
-	// module_output.c
-	int output_isopen(const int type);
-
-	virtual int EndRow(void);
-	void AddSelectedOutput(const char* name, const char* format, va_list argptr);
-
-	void check_database(const char* sz_routine);
-	void do_run(const char* sz_routine, std::istream* pis, FILE* fp, PFN_PRERUN_CALLBACK pfn_pre, PFN_POSTRUN_CALLBACK pfn_post, void *cookie);
-
-protected:
-	void init(void);
-	void update_errors(void);
-
-protected:
-
-	IErrorReporter            *ErrorReporter;
-	std::string                LastErrorString;
-	std::vector< std::string > ErrorLines;
-
-	IErrorReporter            *WarningReporter;
-	std::string                LastWarningString;
-	std::vector< std::string > WarningLines;
-
-	CSelectedOutput           *SelectedOutput;
-	std::string                PunchFileName;
-	bool                       DatabaseLoaded;
-	std::string                StringInput;
-
-	bool                       SelectedOutputOn;
-	bool                       OutputOn;
-	bool                       LogOn;
-	bool                       ErrorOn;
-	bool                       DumpOn;
-	bool                       DumpStringOn;
-
-	std::string                DumpString;
-	std::vector< std::string > DumpLines;
-
-private:
-	static IPhreeqc* Instance;
-	static std::map<size_t, IPhreeqc*> Instances;
-	static size_t InstancesIndex;
-};
-
-#endif /* _INC_IPHREEQC_HPP */

IPhreeqcLib.cpp

@@ -0,0 +1,468 @@
+#include "IPhreeqcLib.h"
+#include "IPhreeqc2.h"
+#include <cassert>
+
+
+int
+CreateIPhreeqc(void)
+{
+	return IPhreeqcLib::CreateIPhreeqc();
+}
+
+IPL_RESULT
+DestroyIPhreeqc(int n)
+{
+	return IPhreeqcLib::DestroyIPhreeqc(n);
+}
+
+int
+LoadDatabaseM(int n, const char* filename)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->LoadDatabase(filename);
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+LoadDatabaseStringM(int n, const char* input)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->LoadDatabaseString(input);
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+UnLoadDatabaseM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->UnLoadDatabase();
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+const char*
+GetLastErrorStringM(int n)
+{
+	static const char err_msg[] = "GetLastErrorString: Bad instance.\n";
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetLastErrorString();
+	}
+	return err_msg;
+}
+
+const char*
+GetDumpStringM(int n)
+{
+	static const char empty[] = "";
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetDumpString();
+	}
+	return empty;
+}
+
+int
+GetDumpLineCountM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetDumpLineCount();
+	}
+	return 0;
+}
+
+const char* 
+GetDumpLineM(int id, int n)
+{
+	static const char err_msg[] = "GetDumpLine: Bad instance.\n";
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetDumpLine(n);
+	}
+	return err_msg;
+}
+
+int
+GetComponentCountM(int id)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->ListComponents().size();
+	}
+	return 0;
+}
+
+const char*
+GetComponentM(int id, int n)
+{
+	static const char err_msg[] = "GetComponent: Bad instance.\n";
+	static const char empty[] = "";
+	static std::string comp;
+
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(id);
+	if (IPhreeqcPtr)
+	{
+		std::list< std::string > comps = IPhreeqcPtr->ListComponents();
+		if (n < 0 || n >= (int)comps.size())
+		{
+			return empty;
+		}
+		std::list< std::string >::iterator it = comps.begin();
+		for(int i = 0; i < n; ++i)
+		{
+			++it;
+		}
+		comp = (*it);
+		return comp.c_str();
+	}
+	return err_msg;
+}
+
+IPL_RESULT
+AccumulateLineM(int n, const char *line)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		switch (IPhreeqcPtr->AccumulateLine(line))
+		{
+		case VR_OK:
+			return IPL_OK;
+		case VR_OUTOFMEMORY:
+			return IPL_OUTOFMEMORY;
+		default:
+			assert(false);
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetSelectedOutputOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetSelectedOutputOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetSelectedOutputOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetSelectedOutputOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetOutputOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetOutputOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetOutputOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetOutputOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetErrorOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetErrorOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetErrorOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetErrorOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetLogOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetLogOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetLogOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetLogOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+
+int
+GetDumpOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetDumpOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetDumpOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetDumpOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetDumpStringOnM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		if (IPhreeqcPtr->GetDumpStringOn())
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+IPL_RESULT
+SetDumpStringOnM(int n, int value)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		IPhreeqcPtr->SetDumpStringOn(value != 0);
+		return IPL_OK;
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+RunAccumulatedM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->RunAccumulated();
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+RunFileM(int n, const char* filename)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->RunFile(filename);
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetSelectedOutputRowCountM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetSelectedOutputRowCount();
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+GetSelectedOutputColumnCountM(int n)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return IPhreeqcPtr->GetSelectedOutputColumnCount();
+	}
+	return IPL_BADINSTANCE;
+}
+
+
+IPL_RESULT
+GetSelectedOutputValueM(int n, int row, int col, VAR* pVAR)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		switch(IPhreeqcPtr->GetSelectedOutputValue(row, col, pVAR))
+		{
+		case VR_OK:          return IPL_OK;
+		case VR_OUTOFMEMORY: return IPL_OUTOFMEMORY;
+		case VR_BADVARTYPE:  return IPL_BADVARTYPE;
+		case VR_INVALIDARG:  return IPL_INVALIDARG;
+		case VR_INVALIDROW:  return IPL_INVALIDROW;
+		case VR_INVALIDCOL:  return IPL_INVALIDCOL;
+		default:
+			assert(false);
+		}
+	}
+	return IPL_BADINSTANCE;
+}
+
+int
+AddErrorM(int n, const char* error_msg)
+{
+	IPhreeqc2* IPhreeqcPtr = IPhreeqcLib::GetInstance(n);
+	if (IPhreeqcPtr)
+	{
+		return (int)IPhreeqcPtr->AddError(error_msg);
+	}
+	return IPL_BADINSTANCE;
+}
+
+std::map<size_t, IPhreeqc2*> IPhreeqcLib::Instances;
+size_t IPhreeqcLib::InstancesIndex = 0;
+
+int
+IPhreeqcLib::CreateIPhreeqc(void)
+{
+	int n = IPL_OUTOFMEMORY;
+	try
+	{
+		IPhreeqc2* IPhreeqcPtr = new IPhreeqc2;
+		if (IPhreeqcPtr)
+		{
+			std::map<size_t, IPhreeqc2*>::value_type instance(IPhreeqcLib::InstancesIndex, IPhreeqcPtr);
+			std::pair<std::map<size_t, IPhreeqc2*>::iterator, bool> pr = IPhreeqcLib::Instances.insert(instance);
+			if (pr.second)
+			{
+				n = (int) (*pr.first).first;
+				++IPhreeqcLib::InstancesIndex;
+			}
+		}
+	}
+	catch(...)
+	{
+		return IPL_OUTOFMEMORY;
+	}
+	return n;
+}
+
+IPL_RESULT
+IPhreeqcLib::DestroyIPhreeqc(int n)
+{
+	IPL_RESULT retval = IPL_BADINSTANCE;
+	if (n >= 0)
+	{
+		std::map<size_t, IPhreeqc2*>::iterator it = IPhreeqcLib::Instances.find(size_t(n));
+		if (it != IPhreeqcLib::Instances.end())
+		{
+			delete (*it).second;
+			IPhreeqcLib::Instances.erase(it);
+			retval = IPL_OK;
+		}
+	}
+	return retval;
+}
+
+IPhreeqc2*
+IPhreeqcLib::GetInstance(int n)
+{
+	std::map<size_t, IPhreeqc2*>::iterator it = IPhreeqcLib::Instances.find(size_t(n));
+	if (it != IPhreeqcLib::Instances.end())
+	{
+		return (*it).second;
+	}
+	return 0;
+}
+

module_files.cpp

@@ -2,12 +2,15 @@
 #if defined(R_SO)
 #include "phreeqc_files.inl"
 #else
-#include "phreeqcpp/phreeqc/phreeqc_files.c"
+// COMMENT: {3/25/2010 12:36:14 PM}#include "phreeqcpp/phreeqc/phreeqc_files.c"
 #endif
 
 // COMMENT: {3/2/2010 4:06:35 PM}static int module_isopen_handler(const int type);
 // COMMENT: {3/2/2010 4:06:35 PM}static int module_open_handler(const int type, const char *file_name);
 
+//{{{3/25/2010 12:37:19 PM}
+#include <cassert>
+//}}{3/25/2010 12:37:19 PM}
 #include "IPhreeqc.hpp"
 
 int IPhreeqc::module_handler(const int action, const int type, const char *err_str, const int stop, void *cookie, const char *format, va_list args)

module_output.cpp

@@ -5,7 +5,7 @@
 #if defined(R_SO)
 #include "output.inl"
 #else
-#include "phreeqcpp/phreeqc/output.c"
+// COMMENT: {3/25/2010 12:36:24 PM}#include "phreeqcpp/phreeqc/output.c"
 #endif