iphreeqc/StorageBin.h

#if !defined(STORAGEBIN_H_INCLUDED)
#define STORAGEBIN_H_INCLUDED

#include "Utils.h"
#include "Parser.h"
#include "Solution.h"
#include "Exchange.h"
#include "GasPhase.h"
#include "cxxKinetics.h"
#include "PPassemblage.h"
#include "SSassemblage.h"
#include "Surface.h"
#include "System.h"
#include "cxxMix.h"
#include "Reaction.h"
#include "Temperature.h"

#include <cassert> // assert
#include <map>     // std::map
#include <string>  // std::string
#include <list>    // std::list
#include <vector>  // std::vector

class cxxStorageBin 
{

public:
        cxxStorageBin();
        cxxStorageBin(struct Use *use_ptr);
        ~cxxStorageBin();

        void import_phreeqc(void);

	void cxxStorageBin2phreeqc(int n);

	void phreeqc2cxxStorageBin(int n);

	void remove(int n);

	cxxSolution *getSolution(int n_user) { 
		if (this->Solutions.find(n_user) != this->Solutions.end()) {
			return(&(this->Solutions.find(n_user)->second));
		} 
		return (NULL);
	}
	void setSolution(int n_user, cxxSolution *entity) { 
	  	if (entity == NULL) return;
		Solutions[n_user] = *entity;
	}
	void removeSolution(int n_user) { 
		Solutions.erase(n_user);
	}

	cxxExchange *getExchange(int n_user) { 
		if (this->Exchangers.find(n_user) != this->Exchangers.end()) {
			return(&(this->Exchangers.find(n_user)->second));
		} 
		return (NULL);
	}
	void setExchange(int n_user, cxxExchange *entity) { 
	  if (entity == NULL) return;
	  Exchangers[n_user] = *entity;
	}
	void removeExchange(int n_user) { 
		Exchangers.erase(n_user);
	}

	cxxPPassemblage *getPPassemblage(int n_user) { 
		if (this->PPassemblages.find(n_user) != this->PPassemblages.end()) {
			return(&(this->PPassemblages.find(n_user)->second));
		} 
		return (NULL);
	}
	void setPPassemblage(int n_user, cxxPPassemblage *entity) { 
	  	if (entity == NULL) return;
		PPassemblages[n_user] = *entity;
	}
	void removePPassemblage(int n_user) { 
		PPassemblages.erase(n_user);
	}

	cxxGasPhase *getGasPhase(int n_user) { 
		if (this->GasPhases.find(n_user) != this->GasPhases.end()) {
			return(&(this->GasPhases.find(n_user)->second));
		} 
		return (NULL);
	}
	void setGasPhase(int n_user, cxxGasPhase *entity) {
	  if (entity == NULL) return;
	  GasPhases[n_user] = *entity;
	}
	void removeGasPhase(int n_user) { 
		GasPhases.erase(n_user);
	}

	cxxSSassemblage *getSSassemblage(int n_user) { 
		if (this->SSassemblages.find(n_user) != this->SSassemblages.end()) {
			return(&(this->SSassemblages.find(n_user)->second));
		} 
		return (NULL);
	}
	void setSSassemblage(int n_user, cxxSSassemblage *entity) {
	  if (entity == NULL) return;
	  SSassemblages[n_user] = *entity;
	}
	void removeSSassemblage(int n_user) { 
		SSassemblages.erase(n_user);
	}

	cxxKinetics *getKinetics(int n_user) { 
		if (this->Kinetics.find(n_user) != this->Kinetics.end()) {
			return(&(this->Kinetics.find(n_user)->second));
		} 
		return (NULL);
	}
	void setKinetics(int n_user, cxxKinetics *entity) {
	  if (entity == NULL) return;
	  Kinetics[n_user] = *entity;
	}
	void removeKinetics(int n_user) { 
		Kinetics.erase(n_user);
	}

