Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_Remote_Name_Space Class Reference

Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings. More...

#include <Remote_Name_Space.h>

Inheritance diagram for ACE_Remote_Name_Space:

Inheritance graph
[legend]
Collaboration diagram for ACE_Remote_Name_Space:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Remote_Name_Space (void)
 "Do-nothing" constructor.

 ACE_Remote_Name_Space (const ACE_TCHAR *hostname, u_short port)
int open (const ACE_TCHAR *servername, u_short port)
 ~ACE_Remote_Name_Space (void)
virtual int bind (const ACE_NS_WString &name_in, const ACE_NS_WString &value_in, const char *type_in="")
 Bind a new name to a naming context (Wide character strings).

virtual int rebind (const ACE_NS_WString &name_in, const ACE_NS_WString &value_in, const char *type_in="")
virtual int unbind (const ACE_NS_WString &name_in)
virtual int resolve (const ACE_NS_WString &name_in, ACE_NS_WString &value_out, char *&type_out)
virtual int list_names (ACE_WSTRING_SET &set_out, const ACE_NS_WString &pattern_in)
virtual int list_values (ACE_WSTRING_SET &set_out, const ACE_NS_WString &pattern_in)
virtual int list_types (ACE_WSTRING_SET &set_out, const ACE_NS_WString &pattern_in)
virtual int list_name_entries (ACE_BINDING_SET &set, const ACE_NS_WString &pattern)
virtual int list_value_entries (ACE_BINDING_SET &set, const ACE_NS_WString &pattern)
virtual int list_type_entries (ACE_BINDING_SET &set, const ACE_NS_WString &pattern)
virtual void dump (void) const
 Dump the state of the object.


Private Attributes

ACE_Name_Proxy ns_proxy_
 Interface to Name server process for NET_LOCAL namespace.

Detailed Description

Maintaining accesses Remote Name Server Database. Allows to add NameBindings, change them, remove them and resolve NameBindings.

