DECLARE_EXPORT SetupMatrix::Rule* SetupMatrix::createRule(const AttributeList& atts)
{
// Pick up the start, end and name attributes
int priority = atts.get(Tags::tag_priority)->getInt();
// Check for existence of a rule with the same priority
Rule* result = firstRule;
while (result && priority > result->priority)
result = result->nextRule;
if (result && result->priority != priority) result = NULL;
// Pick up the action attribute and update the rule accordingly
switch (MetaClass::decodeAction(atts))
{
case ADD:
// Only additions are allowed
if (result)
{
ostringstream o;
o << "Rule with priority " << priority
<< " already exists in setup matrix '" << getName() << "'";
throw DataException(o.str());
}
result = new Rule(this, priority);
return result;
case CHANGE:
// Only changes are allowed
if (!result)
{
ostringstream o;
o << "No rule with priority " << priority
<< " exists in setup matrix '" << getName() << "'";
throw DataException(o.str());
}
return result;
case REMOVE:
// Delete the entity
if (!result)
{
ostringstream o;
o << "No rule with priority " << priority
<< " exists in setup matrix '" << getName() << "'";
throw DataException(o.str());
}
else
{
// Delete it
delete result;
return NULL;
}
case ADD_CHANGE:
if (!result)
// Adding a new rule
result = new Rule(this, priority);
return result;
}
// This part of the code isn't expected not be reached
throw LogicException("Unreachable code reached");
}
DECLARE_EXPORT SetupMatrix::Rule::Rule(SetupMatrix *s, int p)
: cost(0), priority(p), matrix(s), nextRule(NULL), prevRule(NULL)
{
// Validate the arguments
if (!matrix) throw DataException("Can't add a rule to NULL setup matrix");
// Find the right place in the list
Rule *next = matrix->firstRule, *prev = NULL;
while (next && p > next->priority)
{
prev = next;
next = next->nextRule;
}
// Duplicate priority
if (next && next->priority == p)
throw DataException("Multiple rules with identical priority in setup matrix");
// Maintain linked list
nextRule = next;
prevRule = prev;
if (prev) prev->nextRule = this;
else matrix->firstRule = this;
if (next) next->prevRule = this;
// Initialize the Python type
initType(metadata);
}
void SetupMatrixRule::setSetupMatrix(SetupMatrix *s)
{
// Validate the arguments
if (matrix)
throw DataException("Can't reassign setup matrix matrix once assigned");
if (!s)
throw DataException("Can't update setup matrix to nullptr");
// Assign the pointer
matrix = s;
// Find the right place in the list
SetupMatrixRule *next = matrix->firstRule, *prev = nullptr;
while (next && priority > next->priority)
{
prev = next;
next = next->nextRule;
}
// Duplicate priority
if (next && next->priority == priority)
throw DataException("Multiple rules with identical priority in setup matrix");
// Maintain linked list
nextRule = next;
prevRule = prev;
if (prev)
prev->nextRule = this;
else
matrix->firstRule = this;
if (next)
next->prevRule = this;
}
int
FunctionSpace::getTagFromDataPointNo(DataTypes::dim_t dataPointNo) const
{
//
// Get the number of samples and data-points per sample
int numSamples = getNumSamples();
int numDataPointsPerSample = getNumDPPSample();
int numDataPoints = numSamples * numDataPointsPerSample;
if (numDataPointsPerSample==0) {
throw DataException("FunctionSpace::getTagFromDataPointNo error: no data-points associated with this object.");
}
if (dataPointNo<0 || dataPointNo>=numDataPoints) {
throw DataException("FunctionSpace::getTagFromDataPointNo error: invalid data-point number supplied.");
}
//
// Determine the sample number which corresponds to this data-point number
int sampleNo = dataPointNo / numDataPointsPerSample;
//
// Determine the tag number which corresponds to this sample number
int tagNo = getTagFromSampleNo(sampleNo);
//
// return the tag number
return(tagNo);
}
PyObject* SubOperation::create(PyTypeObject* pytype, PyObject* args, PyObject* kwds)
{
try
{
// Pick up the operation
PyObject* oper = PyDict_GetItemString(kwds, "operation");
if (!oper)
throw DataException("Missing operation on SubOperation");
if (!PyObject_TypeCheck(oper, Operation::metadata->pythonClass))
throw DataException("field 'operation' of suboperation must be of type operation");
// Pick up the owner
PyObject* owner = PyDict_GetItemString(kwds, "owner");
if (!owner)
throw DataException("Missing owner on SubOperation");
if (!PyObject_TypeCheck(owner, Operation::metadata->pythonClass))
throw DataException("field 'operation' of suboperation must be of type operation");
// Pick up the type and create the suboperation
SubOperation *l = new SubOperation();
if (oper) l->setOperation(static_cast<Operation*>(oper));
if (owner) l->setOwner(static_cast<Operation*>(owner));
// Iterate over extra keywords, and set attributes. @todo move this responsibility to the readers...
if (l)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
while (PyDict_Next(kwds, &pos, &key, &value))
{
PythonData field(value);
PyObject* key_utf8 = PyUnicode_AsUTF8String(key);
DataKeyword attr(PyBytes_AsString(key_utf8));
Py_DECREF(key_utf8);
if (!attr.isA(Tags::operation) && !attr.isA(Tags::owner)
&& !attr.isA(Tags::type) && !attr.isA(Tags::action))
{
const MetaFieldBase* fmeta = SubOperation::metacategory->findField(attr.getHash());
if (fmeta)
// Update the attribute
fmeta->setField(l, field);
else
l->setProperty(attr.getName(), value);
}
};
}
// Return the object
Py_INCREF(l);
return static_cast<PyObject*>(l);
}
catch (...)
{
PythonType::evalException();
return nullptr;
}
}
Object* MetaCategory::ControllerDefault (
const MetaClass* cat, const DataValueDict& in, CommandManager* mgr
)
{
Action act = MetaClass::decodeAction(in);
switch (act)
{
case REMOVE:
throw DataException
("Entity " + cat->type + " doesn't support REMOVE action");
case CHANGE:
throw DataException
("Entity " + cat->type + " doesn't support CHANGE action");
default:
/* Lookup the class in the map of registered classes. */
const MetaClass* j;
if (cat->category)
// Class metadata passed: we already know what type to create
j = cat;
else
{
// Category metadata passed: we need to look up the type
const DataValue* type = in.get(Tags::type);
j = static_cast<const MetaCategory&>(*cat).findClass(
type ? Keyword::hash(type->getString()) : MetaCategory::defaultHash
);
if (!j)
{
string t(type ? type->getString() : "default");
throw LogicException("No type " + t + " registered for category " + cat->type);
}
}
// Call the factory method
assert(j->factoryMethod);
Object* result = j->factoryMethod();
// Run the callback methods
if (!result->getType().raiseEvent(result, SIG_ADD))
{
// Creation denied
delete result;
throw DataException("Can't create object");
}
// Report the creation to the manager
if (mgr)
mgr->add(new CommandCreateObject(result));
// Creation accepted
return result;
}
throw LogicException("Unreachable code reached");
return nullptr;
}
/** @todo this method implementation is not generic enough and not extendible by subclasses. */
PyObject* ResourceSkill::create(PyTypeObject* pytype, PyObject* args, PyObject* kwds)
{
try
{
// Pick up the skill
PyObject* skill = PyDict_GetItemString(kwds,"skill");
if (!PyObject_TypeCheck(skill, Skill::metadata->pythonClass))
throw DataException("resourceskill skill must be of type skill");
// Pick up the resource
PyObject* res = PyDict_GetItemString(kwds,"resource");
if (!PyObject_TypeCheck(res, Resource::metadata->pythonClass))
throw DataException("resourceskill resource must be of type resource");
// Pick up the priority
PyObject* q1 = PyDict_GetItemString(kwds,"priority");
int q2 = q1 ? PythonObject(q1).getInt() : 1;
// Pick up the effective dates
DateRange eff;
PyObject* eff_start = PyDict_GetItemString(kwds,"effective_start");
if (eff_start)
{
PythonObject d(eff_start);
eff.setStart(d.getDate());
}
PyObject* eff_end = PyDict_GetItemString(kwds,"effective_end");
if (eff_end)
{
PythonObject d(eff_end);
eff.setEnd(d.getDate());
}
// Create the load
ResourceSkill *l = new ResourceSkill(
static_cast<Skill*>(skill),
static_cast<Resource*>(res),
q2, eff
);
// Return the object
Py_INCREF(l);
return static_cast<PyObject*>(l);
}
catch (...)
{
PythonType::evalException();
return NULL;
}
}
void BindIntVariables(DBHandles *d, DataFeedData *df)
{
SQLRETURN r;
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_TIMESTAMP, 19, 0, df->timestamp, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_DECIMAL, 20, 8, df->highPrice, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_DECIMAL, 20, 8, df->lowPrice, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_DECIMAL, 20, 8, df->openPrice, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_DECIMAL, 20, 8, df->closePrice, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, -5, 8, 0, df->totalVol, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_INTEGER, 4, 0, df->vol, SIZE, &df->stringLength)))
throw DataException(__FILE__, __LINE__);
if (o.isOption == true || o.isFutures == true || o.useContract == true) {
if (!SQL_SUCCEEDED(r = SQLBindParameter(d->hstmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 10, 0, (SQLPOINTER) df->symbol, (SQLINTEGER) strlen(df->symbol), &df->stringLength)))
throw DataException(__FILE__, __LINE__);
}
}
DECLARE_EXPORT PyObject* readXMLdata(PyObject *self, PyObject *args)
{
// Pick up arguments
char *data;
int validate(1), validate_only(0);
PyObject *userexit = NULL;
int ok = PyArg_ParseTuple(args, "s|iiO:readXMLdata",
&data, &validate, &validate_only, &userexit);
if (!ok) return NULL;
// Free Python interpreter for other threads
Py_BEGIN_ALLOW_THREADS
// Execute and catch exceptions
try
{
if (!data) throw DataException("No input data");
XMLInputString p(data);
if (userexit) p.setUserExit(userexit);
if (validate_only!=0)
p.parse(NULL, true);
else
p.parse(&Plan::instance(), validate!=0);
}
catch (...)
{
Py_BLOCK_THREADS;
PythonType::evalException();
return NULL;
}
Py_END_ALLOW_THREADS // Reclaim Python interpreter
return Py_BuildValue(""); // Safer than using Py_None, which is not portable across compilers
}
DECLARE_EXPORT void Resource::setMaximum(double m)
{
if (m < 0)
throw DataException("Maximum capacity for resource '" + getName() + "' must be postive");
// There is already a maximum calendar.
if (size_max_cal)
{
// We update the field, but don't use it yet.
size_max = m;
return;
}
// Mark as changed
setChanged();
// Set field
size_max = m;
// Create or update a single timeline max event
for (loadplanlist::iterator oo=loadplans.begin(); oo!=loadplans.end(); oo++)
if (oo->getType() == 4)
{
// Update existing event
static_cast<loadplanlist::EventMaxQuantity *>(&*oo)->setMax(size_max);
return;
}
// Create new event
loadplanlist::EventMaxQuantity *newEvent =
new loadplanlist::EventMaxQuantity(Date::infinitePast, &loadplans, size_max);
loadplans.insert(newEvent);
}
int WriteDataToDB(DBHandles *d, DataFeedData *df)
{
SQLINTEGER stringLength = SQL_NTS;
SQLRETURN r;
//only daily data need this, because the times are jacked up so
//I just manually set it to midnight
if (o.useDaily == true)
{
char newTransactionTime[50];
char dummy[50];
sscanf(df->timestamp, "%s %s", newTransactionTime, dummy);
sprintf(df->timestamp, "%s 00:00:00", newTransactionTime);
}
r = SQLExecute(d->hstmt);
if (!SQL_SUCCEEDED(r))
{
std::string errorString;
int errorNum = ODBCError(d, errorString);
//error code denoting that the row already exists
if (errorNum == 2601 || errorNum == 2627)
return 0;
else
throw DataException(__FILE__, __LINE__);
}
return 1;
}
void SubOperation::setOwner(Operation* o)
{
if (o == owner)
// No change
return;
if (o && !o->hasSubOperations())
// Some operation types don't have suboperations
throw DataException("Operation '" + o->getName() + "' can't have suboperations");
// Remove from previous owner
if (oper && owner)
oper->removeSuperOperation(owner);
if (owner)
owner->getSubOperations().remove(this);
// Update
owner = o;
// Insert at new owner
if (oper && owner)
oper->addSuperOperation(owner);
if (owner)
{
Operation::Operationlist::iterator iter = owner->getSubOperations().begin();
while (iter != owner->getSubOperations().end() && prio >= (*iter)->getPriority())
++iter;
owner->getSubOperations().insert(iter, this);
}
}
PyObject* saveXMLfile(PyObject* self, PyObject* args)
{
// Pick up arguments
char *filename;
char *content = NULL;
int ok = PyArg_ParseTuple(args, "s|s:save", &filename, &content);
if (!ok) return NULL;
// Execute and catch exceptions
Py_BEGIN_ALLOW_THREADS // Free Python interpreter for other threads
try
{
XMLOutputFile o(filename);
if (content)
{
if (!strcmp(content,"STANDARD"))
o.setContentType(XMLOutput::STANDARD);
else if (!strcmp(content,"PLAN"))
o.setContentType(XMLOutput::PLAN);
else if (!strcmp(content,"PLANDETAIL"))
o.setContentType(XMLOutput::PLANDETAIL);
else
throw DataException("Invalid content type '" + string(content) + "'");
}
o.writeElementWithHeader(Tags::tag_plan, &Plan::instance());
}
catch (...)
{
Py_BLOCK_THREADS;
PythonType::evalException();
return NULL;
}
Py_END_ALLOW_THREADS // Reclaim Python interpreter
return Py_BuildValue("");
}
DECLARE_EXPORT void Calendar::removeBucket(CalendarBucket* bkt)
{
// Verify the bucket is on this calendar indeed
CalendarBucket *b = firstBucket;
while (b && b != bkt) b = b->nextBucket;
// Error
if (!b)
throw DataException("Trying to remove unavailable bucket from calendar '"
+ getName() + "'");
// Update the list
if (bkt->prevBucket)
// Previous bucket links to a new next bucket
bkt->prevBucket->nextBucket = bkt->nextBucket;
else
// New head for the bucket list
firstBucket = bkt->nextBucket;
if (bkt->nextBucket)
// Update the reference prevBucket of the next bucket
bkt->nextBucket->prevBucket = bkt->prevBucket;
// Delete the bucket
delete bkt;
}
QString Customizations::DataBasePath()
{
static bool cached = false;
if ( cached )
return dataBasePath_;
QList<QString> checked_paths;
QString sub_path( "lobby/SpringLobby/customizations/" );
sub_path.append( m_shortname );
for ( int i = 0; i < susynclib().GetSpringDataDirCount(); ++i ) {
QDir data ( ToQString( susynclib().GetSpringDataDirByIndex(i) ) );
checked_paths.append( data.absolutePath().append("/").append( sub_path ) );
if ( data.cd( sub_path ) ) {
dataBasePath_ = data.absolutePath();
break;
}
}
if( dataBasePath_ != QString() )
return dataBasePath_ ;
checked_paths.prepend( QString("Couldn't find customization data in any of these directories:\n ") );
throw DataException( checked_paths );
return QString();
}
int WriteOneLine(DBHandles *d, char *oneLine, boost::unordered_set<dataPoint> *hash, DataFeedData *df)
{
if (o.useTicks == true)
{
ExtractTickData(oneLine, df);
//first check the hashTable to see if it already has the data
if (o.useHashTable == true && hash != NULL)
{
dataPoint dp;
dp.date = GetUDate(df->timestamp, dateGC);
dp.tickId = atoi(df->tickId);
if (hash->find(dp) != hash->end())
return 0;
}
}
else if (o.useInterval == true || o.useDaily == true)
{
ExtractIntData(oneLine, df);
}
else
{
WriteLog("Missing useInterval or useTicks\n");
throw DataException(__FILE__, __LINE__);
}
return WriteDataToDB(d, df);
}
DECLARE_EXPORT void Load::setAlternate(Load *f)
{
// Can't be an alternate to oneself.
// No need to flag as an exception.
if (f == this) return;
// Validate the argument
if (!f)
throw DataException("Setting NULL alternate load");
if (hasAlts || f->altLoad)
throw DataException("Nested alternate loads are not allowed");
// Update both flows
f->hasAlts = true;
altLoad = f;
}
DECLARE_EXPORT void LoadPlan::setLoad(Load* newld)
{
// No change
if (newld == ld) return;
// Verify the data
if (!newld) throw DataException("Can't switch to NULL load");
if (ld && ld->getOperation() != newld->getOperation())
throw DataException("Only switching to a load on the same operation is allowed");
// Update the load and resource fields
LoadPlan* o = getOtherLoadPlan();
if (o) o->ld = newld;
ld = newld;
setResource(newld->getResource());
}
void SetupMatrixRule::setPriority(const int n)
{
if (n == priority)
return;
if (!matrix)
{
// As long as there is no matrix assigned, anything goes
priority = n;
return;
}
// Check for duplicate priorities, before making any changes
for (SetupMatrixRule *i = matrix->firstRule; i; i = i->nextRule)
if (i->priority == n)
{
ostringstream o;
o << "Rule with priority " << priority << " in setup matrix '"
<< matrix->getName() << "' already exists";
throw DataException(o.str());
}
else if (i->priority > n)
break;
// Update the field
priority = n;
// Check ordering on the left
while (prevRule && priority < prevRule->priority)
{
SetupMatrixRule* next = nextRule;
SetupMatrixRule* prev = prevRule;
if (prev->prevRule)
prev->prevRule->nextRule = this;
else
matrix->firstRule = this;
prev->nextRule = nextRule;
nextRule = prev;
prevRule = prev->prevRule;
if (next)
next->prevRule = prev;
prev->prevRule = this;
}
// Check ordering on the right
while (nextRule && priority > nextRule->priority)
{
SetupMatrixRule* next = nextRule;
SetupMatrixRule* prev = prevRule;
nextRule = next->nextRule;
if (next->nextRule)
next->nextRule->prevRule = this;
if (prev)
prev->nextRule = next;
else
matrix->firstRule = next;
next->nextRule = this;
next->prevRule = prev;
prevRule = next;
}
}
DECLARE_EXPORT void Load::setAlternateName(string n)
{
if (!getOperation())
throw LogicException("Can't set an alternate load before setting the operation");
Load *x = getOperation()->loaddata.find(n);
if (!x) throw DataException("Can't find load with name '" + n + "'");
setAlternate(x);
}
Object* MetaCategory::ControllerDefault (const MetaClass* cat, const AttributeList& in)
{
Action act = ADD;
switch (act)
{
case REMOVE:
throw DataException
("Entity " + cat->type + " doesn't support REMOVE action");
case CHANGE:
throw DataException
("Entity " + cat->type + " doesn't support CHANGE action");
default:
/* Lookup for the class in the map of registered classes. */
const MetaClass* j;
if (cat->category)
// Class metadata passed: we already know what type to create
j = cat;
else
{
// Category metadata passed: we need to look up the type
const DataElement* type = in.get(Tags::tag_type);
j = static_cast<const MetaCategory&>(*cat).findClass(*type ? Keyword::hash(type->getString()) : MetaCategory::defaultHash);
if (!j)
{
string t(*type ? type->getString() : "default");
throw LogicException("No type " + t + " registered for category " + cat->type);
}
}
// Call the factory method
Object* result = j->factoryMethodDefault();
// Run the callback methods
if (!result->getType().raiseEvent(result, SIG_ADD))
{
// Creation denied
delete result;
throw DataException("Can't create object");
}
// Creation accepted
return result;
}
throw LogicException("Unreachable code reached");
return NULL;
}
DECLARE_EXPORT void Flow::setAlternate(Flow *f)
{
// Can't be an alternate to oneself.
// No need to flag as an exception.
if (f == this) return;
// Validate the argument
if (!f)
throw DataException("Setting NULL alternate flow");
if (hasAlts || f->altFlow)
throw DataException("Nested alternate flows are not allowed");
if (f->getQuantity() > 0.0 || getQuantity() > 0.0)
throw DataException("Only consuming alternate flows are supported");
// Update both flows
f->hasAlts = true;
altFlow = f;
}
DECLARE_EXPORT void CalendarBucket::setEnd(const Date d)
{
// Check
if (d < startdate)
throw DataException("Calendar bucket end must be later than its start");
// Update
enddate = d;
}
DataTypes::dim_t FunctionSpace::getReferenceIDFromDataPointNo(DataTypes::dim_t dataPointNo) const
{
//
// Get the number of samples and data-points per sample
DataTypes::dim_t numSamples = getNumSamples();
int numDataPointsPerSample = getNumDPPSample();
const DataTypes::dim_t* referenceIDs= borrowSampleReferenceIDs();
DataTypes::dim_t numDataPoints = numSamples * numDataPointsPerSample;
if (numDataPointsPerSample==0) {
throw DataException("FunctionSpace::getReferenceIDFromDataPointNo error: no data-points associated with this object.");
}
if (dataPointNo<0 || dataPointNo>numDataPoints) {
throw DataException("FunctionSpace::getReferenceIDFromDataPointNo error: invalid data-point number supplied.");
}
DataTypes::dim_t sampleNo = dataPointNo / numDataPointsPerSample;
return referenceIDs[sampleNo];
}
DECLARE_EXPORT void Flow::setAlternateName(const string& n)
{
if (!getOperation())
throw LogicException("Can't set an alternate flow before setting the operation");
Flow *x = getOperation()->flowdata.find(n);
if (!x)
throw DataException("Can't find flow with name '" + n + "'");
setAlternate(x);
}
// FunctionSpace instances should not be overwritten to point to different domains/types
// The only time this was actually used was in constructors and the copy constructor can deal with that
FunctionSpace&
FunctionSpace::operator=(const FunctionSpace& other)
{
throw DataException("FunctionSpace::= should not be called. Programming Error.");
// explicitly defined assignment operator to emphasise pointer copy
/* m_functionSpaceType=other.m_functionSpaceType;
m_domain=other.m_domain;
return *this;*/
}
DECLARE_EXPORT void Flow::validate(Action action)
{
// Catch null operation and buffer pointers
Operation* oper = getOperation();
Buffer* buf = getBuffer();
if (!oper || !buf)
{
// This flow is not a valid one since it misses essential information
if (!oper && !buf)
throw DataException("Missing operation and buffer on a flow");
else if (!oper)
throw DataException("Missing operation on a flow with buffer '"
+ buf->getName() + "'");
else
throw DataException("Missing buffer on a flow with operation '"
+ oper->getName() + "'");
}
// Check if a flow with 1) identical buffer, 2) identical operation and
// 3) overlapping effectivity dates already exists, and 4) same
// flow type.
Operation::flowlist::const_iterator i = oper->getFlows().begin();
for (; i != oper->getFlows().end(); ++i)
if (i->getBuffer() == buf
&& i->getEffective().overlap(getEffective())
&& i->getType() == getType()
&& &*i != this)
break;
// Apply the appropriate action
switch (action)
{
case ADD:
if (i != oper->getFlows().end())
throw DataException("Flow of '" + oper->getName() + "' and '" +
buf->getName() + "' already exists");
break;
case CHANGE:
throw DataException("Can't update a flow");
case ADD_CHANGE:
// ADD is handled in the code after the switch statement
if (i == oper->getFlows().end()) break;
throw DataException("Can't update a flow between '" +
oper->getName() + "' and '" + buf->getName() + "')");
case REMOVE:
// Delete the temporary flow object
delete this;
// Nothing to delete
if (i == oper->getFlows().end())
throw DataException("Can't remove nonexistent flow of '"
+ oper->getName() + "' and '" + buf->getName() + "'");
// Delete
delete &*i;
}
// Set a flag to make sure the level computation is triggered again
HasLevel::triggerLazyRecomputation();
}
void OperationTransport::setFromBuffer(Buffer *b)
{
// Don't update the operation if operationplans already exist
if (OperationPlan::iterator(this) != OperationPlan::end())
throw DataException("Can't update an initialized transport operation");
// Create a flow
fromBuf = b;
new Flow(this, b, -1);
}
DECLARE_EXPORT void Solver::endElement(XMLInput& pIn, const Attribute& pAttr, const DataElement& pElement)
{
if (pAttr.isA(Tags::tag_loglevel))
{
int i = pElement.getInt();
if (i<0 || i>USHRT_MAX)
throw DataException("Invalid log level" + pElement.getString());
setLogLevel(i);
}
}
void Data::isReady(){
if(eof()){
throw DataException("Stream is closed!");
return;
}
if(!ready){
makeReady();
}
return;
}
