pyEQL 1.4.0rc9__cp313-cp313-macosx_11_0_arm64.whl

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/CSelectedOutput.cpp

@@ -0,0 +1,401 @@
+// SelectedOutput.cpp: implementation of the CSelectedOutput class.
+//
+//////////////////////////////////////////////////////////////////////
+#if defined(WIN32)
+#include <windows.h>                // OutputDebugString
+#endif
+
+#if defined(_DEBUG)
+#include <sstream>                  // std::ostringstream
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>                 // strlen
+
+#include "Debug.h"                  // ASSERT
+
+#if defined(R_SO)
+#include "CSelectedOutputhxx.h"     // CSelectedOutput
+#else
+#include "CSelectedOutput.hxx"      // CSelectedOutput
+#endif
+
+const float INACTIVE_CELL_VALUE = 1.0e30f;
+const size_t RESERVE_ROWS = 80;
+const size_t RESERVE_COLS = 80;
+
+CSelectedOutput::CSelectedOutput()
+: m_nRowCount(0)
+{
+	this->m_arrayVar.reserve(RESERVE_COLS);
+}
+
+CSelectedOutput::~CSelectedOutput()
+{
+}
+
+void CSelectedOutput::Clear(void)
+{
+	this->m_nRowCount = 0;
+	this->m_vecVarHeadings.clear();
+	this->m_arrayVar.clear();
+	this->m_mapHeadingToCol.clear();
+}
+
+size_t CSelectedOutput::GetRowCount(void)const
+{
+	if (this->GetColCount())
+	{
+		return this->m_nRowCount + 1; // rows + heading
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+size_t CSelectedOutput::GetColCount(void)const
+{
+	return this->m_vecVarHeadings.size();
+}
+
+CVar CSelectedOutput::Get(int nRow, int nCol)const
+{
+	CVar v;
+	this->Get(nRow, nCol, &v);
+	return v;
+}
+
+VRESULT CSelectedOutput::Get(int nRow, int nCol, VAR* pVAR)const
+{
+	if (::VarClear(pVAR) == VR_BADVARTYPE)
+	{
+		return VR_BADVARTYPE;
+	}
+	if ((size_t)nRow >= this->GetRowCount() || nRow < 0)
+	{
+		pVAR->type = TT_ERROR;
+		pVAR->vresult = VR_INVALIDROW;
+		return pVAR->vresult;
+	}
+	if ((size_t)nCol >= this->GetColCount() || nCol < 0)
+	{
+		pVAR->type = TT_ERROR;
+		pVAR->vresult = VR_INVALIDCOL;
+		return pVAR->vresult;
+	}
+	if (nRow)
+	{
+		ASSERT((size_t)nRow <= this->m_arrayVar[nCol].size());
+		return ::VarCopy(pVAR, &(this->m_arrayVar[nCol])[nRow - 1]);
+	}
+	else
+	{
+		return ::VarCopy(pVAR, &(this->m_vecVarHeadings[nCol]));
+	}
+}
+
+
+int CSelectedOutput::EndRow(void)
+{
+	if (size_t ncols = this->GetColCount())
+	{
+		++this->m_nRowCount;
+
+		// make sure array is full
+		for (size_t col = 0; col < ncols; ++col)
+		{
+			size_t nrows = this->m_arrayVar[col].size();
+			if (nrows < this->m_nRowCount)
+			{
+				// fill w/ empty
+				this->m_arrayVar[col].resize(this->m_nRowCount);
+			}
+#if defined(_DEBUG)
+			else if (nrows > this->m_nRowCount)
+			{
+				ASSERT(false);
+			}
+#endif
+		}
+	}
+	return 0;
+}
+
+int CSelectedOutput::PushBack(const char* key, const CVar& var)
+{
+	try
+	{
+		// check if key is new
+		std::map< std::string, size_t >::iterator find;
+		find = this->m_mapHeadingToCol.find(std::string(key));
+		if (find == this->m_mapHeadingToCol.end())
+		{
+			// new key(column)
+			//
+			this->m_mapHeadingToCol.insert(std::map< std::string, size_t >::value_type(std::string(key),
+				this->m_mapHeadingToCol.size()) );
+
+			// add heading
+			//
+			this->m_vecVarHeadings.push_back(CVar(key));
+
+
+			// add new vector(col)
+			//
+			this->m_arrayVar.resize(this->m_arrayVar.size() + 1);
+			this->m_arrayVar.back().reserve(RESERVE_ROWS);
+
+			// add empty rows if nec
+			if (this->m_nRowCount)
+				this->m_arrayVar.back().resize(this->m_nRowCount);
+
+			this->m_arrayVar.back().push_back(var);
+		}
+		else
+		{
+			if (this->m_arrayVar[find->second].size() == this->m_nRowCount) {
+				this->m_arrayVar[find->second].push_back(var);
+			}
+			else {
+				ASSERT(this->m_arrayVar[find->second].size() == this->m_nRowCount + 1);
+				this->m_arrayVar[find->second].at(this->m_nRowCount) = var;
+			}
+		}
+		return 0;
+	}
+	catch(...)
+	{
+		ASSERT(false);
+		throw;
+	}
+	return 1; // error
+}
+
+
+int CSelectedOutput::PushBackDouble(const char* key, double value)
+{
+	CVar v(value);
+	return this->PushBack(key, v);
+}
+
+int CSelectedOutput::PushBackLong(const char* key, long value)
+{
+	CVar v(value);
+	return this->PushBack(key, v);
+}
+
+int CSelectedOutput::PushBackString(const char* key, const char* value)
+{
+	CVar v(value);
+	return this->PushBack(key, v);
+}
+
+int CSelectedOutput::PushBackEmpty(const char* key)
+{
+	CVar v;
+	return this->PushBack(key, v);
+}
+
+#if defined(_DEBUG)
+void CSelectedOutput::Dump(const char* heading)
+{
+	::OutputDebugStringA(heading);
+	std::ostringstream oss;
+	oss << *this;
+	std::istringstream iss(oss.str());
+	std::string line;
+	while (std::getline(iss, line))
+	{
+		::OutputDebugStringA(line.c_str());
+		::OutputDebugStringA("\n");
+	}
+}
+
+void CSelectedOutput::AssertValid(void)const
+{
+	if (size_t cols = this->GetColCount())
+	{
+		size_t rows = this->m_arrayVar[0].size();
+		for (size_t col = 0; col < cols; ++col)
+		{
+			ASSERT(rows == this->m_arrayVar[col].size());
+		}
+	}
+}
+#endif
+
+std::ostream& operator<< (std::ostream &os, const CSelectedOutput &a)
+{
+	os << "CSelectedOutput(rows=" << a.GetRowCount() << ", cols=" << a.GetColCount() << ")\n";
+
+	CVar v;
+	for (size_t r = 0; r < a.GetRowCount(); ++r)
+	{
+		for (size_t c = 0; c < a.GetColCount(); ++c)
+		{
+			a.Get((int)r, (int)c, &v);
+			os << v << ", ";
+			::VarClear(&v);
+		}
+		os << "\n";
+	}
+	os << "\n";
+	return os;
+}
+void CSelectedOutput::Serialize(
+	int row_number,
+	std::vector<int> &types,        // each column for each row types, including headings
+	std::vector<long> &longs,       // in order by occurrence
+	std::vector<double> &doubles,   // in order by occurrence
+	std::string &strings)
+{
+	types.clear();
+	longs.clear();
+	doubles.clear();
+	strings.clear();
+
+	// size_t nrows = this->m_nRowCount;
+	size_t ncols = this->m_vecVarHeadings.size();
+
+	longs.push_back((long) 1);
+	longs.push_back((long) ncols);
+
+	// put headings
+	for (size_t i = 0; i < ncols; i++)
+	{
+		ASSERT(this->m_vecVarHeadings[i].type == TT_STRING);
+		longs.push_back((long) strlen(this->m_vecVarHeadings[i].sVal));
+		strings.append(this->m_vecVarHeadings[i].sVal);
+	}
+
+	// go through rows by column
+	for (size_t j = 0; j < ncols; j++)
+	{
+		for (size_t i = row_number; i < (size_t)(row_number + 1); i++)
+		{
+			types.push_back(m_arrayVar[j][i].type);
+			switch(m_arrayVar[j][i].type)
+			{
+			case TT_EMPTY:
+				break;
+			case TT_ERROR:
+				longs.push_back(m_arrayVar[j][i].vresult);
+				break;
+			case TT_LONG:
+				longs.push_back(m_arrayVar[j][i].lVal);
+				break;
+			case TT_DOUBLE:
+				doubles.push_back(m_arrayVar[j][i].dVal);
+				break;
+			case TT_STRING:
+				longs.push_back((long) strlen(m_arrayVar[j][i].sVal));
+				strings.append(m_arrayVar[j][i].sVal);
+				break;
+
+			}
+		}
+	}
+}
+void CSelectedOutput::DeSerialize(
+	std::vector<int> &types,        // each column for each row types, including headings
+	std::vector<long> &longs,       // in order by occurrence
+	std::vector<double> &doubles,   // in order by occurrence
+	std::string &strings)
+{
+	size_t i_types = 0, i_longs = 0, i_doubles = 0;
+	size_t strings_start = 0;
+
+	size_t nrows = longs[i_longs++];
+	size_t ncols = longs[i_longs++];
+
+	// put headings
+	std::vector<std::string> headings;
+	for (size_t i = 0; i < ncols; i++)
+	{
+		size_t l = (size_t) longs[i_longs++];
+		headings.push_back(strings.substr(strings_start, l));
+		strings_start += l;
+	}
+
+	// go through rows by column
+	for (size_t j = 0; j < ncols; j++)
+	{
+		for (size_t i = 0; i < nrows; i++)
+		{
+			switch((VAR_TYPE) types[i_types++])
+			{
+			case TT_EMPTY:
+				{
+					CVar v;
+					v.Clear();
+					this->PushBack(headings[j].c_str(), v);
+				}
+				break;
+			case TT_ERROR:
+				{
+					CVar v;
+					v.Clear();
+					v.type = TT_ERROR;
+					v.vresult = (VRESULT) longs[i_longs++];
+					this->PushBack(headings[j].c_str(), v);
+				}
+				break;
+			case TT_LONG:
+				PushBackLong(headings[j].c_str(), longs[i_longs++]);
+				break;
+			case TT_DOUBLE:
+				PushBackDouble(headings[j].c_str(), doubles[i_doubles++]);
+				break;
+			case TT_STRING:
+				{
+					size_t l = (size_t) longs[i_longs++];
+					PushBackString(headings[j].c_str(), strings.substr(strings_start, l).c_str());
+					strings_start += l;
+				}
+				break;
+			}
+		}
+	}
+	this->EndRow();
+}
+void CSelectedOutput::Doublize(
+	int &nrow,
+	int &ncol,
+	std::vector < double > &doubles)
+{
+	nrow = (int) this->m_nRowCount;
+	ncol = (int) this->m_vecVarHeadings.size();
+
+	doubles.clear();
+	// go through column dominant order (Fortran)
+	for (size_t j = 0; j < (size_t)ncol; j++)
+	{
+		for (size_t i = 0; i < (size_t)nrow; i++)
+		{
+			switch(m_arrayVar[j][i].type)
+			{
+			case TT_EMPTY:
+				doubles.push_back((double) INACTIVE_CELL_VALUE);
+				break;
+			case TT_ERROR:
+				doubles.push_back((double) INACTIVE_CELL_VALUE);
+				break;
+			case TT_LONG:
+				doubles.push_back((double) m_arrayVar[j][i].lVal);
+				break;
+			case TT_DOUBLE:
+				doubles.push_back(m_arrayVar[j][i].dVal);
+				break;
+			case TT_STRING:
+				doubles.push_back((double) INACTIVE_CELL_VALUE);
+				break;
+			default:
+				doubles.push_back((double) INACTIVE_CELL_VALUE);
+				break;
+
+			}
+		}
+	}
+}

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/CSelectedOutput.hxx

@@ -0,0 +1,77 @@
+// SelectedOutput.h: interface for the CSelectedOutput class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined _INC_SELECTEDOUTPUT_H
+#define _INC_SELECTEDOUTPUT_H
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+#include <string>
+#include <map>
+#include <list>
+#include <vector>
+#include "CVar.hxx"
+
+#include "PHRQ_exports.h"
+
+class IPQ_DLL_EXPORT CSelectedOutput
+{
+public:
+	CSelectedOutput(void);
+	virtual ~CSelectedOutput(void);
+
+	int EndRow(void);
+	void Clear(void);
+
+	size_t GetRowCount(void)const;
+	size_t GetColCount(void)const;
+
+	CVar Get(int nRow, int nCol)const;
+	VRESULT Get(int nRow, int nCol, VAR* pVAR)const;
+
+	int PushBack(const char* key, const CVar& var);
+
+	int PushBackDouble(const char* key, double dVal);
+	int PushBackLong(const char* key, long lVal);
+	int PushBackString(const char* key, const char* sVal);
+	int PushBackEmpty(const char* key);
+
+	// Serialize
+	void Serialize(
+		int row,
+		std::vector<int> &types,
+		std::vector<long> &longs,
+		std::vector<double> &doubles,
+		std::string &strings);
+	void DeSerialize(
+		std::vector<int> &types,        
+		std::vector<long> &longs,       
+		std::vector<double> &doubles,   
+		std::string &strings);
+	void Doublize(
+		int &nrow,
+		int &ncol,
+		std::vector < double > &doubles);
+
+#if defined(_DEBUG)
+	void Dump(const char* heading);
+	void AssertValid(void)const;
+#endif
+
+protected:
+	friend std::ostream& operator<< (std::ostream &os, const CSelectedOutput &a);
+
+	size_t m_nRowCount;
+
+	std::vector< std::vector<CVar> > m_arrayVar;
+	std::vector<CVar> m_vecVarHeadings;
+	std::map< std::string, size_t > m_mapHeadingToCol;
+
+private:
+	static CSelectedOutput* s_instance;
+};
+
+#endif // !defined(_INC_SELECTEDOUTPUT_H)

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/CVar.hxx

@@ -0,0 +1,162 @@
+#ifndef INC_CVAR_HXX
+#define INC_CVAR_HXX
+
+#include "Var.h"
+#include <ostream>          // std::ostream
+
+class CVar : public VAR
+{
+// Constructors
+public:
+	CVar(void) throw()
+	{
+		::VarInit(this);
+	}
+	~CVar(void) //throw()
+	{
+		Clear();
+	}
+	CVar(const VAR& varSrc)
+	{
+		this->type = TT_EMPTY;
+		InternalCopy(&varSrc);
+	}
+	CVar(const CVar& varSrc)
+	{
+		this->type = TT_EMPTY;
+		InternalCopy(&varSrc);
+	}
+	CVar(double dblSrc) throw()
+	{
+		this->type = TT_DOUBLE;
+		this->dVal = dblSrc;
+	}
+	CVar(const char* pszSrc)
+	{
+		this->type = TT_EMPTY;
+		*this = pszSrc;
+	}
+	CVar(long nSrc) throw()
+	{
+		this->type = TT_LONG;
+		this->lVal = nSrc;
+	}
+
+// Assignment Operators
+public:
+	CVar& operator=(const CVar& varSrc)
+	{
+		InternalCopy(&varSrc);
+		return *this;
+	}
+	CVar& operator=(const VAR& varSrc)
+	{
+		InternalCopy(&varSrc);
+		return *this;
+	}
+	CVar& operator=(double dblSrc) throw()
+	{
+		if (type != TT_DOUBLE)
+		{
+			Clear();
+			type = TT_DOUBLE;
+		}
+		this->dVal = dblSrc;
+		return *this;
+	}
+	CVar& operator=(const char* pszSrc)
+	{
+		Clear();
+		this->type = TT_STRING;
+		this->sVal = ::VarAllocString(pszSrc);
+
+		if (this->sVal == NULL && pszSrc != NULL)
+		{
+			this->type = TT_ERROR;
+			this->vresult = VR_OUTOFMEMORY;
+		}
+		return *this;
+	}
+
+	friend std::ostream& operator<< (std::ostream &os, const CVar &a);
+
+
+// Operations
+public:
+	VRESULT Clear(void) { return ::VarClear(this); }
+	VRESULT Copy(const VAR* pSrc) { return ::VarCopy(this, const_cast<VAR*>(pSrc)); }
+
+// Implementation
+public:
+	VRESULT InternalClear()
+	{
+		VRESULT vr = Clear();
+		if (vr != VR_OK)
+		{
+			this->type = TT_ERROR;
+			this->vresult = vr;
+		}
+		return vr;
+	}
+
+	void InternalCopy(const VAR* pSrc)
+	{
+		VRESULT vr = Copy(pSrc);
+		if (vr != VR_OK)
+		{
+			this->type = TT_ERROR;
+			this->vresult = vr;
+		}
+	}
+
+};
+
+inline std::ostream& operator<< (std::ostream &os, const CVar &a)
+{
+	switch (a.type) {
+	case TT_EMPTY:
+		os << "(TT_EMPTY)";
+		break;
+	case TT_ERROR:
+		switch (a.vresult) {
+		case VR_OK:
+			os << "VR_OK";
+			break;
+		case VR_OUTOFMEMORY:
+			os << "VR_OUTOFMEMORY";
+			break;
+		case VR_BADVARTYPE:
+			os << "VR_BADVARTYPE";
+			break;
+		case VR_INVALIDARG:
+			os << "VR_INVALIDARG";
+			break;
+		case VR_INVALIDROW:
+			os << "VR_INVALIDROW";
+			break;
+		case VR_INVALIDCOL:
+			os << "VR_INVALIDCOL";
+			break;
+		}
+		os << "(TT_ERROR)";
+		break;
+	case TT_LONG:
+		os << a.lVal;
+		os << "(TT_LONG)";
+		break;
+	case TT_DOUBLE:
+		os << a.dVal;
+		os << "(TT_DOUBLE)";
+		break;
+	case TT_STRING:
+		os << "\"" << a.sVal << "\"";
+		os << "(TT_STRING)";
+		break;
+	default:
+		os << "(BAD)";
+		break;
+	}
+	return os;
+}
+
+#endif // INC_CVAR_HXX

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/Debug.h

@@ -0,0 +1,12 @@
+#ifndef _INC_DEBUG_H
+#define _INC_DEBUG_H
+
+#if defined(_MSC_VER)
+#include <crtdbg.h>
+#define ASSERT _ASSERT
+#else
+#include <cassert>
+#define ASSERT assert
+#endif
+
+#endif  /*_INC_DEBUG_H*/

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/ErrorReporter.hxx

@@ -0,0 +1,70 @@
+#if !defined(__ERROR_REPORTER_HXX_INC)
+#define __ERROR_REPORTER_HXX_INC
+
+
+#include <iosfwd>          // std::ostream
+#include <cstdio>          // std::fprintf
+
+class IErrorReporter
+{
+public:
+	virtual size_t AddError(const char* error_msg) = 0;
+	virtual void Clear(void) = 0;
+	virtual ~IErrorReporter(void) = 0;
+};
+
+// Note: this is req'd in order for subclass dtors to be called
+//
+IErrorReporter::~IErrorReporter(void)
+{
+}
+
+template <typename OS>
+class CErrorReporter : public IErrorReporter
+{
+public:
+	CErrorReporter(void);
+	virtual ~CErrorReporter(void);
+
+	virtual size_t AddError(const char *error_msg);
+	virtual void Clear(void);
+	OS* GetOS(void) { return m_pOS; }
+protected:
+	OS* m_pOS;
+	size_t m_error_count;
+};
+
+template<typename OS>
+CErrorReporter<OS>::CErrorReporter(void)
+: m_pOS(0)
+, m_error_count(0)
+{
+	this->m_pOS = new OS;
+}
+
+template<typename OS>
+CErrorReporter<OS>::~CErrorReporter(void)
+{
+	delete this->m_pOS;
+}
+
+template<typename OS>
+size_t CErrorReporter<OS>::AddError(const char* error_msg)
+{
+	++this->m_error_count;
+	(*this->m_pOS) << error_msg;
+	return this->m_error_count;
+}
+
+template<typename OS>
+void CErrorReporter<OS>::Clear(void)
+{
+	this->m_error_count = 0;
+	if (this->m_pOS->tellp() != std::ios::pos_type(-1))
+	{
+		delete this->m_pOS;
+		this->m_pOS = new OS;
+	}
+}
+
+#endif // __ERROR_REPORTER_HXX_INC