	cxxSurface *getSurface(int n_user) 
	{ 
	  if (this->Surfaces.find(n_user) != this->Surfaces.end()) 
	  {
	    return(&(this->Surfaces.find(n_user)->second));
	  } 
	  return (NULL);
	}
	void setSurface(int n_user, cxxSurface *entity) {
	  if (entity == NULL) return;
	  Surfaces[n_user] = *entity;
	}
	void removeSurface(int n_user) { 
		Surfaces.erase(n_user);
	}

	cxxMix *getMix(int n_user) { 
		if (this->Mixes.find(n_user) != this->Mixes.end()) {
			return(&(this->Mixes.find(n_user)->second));
		} 
		return (NULL);
	}
	void setMix(int n_user, cxxMix *entity) {
	  if (entity == NULL) return;
	  Mixes[n_user] = *entity;
	}
	void removeMix(int n_user) { 
		Mixes.erase(n_user);
	}

 	cxxReaction *getReaction(int n_user) { 
		if (this->Reactions.find(n_user) != this->Reactions.end()) {
			return(&(this->Reactions.find(n_user)->second));
		} 
		return (NULL);
	}
	void setReaction(int n_user, cxxReaction *entity) {
	  if (entity == NULL) return;
	  Reactions[n_user] = *entity;
	}
	void removeReaction(int n_user) { 
		Reactions.erase(n_user);
	}

 	cxxTemperature *getTemperature(int n_user) { 
		if (this->Temperatures.find(n_user) != this->Temperatures.end()) {
			return(&(this->Temperatures.find(n_user)->second));
		} 
		return (NULL);
	}
	void setTemperature(int n_user, cxxTemperature *entity) {
	  if (entity == NULL) return;
	  Temperatures[n_user] = *entity;
	}
	void removeTemperature(int n_user) { 
		Temperatures.erase(n_user);
	}

	void setSystem(struct Use *use_ptr); 

	void dump_raw(std::ostream& s_oss, unsigned int indent)const;

        void dump_raw(std::ostream& s_oss, int i, unsigned int indent);

        void read_raw(CParser& parser);
	int read_raw_keyword(CParser& parser);

	void add(struct system *sys_ptr);

	struct system *cxxStorageBin2system(int i);

	//cxxSolution *mix_cxxSolutions(cxxMix &mixmap);
	cxxExchange *mix_cxxExchange(cxxMix &mixmap);

	const std::map<int, cxxSolution>& getSolutions()const {return this->Solutions;};
	const std::map<int, cxxExchange>& getExchangers()const {return this->Exchangers;};
	const std::map<int, cxxGasPhase>& getGasPhases()const {return this->GasPhases;};
	const std::map<int, cxxKinetics>& getKinetics()const {return this->Kinetics;};
	const std::map<int, cxxPPassemblage>& getPPassemblages()const {return this->PPassemblages;};
	const std::map<int, cxxSSassemblage>& getSSassemblages()const {return this->SSassemblages;};
	const std::map<int, cxxSurface>& getSurfaces()const {return this->Surfaces;};

#ifdef USE_MPI
	void mpi_send(int n, int task_number);
	void mpi_recv(int task_number);
#endif
#ifdef ORCHESTRA
	void ORCH_write(std::ostream &chemistry_dat, std::ostream &input_dat, std::ostream &output_dat);
#endif
protected:
	// Tidied classes
	std::map<int, cxxSolution>      Solutions;
	std::map<int, cxxExchange>      Exchangers;
	std::map<int, cxxGasPhase>      GasPhases;
	std::map<int, cxxKinetics>      Kinetics;
	std::map<int, cxxPPassemblage>  PPassemblages;
	std::map<int, cxxSSassemblage>  SSassemblages;
	std::map<int, cxxSurface>       Surfaces;

	//bool b = exists (Solutions, 5);
	// Initial classes
	//std::map<int, cxxISolution>     ISolutions;

	// Reaction classes
	std::map<int, cxxMix>           Mixes;
	std::map<int, cxxReaction>      Reactions;
	std::map<int, cxxTemperature>   Temperatures;
	cxxSystem                       system;
public:
        //static std::map<int, cxxStorageBin>& map;

};

#endif // !defined(STORAGEBIN_H_INCLUDED)