pyEQL 1.4.0rc9__cp311-cp311-macosx_11_0_arm64.whl

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/Serializer.cxx

@@ -0,0 +1,213 @@
+#include "Serializer.h"
+#include "Phreeqc.h"
+#include "Utils.h"
+#include "Solution.h"
+#include "Exchange.h"
+#include "Temperature.h"
+#include "GasPhase.h"
+#include "cxxKinetics.h"
+#include "PPassemblage.h"
+#include "SSassemblage.h"
+#include "Surface.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+Serializer::Serializer(PHRQ_io *io)
+	: PHRQ_base(io)
+{
+}
+Serializer::~Serializer(void)
+{
+}
+bool Serializer::Serialize(Phreeqc &phreeqc_ref, int start, int end, bool include_t, bool include_p, PHRQ_io *io)
+{
+	for (int i = start; i <= end; i++)
+	{
+		cxxSolution *soln_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_solution_map(), i);
+		if (soln_ptr)
+		{
+			ints.push_back((int) PT_SOLUTION);
+			soln_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+		}
+		// Exchangers
+		{
+			cxxExchange *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_exchange_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_EXCHANGE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// GasPhases
+		{
+			cxxGasPhase *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_gas_phase_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_GASPHASE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// Kinetics
+		{
+			cxxKinetics *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_kinetics_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_KINETICS);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// PPassemblages
+		{
+			cxxPPassemblage *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_pp_assemblage_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_PPASSEMBLAGE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// SSassemblages
+		{
+			cxxSSassemblage *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_ss_assemblage_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_SSASSEMBLAGE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// Surfaces
+		{
+			cxxSurface *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_surface_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_SURFACES);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// Temperature
+		if (include_t)
+		{		
+			cxxTemperature *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_temperature_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_TEMPERATURE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}
+		// Pressure
+		if (include_p)
+		{		
+			cxxPressure *entity_ptr = Utilities::Rxn_find(phreeqc_ref.Get_Rxn_pressure_map(), i);
+			if (entity_ptr)
+			{
+				ints.push_back((int) PT_PRESSURE);
+				entity_ptr->Serialize(this->dictionary, this->ints, this->doubles);
+			}
+		}			
+	}	
+	return true;
+}
+
+bool 
+Serializer::Deserialize(Phreeqc &phreeqc_ref, Dictionary &dictionary, std::vector<int> &ints, std::vector<double> &doubles)
+{
+	int ii = 0;
+	int dd = 0;
+	while (ii < (int) ints.size())
+	{
+		PACK_TYPE type = (PACK_TYPE) ints[ii++];
+		switch (type)
+		{
+		case PT_SOLUTION:	
+			{
+				cxxSolution soln;
+				soln.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = soln.Get_n_user();
+				//std::cerr << "unpacked solution " << n_user << std::endl;
+				phreeqc_ref.Get_Rxn_solution_map()[n_user] = soln;
+			}
+			break;
+		case PT_EXCHANGE:	
+			{
+				cxxExchange entity;
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_exchange_map()[n_user] = entity;
+			}
+			break;
+		case PT_GASPHASE:
+			{
+				cxxGasPhase entity(phreeqc_ref.Get_phrq_io());
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_gas_phase_map()[n_user] = entity;
+			}
+			break;
+		case PT_KINETICS:	
+			{
+				cxxKinetics entity(phreeqc_ref.Get_phrq_io());
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_kinetics_map()[n_user] = entity;
+			}
+			break;
+		case PT_PPASSEMBLAGE:	
+			{
+				cxxPPassemblage entity;
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				//std::cerr << "unpacked pp assemblage " << n_user << std::endl;
+				phreeqc_ref.Get_Rxn_pp_assemblage_map()[n_user] = entity;
+			}
+			break;
+		case PT_SSASSEMBLAGE:	
+			{
+				cxxSSassemblage entity(phreeqc_ref.Get_phrq_io());
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_ss_assemblage_map()[n_user] = entity;
+			}
+			break;
+		case PT_SURFACES:	
+			{
+				cxxSurface entity;
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_surface_map()[n_user] = entity;
+			}
+			break;
+		case PT_TEMPERATURE:
+			{
+				cxxTemperature entity;
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_temperature_map()[n_user] = entity;
+			}
+			break;
+		case PT_PRESSURE:	
+			{
+				cxxPressure entity;
+				entity.Deserialize(dictionary, ints, doubles, ii, dd);
+				int n_user = entity.Get_n_user();
+				phreeqc_ref.Get_Rxn_pressure_map()[n_user] = entity;
+			}
+			break;
+		default:
+#if !defined(R_SO)
+			std::cerr << "Unknown pack type in deserialize " << type << std::endl;
+			exit(4);
+#else
+			std::ostringstream oss;
+			oss << "Unknown pack type in deserialize " << type << std::endl;
+			phreeqc_ref.error_msg(oss.str().c_str(), STOP);
+#endif
+			break;
+		}
+	}
+	return true;
+}

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/Serializer.h

@@ -0,0 +1,42 @@
+#if !defined(SERIALIZER_H_INCLUDED)
+#define SERIALIZER_H_INCLUDED
+#include <iostream>
+#include <map>
+#include <vector>
+#include <sstream>
+#include "PHRQ_base.h"
+#include "Dictionary.h"
+class Phreeqc;
+class Serializer : public PHRQ_base
+{
+public:
+	Serializer(PHRQ_io *io = NULL);
+	~Serializer(void);
+
+	enum PACK_TYPE
+	{
+		PT_SOLUTION     = 0,
+		PT_EXCHANGE     = 1,
+		PT_GASPHASE     = 2,
+		PT_KINETICS     = 3,
+		PT_PPASSEMBLAGE = 4,
+		PT_SSASSEMBLAGE = 5,
+		PT_SURFACES     = 6,
+		PT_TEMPERATURE  = 7,
+		PT_PRESSURE     = 8
+	};
+	bool Serialize(Phreeqc &phreeqc_ptr, int start, int end, bool include_t, bool include_p, PHRQ_io *io = NULL);
+	bool Deserialize(Phreeqc &phreeqc_ptr, Dictionary &dictionary, std::vector<int> &ints, std::vector<double> &doubles);
+	Dictionary &GetDictionary(void) {return this->dictionary;}
+	std::vector<int> &GetInts(void) {return this->ints;}
+	std::vector<double> &GetDoubles(void) {return this->doubles;}
+	//std::string &GetWordsString(void) {return this->words_string;}
+
+
+protected:
+	std::vector<int> ints;
+	std::vector<double> doubles;
+	//std::string words_string;
+	Dictionary dictionary;
+};
+#endif // !defined(SERIALIZER_H_INCLUDED)