本文整理汇总了C++中ACE_NEW_RETURN函数的典型用法代码示例。如果您正苦于以下问题:C++ ACE_NEW_RETURN函数的具体用法?C++ ACE_NEW_RETURN怎么用?C++ ACE_NEW_RETURN使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了ACE_NEW_RETURN函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: ACE_ERROR_RETURN
int
be_visitor_interface_ss::gen_abstract_ops_helper (
be_interface *node,
be_interface *base,
TAO_OutStream *os)
{
if (!base->is_abstract ())
{
return 0;
}
AST_Decl *d = 0;
be_visitor_context ctx;
ctx.stream (os);
ctx.state (TAO_CodeGen::TAO_ROOT_SS);
for (UTL_ScopeActiveIterator si (base, UTL_Scope::IK_decls);
!si.is_done ();
si.next ())
{
d = si.item ();
if (d == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("be_visitor_interface_ss::")
ACE_TEXT ("gen_abstract_ops_helper - ")
ACE_TEXT ("bad node in this scope\n")),
-1);
}
AST_Decl::NodeType nt = d->node_type ();
UTL_ScopedName *item_new_name = 0;
UTL_ScopedName *new_name = 0;
if (AST_Decl::NT_op == nt || AST_Decl::NT_attr == nt)
{
ACE_NEW_RETURN (item_new_name,
UTL_ScopedName (d->local_name ()->copy (),
0),
-1);
new_name = (UTL_ScopedName *) node->name ()->copy ();
new_name->nconc (item_new_name);
}
else
{
continue;
}
// We pass the node's is_abstract flag to the operation
// constructor so we will get the right generated operation
// body if we are regenerating an operation from an
// abstract interface in a concrete interface or component.
if (AST_Decl::NT_op == nt)
{
be_operation *op = be_operation::narrow_from_decl (d);
UTL_ScopedName *old_name =
(UTL_ScopedName *) op->name ()->copy ();
op->set_name (new_name);
op->set_defined_in (node);
op->is_abstract (node->is_abstract ());
be_visitor_operation_ss op_visitor (&ctx);
op_visitor.visit_operation (op);
op->set_name (old_name);
op->set_defined_in (base);
op->is_abstract (base->is_abstract ());
}
else if (AST_Decl::NT_attr == nt)
{
AST_Attribute *attr =
AST_Attribute::narrow_from_decl (d);
be_attribute new_attr (attr->readonly (),
attr->field_type (),
0,
attr->is_local (),
attr->is_abstract ());
new_attr.set_defined_in (node);
new_attr.set_name (new_name);
UTL_ExceptList *get_exceptions =
attr->get_get_exceptions ();
if (0 != get_exceptions)
{
new_attr.be_add_get_exceptions (get_exceptions->copy ());
}
UTL_ExceptList *set_exceptions =
attr->get_set_exceptions ();
if (0 != set_exceptions)
{
new_attr.be_add_set_exceptions (set_exceptions->copy ());
}
be_visitor_attribute attr_visitor (&ctx);
//.........这里部分代码省略.........
示例2: ACE_TRACE
ACE_Message_Block *
ACE_Message_Block::clone (Message_Flags mask) const
{
ACE_TRACE ("ACE_Message_Block::clone");
// Get a pointer to a "cloned" <ACE_Data_Block> (will copy the
// values rather than increment the reference count).
ACE_Data_Block *db = this->data_block ()->clone (mask);
if (db == 0)
return 0;
ACE_Message_Block *nb = 0;
if(message_block_allocator_ == 0)
{
ACE_NEW_RETURN (nb,
ACE_Message_Block (0, // size
ACE_Message_Type (0), // type
0, // cont
0, // data
0, // allocator
0, // locking strategy
0, // flags
this->priority_, // priority
ACE_EXECUTION_TIME, // execution time
ACE_DEADLINE_TIME, // absolute time to deadline
// Get a pointer to a
// "duplicated" <ACE_Data_Block>
// (will simply increment the
// reference count).
db,
db->data_block_allocator (),
this->message_block_allocator_),
0);
}
else
{
// This is the ACE_NEW_MALLOC macro with the return check removed.
// We need to do it this way because if it fails we need to release
// the cloned data block that was created above. If we used
// ACE_NEW_MALLOC_RETURN, there would be a memory leak because the
// above db pointer would be left dangling.
nb = static_cast<ACE_Message_Block*> (message_block_allocator_->malloc (sizeof (ACE_Message_Block)));
if(nb != 0)
new (nb) ACE_Message_Block (0, // size
ACE_Message_Type (0), // type
0, // cont
0, // data
0, // allocator
0, // locking strategy
0, // flags
this->priority_, // priority
ACE_EXECUTION_TIME, // execution time
ACE_DEADLINE_TIME, // absolute time to deadline
db,
db->data_block_allocator (),
this->message_block_allocator_);
}
if (nb == 0)
{
db->release ();
return 0;
}
// Set the read and write pointers in the new <Message_Block> to the
// same relative offset as in the existing <Message_Block>.
nb->rd_ptr (this->rd_ptr_);
nb->wr_ptr (this->wr_ptr_);
// Clone all the continuation messages if necessary.
if (this->cont () != 0
&& (nb->cont_ = this->cont ()->clone (mask)) == 0)
{
nb->release ();
return 0;
}
return nb;
}
示例3: ACE_TMAIN
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_LOG_MSG->open (argv[0] ? argv[0] : ACE_TEXT("preempt"));
#if defined (ACE_HAS_THREADS) || !defined (ACE_LACKS_FORK)
u_int i;
if (get_options (argc, argv))
ACE_OS::exit (-1);
// Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
if (ACE_OS::sched_params (
ACE_Sched_Params (
ACE_SCHED_FIFO,
ACE_Sched_Params::priority_min (ACE_SCHED_FIFO),
ACE_SCOPE_PROCESS)) != 0)
{
if (ACE_OS::last_error () == EPERM)
ACE_DEBUG ((LM_MAX, "preempt: user is not superuser, "
"so remain in time-sharing class\n"));
else
ACE_ERROR_RETURN ((LM_ERROR, "%n: ACE_OS::sched_params failed\n%a"),
-1);
}
High_Priority_Task *high_priority_task;
ACE_NEW_RETURN (high_priority_task, High_Priority_Task [high_priority_tasks],
1);
Low_Priority_Task low_priority_task (high_priority_task[0]);
if (! use_fork)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) main (), wait for threads to exit . . .\n"));
}
// Save the start time, so that deltas can be displayed later.
starttime = ACE_OS::gethrtime ();
// Spawn the threads/processes . . .
pid_t child = 0;
if (use_fork == 1)
{
switch ((child = ACE_OS::fork (ACE_TEXT("preempt-low_priority_process"))))
{
case -1:
ACE_ERROR ((LM_ERROR, "%p\n%a", "fork failed"));
return -1;
case 0: // In child
{
low_priority_task.open (0);
break;
}
default: // In parent
for (i = 0; i < high_priority_tasks; ++i)
{
high_priority_task[i].open (0);
}
break;
}
}
else
{
for (i = 0; i < high_priority_tasks; ++i)
{
high_priority_task[i].open (0);
}
low_priority_task.open (0);
#if defined (ACE_HAS_THREADS)
// Wait for all threads to exit.
ACE_Thread_Manager::instance ()->wait ();
#endif /* ACE_HAS_THREADS */
}
// Display the time deltas. They should be about a half second apart.
if (child || ! use_fork)
{
for (i = 0; i < high_priority_tasks; ++i)
{
ACE_DEBUG ((LM_DEBUG, "High priority task %u:\n", i + 1));
high_priority_task[i].print_times ();
}
}
delete [] high_priority_task;
#else /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
ACE_ERROR ((LM_ERROR, "threads and fork not supported on this platform\n"));
#endif /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */
return 0;
}
示例4: ACE_TMAIN
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
CORBA::ORB_var orb;
try
{
PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
PortableInterceptor::ORBInitializer::_nil ();
PortableInterceptor::ORBInitializer_var orb_initializer;
// Register the ClientRequest_Interceptor ORBInitializer.
ACE_NEW_RETURN (temp_orb_initializer,
ClientORBInitializer,
-1);
orb_initializer = temp_orb_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object (ior);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in () );
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
ACE_DEBUG ((LM_DEBUG, "Client about to make method call that is doomed to failure...\n"));
CORBA::String_var the_string =
hello->get_string ();
ACE_ERROR_RETURN ((LM_DEBUG,
"Error - the remote call succeeded which is bloody miraculous given that no server is running !!\n"),
1);
orb->destroy ();
}
catch (const CORBA::Exception&)
{
orb->destroy ();
if (ClientRequest_Interceptor::success_flag_)
{
ACE_DEBUG ((LM_DEBUG, "Success - the server was unreachable and PI receive_exception was invoked.\n"));
return 0;
}
else
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Error: regression failed - interceptor receive_exception interception point was not invoked !!\n"),
1);
}
}
return 1;
}
示例5: BE_init
int
BE_init(int&, ACE_TCHAR*[])
{
ACE_NEW_RETURN(be_global, BE_GlobalData, -1);
return 0;
}
示例6: while
int
Periodic_Task::init_task (ACE_Arg_Shifter& arg_shifter)
{
const ACE_TCHAR *current_arg = 0;
while (arg_shifter.is_anything_left ())
{
if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-JobName"))))
{
name_ = ACE_TEXT_ALWAYS_CHAR(current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Priority"))))
{
task_priority_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Period"))))
{
period_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ExecTime"))))
{
exec_time_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Phase"))))
{
phase_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Iter"))))
{
iter_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
// create the stat object.
ACE_NEW_RETURN (task_stats_, Task_Stats (iter_), -1);
if (task_stats_->init () == -1)
return -1;
}
else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Load"))))
{
load_ = ACE_OS::atoi (current_arg);
arg_shifter.consume_arg ();
return 0;
}
else
{
ACE_DEBUG ((LM_DEBUG, "parse Task unknown option %s\n",
arg_shifter.get_current ()));
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG, "name %s, priority %d, period %duS, exec_time %duS, phase %duS, iter %d, load %d\n",
name_.c_str(), task_priority_, period_, exec_time_, phase_, iter_, load_));
break;
}
}
return 0;
}
示例7: ACE_GUARD_RETURN
int WorldSocket::SendPacket(WorldPacket const& pct)
{
ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
if (closing_)
return -1;
// Dump outgoing packet
if (sPacketLog->CanLogPacket())
sPacketLog->LogPacket(pct, SERVER_TO_CLIENT);
WorldPacket const* pkt = &pct;
// Empty buffer used in case packet should be compressed
// Disable compression for now :)
/* WorldPacket buff;
if (m_Session && pkt->size() > 0x400)
{
buff.Compress(m_Session->GetCompressionStream(), pkt);
pkt = &buff;
}*/
if (m_Session)
TC_LOG_TRACE("network.opcode", "S->C: %s %s", m_Session->GetPlayerInfo().c_str(), GetOpcodeNameForLogging(pkt->GetOpcode()).c_str());
sScriptMgr->OnPacketSend(this, *pkt);
ServerPktHeader header(!m_Crypt.IsInitialized() ? pkt->size() + 2 : pct.size(), pkt->GetOpcode(), &m_Crypt);
if (m_OutBuffer->space() >= pkt->size() + header.getHeaderLength() && msg_queue()->is_empty())
{
// Put the packet on the buffer.
if (m_OutBuffer->copy((char*) header.header, header.getHeaderLength()) == -1)
ACE_ASSERT (false);
if (!pkt->empty())
if (m_OutBuffer->copy((char*) pkt->contents(), pkt->size()) == -1)
ACE_ASSERT (false);
}
else
{
// Enqueue the packet.
ACE_Message_Block* mb;
ACE_NEW_RETURN(mb, ACE_Message_Block(pkt->size() + header.getHeaderLength()), -1);
mb->copy((char*) header.header, header.getHeaderLength());
if (!pkt->empty())
mb->copy((const char*)pkt->contents(), pkt->size());
if (msg_queue()->enqueue_tail(mb, (ACE_Time_Value*)&ACE_Time_Value::zero) == -1)
{
TC_LOG_ERROR("network", "WorldSocket::SendPacket enqueue_tail failed");
mb->release();
return -1;
}
}
return 0;
}
示例8: ACE_NEW_RETURN
//
// begin
//
CUTS_Action_Iterator * CUTS_Worker::begin (void)
{
CUTS_Action_Iterator * iter = 0;
ACE_NEW_RETURN (iter, CUTS_Action_Iterator (), 0);
return iter;
}
示例9: defined
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int
ACE_OS::argv_to_string (ACE_TCHAR **argv,
ACE_TCHAR *&buf,
int substitute_env_args)
{
if (argv == 0 || argv[0] == 0)
return 0;
size_t buf_len = 0;
// Determine the length of the buffer.
for (int i = 0; argv[i] != 0; i++)
{
#if !defined (ACE_LACKS_ENV)
// Account for environment variables.
if (substitute_env_args && argv[i][0] == ACE_LIB_TEXT ('$'))
{
# if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR)
ACE_TCHAR *temp = 0;
// Win32 is the only platform with a wide-char ACE_OS::getenv().
if ((temp = ACE_OS::getenv (&argv[i][1])) != 0)
buf_len += ACE_OS::strlen (temp);
else
buf_len += ACE_OS::strlen (argv[i]);
# else
// This is an ACE_HAS_WCHAR platform and not ACE_WIN32.
// Convert the env variable name for getenv(), then add
// the length of the returned char *string. Later, when we
// actually use the returned env variable value, convert it
// as well.
char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[i][1]));
if (ctemp == 0)
buf_len += ACE_OS::strlen (argv[i]);
else
buf_len += ACE_OS::strlen (ctemp);
# endif /* ACE_WIN32 || !ACE_HAS_WCHAR */
}
else
#endif /* ACE_LACKS_ENV */
buf_len += ACE_OS::strlen (argv[i]);
// Add one for the extra space between each string.
buf_len++;
}
// Step through all argv params and copy each one into buf; separate
// each param with white space.
ACE_NEW_RETURN (buf,
ACE_TCHAR[buf_len + 1],
0);
// Initial null charater to make it a null string.
buf[0] = '\0';
ACE_TCHAR *end = buf;
int j;
for (j = 0; argv[j] != 0; j++)
{
#if !defined (ACE_LACKS_ENV)
// Account for environment variables.
if (substitute_env_args && argv[j][0] == ACE_LIB_TEXT ('$'))
{
# if defined (ACE_WIN32) || !defined (ACE_HAS_WCHAR)
// Win32 is the only platform with a wide-char ACE_OS::getenv().
ACE_TCHAR *temp = ACE_OS::getenv (&argv[j][1]);
if (temp != 0)
end = ACE_OS::strecpy (end, temp);
else
end = ACE_OS::strecpy (end, argv[j]);
# else
// This is an ACE_HAS_WCHAR platform and not ACE_WIN32.
// Convert the env variable name for getenv(), then convert
// the returned char *string back to wchar_t.
char *ctemp = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (&argv[j][1]));
if (ctemp == 0)
end = ACE_OS::strecpy (end, argv[j]);
else
end = ACE_OS::strecpy (end, ACE_TEXT_CHAR_TO_TCHAR (ctemp));
# endif /* ACE_WIN32 || !ACE_HAS_WCHAR */
}
else
#endif /* ACE_LACKS_ENV */
end = ACE_OS::strecpy (end, argv[j]);
// Replace the null char that strecpy put there with white
// space.
end[-1] = ' ';
}
// Null terminate the string.
*end = '\0';
// The number of arguments.
return j;
}
示例10: if
template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::open
(creation_strategy_type *cre_s,
ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
ACE_Recycling_Strategy<SVC_HANDLER> *rec_s)
{
// Initialize the creation strategy.
// First we decide if we need to clean up.
if (this->creation_strategy_ != 0 &&
this->delete_creation_strategy_ != 0 &&
cre_s != 0)
{
delete this->creation_strategy_;
this->creation_strategy_ = 0;
this->delete_creation_strategy_ = 0;
}
if (cre_s != 0)
this->creation_strategy_ = cre_s;
else if (this->creation_strategy_ == 0)
{
ACE_NEW_RETURN (this->creation_strategy_,
CREATION_STRATEGY, -1);
this->delete_creation_strategy_ = 1;
}
// Initialize the concurrency strategy.
if (this->concurrency_strategy_ != 0 &&
this->delete_concurrency_strategy_ != 0 &&
con_s != 0)
{
delete this->concurrency_strategy_;
this->concurrency_strategy_ = 0;
this->delete_concurrency_strategy_ = 0;
}
if (con_s != 0)
this->concurrency_strategy_ = con_s;
else if (this->concurrency_strategy_ == 0)
{
ACE_NEW_RETURN (this->concurrency_strategy_,
CONCURRENCY_STRATEGY, -1);
this->delete_concurrency_strategy_ = 1;
}
// Initialize the recycling strategy.
if (this->recycling_strategy_ != 0 &&
this->delete_recycling_strategy_ != 0 &&
rec_s != 0)
{
delete this->recycling_strategy_;
this->recycling_strategy_ = 0;
this->delete_recycling_strategy_ = 0;
}
if (rec_s != 0)
this->recycling_strategy_ = rec_s;
else if (this->recycling_strategy_ == 0)
{
ACE_NEW_RETURN (this->recycling_strategy_,
RECYCLING_STRATEGY, -1);
this->delete_recycling_strategy_ = 1;
}
return 0;
}
示例11: ACE_NEW_RETURN
TAO::CSD::Strategy_Base::DispatchResult
TAO_DTP_POA_Strategy::dispatch_collocated_request_i
(TAO_ServerRequest& server_request,
const PortableServer::ObjectId& object_id,
PortableServer::POA_ptr poa,
const char* operation,
PortableServer::Servant servant)
{
TAO::CSD::TP_Servant_State::HandleType servant_state =
this->get_servant_state (servant);
bool is_sync_with_server = server_request.sync_with_server ();
bool is_synchronous = server_request.response_expected ();
TAO::CSD::TP_Collocated_Synch_Request_Handle
synch_request;
TAO::CSD::TP_Collocated_Synch_With_Server_Request_Handle
synch_with_server_request;
TAO::CSD::TP_Request_Handle
request;
// Create the request object using the appropriate concrete type.
if (is_sync_with_server)
{
TAO::CSD::TP_Collocated_Synch_With_Server_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Synch_With_Server_Request
(server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
synch_with_server_request = req_ptr;
// Give the request handle its own "copy".
synch_with_server_request->_add_ref ();
request = synch_with_server_request.in ();
}
else if (is_synchronous)
{
TAO::CSD::TP_Collocated_Synch_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Synch_Request (
server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
synch_request = req_ptr;
// Give the request handle its own "copy".
synch_request->_add_ref ();
request = synch_request.in ();
}
else
{
TAO::CSD::TP_Collocated_Asynch_Request *req_ptr;
ACE_NEW_RETURN (req_ptr,
TAO::CSD::TP_Collocated_Asynch_Request (server_request,
object_id,
poa,
operation,
servant,
servant_state.in ()),
DISPATCH_REJECTED);
// Just use the (base) request handle to hold the request object.
request = req_ptr;
}
// Hand the request object to our task so that it can add the request
// to its "request queue".
if (!this->dtp_task_.add_request (request.in ()))
{
// Return the DISPATCH_REJECTED return code so that the caller (our
// base class' dispatch_request() method) knows that we did
// not handle the request, and that it should be rejected.
return DISPATCH_REJECTED;
}
// We need to wait on the request object if the request type is a
// synchronous request.
if (!synch_request.is_nil ())
{
int srw = synch_request->wait ();
if (srw == false)
{
// Raise exception when request was cancelled.
throw ::CORBA::NO_IMPLEMENT ();
}
}
//.........这里部分代码省略.........
示例12: ACE_TMAIN
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
if (CORBA::is_nil (root_poa.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil RootPOA\n"),
1);
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
// Make all oneways "reliable."
{
CORBA::Object_var manager_object =
orb->resolve_initial_references("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow(manager_object.in());
if (CORBA::is_nil (policy_manager.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Panic: nil PolicyManager\n"),
1);
CORBA::Any policy_value;
policy_value <<= Messaging::SYNC_WITH_SERVER;
CORBA::PolicyList policies(1); policies.length(1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
policy_value);
policy_manager->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
policies[0]->destroy ();
}
if (parse_args (argc, argv) != 0)
return 1;
Service *service_impl;
ACE_NEW_RETURN (service_impl,
Service(orb.in ()),
1);
PortableServer::ServantBase_var owner_transfer(service_impl);
PortableServer::ObjectId_var id =
root_poa->activate_object (service_impl);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Test::Service_var service =
Test::Service::_narrow (object.in ());
CORBA::String_var ior =
orb->object_to_string (service.in ());
// If the ior_output_file exists, output the ior to it
FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
if (output_file == 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot open output file for writing IOR: %s",
ior_output_file),
1);
ACE_OS::fprintf (output_file, "%s", ior.in ());
ACE_OS::fclose (output_file);
poa_manager->activate ();
orb->run ();
ACE_DEBUG ((LM_DEBUG, "Event loop finished\n"));
service_impl->dump_results ();
root_poa->destroy (1, 1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
示例13: test_active_map_manager
static int
test_active_map_manager (size_t table_size,
size_t iterations,
int test_iterators)
{
ACTIVE_MAP_MANAGER map (table_size);
TYPE i;
TYPE j = 0;
ssize_t k;
ACTIVE_MAP_MANAGER::key_type *active_keys;
ACE_NEW_RETURN (active_keys,
ACTIVE_MAP_MANAGER::key_type[iterations],
1);
for (i = 0;
i < iterations;
i++)
ACE_TEST_ASSERT (map.bind (i, active_keys[i]) != -1);
if (test_iterators)
{
{
i = 0;
ACTIVE_MAP_MANAGER::iterator end = map.end ();
for (ACTIVE_MAP_MANAGER::iterator iter = map.begin ();
iter != end;
++iter)
{
ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d-%d|%d)"),
i,
entry.ext_id_.slot_index (),
entry.ext_id_.slot_generation (),
entry.int_id_));
++i;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_TEST_ASSERT (i == iterations);
}
{
k = iterations - 1;
ACTIVE_MAP_MANAGER::reverse_iterator rend = map.rend ();
for (ACTIVE_MAP_MANAGER::reverse_iterator iter = map.rbegin ();
iter != rend;
++iter)
{
ACTIVE_MAP_MANAGER::ENTRY &entry = *iter;
ACE_UNUSED_ARG (entry);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%d|%d-%d|%d)"),
k,
entry.ext_id_.slot_index (),
entry.ext_id_.slot_generation (),
entry.int_id_));
k--;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("\n")));
ACE_TEST_ASSERT (k == -1);
}
}
for (i = 0; i < iterations; ++i)
{
ACE_TEST_ASSERT (map.find (active_keys[i], j) != -1);
ACE_TEST_ASSERT (i == j);
}
size_t remaining_entries = iterations;
for (i = 0; i < iterations; ++i)
{
ACE_TEST_ASSERT (map.unbind (active_keys[i]) != -1);
--remaining_entries;
ACE_TEST_ASSERT (map.current_size () == remaining_entries);
}
delete [] active_keys;
return 0;
}
示例14: test_orb
int test_orb (CORBA::ORB_ptr orb)
{
int errors = 0;
POA_TestModule::test* test = 0;
ACE_NEW_RETURN (test,
test_i, 1);
PortableServer::ServantBase_var safe (test);
CORBA::Object_var object = test->_this ();
orb->register_initial_reference ("ORBMyService",
object.in ());
bool invalid_name = false;
try
{
// Registering with an empty string should give an exception
orb->register_initial_reference ("",
object.in ());
}
catch (const CORBA::ORB::InvalidName&)
{
invalid_name = true;
}
catch (const CORBA::Exception&)
{
}
if (!invalid_name)
{
errors++;
ACE_ERROR ((LM_ERROR, "ERROR: Registering with an empty string with the ORB"
"doesn't throw an exception\n"));
}
bool duplicate_name = false;
try
{
// Registering with an duplicate string should give an exception
orb->register_initial_reference ("ORBMyService",
object.in ());
}
catch (const CORBA::ORB::InvalidName&)
{
duplicate_name = true;
}
catch (const CORBA::Exception&)
{
}
if (!duplicate_name)
{
errors++;
ACE_ERROR ((LM_ERROR, "ERROR: Registering with a duplicate with ORB "
"doesn't throw the expected exception\n"));
}
bool invalid_object = false;
try
{
// Registering with a nil object
orb->register_initial_reference ("ORBNilServer",
CORBA::Object::_nil());
}
catch (const CORBA::BAD_PARAM& ex)
{
if ((ex.minor() & 0xFFFU) == 27)
{
invalid_object = true;
}
}
catch (const CORBA::Exception&)
{
}
if (!invalid_object)
{
errors++;
ACE_ERROR ((LM_ERROR, "ERROR: Registering with a nil object to ORB "
"doesn't throw bad param with minor code 27\n"));
}
return errors;
}
示例15: while
int
ACE_OS::string_to_argv (ACE_TCHAR *buf,
int &argc,
ACE_TCHAR **&argv,
int substitute_env_args)
{
// Reset the number of arguments
argc = 0;
if (buf == 0)
return -1;
ACE_TCHAR *cp = buf;
// First pass: count arguments.
// '#' is the start-comment token..
while (*cp != ACE_LIB_TEXT ('\0') && *cp != ACE_LIB_TEXT ('#'))
{
// Skip whitespace..
while (ACE_OS::ace_isspace (*cp))
cp++;
// Increment count and move to next whitespace..
if (*cp != ACE_LIB_TEXT ('\0'))
argc++;
while (*cp != ACE_LIB_TEXT ('\0') && !ACE_OS::ace_isspace (*cp))
{
// Grok quotes....
if (*cp == ACE_LIB_TEXT ('\'') || *cp == ACE_LIB_TEXT ('"'))
{
ACE_TCHAR quote = *cp;
// Scan past the string..
for (cp++; *cp != ACE_LIB_TEXT ('\0') && *cp != quote; cp++)
continue;
// '\0' implies unmatched quote..
if (*cp == ACE_LIB_TEXT ('\0'))
{
argc--;
break;
}
else
cp++;
}
else
cp++;
}
}
// Second pass: copy arguments.
ACE_TCHAR arg[ACE_DEFAULT_ARGV_BUFSIZ];
ACE_TCHAR *argp = arg;
// Make sure that the buffer we're copying into is always large
// enough.
if (cp - buf >= ACE_DEFAULT_ARGV_BUFSIZ)
ACE_NEW_RETURN (argp,
ACE_TCHAR[cp - buf + 1],
-1);
// Make a new argv vector of argc + 1 elements.
ACE_NEW_RETURN (argv,
ACE_TCHAR *[argc + 1],
-1);
ACE_TCHAR *ptr = buf;
for (int i = 0; i < argc; i++)
{
// Skip whitespace..
while (ACE_OS::ace_isspace (*ptr))
ptr++;
// Copy next argument and move to next whitespace..
cp = argp;
while (*ptr != ACE_LIB_TEXT ('\0') && !ACE_OS::ace_isspace (*ptr))
if (*ptr == ACE_LIB_TEXT ('\'') || *ptr == ACE_LIB_TEXT ('"'))
{
ACE_TCHAR quote = *ptr++;
while (*ptr != ACE_LIB_TEXT ('\0') && *ptr != quote)
*cp++ = *ptr++;
if (*ptr == quote)
ptr++;
}
else
*cp++ = *ptr++;
*cp = ACE_LIB_TEXT ('\0');
#if !defined (ACE_LACKS_ENV)
// Check for environment variable substitution here.
if (substitute_env_args) {
argv[i] = ACE_OS::strenvdup(argp);
if (argv[i] == 0)
//.........这里部分代码省略.........