ACE/ace/Local_Name_Space_T.cpp

   1 #ifndef ACE_LOCAL_NAME_SPACE_T_CPP
   2 #define ACE_LOCAL_NAME_SPACE_T_CPP
   3
   4 #include "ace/ACE.h"
   5
   6 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   7 # pragma once
   8 #endif /* ACE_LACKS_PRAGMA_ONCE */
   9
  10 #include "ace/Local_Name_Space.h"
  11 #include "ace/Guard_T.h"
  12 #include "ace/OS_NS_regex.h"
  13 #include "ace/OS_NS_string.h"
  14 #include "ace/OS_NS_unistd.h"
  15 #include <memory>
  16
  17 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 template <class ALLOCATOR>
  20 ACE_Name_Space_Map<ALLOCATOR>::ACE_Name_Space_Map (ALLOCATOR *alloc)
  21   : MAP_MANAGER (alloc)
  22 {
  23   ACE_TRACE ("ACE_Name_Space_Map::ACE_Name_Space_Map");
  24 }
  25
  26 template <class ALLOCATOR> int
  27 ACE_Name_Space_Map<ALLOCATOR>::close (ALLOCATOR *alloc)
  28 {
  29   ACE_TRACE ("ACE_Name_Space_Map::close");
  30
  31   this->table_allocator_ = alloc;
  32   this->entry_allocator_ = alloc;
  33   return this->close_i ();
  34 }
  35
  36 template <class ALLOCATOR> int
  37 ACE_Name_Space_Map<ALLOCATOR>::bind (const ACE_NS_String &ext_id,
  38                                      const ACE_NS_Internal &int_id,
  39                                      ALLOCATOR *alloc)
  40 {
  41   ACE_TRACE ("ACE_Name_Space_Map::bind");
  42
  43   this->table_allocator_ = alloc;
  44   this->entry_allocator_ = alloc;
  45   return this->bind_i (ext_id, int_id);
  46 }
  47
  48 template <class ALLOCATOR> int
  49 ACE_Name_Space_Map<ALLOCATOR>::unbind (const ACE_NS_String &ext_id,
  50                                        ACE_NS_Internal &int_id,
  51                                        ALLOCATOR *alloc)
  52 {
  53   ACE_TRACE ("ACE_Name_Space_Map::unbind");
  54
  55   this->table_allocator_ = alloc;
  56   this->entry_allocator_ = alloc;
  57   return this->unbind_i (ext_id, int_id);
  58 }
  59
  60 template <class ALLOCATOR> int
  61 ACE_Name_Space_Map<ALLOCATOR>::rebind (const ACE_NS_String &ext_id,
  62                                        const ACE_NS_Internal &int_id,
  63                                        ACE_NS_String &old_ext_id,
  64                                        ACE_NS_Internal &old_int_id,
  65                                        ALLOCATOR *alloc)
  66 {
  67   ACE_TRACE ("ACE_Name_Space_Map::rebind");
  68
  69   this->table_allocator_ = alloc;
  70   this->entry_allocator_ = alloc;
  71   return this->rebind_i (ext_id, int_id, old_ext_id, old_int_id);
  72 }
  73
  74 template <class ALLOCATOR> int
  75 ACE_Name_Space_Map<ALLOCATOR>::find (const ACE_NS_String &ext_id,
  76                                      ACE_NS_Internal &int_id,
  77                                      ALLOCATOR *alloc)
  78 {
  79   ACE_TRACE ("ACE_Name_Space_Map::find");
  80
  81   this->table_allocator_ = alloc;
  82   this->entry_allocator_ = alloc;
  83   return this->find_i (ext_id, int_id);
  84 }
  85
  86 #if defined (ACE_WIN32)
  87 template <ACE_MEM_POOL_1, class ACE_LOCK> int
  88 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::remap (EXCEPTION_POINTERS *ep)
  89 {
  90   ACE_TRACE ("ACE_Local_Name_Space::remap");
  91
  92   void *addr = (void *) ep->ExceptionRecord->ExceptionInformation[1];
  93
  94   // The following requires Memory Pool to have ::remap()
  95   // defined. Thus currently this will only work for
  96   // ACE_MMap_Memory_Pool.
  97   if (this->allocator_->alloc ().memory_pool ().remap (addr) == -1)
  98     // Kick it upstairs...
  99     return EXCEPTION_CONTINUE_SEARCH;
 100
 101 #if __X86__
 102   // This is 80x86-specific.
 103   ep->ContextRecord->Edi = (DWORD) addr;
 104 #elif __MIPS__
 105   ep->ContextRecord->IntA0 =
 106     ep->ContextRecord->IntV0 = (DWORD) addr;
 107   ep->ContextRecord->IntT5 = ep->ContextRecord->IntA0 + 3;
 108 #endif /* __X86__ */
 109     // Resume execution at the original point of "failure."
 110   return EXCEPTION_CONTINUE_EXECUTION;
 111 }
 112 #endif /* ACE_WIN32 */
 113
 114 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 115 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (
 116   const ACE_NS_WString &name,
 117   const ACE_NS_WString &value,
 118   const char *type,
 119   int rebind)
 120 {
 121   // Note that we *must* use structured exception handling here
 122   // because (1) we may need to commit virtual memory pages and (2)
 123   // C++ exception handling doesn't support resumption.
 124   int result = 0;
 125   ACE_SEH_TRY
 126     {
 127       result = this->shared_bind_i (name, value, type, rebind);
 128     }
 129   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 130     {
 131     }
 132   return result;
 133 }
 134
 135 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 136 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind_i (
 137   const ACE_NS_WString &name,
 138   const ACE_NS_WString &value,
 139   const char *type,
 140   int rebind)
 141 {
 142   ACE_TRACE ("ACE_Local_Name_Space::shared_bind_i");
 143   const size_t name_len = (name.length () + 1) * sizeof (ACE_WCHAR_T);
 144   const size_t value_len = (value.length () + 1) * sizeof (ACE_WCHAR_T);
 145   const size_t type_len = ACE_OS::strlen (type) + 1;
 146   const size_t total_len = name_len + value_len + type_len;
 147   char *ptr = (char *) this->allocator_->malloc (total_len);
 148
 149   if (ptr == 0)
 150     return -1;
 151   else
 152     {
 153       // Note that the value_rep *must* come first to make sure we can
 154       // retrieve this pointer later on in unbind().
 155       ACE_WCHAR_T *value_rep = (ACE_WCHAR_T *) (ptr);
 156       ACE_WCHAR_T *name_rep = (ACE_WCHAR_T *) (ptr + value_len);
 157       char *new_type = (char *) (ptr + value_len + name_len);
 158
 159       std::unique_ptr<ACE_WCHAR_T[]> name_urep (name.rep ());
 160       std::unique_ptr<ACE_WCHAR_T[]> value_urep (value.rep ());
 161       ACE_NS_String new_name (name_rep, name_urep.get (), name_len);
 162       ACE_NS_String new_value (value_rep, value_urep.get (), value_len);
 163
 164       ACE_OS::strcpy (new_type, type);
 165       ACE_NS_Internal new_internal (new_value, new_type);
 166       int result = -1;
 167
 168       if (rebind == 0)
 169         {
 170           // Do a normal bind.  This will fail if there's already an
 171           // <new_internal> with the same name.
 172           result = this->name_space_map_->bind (new_name,
 173                                                 new_internal,
 174                                                 this->allocator_);
 175
 176           if (result == 1)
 177             {
 178               // Entry already existed so bind failed. Free our
 179               // dynamically allocated memory.
 180               this->allocator_->free ((void *) ptr);
 181               return result;
 182             }
 183         }
 184       else
 185         {
 186           // Do a rebind.  If there's already any entry, this will
 187           // return the existing <new_name> and <new_internal> and
 188           // overwrite the existing name binding.
 189           ACE_NS_String old_name;
 190           ACE_NS_Internal old_internal;
 191
 192           result = this->name_space_map_->rebind (new_name, new_internal,
 193                                                   old_name, old_internal,
 194                                                   this->allocator_);
 195           if (result == 1)
 196             {
 197               // Free up the memory we allocated in shared_bind().
 198               // Note that this assumes that the "value" pointer comes
 199               // first and that the value, name, and type are
 200               // contiguously allocated (see above for details)
 201               this->allocator_->free ((void *) (old_internal.value ()).fast_rep ());
 202             }
 203         }
 204
 205       if (result == -1)
 206         // Free our dynamically allocated memory.
 207         this->allocator_->free ((void *) ptr);
 208       else
 209         // If bind() or rebind() succeed, they will automatically sync
 210         // up the map manager entry.  However, we must sync up our
 211         // name/value memory.
 212         this->allocator_->sync (ptr, total_len);
 213
 214       return result;
 215     }
 216 }
 217
 218 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 219 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind (
 220   const ACE_NS_WString &name)
 221 {
 222   // Note that we *must* use structured exception handling here
 223   // because (1) we may need to commit virtual memory pages and (2)
 224   // C++ exception handling doesn't support resumption.
 225   int result = 0;
 226   ACE_SEH_TRY
 227     {
 228       result = this->unbind_i (name);
 229     }
 230   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 231     {
 232     }
 233   return result;
 234 }
 235
 236 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 237 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::unbind_i (
 238   const ACE_NS_WString &name)
 239 {
 240   ACE_TRACE ("ACE_Local_Name_Space::unbind_i");
 241
 242   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 243   ACE_NS_String ns_name (name);
 244   ACE_NS_Internal ns_internal;
 245   if (this->name_space_map_->unbind (ns_name,
 246                                      ns_internal,
 247                                      this->allocator_) != 0)
 248     return -1;
 249
 250   // Free up the memory we allocated in shared_bind().  Note that this
 251   // assumes that the "value" pointer comes first and that the value,
 252   // name and type are contiguously allocated (see shared_bind() for
 253   // details)
 254   this->allocator_->free ((void *) (ns_internal.value ()).fast_rep ());
 255   return 0;
 256 }
 257
 258 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 259 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::bind (
 260   const ACE_NS_WString &name,
 261   const ACE_NS_WString &value,
 262   const char *type)
 263 {
 264   ACE_TRACE ("ACE_Local_Name_Space::bind");
 265   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 266
 267   return this->shared_bind (name, value, type, 0);
 268 }
 269
 270 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 271 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::rebind (
 272   const ACE_NS_WString &name,
 273   const ACE_NS_WString &value,
 274   const char *type)
 275 {
 276   ACE_TRACE ("ACE_Local_Name_Space::rebind");
 277   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 278
 279   return this->shared_bind (name, value, type, 1);
 280 }
 281
 282 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 283 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve (
 284   const ACE_NS_WString &name,
 285   ACE_NS_WString &value,
 286   char *&type)
 287 {
 288   // Note that we *must* use structured exception handling here
 289   // because (1) we may need to commit virtual memory pages and (2)
 290   // C++ exception handling doesn't support resumption.
 291   int result = 0;
 292   ACE_SEH_TRY
 293     {
 294       result = this->resolve_i (name, value, type);
 295     }
 296   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 297     {
 298     }
 299   return result;
 300 }
 301
 302
 303 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 304 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::resolve_i (
 305   const ACE_NS_WString &name,
 306   ACE_NS_WString &value,
 307   char *&type)
 308 {
 309   ACE_TRACE ("ACE_Local_Name_Space::resolve_i");
 310   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 311
 312   ACE_NS_String ns_name (name);
 313   ACE_NS_Internal ns_internal;
 314   ACE_NS_String nbc_string; // Note the classy variable name! :)
 315
 316   if (this->name_space_map_->find (ns_name,
 317                                    ns_internal,
 318                                    this->allocator_) != 0)
 319     return -1;
 320
 321   // Calls conversion operator and then calls the ACE_NS_WString
 322   // assignment operator to get a fresh copy.  (*#*(@#&!*@!!*@&( HP
 323   // compiler causes us to add an extra copy explicitly !! :)
 324   nbc_string = ns_internal.value ();
 325   value = nbc_string;
 326
 327   // Gets type and then the actual reprsentation which is a
 328   // ACE_WCHAR_T
 329   const char *temp = ns_internal.type ();
 330
 331   size_t len = ACE_OS::strlen (ns_internal.type ());
 332   // Makes a copy here. Caller needs to call delete to free up
 333   // memory.
 334   char *new_type = 0;
 335 #if defined (ACE_HAS_ALLOC_HOOKS)
 336   ACE_ALLOCATOR_RETURN (new_type,
 337                         static_cast<char*>(ACE_Allocator::instance()->malloc(sizeof(char) * (len + 1))),
 338                         -1);
 339 #else
 340   ACE_NEW_RETURN (new_type,
 341                   char [len + 1],
 342                   -1);
 343 #endif /* ACE_HAS_ALLOC_HOOKS */
 344
 345   ACE_OS::strsncpy (new_type, temp, len + 1);
 346   type = new_type;
 347   return 0;
 348 }
 349
 350 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 351 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::open (
 352   ACE_Naming_Context::Context_Scope_Type scope_in)
 353 {
 354   ACE_TRACE ("ACE_Local_Name_Space::open");
 355   this->ns_scope_ = scope_in;
 356
 357   return this->create_manager ();
 358 }
 359
 360 template <ACE_MEM_POOL_1, class ACE_LOCK>
 361 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Local_Name_Space ()
 362   : allocator_ (0),
 363     name_space_map_ (0),
 364     name_options_ (0)
 365 {
 366   ACE_TRACE ("ACE_Local_Name_Space::ACE_Local_Name_Space");
 367 }
 368
 369 template <ACE_MEM_POOL_1, class ACE_LOCK>
 370 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Local_Name_Space (
 371   ACE_Naming_Context::Context_Scope_Type scope_in,
 372   ACE_Name_Options *name_options)
 373   : allocator_ (0),
 374     name_space_map_ (0),
 375     name_options_ (name_options),
 376     lock_ (0)
 377 {
 378   ACE_TRACE ("ACE_Local_Name_Space::ACE_Local_Name_Space");
 379   if (this->open (scope_in) == -1)
 380     ACELIB_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Local_Name_Space::ACE_Local_Name_Space")));
 381 }
 382
 383 template <ACE_MEM_POOL_1, class ACE_LOCK>
 384 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::~ACE_Local_Name_Space ()
 385 {
 386   ACE_TRACE ("ACE_Local_Name_Space::~ACE_Local_Name_Space");
 387
 388   // Remove the map.
 389   delete this->allocator_;
 390   delete this->lock_;
 391 }
 392
 393 ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Local_Name_Space)
 394
 395 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 396 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager ()
 397 {
 398   // Note that we *must* use structured exception handling here
 399   // because (1) we may need to commit virtual memory pages and (2)
 400   // C++ exception handling doesn't support resumption.
 401   int result = 0;
 402   ACE_SEH_TRY
 403     {
 404       result = this->create_manager_i ();
 405     }
 406   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 407     {
 408     }
 409   return result;
 410 }
 411
 412
 413 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 414 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::create_manager_i ()
 415 {
 416   ACE_TRACE ("ACE_Local_Name_Space::create_manager_i");
 417   // Get directory name
 418   const ACE_TCHAR *dir = this->name_options_->namespace_dir ();
 419   const ACE_TCHAR *database = this->name_options_->database ();
 420
 421   // Use process name as the file name.
 422   size_t len = ACE_OS::strlen (dir);
 423   len += ACE_OS::strlen (ACE_DIRECTORY_SEPARATOR_STR);
 424   len += ACE_OS::strlen (database) + 1;
 425
 426   if (len >= MAXNAMELEN + MAXPATHLEN)
 427     {
 428       errno = ENAMETOOLONG;
 429       return -1;
 430     }
 431
 432   ACE_OS::strcpy (this->context_file_, dir);
 433   ACE_OS::strcat (this->context_file_, ACE_DIRECTORY_SEPARATOR_STR);
 434   ACE_OS::strcat (this->context_file_, database);
 435
 436   ACE_MEM_POOL_OPTIONS options (this->name_options_->base_address ());
 437
 438   ACE_TCHAR lock_name_for_local_name_space [MAXNAMELEN + MAXPATHLEN];
 439   ACE_TCHAR lock_name_for_backing_store [MAXPATHLEN + MAXNAMELEN];
 440   const ACE_TCHAR *postfix = database;
 441
 442   size_t length = sizeof lock_name_for_local_name_space / sizeof (ACE_TCHAR);
 443   ACE_OS::strsncpy (lock_name_for_local_name_space,
 444                     dir,
 445                     length);
 446
 447   ACE_OS::strncat (lock_name_for_local_name_space,
 448                    ACE_DIRECTORY_SEPARATOR_STR,
 449                    length -  ACE_OS::strlen (lock_name_for_local_name_space));
 450   ACE_OS::strncat (lock_name_for_local_name_space,
 451                    ACE_TEXT ("name_space_"),
 452                    length -  ACE_OS::strlen (lock_name_for_local_name_space));
 453   ACE_OS::strncat (lock_name_for_local_name_space,
 454                    postfix,
 455                    length -  ACE_OS::strlen (lock_name_for_local_name_space));
 456
 457   length = sizeof lock_name_for_backing_store / sizeof (ACE_TCHAR);
 458   ACE_OS::strsncpy (lock_name_for_backing_store,
 459                     dir,
 460                     length);
 461   ACE_OS::strncat (lock_name_for_backing_store,
 462                    ACE_DIRECTORY_SEPARATOR_STR,
 463                    length -  ACE_OS::strlen (lock_name_for_backing_store));
 464   ACE_OS::strncat (lock_name_for_backing_store,
 465                    ACE_TEXT ("backing_store_"),
 466                    length -  ACE_OS::strlen (lock_name_for_backing_store));
 467   ACE_OS::strncat (lock_name_for_backing_store,
 468                    postfix,
 469                    length - ACE_OS::strlen (ACE_TEXT ("backing_store_")));
 470
 471   // Create the allocator with the appropriate options.
 472   ACE_NEW_RETURN (this->allocator_,
 473                   ALLOCATOR (this->context_file_,
 474                              lock_name_for_backing_store,
 475                              &options), -1);
 476
 477   if (ACE_LOG_MSG->op_status ())
 478     ACELIB_ERROR_RETURN ((LM_ERROR,
 479                        ACE_TEXT ("Allocator::Allocator\n")),
 480                       -1);
 481
 482   ACE_NEW_RETURN (this->lock_,
 483                   ACE_LOCK (lock_name_for_local_name_space),
 484                   -1);
 485
 486 #if !defined (ACE_LACKS_ACCESS)
 487   // Now check if the backing store has been created successfully
 488   if (ACE_OS::access (this->context_file_, F_OK) != 0)
 489     ACELIB_ERROR_RETURN ((LM_ERROR,
 490                        ACE_TEXT ("create_manager\n")),
 491                       -1);
 492 #endif /* ACE_LACKS_ACCESS */
 493
 494   void *ns_map = 0;
 495
 496   // This is the easy case since if we find the Name Server Map
 497   // Manager we know it's already initialized.
 498   if (this->allocator_->find (ACE_NAME_SERVER_MAP, ns_map) == 0)
 499     {
 500       this->name_space_map_ = (ACE_Name_Space_Map <ALLOCATOR> *) ns_map;
 501       if (ACE::debug ())
 502         ACELIB_DEBUG ((LM_DEBUG,
 503                     ACE_TEXT ("name_space_map_ = %@, ns_map = %@\n"),
 504                     this->name_space_map_, ns_map));
 505     }
 506
 507   // This is the hard part since we have to avoid potential race
 508   // conditions...  We will use the double check here
 509   else
 510     {
 511       ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 512
 513       // This is the easy case since if we find the Name Server Map
 514       // Manager we know it's already initialized.
 515       if (this->allocator_->find (ACE_NAME_SERVER_MAP, ns_map) == 0)
 516         {
 517           this->name_space_map_ = (ACE_Name_Space_Map <ALLOCATOR> *) ns_map;
 518           if (ACE::debug ())
 519             ACELIB_DEBUG ((LM_DEBUG,
 520                         ACE_TEXT ("name_space_map_ = %@, ns_map = %@\n"),
 521                         this->name_space_map_, ns_map));
 522         }
 523       else
 524         {
 525           size_t map_size = sizeof *this->name_space_map_;
 526           ns_map = this->allocator_->malloc (map_size);
 527
 528           // Initialize the map into its memory location (e.g., shared memory).
 529           this->name_space_map_ =
 530             new (ns_map) ACE_Name_Space_Map <ALLOCATOR> (this->allocator_);
 531
 532           if (this->allocator_->bind (ACE_NAME_SERVER_MAP, ns_map) == -1)
 533             ACELIB_ERROR_RETURN ((LM_ERROR,
 534                                ACE_TEXT ("create_manager\n")), -1);
 535         }
 536
 537       if (ACE::debug ())
 538         ACELIB_DEBUG ((LM_DEBUG,
 539                     ACE_TEXT ("name_space_map_ = %@, ns_map = %@\n"),
 540                     this->name_space_map_, ns_map));
 541     }
 542
 543   return 0;
 544 }
 545
 546 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 547 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names_i (
 548   ACE_WSTRING_SET &set,
 549   const ACE_NS_WString &pattern)
 550 {
 551   ACE_TRACE ("ACE_Local_Name_Space::list_names_i");
 552   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 553
 554   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 555   MAP_MANAGER::ENTRY *map_entry;
 556
 557   int result = 1;
 558
 559   for (map_entry = 0;
 560        map_iterator.next (map_entry) != 0;
 561        map_iterator.advance())
 562     {
 563       if (map_entry->ext_id_.strstr (pattern) != -1)
 564         {
 565           ACE_NS_WString entry (map_entry->ext_id_ );
 566
 567           if (set.insert (entry) == -1)
 568             {
 569               result = -1;
 570               break;
 571             }
 572           else
 573             result = 0;
 574         }
 575     }
 576
 577   return result;
 578 }
 579
 580 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 581 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values_i (
 582   ACE_WSTRING_SET &set,
 583   const ACE_NS_WString &pattern)
 584 {
 585   ACE_TRACE ("ACE_Local_Name_Space::list_values_i");
 586   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 587
 588   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 589   MAP_MANAGER::ENTRY *map_entry;
 590
 591   int result = 1;
 592
 593   for (map_entry = 0;
 594        map_iterator.next (map_entry) != 0;
 595        map_iterator.advance ())
 596     {
 597       if (map_entry->int_id_.value ().strstr (pattern) != -1)
 598         {
 599           ACE_NS_WString entry (map_entry->int_id_.value ());
 600
 601           if (set.insert (entry) == -1)
 602             {
 603               result = -1;
 604               break;
 605             }
 606           else
 607             result = 0;
 608         }
 609     }
 610
 611   return result;
 612 }
 613
 614 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 615 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types_i (
 616   ACE_WSTRING_SET &set,
 617   const ACE_NS_WString &pattern)
 618 {
 619   ACE_TRACE ("ACE_Local_Name_Space::list_types_i");
 620   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 621
 622   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 623   MAP_MANAGER::ENTRY *map_entry;
 624
 625   char *compiled_regexp = 0;
 626
 627   // Note that char_rep() allocates memory so we need to delete it
 628   char *pattern_rep = pattern.char_rep ();
 629
 630   // Check for wildcard case first.
 631   if (ACE_OS::strcmp ("", pattern_rep) == 0)
 632     ACE_ALLOCATOR_RETURN (compiled_regexp,
 633                           ACE_OS::strdup (""),
 634                           -1);
 635   else
 636     // Compile the regular expression (the 0's cause ACE_OS::compile
 637     // to allocate space).
 638 #if defined (ACE_HAS_REGEX)
 639     compiled_regexp = ACE_OS::compile (pattern_rep, 0, 0);
 640 #else
 641   // If we don't have regular expressions just use the pattern
 642   // directly.
 643   compiled_regexp = pattern_rep;
 644 #endif /* ACE_HAS_REGEX */
 645
 646   int result = 1;
 647
 648   for (map_entry = 0;
 649        map_iterator.next (map_entry) != 0;
 650        map_iterator.advance ())
 651     {
 652       // Get the type
 653       const char *type = map_entry->int_id_.type ();
 654
 655       // Everything matches the wildcard.
 656       if (ACE_OS::strcmp ("", pattern_rep) == 0
 657 #if defined (ACE_HAS_REGEX)
 658           || ACE_OS::step (type, compiled_regexp) != 0)
 659 #else
 660         // If we don't have regular expressions just use strstr() for
 661         // substring matching.
 662         || ACE_OS::strstr (type, compiled_regexp) != 0)
 663 #endif /* ACE_HAS_REGEX */
 664
 665         {
 666           ACE_NS_WString entry (type);
 667
 668           if (set.insert (entry) == -1)
 669             {
 670               result = -1;
 671               break;
 672             }
 673           else
 674             result = 0;
 675         }
 676     }
 677 #if defined (ACE_HAS_REGEX)
 678   if (compiled_regexp)
 679     ACE_OS::free ((void *) compiled_regexp);
 680 #endif /* ACE_HAS_REGEX */
 681 #if defined (ACE_HAS_ALLOC_HOOKS)
 682   ACE_Allocator::instance()->free(pattern_rep);
 683 #else
 684   delete [] pattern_rep;  // delete pattern_rep;
 685 #endif /* ACE_HAS_ALLOC_HOOKS */
 686   return result;
 687 }
 688
 689 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 690 ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries_i (
 691   ACE_BINDING_SET &set,
 692   const ACE_NS_WString &pattern)
 693 {
 694   ACE_TRACE ("ACE_Local_Name_Space::list_name_entries_i");
 695   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 696
 697   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 698   MAP_MANAGER::ENTRY *map_entry;
 699
 700   for (map_entry = 0;
 701        map_iterator.next (map_entry) != 0;
 702        map_iterator.advance())
 703     {
 704       if (map_entry->ext_id_.strstr (pattern) != -1)
 705         {
 706           ACE_Name_Binding entry (map_entry->ext_id_,
 707                                   map_entry->int_id_.value (),
 708                                   map_entry->int_id_.type ());
 709
 710           if (set.insert (entry) == -1)
 711             return -1;
 712         }
 713     }
 714
 715   return 0;
 716 }
 717
 718 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 719 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries_i (
 720   ACE_BINDING_SET &set,
 721   const ACE_NS_WString &pattern)
 722 {
 723   ACE_TRACE ("ACE_Local_Name_Space::list_value_entries_i");
 724   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 725
 726   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 727   MAP_MANAGER::ENTRY *map_entry;
 728
 729   for (map_entry = 0;
 730        map_iterator.next (map_entry) != 0;
 731        map_iterator.advance ())
 732     {
 733       if (map_entry->int_id_.value ().strstr (pattern) != -1)
 734         {
 735           ACE_Name_Binding entry (map_entry->ext_id_,
 736                                   map_entry->int_id_.value (),
 737                                   map_entry->int_id_.type ());
 738
 739           if (set.insert (entry) == -1)
 740             return -1;
 741         }
 742     }
 743   return 0;
 744 }
 745
 746 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 747 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries_i (
 748   ACE_BINDING_SET &set,
 749   const ACE_NS_WString &pattern)
 750 {
 751   ACE_TRACE ("ACE_Local_Name_Space::list_type_entries_i");
 752   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, *this->lock_, -1);
 753
 754   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 755   MAP_MANAGER::ENTRY *map_entry;
 756
 757   char *compiled_regexp = 0;
 758   // Note that char_rep() allocates memory so we need to delete it
 759   char *pattern_rep = pattern.char_rep ();
 760
 761   // Check for wildcard case first.
 762   if (ACE_OS::strcmp ("", pattern_rep) == 0)
 763     compiled_regexp = ACE_OS::strdup ("");
 764   else
 765     // Compile the regular expression (the 0's cause ACE_OS::compile
 766     // to allocate space).
 767 #if defined (ACE_HAS_REGEX)
 768     compiled_regexp = ACE_OS::compile (pattern_rep, 0, 0);
 769 #else /* If we don't have regular expressions just the pattern
 770          directly. */
 771   compiled_regexp = pattern_rep;
 772 #endif /* ACE_HAS_REGEX */
 773
 774   for (map_entry = 0;
 775        map_iterator.next (map_entry) != 0;
 776        map_iterator.advance ())
 777     {
 778       // Get the type.
 779       const char *type = map_entry->int_id_.type ();
 780
 781       if (ACE_OS::strcmp ("", pattern_rep) == 0 // Everything matches
 782                                                 // the wildcard.
 783 #if defined (ACE_HAS_REGEX)
 784           || ACE_OS::step (type, compiled_regexp) != 0)
 785 #else /* If we don't have regular expressions just use strstr() for
 786          substring matching. */
 787         || ACE_OS::strstr (type, compiled_regexp) != 0)
 788 #endif /* ACE_HAS_REGEX */
 789         {
 790           ACE_Name_Binding entry (map_entry->ext_id_,
 791                                   map_entry->int_id_.value (),
 792                                   map_entry->int_id_.type ());
 793
 794           if (set.insert (entry) == -1)
 795             return -1;
 796         }
 797     }
 798 #if defined (ACE_HAS_REGEX)
 799   if (compiled_regexp)
 800     ACE_OS::free ((void *) compiled_regexp);
 801 #endif /* ACE_HAS_REGEX */
 802 #if defined (ACE_HAS_ALLOC_HOOKS)
 803   ACE_Allocator::instance()->free(pattern_rep);
 804 #else
 805   delete [] pattern_rep;  // delete pattern_rep;
 806 #endif /* ACE_HAS_ALLOC_HOOKS */
 807   return 0;
 808 }
 809
 810 template <ACE_MEM_POOL_1, class ACE_LOCK> void
 811 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::dump_i () const
 812 {
 813   ACE_TRACE ("ACE_Local_Name_Space::dump_i");
 814
 815   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 816
 817   MAP_MANAGER::ITERATOR map_iterator (*this->name_space_map_);
 818   MAP_MANAGER::ENTRY *map_entry;
 819
 820   for (map_entry = 0;
 821        map_iterator.next (map_entry) != 0;
 822        map_iterator.advance())
 823     {
 824       char *key = map_entry->ext_id_.char_rep ();
 825       char *value = map_entry->int_id_.value ().char_rep ();
 826 #if !defined (ACE_NLOGGING)
 827       const char *type = map_entry->int_id_.type ();
 828 #endif /* ! ACE_NLOGGING */
 829
 830       ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("key=%C\nvalue=%C\ntype=%C\n"),
 831                   key, value, type));
 832       // We need to delete key and value since char_rep allocates
 833       // memory for them
 834 #if defined (ACE_HAS_ALLOC_HOOKS)
 835       ACE_Allocator::instance()->free(key);
 836       ACE_Allocator::instance()->free(value);
 837 #else
 838       delete [] key;
 839       delete [] value;
 840 #endif /* ACE_HAS_ALLOC_HOOKS */
 841     }
 842
 843   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 844 }
 845
 846 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 847 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_names (
 848   ACE_WSTRING_SET &set,
 849   const ACE_NS_WString &pattern)
 850 {
 851   // Note that we *must* use structured exception handling here
 852   // because (1) we may need to commit virtual memory pages and (2)
 853   // C++ exception handling doesn't support resumption.
 854   int result = 0;
 855   ACE_SEH_TRY
 856     {
 857       result = this->list_names_i (set, pattern);
 858     }
 859   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 860     {
 861     }
 862   return result;
 863 }
 864
 865 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 866 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_values (
 867   ACE_WSTRING_SET &set,
 868   const ACE_NS_WString &pattern)
 869 {
 870   // Note that we *must* use structured exception handling here
 871   // because (1) we may need to commit virtual memory pages and (2)
 872   // C++ exception handling doesn't support resumption.
 873   int result = 0;
 874   ACE_SEH_TRY
 875     {
 876       result = this->list_values_i (set, pattern);
 877     }
 878   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 879     {
 880     }
 881   return result;
 882 }
 883
 884 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 885 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_types (
 886   ACE_WSTRING_SET &set,
 887   const ACE_NS_WString &pattern)
 888 {
 889   // Note that we *must* use structured exception handling here
 890   // because (1) we may need to commit virtual memory pages and (2)
 891   // C++ exception handling doesn't support resumption.
 892   int result = 0;
 893   ACE_SEH_TRY
 894     {
 895       result = this->list_types_i (set, pattern);
 896     }
 897   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 898     {
 899     }
 900   return result;
 901 }
 902
 903 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 904 ACE_Local_Name_Space <ACE_MEM_POOL_2, ACE_LOCK>::list_name_entries (
 905   ACE_BINDING_SET &set,
 906   const ACE_NS_WString &pattern)
 907 {
 908   // Note that we *must* use structured exception handling here
 909   // because (1) we may need to commit virtual memory pages and (2)
 910   // C++ exception handling doesn't support resumption.
 911   int result = 0;
 912   ACE_SEH_TRY
 913     {
 914       result = this->list_name_entries_i (set, pattern);
 915     }
 916   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 917     {
 918     }
 919   return result;
 920 }
 921
 922 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 923 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_value_entries (
 924   ACE_BINDING_SET &set,
 925   const ACE_NS_WString &pattern)
 926 {
 927   // Note that we *must* use structured exception handling here
 928   // because (1) we may need to commit virtual memory pages and (2)
 929   // C++ exception handling doesn't support resumption.
 930   int result = 0;
 931   ACE_SEH_TRY
 932     {
 933       result = this->list_value_entries_i (set, pattern);
 934     }
 935   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 936     {
 937     }
 938   return result;
 939 }
 940
 941 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 942 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::list_type_entries (
 943   ACE_BINDING_SET &set,
 944   const ACE_NS_WString &pattern)
 945 {
 946   // Note that we *must* use structured exception handling here
 947   // because (1) we may need to commit virtual memory pages and (2)
 948   // C++ exception handling doesn't support resumption.
 949   int result = 0;
 950   ACE_SEH_TRY
 951     {
 952       result = this->list_type_entries_i (set, pattern);
 953     }
 954   ACE_SEH_EXCEPT (this->remap (GetExceptionInformation ()))
 955     {
 956     }
 957   return result;
 958 }
 959
 960 template <ACE_MEM_POOL_1, class ACE_LOCK> void
 961 ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK>::dump () const
 962 {
 963 #if defined (ACE_HAS_DUMP)
 964   // Note that we *must* use structured exception handling here
 965   // because (1) we may need to commit virtual memory pages and (2)
 966   // C++ exception handling doesn't support resumption.
 967
 968   // This should really be a const cast
 969   ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK> *fake_this =
 970     (ACE_Local_Name_Space<ACE_MEM_POOL_2, ACE_LOCK> *) this;
 971   ACE_UNUSED_ARG (fake_this);
 972
 973   ACE_SEH_TRY
 974     {
 975       this->dump_i ();
 976     }
 977   ACE_SEH_EXCEPT (fake_this->remap (GetExceptionInformation ()))
 978     {
 979     }
 980 #endif /* ACE_HAS_DUMP */
 981 }
 982
 983 ACE_END_VERSIONED_NAMESPACE_DECL
 984
 985 #endif /* ACE_LOCAL_NAME_SPACE_T_CPP */