MethodResponse
Dispatcher::system_methodHelp(const MethodCall &calldata,
const Dispatcher *disp)
{
ULXR_TRACE("system_methodHelp");
if (calldata.numParams() != 1)
throw ParameterException(InvalidMethodParameterError,
"Exactly 1 parameter allowed for \"system.methodHelp\"");
if (calldata.getParam(0).getType() != RpcStrType)
throw ParameterException(InvalidMethodParameterError,
"Parameter 1 not of type \"String\" \"system.listMethods\"");
RpcString vs = calldata.getParam(0);
std::string name = vs.getString();
std::string s;
MethodCallMap::const_iterator it;
std::string s_prev;
for (it = disp->methodcalls.begin(); it != disp->methodcalls.end(); ++it)
if (name == (*it).first.method_name && (*it).first.documentation.length() != 0)
{
if ( s_prev != (*it).first.documentation
&& (*it).first.documentation.length() != 0)
{
if (s.length() != 0)
s = "* " +s + "\n* ";
s += (*it).first.documentation;
}
s_prev = (*it).first.documentation;
}
return MethodResponse (RpcString(s));
}
//---------------------------------------------------------------------------
void ObjectPropertyWrapper::SetupWrapper()
{
wxString type, owner, depobj;
GmatStringUtil::ParseParameter(description, type, owner, depobj);
#ifdef DEBUG_OPW
MessageInterface::ShowMessage
(wxT("In ObjPropWrapper::SetupWrapper, desc='%s'\n owner='%s', depobj='%s', ")
wxT("type='%s'\n"), description.c_str(), owner.c_str(), depobj.c_str(), type.c_str());
#endif
//if (depobj != wxT(""))
//{
// throw ParameterException(
// wxT("Dependent objects not yet supported for the object property wrapper \"") +
// description + wxT("\".\n"));
// /// @todo Handle object properties that use dependent objects here
//}
if (owner == wxT(""))
{
throw ParameterException(
wxT("Owner object name is empty for the object property wrapper \"") +
description + wxT("\".\n"));
}
if (type == wxT(""))
{
throw ParameterException(
wxT("Property ID string is empty for the object property wrapper \"") +
description + wxT("\".\n"));
}
refObjectNames.push_back(owner);
propIDNames.push_back(type);
ownedObjName = depobj;
}
//---------------------------------------------------------------------------
Real ObjectPropertyWrapper::EvaluateReal() const
{
if (object == NULL)
throw ParameterException(
wxT("Cannot return value of ObjectProperty - object pointer is NULL\n"));
Real itsValue;
try
{
itsValue = object->GetRealParameter(propID);
#ifdef DEBUG_OPW
MessageInterface::ShowMessage(
wxT("In ObjPropWrapper::EvaluateReal, value = %.12f\n"), itsValue);
#endif
}
catch (BaseException &be)
{
wxString errmsg;
// errmsg << wxT("Cannot return Real value for id \"") << propID;
// errmsg << wxT("\" for object \"") << object->GetName();
// errmsg << wxT("\" - exception thrown: ")<< be.GetFullMessage() << std::endl;
errmsg << be.GetFullMessage() << wxT("\n");
throw ParameterException(errmsg);
}
return itsValue;
}
MethodResponse
Dispatcher::system_listMethods(const MethodCall &calldata,
const Dispatcher *disp)
{
ULXR_TRACE("system_listMethods");
if (calldata.numParams() > 1)
throw ParameterException(InvalidMethodParameterError,
"At most 1 parameter allowed for \"system.listMethods\"");
if ( calldata.numParams() == 1
&& calldata.getParam(0).getType() != RpcStrType)
throw ParameterException(InvalidMethodParameterError,
"Parameter 1 not of type \"String\" \"system.listMethods\"");
// FIXME: what to do with param 1 if present ??
Array arr;
std::string m_prev;
MethodCallMap::const_iterator it;
for (it = disp->methodcalls.begin(); it != disp->methodcalls.end(); ++it)
if ( m_prev != (*it).first.method_name
&& (*it).first.method_name.length() != 0)
{
arr.addItem(RpcString((*it).first.method_name));
m_prev = (*it).first.method_name;
}
return MethodResponse (arr);
}
//---------------------------------------------------------------------------
bool ObjectPropertyWrapper::SetReal(const Real toValue)
{
if (object == NULL)
throw ParameterException(
wxT("Cannot set value of ObjectProperty - object pointer is NULL\n"));
try
{
#ifdef DEBUG_OPW
MessageInterface::ShowMessage(
wxT("In ObjPropWrapper::SetReal, about to set value to %.12f\n"), toValue);
#endif
object->SetRealParameter(propID, toValue);
#ifdef DEBUG_OPW
MessageInterface::ShowMessage(
wxT("In ObjPropWrapper::SetReal, value has been set to %.12f\n"), toValue);
#endif
}
catch (BaseException &be)
{
#ifdef DEBUG_OPW
MessageInterface::ShowMessage(
wxT(" exception thrown! msg = %s\n"), (be.GetFullMessage()).c_str());
#endif
wxString errmsg;
// errmsg << wxT("Cannot set Real value for id \"") << propID;
// errmsg << wxT("\" for object \"") << object->GetName();
// errmsg << wxT("\" - exception thrown: ")<< be.GetFullMessage() << std::endl;
errmsg << be.GetFullMessage() << wxT("\n");
throw ParameterException(errmsg);
}
return true;
}
//------------------------------------------------------------------------------
// void SetRvector(Integer item, const Rvector &value)
//------------------------------------------------------------------------------
void AttitudeData::SetRvector(Integer item, const Rvector &value)
{
#ifdef DEBUG_SET_RVECTOR
MessageInterface::ShowMessage
("AttitudeData::SetRvector() entered, item = %d, value = '%s'\n",
item, value.c_str());
#endif
if (mSpacecraft == NULL)
InitializeRefObjects();
Attitude *attitude = (Attitude*)mSpacecraft->GetRefObject(Gmat::ATTITUDE, "");
if (attitude == NULL)
throw ParameterException
("AttitudeData::SetRvector() Attitude of the Spacecraft \"" +
mSpacecraft->GetName() + "\" is NULL\n");
switch (item)
{
case QUATERNION:
attitude->SetRvectorParameter("Quaternion", value);
break;
default:
// otherwise, there is an error
throw ParameterException
("AttitudeData::SetString() Unknown item id: " +
GmatRealUtil::ToString(item));
}
}
//------------------------------------------------------------------------------
Real Variable::EvaluateReal()
{
#ifdef DEBUG_VARIABLE_EVAL
MessageInterface::ShowMessage
(wxT("Variable::EvaluateReal() this=<%p>'%s', mExpr=%s, mIsNumber=%d\n"),
this, GetName().c_str(), mExpr.c_str(), mIsNumber);
#endif
if (mIsNumber)
{
#ifdef DEBUG_VARIABLE_EVAL
MessageInterface::ShowMessage
(wxT("Variable::EvaluateReal() Returning just a number: mRealValue=%f\n"),
mRealValue);
#endif
return mRealValue;
}
else
{
//=======================================================
#ifdef __ALLOW_SIMPLE_VAR_EXP__
//=======================================================
try
{
// Evaluate the expression
mRealValue = mExpParser->EvalExp(mExpr.c_str());
#ifdef DEBUG_VARIABLE_EVAL
MessageInterface::ShowMessage
(wxT("Variable::EvaluateReal() Returning expression evaluation: ")
wxT("mRealValue=%f\n"), mRealValue);
#endif
return mRealValue;
}
catch (BaseException &e)
{
throw ParameterException
(e.GetFullMessage() + wxT(" for the Variable \"") + GetName() + wxT("\""));
}
//=======================================================
#endif
//=======================================================
}
// If you get here, the evaluation failed
throw ParameterException(wxT("Variable::EvaluateReal() failed for the Variable \"") +
GetName() + wxT("\""));
}
//------------------------------------------------------------------------------
Integer Array::SetIntegerParameter(const Integer id, const Integer value)
{
switch (id)
{
case NUM_ROWS:
if (value > MAX_ROWS)
{
std::stringstream errmsg("");
errmsg << "Row value for Array " << instanceName << " is too large. Arrays are currently limited to ";
errmsg << MAX_ROWS << " rows." << std::endl;
throw ParameterException(errmsg.str());
}
if (mNumRows == 0)
mNumRows = value;
else
throw ParameterException("Row has already been set for " + GetName());
if (mNumCols > 0 && !mSizeSet)
{
mRmatValue.SetSize(mNumRows, mNumCols);
mSizeSet = true;
}
return value;
case NUM_COLS:
if (value > MAX_COLS)
{
std::stringstream errmsg("");
errmsg << "Column value for Array " << instanceName << " is too large. Arrays are currently limited to ";
errmsg << MAX_COLS << " columns." << std::endl;
throw ParameterException(errmsg.str());
}
if (mNumCols == 0)
mNumCols = value;
else
throw ParameterException("Column has already been set for " + GetName());
if (mNumRows > 0 && !mSizeSet)
{
mRmatValue.SetSize(mNumRows, mNumCols);
mSizeSet = true;
}
return value;
case INITIAL_VALUE_TYPE:
mInitialValueType = value;
return value;
default:
return Parameter::SetIntegerParameter(id, value);
}
}
ResultStatus SessionInfoCube::setCellValue(PServer server, PDatabase db, PCubeArea cellPath, CellValue value, PLockedCells lockedCells, PUser user, boost::shared_ptr<PaloSession> session, bool checkArea, bool addValue, SplashMode splashMode, bool bWriteToJournal, User::RightSetting* checkRights, set<PCube> &changedCubes, bool possibleCommit, CubeArea::CellType ct)
{
if (User::checkUser(user) && user->getRoleRight(User::sysOpRight) < RIGHT_DELETE) {
throw ParameterException(ErrorException::ERROR_NOT_AUTHORIZED, "insufficient access rights to terminate session!", "user", user ? (int)user->getId() : 0);
}
if (value.isString()) {
ResultStatus result = RESULT_FAILED;
WriteLocker paloSessionLock(&PaloSession::m_main_Lock);
IdentifiersType key = *cellPath->pathBegin();
// find session
map<IdentifierType, boost::shared_ptr<PaloSession> >::iterator sessionIt = PaloSession::sessionIds.find(key[0]);
if (sessionIt != PaloSession::sessionIds.end()) {
string command = value;
if (command == string("close")) {
boost::shared_ptr<PaloSession> session = sessionIt->second;
if (session->isWorker()) {
session->command = "Invalid command:\""+command+"\"\nSVS session can't be closed";
throw ErrorException(ErrorException::ERROR_NOT_AUTHORIZED, "SVS session can't be closed");
}
session->command = command;
// terminate all session jobs
WriteLocker wl(&sessionIt->second->thisLock);
for (set<const PaloJob *>::iterator jit = sessionIt->second->activeJobs.begin(); jit != sessionIt->second->activeJobs.end(); ++jit) {
if (*jit) {
Context *jobContext = const_cast<Context *>((*jit)->getContext());
if (jobContext) {
jobContext->stop();
}
}
}
PaloSession::deleteSession(session, true);
} else {
#ifdef _DEBUG
session->command = "Invalid command:\""+command+"\"\nCommands: close - close this session";
#endif
Logger::warning << "Invalid session command. User: "******"System") << " Command: '" << command << "'" << endl;
throw ParameterException(ErrorException::ERROR_INVALID_COMMAND, "Invalid command received", "value", command);
}
Logger::info << "Session command accepted. User: "******"System") << " Command: '" << command << "'" << endl;
result = RESULT_OK;
} else {
throw ParameterException(ErrorException::ERROR_ELEMENT_NOT_FOUND, "session element not found", "element", key[0]);
}
return result;
} else {
throw ParameterException(ErrorException::ERROR_NOT_AUTHORIZED, "session info cube cannot be modified", "user", user ? (int)user->getId() : 0);
}
}
void RightsDimension::checkElementAccessRight(const User *user, CPDatabase db, RightsType minimumRight) const
{
RightsType rt = getElementAccessRight(user, db);
if (rt < minimumRight && (getDimensionType() != Dimension::CONFIG || minimumRight > RIGHT_READ)) {
throw ParameterException(ErrorException::ERROR_NOT_AUTHORIZED, "insufficient access rights", "user", (int)user->getId());
}
}
LegacyRule::LegacyRule(PEngineBase engine, CPPlanNode node) :
engine(engine), isValidPath(false), node(node)
{
Context *context = Context::getContext();
const LegacyRulePlanNode *legacyRulePlanNode = dynamic_cast<const LegacyRulePlanNode *>(node.get());
cube = legacyRulePlanNode->getCube();
db = CONST_COMMITABLE_CAST(Database, context->getParent(cube));
mem_context = context->getRulesContext();
ECube *ecube = NewEntryCube(*cube, *db, *engine, context);
CPRule rule = legacyRulePlanNode->getRule();
generateEmptyResults = node->getDefaultValue() != 0;
area.reset(new CubeArea(db, cube, *node->getArea().get()));
erule = ecube->findRule(rule->getId());
if (erule && erule->arule) {
generateSources();
} else {
stringstream msg;
msg << "rule " << rule->getId() << " not found in database " << db->getName() << ", cube " << cube->getName() << ", erule";
if (erule) {
msg << "->nr_rule: " << erule->nr_rule << ", erule->arule: NULL";
} else {
msg << ": NULL";
}
Logger::error << msg.str() << endl;
throw ParameterException(ErrorException::ERROR_RULE_NOT_FOUND, "rule not found in cube", "cube", (int)cube->getId(), "rule", (int)(erule ? erule->nr_rule : NO_IDENTIFIER));
}
}
//------------------------------------------------------------------------------
Gmat::ParameterType ObjectPropertyWrapper::GetDataType() const
{
#ifdef DEBUG_OPW
MessageInterface::ShowMessage
(wxT("ObjectPropertyWrapper::GetDataType() entered, propID = %d\n"), propID);
#endif
if (object == NULL)
throw ParameterException
(wxT("ObjectPropertyWrapper::GetDataType() The object is NULL, ")
wxT("so cannot get data type"));
Gmat::ParameterType propType = object->GetParameterType(propID);
#ifdef DEBUG_OPW
MessageInterface::ShowMessage
(wxT("ObjectPropertyWrapper::GetDataType() returning %d\n"), propType);
#endif
#ifdef DEBUG_OPW
MessageInterface::ShowMessage
(wxT("ObjectPropertyWrapper::GetDataType() returning %d\n"), propType);
#endif
return propType;
}
void CubeDimension::changeElementName(PServer server, PDatabase db, Element * element, const string& name, PUser user, bool useJournal, bool useDimWorker)
{
if (user) {
throw ParameterException(ErrorException::ERROR_DIMENSION_UNCHANGABLE, "dimension is not changable", "user", (int)user->getId());
}
return SystemDimension::changeElementName(server, db, element, name, user, useJournal, useDimWorker);
}
Element* CubeDimension::addElement(PServer server, PDatabase db, IdentifierType idElement, const string& name, Element::Type elementType, PUser user, bool useJournal)
{
if (user) {
throw ParameterException(ErrorException::ERROR_DIMENSION_UNCHANGABLE, "dimension is not changable", "user", (int)user->getId());
}
return SystemDimension::addElement(server, db, idElement, name, Element::STRING, user, useJournal);
}
//------------------------------------------------------------------------------
// virtual void InitializeRefObjects()
//------------------------------------------------------------------------------
void TimeData::InitializeRefObjects()
{
mSpacecraft = (Spacecraft*)FindFirstObject(VALID_OBJECT_TYPE_LIST[SPACECRAFT]);
if (mSpacecraft == NULL)
{
wxString scName = GetRefObjectName(Gmat::SPACECRAFT);
#ifdef DEBUG_TIMEDATA
MessageInterface::ShowMessage
(wxT("TimeData::InitializeRefObjects() Cannot find Spacecraft object named ")
wxT("\"%s\"\n"), scName.c_str());
#endif
throw ParameterException
(wxT("TimeData::InitializeRefObjects() Cannot find Spacecraft object named \"") +
scName + wxT("\"\n"));
}
else
{
if (!mIsInitialEpochSet)
{
mInitialEpoch = mSpacecraft->GetEpoch();
mIsInitialEpochSet = true;
#ifdef DEBUG_TIMEDATA
MessageInterface::ShowMessage
(wxT("TimeData::InitializeRefObjects() set mInitialEpoch to %f\n"), mInitialEpoch);
#endif
}
}
}
//------------------------------------------------------------------------------
// Rvector GetRvector(Integer item)
//------------------------------------------------------------------------------
Rvector AttitudeData::GetRvector(Integer item)
{
#ifdef DEBUG_GET_RVECTOR
MessageInterface::ShowMessage
("AttitudeData::GetRvector() entered, item = %d\n", item);
#endif
if (mSpacecraft == NULL)
InitializeRefObjects();
Real epoch = mSpacecraft->GetEpoch();
// Get cosine matrix which is internal representation and always gets updated
Rmatrix33 cosMat = mSpacecraft->GetAttitude(epoch);
Rvector quat = AttitudeConversionUtility::ToQuaternion(cosMat);
switch (item)
{
case QUATERNION:
{
return quat;
}
default:
// otherwise, there is an error
throw ParameterException
("AttitudeData::SetString() Not redable or unknown item id: " +
GmatRealUtil::ToString(item));
}
}
//------------------------------------------------------------------------------
// Rvector GetRvectorParameter(const Integer id, const Integer index) const
//------------------------------------------------------------------------------
Rvector Array::GetRvectorParameter(const Integer id, const Integer index) const
{
switch (id)
{
case ROW_VALUE:
{
Rvector rvec(mNumCols);
for (int i=0; i<mNumCols; i++)
rvec.SetElement(i, mRmatValue.GetElement(index, i));
return rvec;
}
case COL_VALUE:
{
Rvector rvec(mNumRows);
for (int i=0; i<mNumRows; i++)
rvec.SetElement(i, mRmatValue.GetElement(i, index));
return rvec;
}
default:
throw ParameterException
("Array::GetRvectorParameter() Unknown Parameter Name" + PARAMETER_TEXT[id]);
//return Parameter::GetRvectorParameter(id, index);
}
}
//---------------------------------------------------------------------------
void ArrayElementWrapper::SetupWrapper()
{
try
{
GmatStringUtil::GetArrayIndexVar(description, rowName, columnName,
arrayName);
}
catch (UtilityException &)
{
wxString errmsg = wxT("Unable to set up ArrayElementWrapper \"") +
description;
errmsg += wxT("\" - does not parse correctly as an array.\n");
throw ParameterException(errmsg);
}
#ifdef DEBUG_AE_WRAPPER
MessageInterface::ShowMessage(
wxT("AEWrapper::SetupWrapper for array named '%s' \n"), arrayName.c_str());
MessageInterface::ShowMessage(wxT(" description = %s\n"), description.c_str());
MessageInterface::ShowMessage(wxT(" rowName = %s\n"), rowName.c_str());
MessageInterface::ShowMessage(wxT(" columnName = %s\n"), columnName.c_str());
MessageInterface::ShowMessage(wxT(" arrayName = %s\n"), arrayName.c_str());
#endif
// for now, put the array name in the list of reference objects - add
// all the other stuff when GetRefObjectNames is called
refObjectNames.push_back(arrayName);
}
//---------------------------------------------------------------------------
bool ObjectPropertyWrapper::RenameObject(const wxString &oldName,
const wxString &newName)
{
ElementWrapper::RenameObject(oldName, newName);
// now rebuild the description string from the refObjectNames
Integer pos = description.find(wxT("."));
if (description.find(wxT(".")) != wxString::npos)
{
#ifdef DEBUG_RENAME_OBJ_PROP
MessageInterface::ShowMessage(
wxT("Found a dot at position %d in the description string %s\n"),
(Integer) pos, description.c_str());
#endif
description.replace(0,pos,refObjectNames[0]);
#ifdef DEBUG_RENAME_OBJ_PROP
MessageInterface::ShowMessage(
wxT("--- replacing with %s\n"), (refObjectNames[0]).c_str());
MessageInterface::ShowMessage(
wxT("--- and now description is %s\n"), description.c_str());
#endif
}
else // this shouldn't happen, but ...
{
wxString errmsg =
wxT("Expecting a \".\" in the description for object property \"");
errmsg += description + wxT(" \"");
throw ParameterException(errmsg);
}
return true;
}
//------------------------------------------------------------------------------
bool Variable::SetRefObjectName(const Gmat::ObjectType type,
const wxString &name)
{
#ifdef DEBUG_VARIABLE_SET
MessageInterface::ShowMessage
(wxT("Variable::SetRefObjectName() this=<%p>'%s', type=%d, name=%s\n"), this,
GetName().c_str(), type, name.c_str());
#endif
if (type != Gmat::PARAMETER)
{
throw ParameterException
(wxT("Variable::SetRefObjectName() ") + GmatBase::GetObjectTypeString(type) +
wxT(" is not valid object type of ") + this->GetTypeName() + wxT("\n"));
}
#ifdef DEBUG_VARIABLE_SET
MessageInterface::ShowMessage
(wxT(" Adding '%s' to '%s' parameter database\n"), name.c_str(), GetName().c_str());
#endif
#ifdef __ALLOW_SIMPLE_VAR_EXP__
mParamDb->Add(name);
#endif
return true;
}
void CubeDimension::deleteElement(PServer server, PDatabase db, Element * element, PUser user, bool useJournal, CubeRulesArray* disabledRules, bool useDimWorker)
{
if (user) {
throw ParameterException(ErrorException::ERROR_DIMENSION_UNCHANGABLE, "dimension is not changable", "user", (int)user->getId());
}
return SystemDimension::deleteElement(server, db, element, user, useJournal, disabledRules, useDimWorker);
}
//------------------------------------------------------------------------------
// const StringArray& GetRefObjectNameArray(const Gmat::ObjectType type)
//------------------------------------------------------------------------------
const StringArray& Variable::GetRefObjectNameArray(const Gmat::ObjectType type)
{
//=======================================================
#ifdef __ALLOW_SIMPLE_VAR_EXP__
//=======================================================
if (mParamDb == NULL)
throw ParameterException
(wxT("Variable::GetRefObjectNameArray() mParamDb is NULL\n"));
#ifdef DEBUG_REF_OBJ
MessageInterface::ShowMessage
(wxT("Variable::GetRefObjectNameArray() type=%d\n"), type);
StringArray paramNames = mParamDb->GetNamesOfParameters();
MessageInterface::ShowMessage
(wxT("Variable::GetStringArrayParameter() mParamDb->GetNamesOfParameters() ")
wxT("size=%d\n"), paramNames.size());
for (unsigned int i=0; i<paramNames.size(); i++)
MessageInterface::ShowMessage
(wxT("Variable::GetStringArrayParameter() ")
wxT("paramNames[%d]=%s\n"), i, paramNames[i].c_str());
#endif
return mParamDb->GetNamesOfParameters();
//=======================================================
#else
//=======================================================
static StringArray objectNames;
return objectNames;
//=======================================================
#endif
//=======================================================
}
void CubeDimension::changeElementType(PServer server, PDatabase db, Element * element, Element::Type elementType, PUser user, bool setConsolidated, CubeRulesArray* disabledRules, IdentifiersType *elemsToDeleteFromCubes, bool doRemove)
{
if (user) {
throw ParameterException(ErrorException::ERROR_DIMENSION_UNCHANGABLE, "dimension is not changable", "user", (int)user->getId());
}
return SystemDimension::changeElementType(server, db, element, Element::STRING, user, setConsolidated, disabledRules, elemsToDeleteFromCubes, doRemove);
}
void FlowManager::set_scheduler_type(const PortId port, const std::string type)
{
std::unique_lock<std::mutex> lock(mutex_);
if (port != DEFAULT_BELOW_PORT_ID)
throw ParameterException("Defining a scheduler for given lower layer port is not supported at the moment.");
schedulers_[port] = SchedulerFactory::make_scheduler(type);
}
Value MethodCall::getParam(unsigned ind) const
{
if (ind < params.size() )
return params[ind];
throw ParameterException(InvalidMethodParameterError,
"MethodCall::getParam: Parameter index " + toString(ind) + " in " + getSignature() + " method is out-of-range.");
}
MethodResponse
Dispatcher::xml_pretty_print(const MethodCall &calldata,
const Dispatcher *disp)
{
ULXR_TRACE("xml_pretty_print");
if (calldata.numParams() > 1)
throw ParameterException(InvalidMethodParameterError,
"At most 1 parameter allowed for \"system.listMethods\"");
if ( calldata.numParams() == 1
&& calldata.getParam(0).getType() != RpcBoolean)
throw ParameterException(InvalidMethodParameterError,
"Parameter 1 not of type \"Boolean\" \"ulxmlrpcpp.xml_pretty_print\"");
bool enable = Boolean(calldata.getParam(0)).getBoolean();
enableXmlPrettyPrint(enable);
return MethodResponse (Void());
}
ULXR_API_IMPL(Value) MethodCall::getParam(unsigned ind) const
{
if (ind < params.size() )
return params[ind];
throw ParameterException(InvalidMethodParameterError,
ulxr_i18n(ULXR_PCHAR("Not enough actual parameters for call to method: ")
+getSignature()));
}
//------------------------------------------------------------------------------
void BooleanWrapper::SetupWrapper()
{
if (GmatStringUtil::ToBoolean(description, value) == false)
{
std::string errmsg = "For Boolean wrapper \"";
errmsg += description;
errmsg += "\", the description string does not evaluate to Boolean\n";
throw ParameterException(errmsg);
}
}
//------------------------------------------------------------------------------
// Real GetRealParameter(const Integer id, const Integer index)
//------------------------------------------------------------------------------
Real Array::GetRealParameter(const Integer id, const Integer index) const
{
switch (id)
{
case SINGLE_VALUE:
return mRmatValue.GetElement(0, index);
default:
throw ParameterException
("Array::GetRealParameter() Unknown Parameter Name" + PARAMETER_TEXT[id]);
}
}
MethodCall& /**/ MethodCall::setParam (unsigned ind, const Value &val)
{
if (ind < params.size() )
{
params[ind] = val;
return *this;
}
throw ParameterException(InvalidMethodParameterError,
"MethodCall::setParam: Parameter index " + toString(ind) + " in " + getSignature() + " method is out-of-range");
}
