void
EDF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri)
{
int int_guid;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_RECEIVE_REPLY, 0, 0, 0);
RTScheduling::Current::IdType guid;
CORBA::String_var operation = ri->operation ();
CORBA::Object_var target = ri->target ();
ACE_CString opname = operation.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):receive_reply from "
"\"%s\"\n",
opname.c_str ()));
#endif
// Check that the reply service context was received as
// expected.
IOP::ServiceContext_var sc =
ri->get_reply_service_context (Client_Interceptor::SchedulingInfo);
CORBA::Long importance;
TimeBase::TimeT deadline;
if (sc.ptr () == 0)
{
ACE_DEBUG ((LM_DEBUG, "service context was not filled\n"));
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
//Don't store in a _var, since >>= returns a pointer to an internal buffer
//and we are not supposed to free it.
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
sc_qos_as_any >>= sc_qos_ptr;
deadline = sc_qos_ptr->deadline;
importance = sc_qos_ptr->importance;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):Importance = %d in recvd service context\n",
importance));
}
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
EDF_Scheduler_Traits::QoSDescriptor_t qos;
qos.deadline_ = qos.importance_ = importance;
qos.deadline_ = deadline;
this->kokyu_dispatcher_->schedule (guid, qos);
DSUI_EVENT_LOG (EDF_SCHED_FAM, EXIT_RECEIVE_REPLY, int_guid, 0, 0);
}
void
EDF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri,
RTScheduling::Current::IdType_out guid_out,
CORBA::String_out /*name*/,
CORBA::Policy_out sched_param_out,
CORBA::Policy_out /*implicit_sched_param_out*/)
{
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
RTScheduling::Current::IdType guid;
int int_guid;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_SERVER_SCHED_TIME, 0, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):entered EDF_Scheduler::receive_request\n"));
#endif
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): receive_request from "
"\"%s\"\n",
operation.in ()));
#endif
// Ignore the "_is_a" operation since it may have been invoked
// locally on the server side as a side effect of another call,
// meaning that the client hasn't added the service context yet.
if (ACE_OS::strcmp ("_is_a", operation.in ()) == 0)
return;
IOP::ServiceContext_var sc =
ri->get_request_service_context (Server_Interceptor::SchedulingInfo);
CORBA::Long importance;
TimeBase::TimeT deadline;
TimeBase::TimeT period;
CORBA::Long task_id=-1;
if (sc.ptr () == 0)
{
//Since send_request will add an QoS for any request, why can this case happen?
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
period = 0;
// task_id = ID_BEGIN ++;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
//Don't store in a _var, since >>= returns a pointer to an
//internal buffer and we are not supposed to free it.
sc_qos_as_any >>= sc_qos_ptr;
deadline = sc_qos_ptr->deadline;
importance = sc_qos_ptr->importance;
period = sc_qos_ptr->period;
task_id = sc_qos_ptr->task_id;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
ACE_NEW (guid_out.ptr (),
RTScheduling::Current::IdType);
guid_out.ptr ()->length (guid.length ());
*(guid_out.ptr ()) = guid;
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): Importance = %d, guid = %d "
"in recvd service context\n",
importance,
int_guid));
#endif
EDF_Scheduling::SchedulingParameter sched_param;
sched_param.importance = importance;
sched_param.deadline = deadline;
sched_param.period = period;
sched_param.task_id = task_id;
sched_param_out = this->create_scheduling_parameter (sched_param);
}
EDF_Scheduler_Traits::QoSDescriptor_t qos;
qos.importance_ = importance;
qos.deadline_ = deadline;
qos.period_ = period;
qos.task_id_ = task_id;
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_SERVER_DISPATCH_SCHEDULE, int_guid, 0, 0);
/*DTTIME:
record the entering dispatcher time on the server side.
Tenth Time.
*/
#ifdef KOKYU_HAS_RELEASE_GUARD
this->kokyu_dispatcher_->release_guard (guid, qos);
#else
this->kokyu_dispatcher_->schedule (guid, qos);
#endif
/*DTTIME:
record the leaving dispatcher time on the server side.
Eleventh Time.
*/
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_SERVER_DISPATCH_SCHEDULE, int_guid, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): receive_request interceptor done\n"));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_SERVER_SCHED_TIME, 0, 0, 0);
}
bool execute() {
try {
if (mdocall) {
CORBA::Any_var any = mfact->callOperation( mop.c_str(), nargs.inout() );
for (size_t i=0; i < margs.size(); ++i ) {
const types::TypeInfo* ti = margs[i]->getTypeInfo();
CorbaTypeTransporter* ctt = dynamic_cast<CorbaTypeTransporter*>( ti->getProtocol(ORO_CORBA_PROTOCOL_ID) );
assert( ctt );
ctt->updateFromAny( &nargs[i], margs[i] );
}
// convert returned any to local type:
if (mctt)
return mctt->updateFromAny(&any.in(), mresult);
} else {
CSendHandle_var sh = mfact->sendOperation( mop.c_str(), nargs.in() );
AssignableDataSource<CSendHandle_var>::shared_ptr ads = AssignableDataSource<CSendHandle_var>::narrow( mresult.get() );
if (ads) {
ads->set( sh ); // _var creates a copy of the obj reference.
}
}
return true;
} catch ( corba::CNoSuchNameException& ) {
return false;
} catch ( corba::CWrongNumbArgException& ) {
return false;
} catch ( corba::CWrongTypeArgException& ) {
return false;
}
}
DynamicAny::AnySeq *
TAO_DynSequence_i::get_elements (void)
{
if (this->destroyed_)
{
throw ::CORBA::OBJECT_NOT_EXIST ();
}
CORBA::ULong length = static_cast<CORBA::ULong> (this->da_members_.size ());
DynamicAny::AnySeq *elements;
ACE_NEW_THROW_EX (elements,
DynamicAny::AnySeq (length),
CORBA::NO_MEMORY ());
elements->length (length);
DynamicAny::AnySeq_var safe_retval = elements;
// Initialize each Any.
for (CORBA::ULong i = 0; i < length; ++i)
{
CORBA::Any_var tmp =
this->da_members_[i]->to_any ();
safe_retval[i] = tmp.in ();
}
return safe_retval._retn ();
}
CORBA::Contained::Description *
TAO_ConstantDef_i::describe_i (void)
{
CORBA::Contained::Description *desc_ptr = 0;
ACE_NEW_THROW_EX (desc_ptr,
CORBA::Contained::Description,
CORBA::NO_MEMORY ());
CORBA::Contained::Description_var retval = desc_ptr;
retval->kind = this->def_kind ();
CORBA::ConstantDescription cd;
cd.name = this->name_i ();
cd.id = this->id_i ();
ACE_TString container_id;
this->repo_->config ()->get_string_value (this->section_key_,
"container_id",
container_id);
cd.defined_in = container_id.c_str ();
cd.version = this->version_i ();
cd.type = this->type_i ();
CORBA::Any_var val = this->value_i ();
cd.value = val.in ();
retval->value <<= cd;
return retval._retn ();
}
void
MIF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri)
{
RTScheduling::Current::IdType guid;
CORBA::Short importance=0;
CORBA::String_var operation = ri->operation ();
CORBA::Object_var target = ri->target ();
ACE_CString opname = operation.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):receive_reply from "
"\"%s\"\n",
opname.c_str ()));
#endif
// Check that the reply service context was received as
// expected.
IOP::ServiceContext_var sc =
ri->get_reply_service_context (Client_Interceptor::SchedulingInfo);
if (sc.ptr () == 0)
{
importance = 0;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
//Don't store in a _var, since >>= returns a pointer to an internal buffer
//and we are not supposed to free it.
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
sc_qos_as_any >>= sc_qos_ptr;
importance = sc_qos_ptr->importance;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): Importance = %d in recvd service context\n",
importance ));
#endif
}
MIF_Scheduler_Traits::QoSDescriptor_t qos;
qos.importance_ = importance;
this->kokyu_dispatcher_->schedule (guid, qos);
}
void
OCI_APT::ArgList::prepare_request(CORBA::NVList_ptr args,
CORBA::TypeCode_ptr &result_tc,
bool &is_oneway)
{
is_oneway = this->is_oneway_;
if (!is_oneway)
result_tc = CORBA::TypeCode::_duplicate (this->result_.tc_);
for (CORBA::ULong i = 0; i < this->num_args_; i++)
{
TAO::Unknown_IDL_Type *ut = 0;
ACE_NEW(ut, TAO::Unknown_IDL_Type(this->args_[i].tc_));
CORBA::Any_var value = new CORBA::Any;
value->replace(ut);
args->add_value("",value.in(), this->args_[i].mode_);
}
}
void
TAO_CEC_Pull_Event::work (TAO_CEC_ProxyPullConsumer *consumer)
{
CORBA::Boolean has_event = 0;
CORBA::Any_var any;
try
{
any = consumer->try_pull_from_supplier (has_event);
}
catch (const CORBA::Exception&)
{
// Ignore all exceptions
return;
}
if (has_event)
{
this->consumer_admin_->push (any.in ());
}
}
int
TAO_Log_Constraint_Visitor::visit_in (
ETCL_Binary_Expr *binary)
{
int return_value = -1;
ETCL_Constraint *lhs = binary->lhs ();
// Determine if the left operand is contained in the right.
if (lhs->accept (this) == 0)
{
TAO_ETCL_Literal_Constraint left;
this->queue_.dequeue_head (left);
ETCL_Constraint *rhs = binary->rhs ();
if (rhs->accept (this) == 0)
{
TAO_ETCL_Literal_Constraint bag;
this->queue_.dequeue_head (bag);
if (bag.expr_type () == ETCL_COMPONENT)
{
CORBA::Any_ptr any_ptr = 0;
ACE_NEW_RETURN (any_ptr,
CORBA::Any,
-1);
CORBA::Any_var component = any_ptr;
component->replace (bag);
component->impl ()->_add_ref ();
CORBA::TCKind kind = CORBA::tk_null;
try
{
CORBA::TypeCode_var tc = component->type ();
kind = TAO_DynAnyFactory::unalias (tc.in ());
}
catch (const CORBA::Exception&)
{
return return_value;
}
CORBA::Boolean result = 0;
switch (kind)
{
case CORBA::tk_sequence:
result = this->sequence_does_contain (&component.in (),
left);
break;
case CORBA::tk_array:
result = this->array_does_contain (&component.in (),
left);
break;
case CORBA::tk_struct:
result = this->struct_does_contain (&component.in (),
left);
break;
case CORBA::tk_union:
result = this->union_does_contain (&component.in (),
left);
break;
case CORBA::tk_any:
result = this->any_does_contain (&component.in (),
left);
break;
default:
return return_value;
}
this->queue_.enqueue_head (TAO_ETCL_Literal_Constraint (result));
return_value = 0;
}
}
}
return return_value;
}
void
ReplicaController::send_reply (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
FT::FTRequestServiceContext_var ftr (
extract_context (ri));
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Sending reply for %s with rid %i\n",
ftr->client_id.in (),
ftr->retention_id));
// Prepare reply for logging.
CORBA::Any_var result =
ri->result ();
TAO_OutputCDR cdr;
result->impl ()->marshal_value (cdr);
Dynamic::ParameterList_var pl =
ri->arguments ();
CORBA::ULong len = pl->length ();
for (CORBA::ULong index = 0; index != len ; ++index)
{
//@@ No chance for PARAM_OUT
if ((*pl)[index].mode == CORBA::PARAM_INOUT)
{
(*pl)[index].argument.impl ()->marshal_value (cdr);
}
}
CORBA::OctetSeq_var reply;
ACE_NEW (reply.out (), CORBA::OctetSeq (cdr.total_length ()));
reply->length (cdr.total_length ());
CORBA::Octet* buf = reply->get_buffer ();
// @@ What if this throws an exception?? We don't have any way to
// check whether this succeeded
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
// Logging the reply and state update.
//
// First send message to members.
//
{
// Extract state update.
CORBA::OctetSeq_var oid = ri->object_id ();
PortableInterceptor::AdapterName_var an = ri->adapter_name ();
CORBA::Any_var state = ri->get_slot (state_slot_id ());
CORBA::TypeCode_var tc = state->type ();
if (tc->kind () == CORBA::tk_null)
{
ACE_DEBUG ((LM_DEBUG, "Slot update is void\n"));
PortableServer::POA_var poa = resolve_poa (an.in ());
PortableServer::ServantBase_var servant =
poa->id_to_servant (oid.in ());
Checkpointable* target =
dynamic_cast<Checkpointable*> (servant.in ());
if (target)
{
CORBA::Any_var tmp = target->get_state ();
if (tmp.ptr () != 0) state = tmp._retn ();
}
}
TAO_OutputCDR cdr;
cdr << oid.in ();
cdr << an.in ();
cdr << ftr->client_id.in ();
cdr << ftr->retention_id;
cdr << reply.in ();
cdr << state.in ();
size_t size = cdr.total_length ();
CORBA::OctetSeq_var msg;
ACE_NEW (msg.out (), CORBA::OctetSeq (size));
msg->length (size);
{
CORBA::Octet* buf = msg->get_buffer ();
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
}
CORBA::Octet* buf = msg->get_buffer ();
// Crash point 1.
//
if (crash_point == 1 && ftr->retention_id > 2) ACE_OS::exit (1);
try
{
while (true)
{
try
{
group_->send (buf, size);
ACE_DEBUG ((LM_DEBUG, "Sent log record of length %i\n", size));
break;
}
catch (ACE_TMCast::Group::Aborted const&)
{
ACE_DEBUG ((LM_DEBUG, "Retrying to send log record.\n"));
}
}
}
catch (ACE_TMCast::Group::Failed const&)
{
ACE_DEBUG ((LM_DEBUG,
"Group failure. Perhaps, I am alone in the group.\n"));
}
}
// Now perform local logging.
//
RecordId rid (ftr->client_id.in (), ftr->retention_id);
// This is slow but eh-safe ;-).
//
log_.insert (rid, reply);
// Crash point 2.
//
if (crash_point == 2 && ftr->retention_id > 2) ACE_OS::exit (1);
}
void DynAnyAnalyzer::analyze (DynamicAny::DynAny_ptr da)
{
CORBA::TypeCode_var tc = da->type ();
CORBA::TCKind kind = tc->kind ();
CORBA::TypeCode_var dup = CORBA::TypeCode::_duplicate (tc.in ());
// strip aliases
while (kind == CORBA::tk_alias)
{
dup = dup->content_type ();
kind = dup->kind ();
}
switch (kind)
{
case CORBA::tk_struct:
{
DynamicAny::DynStruct_var ds
= DynamicAny::DynStruct::_narrow (da);
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"STRUCT\n"));
}
if (da->seek (0) )
{
level_++;
do
{
DynamicAny::DynAny_var cc =
ds->current_component ();
DynamicAny::FieldName_var fn =
ds->current_member_name ();
tab(level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"Member = %C\n", fn.in ()));
}
if (!CORBA::is_nil (cc.in ()))
{
this->analyze (cc.in ());
}
} while (da->next ());
level_--;
}
}
break; // end tk_struct
case CORBA::tk_sequence:
{
if (TAO_DynCommon::is_basic_type_seq (tc.in ()))
{
this->analyze_basic_seq (dup.in (), da);
}
else
{
DynamicAny::DynSequence_var ds =
DynamicAny::DynSequence::_narrow (da);
int i = 0;
tab(level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"SEQUENCE\n"));
}
if (ds->seek (0UL))
{
level_++;
do
{
tab(level_);
if (debug_)
ACE_DEBUG ((LM_DEBUG,
"[%d]\n", i));
DynamicAny::DynAny_var cc (ds->current_component ());
if (!CORBA::is_nil (cc.in ()))
{
analyze (cc.in ());
}
i++;
} while (da->next ());
level_--;
}
}
}
break; // end tk_sequence
case CORBA::tk_array:
{
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG,
"ARRAY\n"));
}
level_++;
CORBA::ULong const len =
dup->length ();
for (CORBA::ULong i = 0 ; i < len; ++i)
{
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, "[%d]\n", i));
}
DynamicAny::DynAny_var cc = da->current_component();
if (!CORBA::is_nil (cc.in ()))
{
analyze (cc.in ());
}
da->next ();
}
level_--;
}
break;
case CORBA::tk_union:
{
DynamicAny::DynUnion_var value =
DynamicAny::DynUnion::_narrow (da);
if (!value->has_no_active_member ())
{
DynamicAny::DynAny_var disc = value->member ();
if (!CORBA::is_nil (disc.in ()))
{
this->analyze (disc.in ());
}
}
}
break;
case CORBA::tk_any:
{
DynamicAny::DynAny_var dynany;
CORBA::Any_var any = da->get_any ();
dynany =
dynany_factory_->create_dyn_any (any.in ());
if (!CORBA::is_nil (dynany.in ()))
{
this->analyze (dynany.in ());
}
dynany->destroy ();
}
break;
case CORBA::tk_enum:
{
DynamicAny::DynEnum_var value =
DynamicAny::DynEnum::_narrow (da);
CORBA::String_var s = value->get_as_string ();
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, " Value (enum) = %C\n", s.in()));
}
}
break;
CASEE (boolean, Boolean, " Value (bool) = %d\n");
CASEE (short, Short, " Value (short) = %d\n");
CASEE (ushort, UShort, " Value (ushort) = %u\n");
CASEE (long, Long, " Value (long) = %d\n");
CASEE (ulong, ULong, " Value (ulong) = %u\n");
CASEE (longlong, LongLong, " Value (longlong) %Ld\n");
CASEE (ulonglong, ULongLong, " Value (ulonglong) %Lu\n");
CASEE (char, Char, " Value (char) = %c\n");
CASEE (float, Float, " Value (float) = %f\n");
CASEE (double, Double, " Value (double) = %f\n");
CASEE (octet, Octet, " Value (octet) = %c\n");
case CORBA::tk_string:
{
CORBA::String_var b (da->get_string ());
tab (level_);
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, " Value (string) = %C\n", b.in ()));
}
}
break;
case CORBA::tk_TypeCode:
{
tab (level_);
if (debug_)
{
CORBA::TCKind const kind =
da->get_typecode ()->kind ();
ACE_DEBUG ((LM_DEBUG,
" Value (TypeCode) = %d\n",
static_cast<int> (kind)));
}
}
break;
default:
{
tab (level_);
if (debug_)
{
CORBA::TCKind const kind =
tc->kind ();
ACE_DEBUG ((LM_DEBUG,
" unhandled typecode = %d\n",
static_cast<int> (kind)));
}
}
break;
}
if (debug_)
{
ACE_DEBUG ((LM_DEBUG, "\n"));
}
}
void
MIF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri,
RTScheduling::Current::IdType_out guid_out,
CORBA::String_out /*name*/,
CORBA::Policy_out sched_param_out,
CORBA::Policy_out /*implicit_sched_param_out*/)
{
Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr;
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):entered MIF_Scheduler::receive_request\n"));
#endif
RTScheduling::Current::IdType guid;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): receive_request from "
"\"%s\"\n",
operation.in ()));
#endif
// Ignore the "_is_a" operation since it may have been invoked
// locally on the server side as a side effect of another call,
// meaning that the client hasn't added the service context yet.
if (ACE_OS::strcmp ("_is_a", operation.in ()) == 0)
return;
IOP::ServiceContext_var sc =
ri->get_request_service_context (Server_Interceptor::SchedulingInfo);
CORBA::Short importance;
if (sc.ptr () == 0)
{
importance = 0;
}
else
{
CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
sc->context_data.length (),
sc->context_data.get_buffer (),
0);
CORBA::Any sc_qos_as_any;
CORBA::Any_var scqostmp = codec_->decode (oc_seq);
sc_qos_as_any = scqostmp.in ();
//Don't store in a _var, since >>= returns a pointer to an
//internal buffer and we are not supposed to free it.
sc_qos_as_any >>= sc_qos_ptr;
importance = sc_qos_ptr->importance;
guid.length (sc_qos_ptr->guid.length ());
guid_copy (guid, sc_qos_ptr->guid);
ACE_NEW (guid_out.ptr (),
RTScheduling::Current::IdType);
guid_out.ptr ()->length (guid.length ());
*(guid_out.ptr ()) = guid;
#ifdef KOKYU_DSRT_LOGGING
int int_guid;
ACE_OS::memcpy (&int_guid,
guid.get_buffer (),
guid.length ());
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): Importance = %d, guid = %d in recvd service context\n",
importance, int_guid));
#endif
MIF_Scheduling::SchedulingParameter sched_param;
sched_param.importance = importance;
sched_param_out = this->create_scheduling_parameter (sched_param);
}
MIF_Scheduler_Traits::QoSDescriptor_t qos;
qos.importance_ = importance;
this->kokyu_dispatcher_->schedule (guid, qos);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): receive_request interceptor done\n"));
#endif
}
