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 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));
   }
}

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: " << (user ? user->getName() : "System") << " Command: '" << command << "'" << endl;
				throw ParameterException(ErrorException::ERROR_INVALID_COMMAND, "Invalid command received", "value", command);
			}
			Logger::info << "Session command accepted. User: " << (user ? user->getName() : "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));
	}
}

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);
}

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.");
}

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);
   }
}