Manages a Naming Service for a remote name space which includes bindings for net_local naming context. All strings are stored in wide character format. A Name Binding consists of a name (that's the key), a value string and an optional type string (no wide chars).

Definition at line 47 of file Remote_Name_Space.h.

Constructor & Destructor Documentation

ACE_Remote_Name_Space::ACE_Remote_Name_Space (  void   ) 
 

"Do-nothing" constructor.

Definition at line 30 of file Remote_Name_Space.cpp.

References ACE_TRACE. 

00031 {
00032   ACE_TRACE ("ACE_Remote_Name_Space::ACE_Remote_Name_Space");
00033 }

ACE_Remote_Name_Space::ACE_Remote_Name_Space (  const ACE_TCHAR *  hostname,
u_short  port
) 
 

Specifies the scope of this namespace, opens and memory-maps the associated file (if accessible) or contacts the dedicated name server process for NET_LOCAL namespace.

Definition at line 35 of file Remote_Name_Space.cpp.

References ACE_ERROR, ACE_TCHAR, ACE_TEXT, ACE_TRACE, LM_ERROR, and open(). 

00037 {
00038   ACE_TRACE ("ACE_Remote_Name_Space::ACE_Remote_Name_Space");
00039   if (this->open (hostname, port) == -1)
00040     ACE_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Remote_Name_Space::ACE_Remote_Name_Space")));
00041 }

ACE_Remote_Name_Space::~ACE_Remote_Name_Space (  void   ) 
 

destructor, do some cleanup :TBD: last dtor should "compress" file

Definition at line 363 of file Remote_Name_Space.cpp.

References ACE_TRACE. 

00364 {
00365   ACE_TRACE ("ACE_Remote_Name_Space::~ACE_Remote_Name_Space");
00366 }

Member Function Documentation

int ACE_Remote_Name_Space::bind (  const ACE_NS_WString &  name_in,
const ACE_NS_WString &  value_in,
const char *  type_in = ""
)  [virtual]
 

Bind a new name to a naming context (Wide character strings).

Implements ACE_Name_Space.

Definition at line 44 of file Remote_Name_Space.cpp.

References ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_String_Base< CHAR >::length(), ns_proxy_, ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::request_reply(), and ACE_OS::strlen(). 

00047 {
00048   ACE_TRACE ("ACE_Remote_Name_Space::bind");
00049   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
00050   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> value_urep (value.rep ());
00051   ACE_UINT32 name_len =
00052     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
00053   ACE_UINT32 value_len =
00054     static_cast<ACE_UINT32> (value.length () * sizeof (ACE_WCHAR_T));
00055   ACE_UINT32 type_len =
00056     static_cast<ACE_UINT32> (ACE_OS::strlen (type));
00057   ACE_Name_Request request (ACE_Name_Request::BIND,
00058                             name_urep.get (),
00059                             name_len,
00060                             value_urep.get (),
00061                             value_len,
00062                             type,
00063                             type_len);
00064   return this->ns_proxy_.request_reply (request);
00065 }

void ACE_Remote_Name_Space::dump (  void   )  const [virtual]
 

Dump the state of the object.

Implements ACE_Name_Space.

Definition at line 369 of file Remote_Name_Space.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_TRACE, ACE_Name_Proxy::dump(), LM_DEBUG, and ns_proxy_. 

00370 {
00371 #if defined (ACE_HAS_DUMP)
00372   ACE_TRACE ("ACE_Remote_Name_Space::dump");
00373 
00374   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00375   this->ns_proxy_.dump ();
00376   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00377 #endif /* ACE_HAS_DUMP */
00378 }

int ACE_Remote_Name_Space::list_name_entries (  ACE_BINDING_SET &  set,
const ACE_NS_WString &  pattern
)  [virtual]
 

Get a set of names matching a specified pattern (wchars). Matching means the names must begin with the pattern string. Returns the complete binding associated each pattern match.

Implements ACE_Name_Space.

Definition at line 241 of file Remote_Name_Space.cpp.

References ACE_BINDING_SET, ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ACE_Name_Request::name(), ACE_Name_Request::name_len(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), ACE_Name_Request::type(), ACE_Name_Request::value(), and ACE_Name_Request::value_len(). 

00243 {
00244   ACE_TRACE ("ACE_Remote_Name_Space::list_name_entries");
00245   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00246   ACE_UINT32 pattern_len =
00247     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00248   ACE_Name_Request request (ACE_Name_Request::LIST_NAME_ENTRIES,
00249                             pattern_urep.get (),
00250                             pattern_len,
00251                             0, 0, 0, 0);
00252 
00253   if (this->ns_proxy_.send_request (request) == -1)
00254     return -1;
00255 
00256   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00257 
00258   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00259     {
00260       if (this->ns_proxy_.recv_reply (reply) == -1)
00261         ACE_ERROR_RETURN ((LM_ERROR,
00262                            ACE_TEXT ("%p\n"),
00263                            ACE_TEXT ("ACE_Remote_Name_Space::list_names")),
00264                            -1);
00265       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00266         {
00267           ACE_NS_WString name (reply.name (),
00268                                reply.name_len () / sizeof (ACE_WCHAR_T));
00269           ACE_NS_WString value (reply.value (),
00270                                 reply.value_len () / sizeof (ACE_WCHAR_T));
00271           ACE_Name_Binding entry (name,
00272                                   value,
00273                                   reply.type ());
00274           if (set.insert (entry) == -1)
00275             return -1;
00276         }
00277     }
00278   return 0;
00279 }

int ACE_Remote_Name_Space::list_names (  ACE_WSTRING_SET &  set_out,
const ACE_NS_WString &  pattern_in
)  [virtual]
 

Get a set of names matching a specified pattern (wchars). Matching means the names must begin with the pattern string.

Implements ACE_Name_Space.

Definition at line 137 of file Remote_Name_Space.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_WSTRING_SET, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ACE_Name_Request::name(), ACE_Name_Request::name_len(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), and ACE_Name_Proxy::send_request(). 

00139 {
00140   ACE_TRACE ("ACE_Remote_Name_Space::list_names");
00141   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00142   ACE_UINT32 pattern_len =
00143     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00144   ACE_Name_Request request (ACE_Name_Request::LIST_NAMES,
00145                             pattern_urep.get (),
00146                             pattern_len,
00147                             0, 0, 0, 0);
00148   if (this->ns_proxy_.send_request (request) == -1)
00149     return -1;
00150 
00151   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00152 
00153   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00154     {
00155       if (this->ns_proxy_.recv_reply (reply) == -1)
00156         ACE_ERROR_RETURN ((LM_ERROR,
00157                            ACE_TEXT ("%p\n"),
00158                            ACE_TEXT ("ACE_Remote_Name_Space::list_names")),
00159                            -1);
00160       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00161         {
00162           ACE_NS_WString name (reply.name (),
00163                                reply.name_len () / sizeof (ACE_WCHAR_T));
00164           set.insert (name);
00165         }
00166     }
00167   return 0;
00168 }

int ACE_Remote_Name_Space::list_type_entries (  ACE_BINDING_SET &  set,
const ACE_NS_WString &  pattern
)  [virtual]
 

Get a set of types matching a specified pattern (wchars). Matching means the types must begin with the pattern string. Returns the complete binding associated each pattern match.

Implements ACE_Name_Space.

Definition at line 323 of file Remote_Name_Space.cpp.

References ACE_BINDING_SET, ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ACE_Name_Request::name(), ACE_Name_Request::name_len(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), ACE_Name_Request::type(), ACE_Name_Request::value(), and ACE_Name_Request::value_len(). 

00325 {
00326   ACE_TRACE ("ACE_Remote_Name_Space::list_type_entries");
00327   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00328   ACE_UINT32 pattern_len =
00329     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00330   ACE_Name_Request request (ACE_Name_Request::LIST_TYPE_ENTRIES,
00331                             pattern_urep.get (),
00332                             pattern_len,
00333                             0, 0, 0, 0);
00334 
00335   if (this->ns_proxy_.send_request (request) == -1)
00336     return -1;
00337 
00338   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00339 
00340   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00341     {
00342       if (this->ns_proxy_.recv_reply (reply) == -1)
00343         ACE_ERROR_RETURN ((LM_ERROR,
00344                            ACE_TEXT ("%p\n"),
00345                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
00346                           -1);
00347       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00348         {
00349           ACE_NS_WString name (reply.name (),
00350                                reply.name_len () / sizeof (ACE_WCHAR_T));
00351           ACE_NS_WString value (reply.value (),
00352                                 reply.value_len () / sizeof (ACE_WCHAR_T));
00353           ACE_Name_Binding entry (name,
00354                                   value,
00355                                   reply.type ());
00356           if (set.insert (entry) == -1)
00357               return -1;
00358         }
00359     }
00360   return 0;
00361 }

int ACE_Remote_Name_Space::list_types (  ACE_WSTRING_SET &  set_out,
const ACE_NS_WString &  pattern_in
)  [virtual]
 

Get a set of types matching a specified pattern (wchars). Matching means the types must begin with the pattern string.

Implements ACE_Name_Space.

Definition at line 206 of file Remote_Name_Space.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_WSTRING_SET, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), and ACE_Name_Request::type(). 

00208 {
00209   ACE_TRACE ("ACE_Remote_Name_Space::list_types");
00210   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00211   ACE_UINT32 pattern_len =
00212     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00213   ACE_Name_Request request (ACE_Name_Request::LIST_TYPES,
00214                             pattern_urep.get (),
00215                             pattern_len,
00216                             0, 0, 0, 0);
00217 
00218   if (this->ns_proxy_.send_request (request) == -1)
00219     return -1;
00220 
00221   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00222 
00223   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00224     {
00225       if (this->ns_proxy_.recv_reply (reply) == -1)
00226         ACE_ERROR_RETURN ((LM_ERROR,
00227                            ACE_TEXT ("%p\n"),
00228                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
00229                            -1);
00230       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00231         {
00232           ACE_NS_WString type (reply.type ());
00233           set.insert (type);
00234         }
00235     }
00236 
00237   return 0;
00238 }

int ACE_Remote_Name_Space::list_value_entries (  ACE_BINDING_SET &  set,
const ACE_NS_WString &  pattern
)  [virtual]
 

Get a set of values matching a specified pattern (wchars). Matching means the values must begin with the pattern string. Returns the complete binding associated each pattern match.

Implements ACE_Name_Space.

Definition at line 282 of file Remote_Name_Space.cpp.

References ACE_BINDING_SET, ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ACE_Name_Request::name(), ACE_Name_Request::name_len(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), ACE_Name_Request::type(), ACE_Name_Request::value(), and ACE_Name_Request::value_len(). 

00284 {
00285   ACE_TRACE ("ACE_Remote_Name_Space::list_value_entries");
00286   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00287   ACE_UINT32 pattern_len =
00288     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00289   ACE_Name_Request request (ACE_Name_Request::LIST_VALUE_ENTRIES,
00290                             pattern_urep.get (),
00291                             pattern_len,
00292                             0, 0, 0, 0);
00293 
00294   if (this->ns_proxy_.send_request (request) == -1)
00295     return -1;
00296 
00297   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00298 
00299   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00300     {
00301       if (this->ns_proxy_.recv_reply (reply) == -1)
00302         ACE_ERROR_RETURN ((LM_ERROR,
00303                            ACE_TEXT ("%p\n"),
00304                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
00305                            -1);
00306       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00307         {
00308           ACE_NS_WString name (reply.name (),
00309                                reply.name_len () / sizeof (ACE_WCHAR_T));
00310           ACE_NS_WString value (reply.value (),
00311                                 reply.value_len () / sizeof (ACE_WCHAR_T));
00312           ACE_Name_Binding entry (name,
00313                                   value,
00314                                   reply.type());
00315           if (set.insert (entry) == -1)
00316             return -1;
00317         }
00318     }
00319   return 0;
00320 }

int ACE_Remote_Name_Space::list_values (  ACE_WSTRING_SET &  set_out,
const ACE_NS_WString &  pattern_in
)  [virtual]
 

Get a set of values matching a specified pattern (wchars). Matching means the values must begin with the pattern string.

Implements ACE_Name_Space.

Definition at line 171 of file Remote_Name_Space.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_TRACE, ACE_WCHAR_T, ACE_WSTRING_SET, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_Unbounded_Set< T >::insert(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_Name_Request::msg_type(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), ACE_Name_Request::value(), and ACE_Name_Request::value_len(). 

00173 {
00174   ACE_TRACE ("ACE_Remote_Name_Space::list_values");
00175   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> pattern_urep (pattern.rep ());
00176   ACE_UINT32 pattern_len =
00177     static_cast<ACE_UINT32> (pattern.length () * sizeof (ACE_WCHAR_T));
00178   ACE_Name_Request request (ACE_Name_Request::LIST_VALUES,
00179                             pattern_urep.get (),
00180                             pattern_len,
00181                             0, 0, 0, 0);
00182   if (this->ns_proxy_.send_request (request) == -1)
00183     return -1;
00184 
00185   ACE_Name_Request reply (0, 0, 0, 0, 0, 0, 0, 0);
00186 
00187   while (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00188     {
00189       if (this->ns_proxy_.recv_reply (reply) == -1)
00190         ACE_ERROR_RETURN ((LM_ERROR,
00191                            ACE_TEXT ("%p\n"),
00192                            ACE_TEXT ("ACE_Remote_Name_Space::list_values")),
00193                            -1);
00194       if (reply.msg_type () != ACE_Name_Request::MAX_ENUM)
00195         {
00196           ACE_NS_WString value (reply.value (),
00197                                 reply.value_len () / sizeof (ACE_WCHAR_T));
00198           set.insert (value);
00199         }
00200     }
00201 
00202   return 0;
00203 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL int ACE_Remote_Name_Space::open (  const ACE_TCHAR *  servername,
u_short  port
) 
 

Specifies the scope of this namespace, opens and memory-maps the associated file (if accessible) or contacts the dedicated name server process for NET_LOCAL namespace.

Definition at line 14 of file Remote_Name_Space.cpp.

References ACE_TCHAR, ACE_TRACE, ns_proxy_, ACE_Name_Proxy::open(), and ACE_INET_Addr::set().

Referenced by ACE_Remote_Name_Space(). 

00015 {
00016   ACE_TRACE ("ACE_Remote_Name_Space::open");
00017   ACE_INET_Addr servaddr;
00018 
00019   // Initialize Addr
00020   if (servaddr.set (port, servername) == -1)
00021     return -1;
00022 
00023   // Connect to Name Server process.
00024   if (this->ns_proxy_.open (servaddr) == -1)
00025     return -1;
00026 
00027   return 0;
00028 }

int ACE_Remote_Name_Space::rebind (  const ACE_NS_WString &  name_in,
const ACE_NS_WString &  value_in,
const char *  type_in = ""
)  [virtual]
 

Overwrite the value or type of an existing name in a ACE_Remote_Name_Space or bind a new name to the context, if it didn't exist yet. (Wide charcter strings interface).

Implements ACE_Name_Space.

Definition at line 68 of file Remote_Name_Space.cpp.

References ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_String_Base< CHAR >::length(), ns_proxy_, ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::request_reply(), and ACE_OS::strlen(). 

00071 {
00072   ACE_TRACE ("ACE_Remote_Name_Space::rebind");
00073   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
00074   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> value_urep (value.rep ());
00075   ACE_UINT32 name_len =
00076     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
00077   ACE_UINT32 value_len =
00078     static_cast<ACE_UINT32> (value.length () * sizeof (ACE_WCHAR_T));
00079   ACE_UINT32 type_len =
00080     static_cast<ACE_UINT32> (ACE_OS::strlen (type));
00081   ACE_Name_Request request (ACE_Name_Request::REBIND,
00082                             name_urep.get (),
00083                             name_len,
00084                             value_urep.get (),
00085                             value_len,
00086                             type,
00087                             type_len);
00088   return this->ns_proxy_.request_reply (request);
00089 }

int ACE_Remote_Name_Space::resolve (  const ACE_NS_WString &  name_in,
ACE_NS_WString &  value_out,
char *&  type_out
)  [virtual]
 

Get value and type of a given name binding (Wide chars). The caller is responsible for deleting both and !

Implements ACE_Name_Space.

Definition at line 92 of file Remote_Name_Space.cpp.

References ACE_NEW_RETURN, ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_String_Base< CHAR >::length(), ns_proxy_, ACE_Name_Proxy::recv_reply(), ACE_String_Base< CHAR >::rep(), ACE_Name_Proxy::send_request(), ACE_OS::strcpy(), ACE_Name_Request::type(), ACE_Name_Request::type_len(), ACE_Name_Request::value(), and ACE_Name_Request::value_len(). 

00095 {
00096   ACE_TRACE ("ACE_Remote_Name_Space::resolve");
00097   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
00098   ACE_UINT32 name_len =
00099     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
00100   ACE_Name_Request request (ACE_Name_Request::RESOLVE,
00101                             name_urep.get (),
00102                             name_len,
00103                             0, 0, 0, 0);
00104 
00105   if (this->ns_proxy_.send_request (request) == -1)
00106     return -1;
00107 
00108   ACE_Name_Request reply;
00109 
00110   if (this->ns_proxy_.recv_reply (reply) == -1)
00111     return -1;
00112 
00113   ACE_NS_WString temp (reply.value (), reply.value_len () / sizeof (ACE_WCHAR_T));
00114   value = temp;
00115   ACE_NEW_RETURN (type,
00116                   char[reply.type_len () + 1],
00117                   -1);
00118   ACE_OS::strcpy (type, reply.type ());
00119   return 0;
00120 }

int ACE_Remote_Name_Space::unbind (  const ACE_NS_WString &  name_in  )  [virtual]
 

Delete a name from a ACE_Remote_Name_Space (Wide charcter strings Interface).

Implements ACE_Name_Space.

Definition at line 123 of file Remote_Name_Space.cpp.

References ACE_TRACE, ACE_WCHAR_T, ACE_Auto_Basic_Array_Ptr< X >::get(), ACE_String_Base< CHAR >::length(), ns_proxy_, ACE_String_Base< CHAR >::rep(), and ACE_Name_Proxy::request_reply(). 

00124 {
00125   ACE_TRACE ("ACE_Remote_Name_Space::unbind");
00126   ACE_Auto_Basic_Array_Ptr<ACE_WCHAR_T> name_urep (name.rep ());
00127   ACE_UINT32 name_len =
00128     static_cast<ACE_UINT32> (name.length () * sizeof (ACE_WCHAR_T));
00129   ACE_Name_Request request (ACE_Name_Request::UNBIND,
00130                             name_urep.get (),
00131                             name_len,
00132                             0, 0, 0, 0);
00133   return this->ns_proxy_.request_reply (request);
00134 }

Member Data Documentation

ACE_Name_Proxy ACE_Remote_Name_Space::ns_proxy_ [private]
 

Interface to Name server process for NET_LOCAL namespace.

Definition at line 140 of file Remote_Name_Space.h.

Referenced by bind(), dump(), list_name_entries(), list_names(), list_type_entries(), list_types(), list_value_entries(), list_values(), open(), rebind(), resolve(), and unbind().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:56:56 2008 for ACE by doxygen 1.3.6