int
DT_Creator::init (int argc, ACE_TCHAR *argv [])
{
gsf_ = ACE_High_Res_Timer::global_scale_factor ();
state_lock_ = new ACE_Lock_Adapter <TAO_SYNCH_MUTEX>;
shutdown_lock_ = new ACE_Lock_Adapter <TAO_SYNCH_MUTEX>;
active_dt_count_ = 0;
active_job_count_ = 0;
ACE_NEW_RETURN (log, char*[BUFSIZ * 100],-1);
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR* current_arg = 0;
dt_count_ = 0;
poa_count_ = 0;
int poa_count = 0;
job_count_ = 0;
int job_count = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-GuidSeed"))))
{
guid_counter = (long) ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-DT_Count"))))
{
dt_count_ = ACE_OS::atoi (current_arg);
ACE_NEW_RETURN (dt_list_, Thread_Task*[dt_count_], -1);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-POA_Count"))))
int
TAO_Notify_Lanes_Supplier_Client::parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Consumers")))) // Number of consumers that we need to send an event to.
{
if (current_arg != 0)
{
this->consumer_count_ = ACE_OS::atoi (current_arg);
}
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-IORoutput")))) // The file to output the supplier ior to.
{
if (current_arg != 0)
{
this->ior_file_name_ = current_arg;
}
arg_shifter.consume_arg ();
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
void
Activity::create_started_flag_file (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR* current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Started_Flag"))))
{
FILE *file = ACE_OS::fopen (current_arg, ACE_TEXT("w"));
if (file == 0)
ACE_ERROR ((LM_ERROR,
"Unable to open %s for writing: %p\n",
current_arg));
ACE_OS::fprintf (file, "ignore");
ACE_OS::fclose (file);
arg_shifter.consume_arg ();
}
else
{
arg_shifter.ignore_arg ();
}
}
}
int
Gateway::parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
const ACE_TCHAR *arg = arg_shifter.get_current ();
if (ACE_OS::strcmp (arg, ACE_TEXT("-s")) == 0)
{
arg_shifter.consume_arg ();
supplierec = arg_shifter.get_current ();
}
if (ACE_OS::strcmp (arg, ACE_TEXT("-c")) == 0)
{
arg_shifter.consume_arg ();
consumerec = arg_shifter.get_current ();
}
arg_shifter.ignore_arg ();
}
// Indicates successful parsing of the command line
return 0;
}
int
parse_args (int argc, char *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
if (arg_shifter.cur_arg_strncasecmp("-?") == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"usage: %s "
"\n",
argv [0]),
-1);
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
void
SubDriver::parse_args(int& argc, char* argv[])
{
// Command-line arguments:
//
// -n <num samples to send>
// -d <data size>
// -p <pub_id:pub_host:pub_port>
// -s <sub_id:sub_host:sub_port>
//
ACE_Arg_Shifter arg_shifter(argc, argv);
bool flag_n = false;
bool flag_d = false;
bool flag_p = false;
bool flag_s = false;
const char* current_arg = 0;
while (arg_shifter.is_anything_left())
{
if ((current_arg = arg_shifter.get_the_parameter("-n")))
{
this->parse_arg_n(current_arg, flag_n);
arg_shifter.consume_arg();
}
else if ((current_arg = arg_shifter.get_the_parameter("-d")))
{
this->parse_arg_d(current_arg, flag_d);
arg_shifter.consume_arg();
}
else if ((current_arg = arg_shifter.get_the_parameter("-p")))
{
this->parse_arg_p(current_arg, flag_p);
arg_shifter.consume_arg();
}
else if ((current_arg = arg_shifter.get_the_parameter("-s")))
{
this->parse_arg_s(current_arg, flag_s);
arg_shifter.consume_arg();
}
else if (arg_shifter.cur_arg_strncasecmp("-?") == 0)
{
this->print_usage(argv[0]);
arg_shifter.consume_arg();
throw TestException();
}
else
{
arg_shifter.ignore_arg();
}
}
this->required_arg('n', flag_n);
this->required_arg('d', flag_d);
this->required_arg('p', flag_p);
this->required_arg('s', flag_s);
}
bool
OpenDDS_Domain_Manager::parse_args (int & argc, ACE_TCHAR * argv [])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR *current = 0;
// Ignore the command - argv[0].
arg_shifter.ignore_arg ();
int transport_impl_id_; // transport switching not implemented for OpenDDS 3.x
while (arg_shifter.is_anything_left ())
{
if ((current = arg_shifter.get_the_parameter (ACE_TEXT("-t"))) != 0)
{
if (ACE_OS::strcmp (current, ACE_TEXT("udp")) == 0)
{
transport_impl_id_ = 2;
}
else if (ACE_OS::strcmp (current,
ACE_TEXT("multicast")) == 0)
{
transport_impl_id_ = 3;
}
else if (ACE_OS::strcmp (current,
ACE_TEXT("default_tcp")) == 0)
{
transport_impl_id_ = 4; //OpenDDS::DCPS::DEFAULT_TCP_ID;
}
else if (ACE_OS::strcmp (current,
ACE_TEXT("default_udp")) == 0)
{
transport_impl_id_ = 5; //OpenDDS::DCPS::DEFAULT_UDP_ID;
}
else if (ACE_OS::strcmp (current,
ACE_TEXT("default_multicast")) == 0)
{
transport_impl_id_ = 6; //OpenDDS::DCPS::DEFAULT_MULTICAST_ID;
}
else
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("Unkown value %s for -t option.\n"),
current));
return false;
}
arg_shifter.consume_arg ();
}
else
{
arg_shifter.ignore_arg ();
}
}
return true;
}
/// parse the command line arguments
int parse_args (int argc, ACE_TCHAR *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -t use_take?1:0 defaults to 0
// -i num_ops_per_thread defaults to 1
// -l num_unlively_periods defaults to 10
// -r num_datareaders defaults to 1
// -n max_samples_per_instance defaults to INFINITE
// -d history.depth defaults to 1
// -z verbose transport debug
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
num_ops_per_thread = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-l"))) != 0)
{
num_unlively_periods = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-t"))) != 0)
{
use_take = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-n"))) != 0)
{
max_samples_per_instance = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-d"))) != 0)
{
history_depth = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-z")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
/// parse the command line arguments
int parse_args (int argc, char *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -t use_take?1:0 defaults to 0
// -i num_reads_per_thread defaults to 1
// -r num_datareaders defaults to 1
// -m multiple_instances?1:0 defaults to 0
// -n max_samples_per_instance defaults to INFINITE
// -d history.depth defaults to 1
const char *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter("-t")) != 0)
{
use_take = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-m")) != 0)
{
multiple_instances = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-i")) != 0)
{
num_reads_per_thread = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-r")) != 0)
{
num_datareaders = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-n")) != 0)
{
max_samples_per_instance = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-d")) != 0)
{
history_depth = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
static void
consume_arg (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
if (arg_shifter.is_anything_left ())
arg_shifter.consume_arg (1);
// Once we initialize an arg_shifter, we must iterate through it all!
while ((arg_shifter.is_anything_left ()))
arg_shifter.ignore_arg (1);
}
/// parse the command line arguments
int parse_args (int argc, ACE_TCHAR *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -d history.depth defaults to 1
// -s subscriber transport address defaults to localhost:23456
// -m num_instances_per_writer defaults to 1
// -i num_samples_per_instance defaults to 1
// -z length of float sequence in data type defaults to 10
// -y read operation interval defaults to 0
// -k data type has no key flag defaults to 0 - has key
// -f mixed transport test flag defaults to 0 - single transport test
// -o directory of synch files used to coordinate publisher and subscriber
// defaults to current directory.
// -v verbose transport debug
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-s"))) != 0)
{
//Maximum two addresses.
static size_t i = 0;
reader_address_str[i] = currentArg;
i++;
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-m"))) != 0)
{
num_instances_per_writer = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
num_samples_per_instance = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-v")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
Client_Options::Client_Options (int &argc, ACE_TCHAR *argv[])
: ior (ACE_TEXT("file://test.ior"))
, iterations (1000)
, nthreads (0)
, high_priority_period (0)
, high_priority_workload (0)
, low_priority_period (0)
, low_priority_workload (0)
, low_priority_consumers (0)
, dump_history (0)
, use_rt_corba (0)
, global_low_priority_rate (0)
, unique_low_priority_event (0)
, funky_supplier_publication (0)
, high_priority_is_last (0)
{
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
const ACE_TCHAR *arg = arg_shifter.get_current ();
if (ACE_OS::strcmp (arg, ACE_TEXT("-k")) == 0)
{
arg_shifter.consume_arg ();
if (arg_shifter.is_parameter_next ())
{
this->ior = arg_shifter.get_current ();
arg_shifter.consume_arg ();
}
}
else if (option (arg_shifter, ACE_TEXT("-i"), iterations)) {}
else if (option (arg_shifter, ACE_TEXT("-n"), nthreads)) {}
else if (option (arg_shifter, ACE_TEXT("-h"), high_priority_period)) {}
else if (option (arg_shifter, ACE_TEXT("-l"), low_priority_period)) {}
else if (option (arg_shifter, ACE_TEXT("-w"), low_priority_workload)) {}
else if (option (arg_shifter, ACE_TEXT("-v"), high_priority_workload)) {}
else if (option (arg_shifter, ACE_TEXT("-c"), low_priority_consumers)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-d"), dump_history)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-r"), use_rt_corba)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-g"), global_low_priority_rate)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-u"), unique_low_priority_event)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-f"), funky_supplier_publication)) {}
else if (boolean_option (arg_shifter, ACE_TEXT("-x"), high_priority_is_last)) {}
else
{
arg_shifter.ignore_arg ();
}
}
}
int
IdAssignment::parse_args (int argc,
ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT ("-iter"))))
{
this->iter_ = ACE_OS::atoi (current_arg);
// The number of times to repeat the test.
arg_shifter.consume_arg ();
}
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT ("-ec_count"))))
{
this->ec_count_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT ("-ca_count"))))
{
this->consumer_admin_count_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT ("-sa_count"))))
{
this->supplier_admin_count_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT ("-?")) == 0)
{
ACE_DEBUG((LM_DEBUG,
"usage: %s "
"-iter <count>",
"-ec_count <count>",
"-ca_count <count>",
"-sa_count <count>\n",
argv[0]));
arg_shifter.consume_arg ();
return -1;
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
int
TAO_Notify_ThreadPool_Supplier_Client::parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Consumers")))) // Number of consumers that we need to send an event to.
{
if (current_arg != 0)
{
this->consumer_count_ = ACE_OS::atoi (current_arg);
}
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-EventChannel_ThreadPool")))) // Specify a threadpool.
{
this->ec_thread_count_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-ProxyConsumer_ThreadPool")))) // Specify a threadpool.
{
this->proxy_consumer_thread_count_= ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-IORoutput")))) // The file to output the supplier ior to.
{
if (current_arg != 0)
{
this->ior_file_name_ = current_arg;
}
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-MaxEvents")))) // Max Events
{
this->max_events_ = ACE_OS::atoi (arg_shifter.get_current ());
arg_shifter.consume_arg ();
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
void
Logger_Service::parse_args (int argc, ACE_TCHAR **argv)
{
DANCE_TRACE ("Logger_Service::parse_args");
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
const ACE_TCHAR *current_arg = 0;
if (0 != (current_arg =
arg_shifter.get_the_parameter
(ACE_TEXT ("-DAnCELogLevel"))))
{
DAnCE_debug_level = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 == arg_shifter.cur_arg_strncasecmp
(ACE_TEXT ("-DAnCETraceEnable")))
{
this->trace_ = true;
arg_shifter.consume_arg ();
}
else if (0 != (current_arg =
arg_shifter.get_the_parameter
(ACE_TEXT ("-DAnCELogFile"))))
{
this->filename_ = current_arg;
arg_shifter.consume_arg ();
}
else if (0 != (current_arg =
arg_shifter.get_the_parameter
(ACE_TEXT ("-DAnCELogBackend"))))
{
this->backend_ = current_arg;
arg_shifter.consume_arg ();
}
else
{
// Can't interpret this argument. Move on to the next
// argument. Any arguments that don't match are ignored
// so that the caller can still use them.
arg_shifter.ignore_arg ();
}
}
}
/// parse the command line arguments
int parse_args (int argc, ACE_TCHAR *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -i num_samples_per_instance defaults to 1
// -w num_datawriters defaults to 1
// -m num_instances_per_writer defaults to 1
// -p pub transport address defaults to localhost:23456
// -z length of float sequence in data type defaults to 10
// -v verbose transport debug
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-m"))) != 0)
{
num_instances_per_writer = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
num_samples_per_instance = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-p"))) != 0)
{
writer_address_str = currentArg;
writer_address_given = 1;
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-v")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
int
TAO_Trading_Loader::parse_args (int &argc, ACE_TCHAR *argv [])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
const ACE_TCHAR *current_arg = arg_shifter.get_current ();
if (ACE_OS::strcmp (current_arg,
ACE_TEXT("-TSfederate")) == 0)
{
arg_shifter.consume_arg ();
this->federate_ = 1;
}
if (ACE_OS::strcmp (current_arg,
ACE_TEXT("-TSdumpior")) == 0)
{
arg_shifter.consume_arg ();
if (arg_shifter.is_parameter_next ())
{
const ACE_TCHAR *file_name =
arg_shifter.get_current ();
this->ior_output_file_ =
ACE_OS::fopen (file_name, ACE_TEXT("w"));
if (this->ior_output_file_ == 0)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Unable to open %s for writing: %p\n",
file_name), -1);
arg_shifter.consume_arg ();
}
else
this->ior_output_file_ =
ACE_OS::fdopen (ACE_STDOUT,
ACE_TEXT("w"));
}
else
arg_shifter.ignore_arg ();
}
return 0;
}
/// parse the command line arguments
int parse_args (int argc, char *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -t threshold liveliness lost defaults to 1000
// -l lease duration defaults to 10
// -x test duration in sec defaults to 40
// -z verbose transport debug
const char *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter("-l")) != 0)
{
LEASE_DURATION_SEC = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-t")) != 0)
{
threshold_liveliness_lost = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter("-x")) != 0)
{
test_duration = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp("-z") == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
int
TAO_EC_TPC_Factory::init (int argc, ACE_TCHAR* argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
const ACE_TCHAR *arg = arg_shifter.get_current ();
if (ACE_OS::strcasecmp (arg, ACE_TEXT("-ECDispatching")) == 0)
{
arg_shifter.consume_arg ();
if (arg_shifter.is_parameter_next ())
{
// Here we print out a message indicating that this
// option isn't valid with this factory and that it's
// being ignored.
ORBSVCS_DEBUG ((LM_ERROR,
"EC_TPC_Factory - "
"-ECDispatching not supported with TPC_Factory; ignoring the option and using thread-per-consumer dispatch strategy\n"));
arg_shifter.consume_arg ();
}
}
if (ACE_OS::strcasecmp (arg, ACE_TEXT("-ECTPCDebug")) == 0)
{
arg_shifter.consume_arg ();
++TAO_EC_TPC_debug_level;
}
else
{
arg_shifter.ignore_arg ();
}
}
return TAO_EC_Default_Factory::init (argc, argv);
}
int parse_args(int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter(argc, argv);
while (arg_shifter.is_anything_left())
{
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-k"))) != 0) {
ior = currentArg;
arg_shifter.consume_arg();
} else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-h")) == 0) {
print_usage();
return 1;
} else {
arg_shifter.ignore_arg();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
int
TAO_Notify_Tests_Command_Builder::init (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
ACE_CString current_arg;
TAO_Notify_Tests_Command_Factory* factory = 0;
if (arg_shifter.is_anything_left ())
{
current_arg = ACE_TEXT_ALWAYS_CHAR(arg_shifter.get_current ());
arg_shifter.consume_arg ();
// obtain the factory
if (this->factory_map_.find (current_arg, factory) == -1)
ACE_DEBUG ((LM_DEBUG, "NS Command: %s not recognized!\n", current_arg.c_str ()));
else
{
TAO_Notify_Tests_Command* new_command = factory->create ();
new_command->init (arg_shifter);
if (this->start_command_ == 0)
{
this->start_command_ = new_command;
this->last_command_ = new_command;
}
else
{
// linked list
this->last_command_->next (new_command);
this->last_command_ = new_command;
}
}
}
return 0;
}
int
LifeCycle::parse_args (int argc,
ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc,
argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-count"))))
{
this->count_ = ACE_OS::atoi (current_arg);
// The number of times to create and destroy.
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
{
ACE_DEBUG ((LM_DEBUG,
"usage: %s "
"-count testcount\n",
argv[0],
argv[0]));
arg_shifter.consume_arg ();
return -1;
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
void
SubDriver::parse_args(int& argc, ACE_TCHAR* argv[])
{
// Command-line arguments:
//
//
ACE_Arg_Shifter arg_shifter(argc, argv);
const ACE_TCHAR* current_arg = 0;
while (arg_shifter.is_anything_left())
{
if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-n"))) != 0)
{
num_writes_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-l"))) != 0)
{
receive_delay_msec_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
// The '-?' option
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-?")) == 0) {
ACE_DEBUG((LM_DEBUG,
"usage: %s\n",
argv[0]));
arg_shifter.consume_arg();
throw TestException();
}
// Anything else we just skip
else {
arg_shifter.ignore_arg();
}
}
}
int
Simple_Test::parse_args (int argc,
ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc,
argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-events"))))
{
this->event_count_ = ACE_OS::atoi (current_arg);
// The number of events to send/receive.
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
{
ACE_DEBUG ((LM_DEBUG,
"usage: %s "
"-events event_count\n",
argv[0],
argv[0]));
arg_shifter.consume_arg ();
return -1;
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
int
AdminProperties::parse_args(int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-max_queue_length"))))
{
this->max_queue_length_ = ACE_OS::atoi (current_arg);
// Max. queue length.
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-max_consumers"))))
{
this->max_consumers_ = ACE_OS::atoi (current_arg);
// Max consumers allowed to connect.
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-max_suppliers"))))
{
this->max_suppliers_ = ACE_OS::atoi (current_arg);
// Max. number of suppliers allowed to connect.
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-reject_new_events")) == 0)
{
this->reject_new_events_ = 1;
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-consumers"))))
{
this->consumers_ = ACE_OS::atoi (current_arg);
// Number of consumers to create.
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-suppliers"))))
{
this->suppliers_ = ACE_OS::atoi (current_arg);
// Number of suppliers to create.
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
{
ACE_DEBUG((LM_DEBUG,
"usage: %s "
"-max_queue_length [max_queue_length] "
"-max_consumers [max_consumers] "
"-max_suppliers [max_suppliers] "
"-reject_new_events [reject_new_events] "
"-consumers [consumers] "
"-suppliers [suppliers] "
"-event_count [event_count] ",
argv[0],
argv[0]));
arg_shifter.consume_arg ();
return -1;
}
else
{
arg_shifter.ignore_arg ();
}
}
return 0;
}
/// parse the command line arguments
int parse_args (int argc, ACE_TCHAR *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS) ;
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS) ;
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ())
{
// options:
// -c expect compatibility defaults to false
// -d durability kind defaults to TRANSIENT_LOCAL_DURABILITY_QOS
// -k liveliness kind defaults to AUTOMATIC_LIVELINESS_QOS
// -l lease duration no default
// -r reliability kind defaults to TRANSIENT_LOCAL_DURABILITY_QOS
// -x test duration in sec defaults to 40
// -z verbose transport debug
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-c"))) != 0)
{
compatible = (ACE_TString(currentArg) == ACE_TEXT ("true"));
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-d"))) != 0)
{
durability_kind_str = currentArg;
durability_kind = ::get_durability_kind(durability_kind_str);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-k"))) != 0)
{
liveliness_kind_str = currentArg;
liveliness_kind = ::get_liveliness_kind(liveliness_kind_str);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-l"))) != 0)
{
LEASE_DURATION_STR = currentArg;
LEASE_DURATION = ::get_lease_duration(LEASE_DURATION_STR);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-r"))) != 0)
{
reliability_kind_str = currentArg;
reliability_kind = ::get_reliability_kind(reliability_kind_str);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT ("-x"))) != 0)
{
test_duration = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT ("-z")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg ();
}
}
// Indicates successful parsing of the command line
return 0;
}
void
PubDriver::parse_args(int& argc, ACE_TCHAR* argv[])
{
// Command-line arguments:
//
// -b <block/non-block waiting>
// -t num_threads_to_write defaults to 1
// -i num_writes_per_thread defaults to 1
// -w num_datawriters_ defaults to 1
// -b block_on_write?1:0 defaults to 0
// -m multiple_instances?1:0 defaults to 0
// -n max_samples_per_instance defaults to INFINITE
// -d history.depth defaults to 1
// -y has_key_flag defaults to 1
// -r data_dropped defaults to 0
ACE_Arg_Shifter arg_shifter(argc, argv);
const ACE_TCHAR* current_arg = 0;
while (arg_shifter.is_anything_left())
{
if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-b"))) != 0)
{
block_on_write_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-t"))) != 0)
{
num_threads_to_write_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-m"))) != 0)
{
multiple_instances_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
num_writes_per_thread_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-w"))) != 0)
{
num_datawriters_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-n"))) != 0)
{
max_samples_per_instance_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-DCPS")) != -1)
{
// ignore -DCPSxxx options that will be handled by Service_Participant
arg_shifter.ignore_arg();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-d"))) != 0)
{
history_depth_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-y"))) != 0)
{
has_key_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-l"))) != 0)
{
write_delay_msec_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if ((current_arg = arg_shifter.get_the_parameter(ACE_TEXT("-r"))) != 0)
{
check_data_dropped_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
// The '-?' option
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-?")) == 0) {
ACE_DEBUG((LM_DEBUG,
"usage: %s\n",
argv[0]));
arg_shifter.consume_arg();
throw TestException();
}
// Anything else we just skip
else {
arg_shifter.ignore_arg();
}
}
}
/// parse the command line arguments
int parse_args(int argc, ACE_TCHAR *argv[])
{
u_long mask = ACE_LOG_MSG->priority_mask(ACE_Log_Msg::PROCESS);
ACE_LOG_MSG->priority_mask(mask | LM_TRACE | LM_DEBUG, ACE_Log_Msg::PROCESS);
ACE_Arg_Shifter arg_shifter(argc, argv);
while (arg_shifter.is_anything_left())
{
// options:
// -o synchronization directory
// -i num_ops_per_thread defaults to 10
// -r num_datareaders defaults to 1
// -n max_samples_per_instance defaults to INFINITE
// -z verbose transport debug
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-o"))) != 0)
{
synch_dir = currentArg;
arg_shifter.consume_arg();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
num_ops_per_thread = ACE_OS::atoi(currentArg);
arg_shifter.consume_arg();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-n"))) != 0)
{
max_samples_per_instance = ACE_OS::atoi(currentArg);
arg_shifter.consume_arg();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-t"))) != 0)
{
if (!ACE_OS::strcmp(currentArg, ACE_TEXT("all")))
{
topics = TOPIC_T1 | TOPIC_T2 | TOPIC_T3 | TOPIC_T4;
}
else
{
int t = ACE_OS::atoi(currentArg);
arg_shifter.consume_arg();
switch (t)
{
case 1: topics |= TOPIC_T1; break;
case 2: topics |= TOPIC_T2; break;
case 3: topics |= TOPIC_T3; break;
case 4: topics |= TOPIC_T4; break;
default:
ACE_ERROR((LM_ERROR,
ACE_TEXT("(%P|%t) Invalid topic id (must be 1-4).\n")));
return 1;
}
}
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-z")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
arg_shifter.ignore_arg();
}
}
// Indicates sucessful parsing of the command line
return 0;
}
/**
* Adds the log cathegory clear names corresponding to the cathegory
* integer constants to the ACE_Log_Record.
*
* Parses the argument vector for the Miro command line option:
* -MiroLogLevel, -MiroLogFilter and -MiroLogDevice.
*
* @TODO -MiroLogDevice has no effect. - Needs to be implemented.
*/
void
Log::init(int& argc, char * argv[])
{
#if (GCC_MAJOR_VERSION >= 3)
std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
#endif
mask_ = 0;
// register all logging cathegories at the log record
for (unsigned int i = 0; i < NUM_CATHEGORIES; ++i) {
ACE_Log_Record::priority_name((ACE_Log_Priority)cathegories[i].priority,
cathegories[i].name);
}
// parse command line arguments
ACE_Arg_Shifter arg_shifter (argc, argv);
while (arg_shifter.is_anything_left ()) {
const ACE_TCHAR *currentArg = arg_shifter.get_current ();
if (ACE_OS::strcasecmp(MIRO_LOG_LEVEL, currentArg) == 0 ||
ACE_OS::strcasecmp(MIRO_LOG_LEVEL_SHORT, currentArg) == 0 ) {
arg_shifter.consume_arg();
if (arg_shifter.is_parameter_next()) {
level_ = strtol(arg_shifter.get_current (), (char**)NULL, 10);
if (level_ == 0 && errno == ERANGE)
throw Miro::CException(errno, "Error parsing -MiroLogLevel");
arg_shifter.consume_arg();
}
}
else if (ACE_OS::strcasecmp(MIRO_LOG_FILTER, currentArg) == 0 ||
ACE_OS::strcasecmp(MIRO_LOG_FILTER_SHORT, currentArg) == 0 ) {
arg_shifter.consume_arg();
while (arg_shifter.is_parameter_next()) {
unsigned int i;
for (i = 0; i < NUM_CATHEGORIES; ++i) {
if (ACE_OS::strcasecmp(cathegories[i].name, arg_shifter.get_current ()) == 0) {
unsigned long p;
ACE_Log_Msg *l = ACE_Log_Msg::instance ();
p = l->priority_mask(ACE_Log_Msg::PROCESS);
p |= cathegories[i].priority;
l->priority_mask(p, ACE_Log_Msg::PROCESS);
break;
}
}
if (i == NUM_CATHEGORIES)
throw Miro::Exception(std::string("Unknown parameter for -MiroLogFilter: ") +
arg_shifter.get_current ());
arg_shifter.consume_arg();
}
}
else if (ACE_OS::strcasecmp(MIRO_LOG_DEVICE, currentArg) == 0) {
arg_shifter.consume_arg();
if (arg_shifter.is_parameter_next()) {
logDevice = arg_shifter.get_current ();
}
}
else {
arg_shifter.ignore_arg ();
}
}
mask_ = ACE_Log_Msg::instance()->priority_mask(ACE_Log_Msg::PROCESS);
// for (unsigned int i = 0; i < 32; ++i) {
// unsigned long p = 1UL << i;
// if (mask_ & p) {
// std::cout << "logged cathegory: "
// << ACE_Log_Record::priority_name((ACE_Log_Priority) p)
// << std::endl;
// }
// }
}
/// parse the command line arguments
int parse_args (int argc, ACE_TCHAR *argv[])
{
ACE_Arg_Shifter arg_shifter (argc, argv);
arg_shifter.ignore_arg (); // ignore the command - argv[0]
while (arg_shifter.is_anything_left ())
{
// options:
// -p <num data writers>
// -i <data writer id>
// -r <num data readers>
// -n <num packets>
// -d <data size>
// -t <max blocking timeout in miliseconds>
// -msi <max samples per instance>
// -mxs <max samples>
// -mxi <max instances>
// -h <throttle_factor>
// -z <verbose transport debug>
const ACE_TCHAR *currentArg = 0;
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-p"))) != 0)
{
num_datawriters = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-r"))) != 0)
{
num_datareaders = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-d"))) != 0)
{
int shift_bits = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
DATA_SIZE = 1 << shift_bits;
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-n"))) != 0)
{
NUM_SAMPLES = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-msi"))) != 0)
{
MAX_SAMPLES_PER_INSTANCE = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-mxs"))) != 0)
{
MAX_SAMPLES = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-mxi"))) != 0)
{
MAX_INSTANCES = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-t"))) != 0)
{
max_mili_sec_blocking = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-h"))) != 0)
{
throttle_factor = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if ((currentArg = arg_shifter.get_the_parameter(ACE_TEXT("-i"))) != 0)
{
id = ACE_OS::atoi (currentArg);
arg_shifter.consume_arg ();
}
else if (arg_shifter.cur_arg_strncasecmp(ACE_TEXT("-z")) == 0)
{
TURN_ON_VERBOSE_DEBUG;
arg_shifter.consume_arg();
}
else
{
ACE_ERROR((LM_ERROR,"(%P|%t) unexpected parameter %s\n", arg_shifter.get_current()));
arg_shifter.ignore_arg ();
return 3;
}
}
// Indicates sucessful parsing of the command line
return 0;
}
