int
main(int ac, char* av[])
{
std::string sim_dir("");
std::string desc_path("description.txt");
std::string chain_path("chain.txt");
std::string sim_path("sim.txt");
std::string result_dir("results/");
std::string world_path("world.txt");
std::string result_path("results");
time_t nowt = time(0);
std::string now = boost::lexical_cast<std::string>(nowt);
std::string txt_end(".txt");
result_path = result_path + now + txt_end;
struct sim_settings sets = _DEFAULT_SETS;
boost::program_options::variables_map vm;
if (!parse_options(ac, av, vm, sets))
{
return 1;
}
/* Check to make sure the simulation directory and all of its components
* exist
*/
if ( (sets.sim_dir.length() == 0)
|| (! boost::filesystem::is_directory(sets.sim_dir)))
{
std::cerr << "The simululation directory ('"
<< sets.sim_dir
<< "') specified by --dir must exist!" << std::endl;
return 1;
}
/* Make sure the directory path ends with a path delimeter */
if (! (sets.sim_dir.at(sets.sim_dir.length()-1) == DELIMITER))
{
sets.sim_dir.push_back(DELIMITER);
}
sets.desc_path = sets.sim_dir + sets.desc_path;
sets.chain_path = sets.sim_dir + sets.chain_path;
sets.sim_path = sets.sim_dir + sets.sim_path;
sets.result_dir = sets.sim_dir + sets.result_dir;
sets.result_path = sets.result_dir + result_path;
sets.world_path = sets.sim_dir + world_path;
if (! boost::filesystem::is_regular_file(sets.desc_path))
{
std::cerr << "The description file does not exist. ("
<< sets.desc_path
<< ")" << std::endl;
return 1;
}
if (! boost::filesystem::is_regular_file(sets.chain_path))
{
std::cerr << "The chain file does not exist. ( " <<
sets.chain_path << ")" << std::endl;
return 1;
}
if (! boost::filesystem::is_regular_file(sets.sim_path))
{
std::cerr << "The simulation file does not exist. ( " <<
sets.sim_path << ")" << std::endl;
return 1;
}
/* Verify and (if needed) create the result directory */
if (! boost::filesystem::is_directory(sets.result_dir))
{
std::cerr << "The result directory doesn't exist yet...creating...";
try
{
boost::filesystem::create_directory(sets.result_dir);
std::cerr << "Last char is: "
<< sets.sim_dir.at(sets.sim_dir.length()-1) << std::endl;
}
catch (std::exception& e)
{
std::cerr << "Error: " << e.what() << std::endl;
return 1;
}
catch (...)
{
std::cerr << "Unknown error occured while creating directory" << std::endl;
return 1;
}
std::cout << "Success!" << std::endl;
}
/* If we're using collisions, make sure the world.txt file exists in
* the simulation directory.
*/
if (sets.collisions && (! boost::filesystem::is_regular_file(sets.world_path)))
{
std::cerr << "You asked to use collisions and the world file ("
<< sets.world_path << ") does not exist." << std::endl;
return 1;
}
Json::Value result_root;
boost::shared_ptr<ckbot::CK_ompl> rate_machine_p;
rate_machine_p = load_ckbot_rate_machine(sets, result_root);
if (!rate_machine_p) {
std::cerr << "Error loading the rate machine. Exiting." << std::endl;
return 1;
}
report_setup(&sets);
boost::shared_ptr<oc::SimpleSetup> ss_p;
ss_p = load_and_run_simulation(rate_machine_p, std::cout, sets, result_root);
if (!ss_p)
{
std::cerr << "Error loading simulation...exiting." << std::endl;
return 1;
}
/* Write the results to file in Json format */
std::ofstream result_file;
result_file.open((char*)sets.result_path.c_str());
result_file << result_root;
result_file.close();
return 0;
}
CORBA::OperationDef_ptr
TAO_InterfaceDef_i::create_operation_i (const char *id,
const char *name,
const char *version,
CORBA::IDLType_ptr result,
CORBA::OperationMode mode,
const CORBA::ParDescriptionSeq ¶ms,
const CORBA::ExceptionDefSeq &exceptions,
const CORBA::ContextIdSeq &contexts)
{
// This will throw an exception if a name clash is found.
// create_common() will check for all other errors.
this->check_inherited (name,
CORBA::dk_Operation);
TAO_Container_i::tmp_name_holder_ = name;
ACE_Configuration_Section_Key new_key;
// Common to all IR objects created in CORBA::Container.
ACE_TString path =
TAO_IFR_Service_Utils::create_common (CORBA::dk_Interface,
CORBA::dk_Operation,
this->section_key_,
new_key,
this->repo_,
id,
name,
&TAO_Container_i::same_as_tmp_name,
version,
"ops");
// Get the TypeCode for the return type.
ACE_TString result_path (TAO_IFR_Service_Utils::reference_to_path (result));
TAO_IDLType_i *result_impl =
TAO_IFR_Service_Utils::path_to_idltype (result_path,
this->repo_);
CORBA::TypeCode_var rettype =
result_impl->type_i ();
CORBA::TCKind kind = rettype->kind ();
// Oneway operations cannot have a non-void return type.
if (mode == CORBA::OP_ONEWAY && kind != CORBA::tk_void)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
this->repo_->config ()->set_string_value (new_key,
"result",
result_path);
// Store the operation mode.
this->repo_->config ()->set_integer_value (new_key,
"mode",
mode);
CORBA::ULong i = 0;
// Store the operation's parameter info.
CORBA::ULong length = params.length ();
if (length > 0)
{
ACE_Configuration_Section_Key params_key;
this->repo_->config ()->open_section (new_key,
"params",
1,
params_key);
this->repo_->config ()->set_integer_value (params_key,
"count",
length);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
// Oneway operations cannot have INOUT or OUT parameters.
if (mode == CORBA::OP_ONEWAY && params[i].mode != CORBA::PARAM_IN)
{
throw CORBA::BAD_PARAM (31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key param_key;
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->open_section (params_key,
stringified,
1,
param_key);
this->repo_->config ()->set_string_value (param_key,
"name",
params[i].name.in ());
type_path =
TAO_IFR_Service_Utils::reference_to_path (
params[i].type_def.in ()
);
this->repo_->config ()->set_string_value (param_key,
"type_path",
type_path);
this->repo_->config ()->set_integer_value (param_key,
"mode",
params[i].mode);
}
}
// Store the operation's exception info.
length = exceptions.length ();
if (length > 0)
{
// Oneway operations cannot throw any user exceptions.
if (mode == CORBA::OP_ONEWAY)
{
throw CORBA::BAD_PARAM (CORBA::OMGVMCID | 31, CORBA::COMPLETED_NO);
}
ACE_Configuration_Section_Key excepts_key;
this->repo_->config ()->open_section (new_key,
"excepts",
1,
excepts_key);
char *type_path = 0;
for (i = 0; i < length; ++i)
{
type_path =
TAO_IFR_Service_Utils::reference_to_path (exceptions[i]);
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (excepts_key,
stringified,
type_path);
}
}
// Store the operation's context info.
length = contexts.length ();
if (length > 0)
{
ACE_Configuration_Section_Key contexts_key;
this->repo_->config ()->open_section (new_key,
"contexts",
1,
contexts_key);
for (i = 0; i < length; ++i)
{
char *stringified = TAO_IFR_Service_Utils::int_to_string (i);
this->repo_->config ()->set_string_value (contexts_key,
stringified,
contexts[i].in ());
}
}
// Create the object reference.
CORBA::Object_var obj =
TAO_IFR_Service_Utils::create_objref (CORBA::dk_Operation,
path.c_str (),
this->repo_);
CORBA::OperationDef_var retval =
CORBA::OperationDef::_narrow (obj.in ());
return retval._retn ();
}
