trunk/ascxx/solverparameters.cpp

#include "solverparameters.h"
#include "solverparameteriterator.h"

#include <iostream>
#include <sstream>
#include <stdexcept>
using namespace std;

//-------------------------------
// SolverParameters

SolverParameters::SolverParameters(const slv_parameters_t &p) : p(p){
    cerr << "CREATED SOLVERPARAMETERS" << endl;
}

SolverParameters::SolverParameters(){
    /* cerr << "CONSTRUCTED SOLVERPARAMETERS NULL" << endl; */
}

SolverParameters::SolverParameters(const SolverParameters &old) : p(old.p){
    // copy constructor
}

const string
SolverParameters::toString() const{
    stringstream ss;
    ss << "SOLVERPARAMETERS:TOSTRING:" << endl;
    ss << "Number of parameters: " << p.num_parms << endl;

    iterator i;
    for(i = begin(); i<end(); ++i){
        SolverParameter p = *i;
#if 0
        ss << p.getLabel() << " [" << p.getDescription() << "]: ";
#else
        ss << p.getName() << ": ";
#endif
        if(p.isInt()){
            ss << p.getIntValue();
        }else if(p.isReal()){
            ss << p.getRealValue();
        }else if(p.isBool()){
            ss << (p.getBoolValue() ? "true" : "false");
        }else if(p.isStr()){
            ss << p.getStrValue();
        }else{
            throw runtime_error("Unhandled case");
        }
        ss << endl;
    }
    return ss.str();
}

const SolverParameterIterator 
SolverParameters::begin() const{
    return SolverParameterIterator(p.parms);
}

const SolverParameterIterator 
SolverParameters::end() const{
    return SolverParameterIterator(p.parms+p.num_parms);
}

const int 
SolverParameters::getLength() const{
    return p.num_parms;
}

SolverParameter
SolverParameters::getParameter(const int &index) const{
    return SolverParameter(&(p.parms[index]));
}

SolverParameter 
SolverParameters::getParameter(const string &name) const{
    for(int i=0;i<p.num_parms;++i){
        //cerr << "Looking at " << p.parms[i].name << endl;
        if(p.parms[i].name==name){
            return SolverParameter(&(p.parms[i]));
        }
    }
    stringstream ss;
    ss << "Invalid parameter name '" << name << "'";
    throw runtime_error(ss.str());
}

slv_parameters_t &
SolverParameters::getInternalType(){
    return p;
}

1	#include "solverparameters.h"
2	#include "solverparameteriterator.h"
3
4	#include <iostream>
5	#include <sstream>
6	#include <stdexcept>
7	using namespace std;
8
9	//-------------------------------
10	// SolverParameters
11
12	SolverParameters::SolverParameters(const slv_parameters_t &p) : p(p){
13	cerr << "CREATED SOLVERPARAMETERS" << endl;
14	}
15
16	SolverParameters::SolverParameters(){
17	/* cerr << "CONSTRUCTED SOLVERPARAMETERS NULL" << endl; */
18	}
19
20	SolverParameters::SolverParameters(const SolverParameters &old) : p(old.p){
21	// copy constructor
22	}
23
24	const string
25	SolverParameters::toString() const{
26	stringstream ss;
27	ss << "SOLVERPARAMETERS:TOSTRING:" << endl;
28	ss << "Number of parameters: " << p.num_parms << endl;
29
30	iterator i;
31	for(i = begin(); i<end(); ++i){
32	SolverParameter p = *i;
33	#if 0
34	ss << p.getLabel() << " [" << p.getDescription() << "]: ";
35	#else
36	ss << p.getName() << ": ";
37	#endif
38	if(p.isInt()){
39	ss << p.getIntValue();
40	}else if(p.isReal()){
41	ss << p.getRealValue();
42	}else if(p.isBool()){
43	ss << (p.getBoolValue() ? "true" : "false");
44	}else if(p.isStr()){
45	ss << p.getStrValue();
46	}else{
47	throw runtime_error("Unhandled case");
48	}
49	ss << endl;
50	}
51	return ss.str();
52	}
53
54	const SolverParameterIterator
55	SolverParameters::begin() const{
56	return SolverParameterIterator(p.parms);
57	}
58
59	const SolverParameterIterator
60	SolverParameters::end() const{
61	return SolverParameterIterator(p.parms+p.num_parms);
62	}
63
64	const int
65	SolverParameters::getLength() const{
66	return p.num_parms;
67	}
68
69	SolverParameter
70	SolverParameters::getParameter(const int &index) const{
71	return SolverParameter(&(p.parms[index]));
72	}
73
74	SolverParameter
75	SolverParameters::getParameter(const string &name) const{
76	for(int i=0;i<p.num_parms;++i){
77	//cerr << "Looking at " << p.parms[i].name << endl;
78	if(p.parms[i].name==name){
79	return SolverParameter(&(p.parms[i]));
80	}
81	}
82	stringstream ss;
83	ss << "Invalid parameter name '" << name << "'";
84	throw runtime_error(ss.str());
85	}
86
87	slv_parameters_t &
88	SolverParameters::getInternalType(){
89	return p;
90	}
91