// Listing 1 code/ch05
int QueueExample::runStackUnboundedQueue (void)
{
ACE_TRACE ("QueueExample::runStackUnboundedQueue");
ACE_Unbounded_Queue<DataElement> queue;
DataElement elem1[10];
int i;
for (i = 0; i < 10; i++)
{
elem1[i].setData (9-i);
queue.enqueue_head (elem1[i]);
}
DataElement elem2[10];
for (i = 0; i < 10; i++)
{
elem2[i].setData (i+10);
queue.enqueue_tail (elem2[i]);
}
for (ACE_Unbounded_Queue_Iterator<DataElement> iter (queue);
!iter.done ();
iter.advance ())
{
DataElement *elem = 0;
iter.next (elem);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%d:"), elem->getData ()));
}
return 0;
}
// Listing 1
// Listing 2 code/ch05
int QueueExample::runHeapUnboundedQueue (void)
{
ACE_TRACE ("QueueExample::runHeapUnboundedQueue");
ACE_Unbounded_Queue<DataElement*> queue;
for (int i = 0; i < 20; i++)
{
DataElement *elem;
ACE_NEW_RETURN(elem, DataElement (i), -1);
queue.enqueue_head (elem);
}
for (ACE_Unbounded_Queue_Iterator<DataElement*> iter
= queue.begin ();
!iter.done ();
iter.advance ())
{
DataElement **elem = 0;
iter.next(elem);
ACE_DEBUG
((LM_DEBUG, ACE_TEXT ("%d:"), (*elem)->getData ()));
delete (*elem);
}
return 0;
}
void
ACE_Stats::mean (ACE_Stats_Value &m,
const ACE_UINT32 scale_factor)
{
if (number_of_samples_ > 0)
{
const ACE_UINT64 ACE_STATS_INTERNAL_OFFSET =
ACE_UINT64_LITERAL (0x100000000);
ACE_UINT64 sum = ACE_STATS_INTERNAL_OFFSET;
ACE_Unbounded_Queue_Iterator<ACE_INT32> i (samples_);
while (! i.done ())
{
ACE_INT32 *sample;
if (i.next (sample))
{
sum += *sample;
i.advance ();
}
}
// sum_ was initialized with ACE_STATS_INTERNAL_OFFSET, so
// subtract that off here.
quotient (sum - ACE_STATS_INTERNAL_OFFSET,
number_of_samples_ * scale_factor,
m);
}
else
{
m.whole (0);
m.fractional (0);
}
}
const be_visitor_typecode_defn::QNode *
be_visitor_typecode_defn::queue_lookup (
ACE_Unbounded_Queue <be_visitor_typecode_defn::QNode *> &queue,
be_type *node
)
{
for (ACE_Unbounded_Queue_Iterator<be_visitor_typecode_defn::QNode *>
iter (queue);
!iter.done ();
iter.advance ())
{
be_visitor_typecode_defn::QNode **addr = 0;
be_visitor_typecode_defn::QNode *item = 0;
iter.next (addr);
item = *addr;
if (!ACE_OS::strcmp (item->node->full_name (),
node->full_name ()))
{
// Found.
return item;
}
}
return 0;
}
void Gadget_Impl::list_parts (void)
{
ACE_Unbounded_Queue_Iterator<Gadget_Part_var> iter (parts_);
Gadget_Part_var *current_part;
while (iter.next (current_part))
{
(*current_part)->print_info ();
iter.advance ();
}
}
void Widget_Impl::list_parts (void)
{
ACE_Unbounded_Queue_Iterator<ACE_Refcounted_Auto_Ptr<Widget_Part, ACE_SYNCH_MUTEX> > iter (parts_);
ACE_Refcounted_Auto_Ptr<Widget_Part, ACE_SYNCH_MUTEX> *current_part;
while (iter.next (current_part))
{
(*current_part)->print_info ();
iter.advance ();
}
}
int
ACE_ARGV::create_buf_from_queue (void)
{
ACE_TRACE ("ACE_ARGV::create_buf_from_queue");
// If the are no arguments, don't do anything
if (this->argc_ <= 0)
return -1;
delete [] this->buf_;
ACE_NEW_RETURN (this->buf_,
ACE_TCHAR[this->length_ + this->argc_],
-1);
// Get an iterator over the queue
ACE_Unbounded_Queue_Iterator<ACE_TCHAR *> iter (this->queue_);
ACE_TCHAR **arg;
ACE_TCHAR *ptr = this->buf_;
size_t len;
int more = 0;
while (!iter.done ())
{
// Get next argument from the queue.
iter.next (arg);
more = iter.advance ();
len = ACE_OS::strlen (*arg);
// Copy the argument into buf_
ACE_OS::memcpy ((void *) ptr,
(const void *) (*arg),
len * sizeof (ACE_TCHAR));
// Move the pointer down.
ptr += len;
// Put in an argument separating space.
if (more != 0)
*ptr++ = ' ';
}
// Put in the NUL terminator
*ptr = '\0';
return 0;
}
CORBA::NVList::~NVList (void)
{
// initialize an iterator and delete each NamedValue
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> iter (this->values_);
for (iter.first (); !iter.done (); iter.advance ())
{
CORBA::NamedValue_ptr *nv = 0;
(void) iter.next (nv);
delete *nv;
}
this->max_ = 0;
// Remove the CDR stream if it is present.
delete this->incoming_;
}
void
CORBA::NVList::_tao_decode (TAO_InputCDR &incoming, int flag)
{
if (TAO_debug_level > 3)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode\n")));
}
// Then unmarshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
// check if it is an in or inout parameter
// @@ this is where we assume that the NVList is coming from
// a Server-side request, we could probably handle both
// cases with a flag, but there is no clear need for that.
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
if (TAO_debug_level > 3)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) : NVList::_tao_decode - %C\n"),
nv->name ()? nv->name () : "(no name given)" ));
}
CORBA::Any_ptr any = nv->value ();
any->impl ()->_tao_decode (incoming
);
}
}
void
ACE_Stats::mean (ACE_Stats_Value &m,
const ACE_UINT32 scale_factor)
{
if (number_of_samples_ > 0)
{
#if defined ACE_LACKS_LONGLONG_T
// If ACE_LACKS_LONGLONG_T, then ACE_UINT64 is a user-defined class.
// To prevent having to construct a static of that class, declare it
// on the stack, and construct it, in each function that needs it.
const ACE_U_LongLong ACE_STATS_INTERNAL_OFFSET (0, 8);
#else /* ! ACE_LACKS_LONGLONG_T */
const ACE_UINT64 ACE_STATS_INTERNAL_OFFSET =
ACE_UINT64_LITERAL (0x100000000);
#endif /* ! ACE_LACKS_LONGLONG_T */
ACE_UINT64 sum = ACE_STATS_INTERNAL_OFFSET;
ACE_Unbounded_Queue_Iterator<ACE_INT32> i (samples_);
while (! i.done ())
{
ACE_INT32 *sample;
if (i.next (sample))
{
sum += *sample;
i.advance ();
}
}
// sum_ was initialized with ACE_STATS_INTERNAL_OFFSET, so
// subtract that off here.
quotient (sum - ACE_STATS_INTERNAL_OFFSET,
number_of_samples_ * scale_factor,
m);
}
else
{
m.whole (0);
m.fractional (0);
}
}
const ACE_TCHAR * duplicate (const ACE_TCHAR *s)
{
void **x;
const ACE_TCHAR *d = 0;
ACE_Unbounded_Queue_Iterator<void *> iter (this->queue_);
while (iter.next (x))
{
d = (const ACE_TCHAR *) *x;
if (ACE_OS::strcmp (d, s) == 0)
break;
d = 0;
iter.advance ();
}
if (d == 0)
{
d = ACE_OS::strdup (s);
this->queue_.enqueue_tail ((void *) d);
}
return d;
}
int
ACE_ARGV_T<CHAR_TYPE>::create_buf_from_queue (void)
{
ACE_TRACE ("ACE_ARGV_T::create_buf_from_queue");
// If the are no arguments, don't do anything
if (this->argc_ <= 0)
return -1;
delete [] this->buf_;
ACE_NEW_RETURN (this->buf_,
CHAR_TYPE[this->length_ + this->argc_],
-1);
// Get an iterator over the queue
ACE_Unbounded_Queue_Iterator<ACE_ARGV_Queue_Entry_T<CHAR_TYPE> > iter (this->queue_);
ACE_ARGV_Queue_Entry_T<CHAR_TYPE> *arg = 0;
CHAR_TYPE *ptr = this->buf_;
size_t len;
while (!iter.done ())
{
// Get next argument from the queue.
iter.next (arg);
iter.advance ();
if (arg->quote_arg_)
{
*ptr++ = '"';
if (ACE_OS::strchr (arg->arg_, '"') != 0)
{
CHAR_TYPE prev = 0;
for (const CHAR_TYPE * p = arg->arg_; *p != '\0'; ++p)
{
if (*p == '"' && prev != '\\') *ptr++ = '\\';
prev = *ptr++ = *p;
}
}
else
{
len = ACE_OS::strlen (arg->arg_);
// Copy the argument into buf_
ACE_OS::memcpy ((void *) ptr,
(const void *) (arg->arg_),
len * sizeof (CHAR_TYPE));
// Move the pointer down.
ptr += len;
}
*ptr++ = '"';
}
else
{
len = ACE_OS::strlen (arg->arg_);
// Copy the argument into buf_
ACE_OS::memcpy ((void *) ptr,
(const void *) (arg->arg_),
len * sizeof (CHAR_TYPE));
// Move the pointer down.
ptr += len;
}
// Put in an argument separating space.
*ptr++ = ' ';
}
// Put in the NUL terminator
ptr[-1] = '\0';
return 0;
}
void
CORBA::NVList::_tao_encode (TAO_OutputCDR &cdr, int flag)
{
ACE_GUARD (TAO_SYNCH_MUTEX,
ace_mon,
this->lock_);
if (this->incoming_ != 0)
{
if (this->max_ == 0)
{
// The list is empty aggressively reduce copies and just send
// the CDR stream, we assume that
// TAO_Server_Request::init_reply
// has inserted appropriated padding already to make this
// operation correct
cdr.write_octet_array_mb (this->incoming_->start ());
return;
}
// Then unmarshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
if (TAO_debug_level > 3)
{
const char* arg = nv->name ();
if (arg == 0)
{
arg = "(nil)";
}
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("NVList::_tao_encode - parameter <%C>\n"),
arg));
}
CORBA::TypeCode_ptr tc = nv->value ()->_tao_get_typecode ();
(void) TAO_Marshal_Object::perform_append (tc,
this->incoming_,
&cdr);
}
delete this->incoming_;
this->incoming_ = 0;
return;
}
// The list is already evaluated, we cannot optimize the copies, go
// ahead with the slow way to do things.
// Then marshal each "in" and "inout" parameter.
ACE_Unbounded_Queue_Iterator<CORBA::NamedValue_ptr> i (this->values_);
for (i.first (); !i.done (); i.advance ())
{
CORBA::NamedValue_ptr *item = 0;
(void) i.next (item);
CORBA::NamedValue_ptr nv = *item;
if (ACE_BIT_DISABLED (nv->flags (), flag))
{
continue;
}
nv->value ()->impl ()->marshal_value (cdr);
}
}
int
ACE_Stats::std_dev (ACE_Stats_Value &std_dev,
const ACE_UINT32 scale_factor)
{
if (number_of_samples_ <= 1)
{
std_dev.whole (0);
std_dev.fractional (0);
}
else
{
const ACE_UINT32 field = std_dev.fractional_field ();
// The sample standard deviation is:
//
// sqrt (sum (sample_i - mean)^2 / (number_of_samples_ - 1))
ACE_UINT64 mean_scaled;
// Calculate the mean, scaled, so that we don't lose its
// precision.
ACE_Stats_Value avg (std_dev.precision ());
mean (avg, 1u);
avg.scaled_value (mean_scaled);
// Calculate the summation term, of squared differences from the
// mean.
ACE_UINT64 sum_of_squares = 0;
ACE_Unbounded_Queue_Iterator<ACE_INT32> i (samples_);
while (! i.done ())
{
ACE_INT32 *sample;
if (i.next (sample))
{
const ACE_UINT64 original_sum_of_squares = sum_of_squares;
// Scale up by field width so that we don't lose the
// precision of the mean. Carefully . . .
const ACE_UINT64 product (*sample * field);
ACE_UINT64 difference;
// NOTE: please do not reformat this code! It //
// works with the Diab compiler the way it is! //
if (product >= mean_scaled) //
{ //
difference = product - mean_scaled; //
} //
else //
{ //
difference = mean_scaled - product; //
} //
// NOTE: please do not reformat this code! It //
// works with the Diab compiler the way it is! //
// Square using 64-bit arithmetic.
sum_of_squares += difference * ACE_U64_TO_U32 (difference);
i.advance ();
if (sum_of_squares < original_sum_of_squares)
{
overflow_ = ENOSPC;
return -1;
}
}
}
// Divide the summation by (number_of_samples_ - 1), to get the
// variance. In addition, scale the variance down to undo the
// mean scaling above. Otherwise, it can get too big.
ACE_Stats_Value variance (std_dev.precision ());
quotient (sum_of_squares,
(number_of_samples_ - 1) * field * field,
variance);
// Take the square root of the variance to get the standard
// deviation. First, scale up . . .
ACE_UINT64 scaled_variance;
variance.scaled_value (scaled_variance);
// And scale up, once more, because we'll be taking the square
// root.
scaled_variance *= field;
ACE_Stats_Value unscaled_standard_deviation (std_dev.precision ());
square_root (scaled_variance,
unscaled_standard_deviation);
// Unscale.
quotient (unscaled_standard_deviation,
scale_factor * field,
std_dev);
}
return 0;
}
void
Event_Supplier::insert_event_data (CORBA::Any &data,
ACE_Unbounded_Queue_Iterator<Schedule_Viewer_Data *> &schedule_iter)
{
static u_long last_completion = 0;
try
{
Schedule_Viewer_Data **sched_data;
if ((schedule_iter.next (sched_data)) && (sched_data) && (*sched_data))
{
if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_20") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "low_20") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "high_1") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "low_1") == 0))
{
if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_20") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "high_1") == 0))
{
navigation_.criticality = 1;
}
else
{
navigation_.criticality = 0;
}
navigation_.position_latitude = ACE_OS::rand() % 90;
navigation_.position_longitude = ACE_OS::rand() % 180;
navigation_.altitude = ACE_OS::rand() % 100;
navigation_.heading = ACE_OS::rand() % 180;
navigation_.roll = (navigation_.roll >= 180) ? -180 : navigation_.roll + 1;
navigation_.pitch = (navigation_.pitch >= 90) ? -90 : navigation_.pitch + 1;
navigation_.utilization = (*sched_data)->utilitzation;
navigation_.overhead = (*sched_data)->overhead;
navigation_.arrival_time = (*sched_data)->arrival_time;
navigation_.deadline_time = (*sched_data)->deadline_time;
navigation_.completion_time = (*sched_data)->completion_time;
navigation_.computation_time = (*sched_data)->computation_time;
navigation_.update_data = 0;
// because the scheduler data does not supply these values
navigation_.utilization = (double) (20.0 + ACE_OS::rand() % 10);
navigation_.overhead = (double) (ACE_OS::rand() % 10);
data <<= navigation_;
}
else if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_10") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "low_10") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "high_5") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "low_5") == 0))
{
if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_10") == 0) ||
(ACE_OS::strcmp((*sched_data)->operation_name, "high_5") == 0))
{
weapons_.criticality = 1;
}
else
{
weapons_.criticality = 0;
}
weapons_.number_of_weapons = 2;
weapons_.weapon1_identifier = CORBA::string_alloc (30);
ACE_OS::strcpy (weapons_.weapon1_identifier.inout (),"Photon Torpedoes");
weapons_.weapon1_status =(ACE_OS::rand() % 4) == 0 ? 0 : 1 ;
weapons_.weapon2_identifier = CORBA::string_alloc (30);
ACE_OS::strcpy (weapons_.weapon2_identifier.inout (),"Quantum Torpedoes");
weapons_.weapon2_status = (ACE_OS::rand() % 4) == 0 ? 0 : 1;
weapons_.weapon3_identifier = CORBA::string_alloc (1);
ACE_OS::strcpy (weapons_.weapon3_identifier.inout (), "");
weapons_.weapon3_status = 0;
weapons_.weapon4_identifier = CORBA::string_alloc (1);
ACE_OS::strcpy (weapons_.weapon4_identifier.inout (), "");
weapons_.weapon4_status = 0;
weapons_.weapon5_identifier = CORBA::string_alloc (1);
ACE_OS::strcpy (weapons_.weapon5_identifier.inout (), "");
weapons_.weapon5_status = 0;
weapons_.utilization = (*sched_data)->utilitzation;
weapons_.overhead = (*sched_data)->overhead;
weapons_.arrival_time = (*sched_data)->arrival_time;
weapons_.deadline_time = (*sched_data)->deadline_time;
weapons_.completion_time = (*sched_data)->completion_time;
weapons_.computation_time = (*sched_data)->computation_time;
weapons_.update_data = 0;
// because the scheduler data does not supply these values
weapons_.utilization = (double) (20.0 + ACE_OS::rand() % 10);
weapons_.overhead = (double) (ACE_OS::rand() % 10);
data <<= weapons_;
}
else {
ACE_ERROR ((LM_ERROR,
"Event_Supplier::insert_event_data:"
"unrecognized operation name [%s]",
(*sched_data)->operation_name));
}
if (last_completion > (*sched_data)->completion_time)
last_completion = 0;
if ((*sched_data)->completion_time >= last_completion)
{
ACE_Time_Value pause (0,
(*sched_data)->completion_time -
last_completion);
ACE_OS::sleep (pause);
last_completion = (*sched_data)->completion_time;
}
}
else
ACE_ERROR ((LM_ERROR,
"Event_Supplier::insert_event_data:"
"Could Not access scheduling data"));
schedule_iter.advance ();
if (schedule_iter.done ())
schedule_iter.first ();
}
catch (const CORBA::Exception&)
{
ACE_ERROR ((LM_ERROR,
"(%t)Error in Event_Supplier::insert_event_data.\n"));
}
}