ACE_Configuration_Heap Class Reference

The concrete implementation of a allocator based configuration database. More...

#include <Configuration.h>

Inheritance diagram for ACE_Configuration_Heap:

Inheritance graph
[legend]
Collaboration diagram for ACE_Configuration_Heap:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_Configuration_Heap (void)
 Default ctor.

virtual ~ACE_Configuration_Heap (void)
 Destructor.

int open (const ACE_TCHAR *file_name, void *base_address=ACE_DEFAULT_BASE_ADDR, size_t default_map_size=ACE_DEFAULT_CONFIG_SECTION_SIZE)
 Opens a configuration based on a file name.

int open (size_t default_map_size=ACE_DEFAULT_CONFIG_SECTION_SIZE)
 Opens a heap based configuration.

virtual int open_section (const ACE_Configuration_Section_Key &base, const ACE_TCHAR *sub_section, int create, ACE_Configuration_Section_Key &result)
virtual int remove_section (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *sub_section, int recursive)
 Removes a named section.

virtual int enumerate_values (const ACE_Configuration_Section_Key &key, int index, ACE_TString &name, VALUETYPE &type)
virtual int enumerate_sections (const ACE_Configuration_Section_Key &key, int index, ACE_TString &name)
virtual int set_string_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, const ACE_TString &value)
 Sets a string-typed value.

virtual int set_integer_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, u_int value)
 Sets a integer-typed value.

virtual int set_binary_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, const void *data, size_t length)
 Sets a binary-typed value.

virtual int get_string_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, ACE_TString &value)
 Gets a string-typed value.

virtual int get_integer_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, u_int &value)
 Gets an integer-typed value.

virtual int get_binary_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, void *&data, size_t &length)
 Gets a binary-typed value.

virtual int find_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name, VALUETYPE &type)
virtual int remove_value (const ACE_Configuration_Section_Key &key, const ACE_TCHAR *name)
 Removes the the value name from key. returns non zero on error.


Private Member Functions

int open_simple_section (const ACE_Configuration_Section_Key &base, const ACE_TCHAR *sub_section, int create, ACE_Configuration_Section_Key &result)
 may not contain path separators

int add_section (const ACE_Configuration_Section_Key &base, const ACE_TCHAR *sub_section, ACE_Configuration_Section_Key &result)
 Adds a new section.

int create_index (void)
 Helper for the method.

int create_index_helper (void *buffer)
int value_open_helper (size_t hash_table_size, void *buffer)
int section_open_helper (size_t hash_table_size, void *buffer)
int load_key (const ACE_Configuration_Section_Key &key, ACE_TString &name)
int new_section (const ACE_TString &section, ACE_Configuration_Section_Key &result)
 ACE_Configuration_Heap (const ACE_Configuration_Heap &rhs)
ACE_Configuration_Heapoperator= (const ACE_Configuration_Heap &rhs)

Private Attributes

ACE_Allocatorallocator_
SECTION_MAPindex_
size_t default_map_size_

Detailed Description

The concrete implementation of a allocator based configuration database.

This class uses ACE's Allocators to manage a memory representation of a configuraiton database. A persistent heap may be used to store configurations persistently

Note:
Before using this class you must call one of the open methods.

Todo:
-Need to investigate what happens if memory mapped file gets mapped to a location different than it was created with.

Definition at line 786 of file Configuration.h.


Constructor & Destructor Documentation

ACE_Configuration_Heap::ACE_Configuration_Heap void   ) 
 

Default ctor.

Definition at line 1250 of file Configuration.cpp.

References ACE_NEW, and ACE_TEXT.

01251   : allocator_ (0),
01252     index_ (0),
01253     default_map_size_ (0)
01254 {
01255   ACE_Configuration_Section_Key_Heap *temp = 0;
01256 
01257   ACE_NEW (temp, ACE_Configuration_Section_Key_Heap (ACE_TEXT ("")));
01258   root_ = ACE_Configuration_Section_Key (temp);
01259 }

ACE_Configuration_Heap::~ACE_Configuration_Heap void   )  [virtual]
 

Destructor.

Definition at line 1261 of file Configuration.cpp.

References ACE_Allocator::sync().

01262 {
01263   if (allocator_)
01264     allocator_->sync ();
01265 
01266   delete allocator_;
01267 }

ACE_Configuration_Heap::ACE_Configuration_Heap const ACE_Configuration_Heap rhs  )  [private]
 


Member Function Documentation

int ACE_Configuration_Heap::add_section const ACE_Configuration_Section_Key base,
const ACE_TCHAR sub_section,
ACE_Configuration_Section_Key result
[private]
 

Adds a new section.

Definition at line 1380 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TEXT, ACE_TString, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::bind(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Allocator::free(), index_, ACE_String_Base< CHAR >::length(), load_key(), ACE_Allocator::malloc(), new_section(), ACE_Configuration_Section_IntId::section_hash_map_, and ACE_OS::strcpy().

Referenced by open_simple_section().

01383 {
01384   ACE_ASSERT (this->allocator_);
01385   ACE_TString section;
01386   if (load_key (base, section))
01387     return -1;
01388 
01389   // Find the base section
01390   ACE_Configuration_ExtId ExtId (section.fast_rep ());
01391   ACE_Configuration_Section_IntId IntId;
01392   if (index_->find (ExtId, IntId, allocator_))
01393     return -1;
01394 
01395   // See if this section already exists
01396   ACE_Configuration_ExtId SubSectionExtId (sub_section);
01397   int ignored = 0;
01398 
01399   if (!IntId.section_hash_map_->find (SubSectionExtId, ignored, allocator_))
01400     {
01401       // already exists!
01402       errno = EEXIST;
01403       return -1;
01404     }
01405 
01406   // Create the new section name
01407   // only prepend a separater if were not at the root
01408   if (section.length ())
01409     section += ACE_TEXT ("\\");
01410 
01411   section += sub_section;
01412 
01413   // Add it to the base section
01414   ACE_TCHAR* pers_name = (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (sub_section) + 1) * sizeof (ACE_TCHAR));
01415   ACE_OS::strcpy (pers_name, sub_section);
01416   ACE_Configuration_ExtId SSExtId (pers_name);
01417   if (IntId.section_hash_map_->bind (SSExtId, ignored, allocator_))
01418     {
01419       allocator_->free (pers_name);
01420       return -1;
01421     }
01422   return (new_section (section, result));
01423 }

int ACE_Configuration_Heap::create_index void   )  [private]
 

Helper for the method.

Definition at line 1319 of file Configuration.cpp.

References ACE_CONFIG_SECTION_INDEX, ACE_ERROR, ACE_TEXT, ACE_Allocator::bind(), create_index_helper(), ACE_Allocator::find(), index_, LM_ERROR, ACE_Allocator::malloc(), new_section(), ACE_Allocator::remove(), and SECTION_MAP.

Referenced by open().

01320 {
01321   void *section_index = 0;
01322 
01323   // This is the easy case since if we find hash table in the
01324   // memory-mapped file we know it's already initialized.
01325   if (this->allocator_->find (ACE_CONFIG_SECTION_INDEX, section_index) == 0)
01326     this->index_ = (SECTION_MAP *) section_index;
01327 
01328   // Create a new <index_> (because we've just created a new
01329   // memory-mapped file).
01330   else
01331     {
01332       size_t index_size = sizeof (SECTION_MAP);
01333       section_index = this->allocator_->malloc (index_size);
01334 
01335       if (section_index == 0
01336           || create_index_helper (section_index) == -1
01337           || this->allocator_->bind (ACE_CONFIG_SECTION_INDEX,
01338                                      section_index) == -1)
01339         {
01340           // Attempt to clean up.
01341           ACE_ERROR ((LM_ERROR,
01342                       ACE_TEXT ("create_index failed\n")));
01343           this->allocator_->remove ();
01344           return -1;
01345         }
01346       // Add the root section
01347       return new_section (ACE_TEXT (""), root_);
01348     }
01349   return 0;
01350 }

int ACE_Configuration_Heap::create_index_helper void *  buffer  )  [private]
 

Helper for create_index() method: places hash table into an allocated space.

Definition at line 1353 of file Configuration.cpp.

References ACE_ASSERT, index_, and SECTION_MAP.

Referenced by create_index().

01354 {
01355   ACE_ASSERT (this->allocator_);
01356   this->index_ = new (buffer) SECTION_MAP (this->allocator_);
01357   return 0;
01358 }

int ACE_Configuration_Heap::enumerate_sections const ACE_Configuration_Section_Key key,
int  index,
ACE_TString name
[virtual]
 

Enumerates through the subsections in a section.

Parameters:
key Section key to iterate through.
index Iteration position. Must be zero on the first call to iterate through key. Increment index by one on each successive call to this method.
name Receives the subsection's name.
Note:
You may not modify the key section while enumerating. If the section is modified during enumeration, results are undefined; you must restart the enumeration from index 0.
Return values:
0 for success, name has a valid name.
1 there are no more subsections in the section.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1746 of file Configuration.cpp.

References ACE_ASSERT, ACE_NEW_RETURN, ACE_TString, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, ACE_Hash< EXT_ID >, ACE_Equal_To< EXT_ID >, ACE_Null_Mutex >::begin(), ACE_Hash_Map_Entry< EXT_ID, INT_ID >::ext_id_, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Configuration::get_internal_key(), index_, ACE_Configuration_Section_Key_Heap::path_, ACE_Configuration_Section_IntId::section_hash_map_, and ACE_Configuration_Section_Key_Heap::section_iter_.

Referenced by remove_section().

01749 {
01750   ACE_ASSERT (this->allocator_);
01751   // cast to a heap section key
01752   ACE_Configuration_Section_Key_Heap* pKey =
01753     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
01754   if (!pKey)
01755     return -1;  // not a heap key!
01756 
01757   // resolve the section
01758   ACE_Configuration_ExtId ExtId (pKey->path_);
01759   ACE_Configuration_Section_IntId IntId;
01760   if (index_->find (ExtId, IntId, allocator_))
01761     return -1; // unknown section
01762 
01763   // Handle iterator resets
01764   if (index == 0)
01765     {
01766       if (pKey->section_iter_)
01767         delete pKey->section_iter_;
01768 
01769       ACE_NEW_RETURN (pKey->section_iter_,
01770                       SUBSECTION_HASH::ITERATOR (IntId.section_hash_map_->begin ()),
01771                       -1);
01772     }
01773 
01774   // Get the next entry
01775   ACE_Hash_Map_Entry<ACE_Configuration_ExtId, int>* entry = 0;
01776   if (!pKey->section_iter_->next (entry))
01777     return 1;
01778 
01779   // Return the value of the iterator and advance it
01780   pKey->section_iter_->advance ();
01781   name = entry->ext_id_.name_;
01782 
01783   return 0;
01784 }

int ACE_Configuration_Heap::enumerate_values const ACE_Configuration_Section_Key key,
int  index,
ACE_TString name,
VALUETYPE type
[virtual]
 

Enumerates through the values in a section.

Parameters:
key Section key to iterate through.
index Iteration position. Must be zero on the first call to iterate through key. Increment index by one on each successive call to this method.
name Receives the value's name.
type Receives the value's data type.
Note:
You may not delete or add values while enumerating. If the section is modified during enumeration, results are undefined; you must restart the enumeration from index 0.
Return values:
0 for success, name and type are valid.
1 there are no more values in the section.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1697 of file Configuration.cpp.

References ACE_ASSERT, ACE_NEW_RETURN, ACE_TString, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::ext_id_, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Configuration::get_internal_key(), index_, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, ACE_Configuration_Section_Key_Heap::path_, ACE_Configuration_Section_IntId::value_hash_map_, and ACE_Configuration_Section_Key_Heap::value_iter_.

01701 {
01702   ACE_ASSERT (this->allocator_);
01703   ACE_Configuration_Section_Key_Heap* pKey =
01704     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
01705   if (!pKey)
01706     return -1;
01707 
01708   name = pKey->path_;
01709 
01710   // resolve the section
01711   ACE_Configuration_ExtId ExtId (pKey->path_);
01712   ACE_Configuration_Section_IntId IntId;
01713   if (index_->find (ExtId, IntId, allocator_))
01714     return -1;
01715 
01716   // Handle iterator resets
01717   if (index == 0)
01718     {
01719       ACE_Hash_Map_Manager_Ex<ACE_Configuration_ExtId ,
01720                               ACE_Configuration_Value_IntId,
01721                               ACE_Hash<ACE_Configuration_ExtId>,
01722                               ACE_Equal_To<ACE_Configuration_ExtId>,
01723                               ACE_Null_Mutex>* hash_map = IntId.value_hash_map_;
01724       delete pKey->value_iter_;
01725 
01726       ACE_NEW_RETURN (pKey->value_iter_,
01727                       VALUE_HASH::ITERATOR (hash_map->begin ()),
01728                       -1);
01729     }
01730 
01731   // Get the next entry
01732   ACE_Hash_Map_Entry<ACE_Configuration_ExtId, ACE_Configuration_Value_IntId>* entry = 0;
01733 
01734   if (!pKey->value_iter_->next (entry))
01735     return 1;
01736 
01737   // Return the value of the iterator and advance it
01738   name = entry->ext_id_.name_;
01739   type = entry->int_id_.type_;
01740   pKey->value_iter_->advance ();
01741 
01742   return 0;
01743 }

int ACE_Configuration_Heap::find_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
VALUETYPE type
[virtual]
 

Retrieves the type of a named configuration value.

Parameters:
key Configuration section to look up the name in.
name Name of the configuration value to get the type of.
type Receives the data type of the named value, if it exists.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 2083 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, load_key(), ACE_Configuration::validate_value_name(), VALUE_HASH, and ACE_Configuration_Section_IntId::value_hash_map_.

02086 {
02087   ACE_ASSERT (this->allocator_);
02088   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
02089   if (validate_value_name (t_name))
02090     return -1;
02091 
02092   // Get the section name from the key
02093   ACE_TString section;
02094   if (load_key (key, section))
02095     return -1;
02096 
02097   // Find this section
02098   ACE_Configuration_ExtId ExtId (section.fast_rep ());
02099   ACE_Configuration_Section_IntId IntId;
02100   if (index_->find (ExtId, IntId, allocator_))
02101     return -1;    // section does not exist
02102 
02103   // Find it
02104   ACE_Configuration_ExtId ValueExtId (t_name);
02105   VALUE_HASH::ENTRY* value_entry;
02106   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
02107     return -1;  // value does not exist
02108 
02109   type_out = value_entry->int_id_.type_;
02110   return 0;
02111 }

int ACE_Configuration_Heap::get_binary_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
void *&  data,
size_t &  length
[virtual]
 

Gets a binary-typed value.

Parameters:
key Configuration section to get the value from.
name Name of the configuration value to get.
data Receives a pointer to memory holding the binary data for the value. This method allocates the memory pointed to using operator new[]. The caller is responsible for freeing the memory using operator delete[].
length Receives the number of bytes in the value.
Return values:
0 for success; caller is responsible for freeing the returned memory.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 2040 of file Configuration.cpp.

References ACE_ASSERT, ACE_NEW_RETURN, ACE_TCHAR, ACE_TString, ACE_Configuration_Value_IntId::data_, ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, ACE_Configuration_Value_IntId::length_, load_key(), ACE_OS::memcpy(), ACE_Configuration_Value_IntId::type_, ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

02045 {
02046   ACE_ASSERT (this->allocator_);
02047   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
02048   if (validate_value_name (t_name))
02049     return -1;
02050 
02051   // Get the section name from the key
02052   ACE_TString section;
02053   if (load_key (key, section))
02054     return -1;
02055 
02056   // Find this section
02057   ACE_Configuration_ExtId ExtId (section.fast_rep ());
02058   ACE_Configuration_Section_IntId IntId;
02059   if (index_->find (ExtId, IntId, allocator_))
02060     return -1;    // section does not exist
02061 
02062   ACE_Configuration_ExtId VExtId (t_name);
02063   ACE_Configuration_Value_IntId VIntId;
02064   // See if it exists first
02065   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_))
02066     return -1;    // unknown value
02067 
02068   // Check type
02069   if (VIntId.type_ != ACE_Configuration::BINARY)
02070     {
02071       errno = ENOENT;
02072       return -1;
02073     }
02074 
02075   // Make a copy
02076   ACE_NEW_RETURN (data, char[VIntId.length_], -1);
02077   ACE_OS::memcpy (data, VIntId.data_.ptr_, VIntId.length_);
02078   length = VIntId.length_;
02079   return 0;
02080 }

int ACE_Configuration_Heap::get_integer_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
u_int &  value
[virtual]
 

Gets an integer-typed value.

Parameters:
key Configuration section to get the value from.
name Name of the configuration value to get.
value Receives the configuration value if it exists and has type INTEGER.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1990 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_Configuration_Value_IntId::data_, ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, load_key(), ACE_Configuration_Value_IntId::type_, ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

01993 {
01994   ACE_ASSERT (this->allocator_);
01995 
01996   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
01997   if (validate_value_name (t_name))
01998     return -1;
01999 
02000   // Get the section name from the key
02001   ACE_TString section (0, 0, false);
02002 
02003   if (this->load_key (key, section) != 0)
02004     {
02005       return -1;
02006     }
02007 
02008   // Find this section
02009   ACE_Configuration_ExtId ExtId (section.fast_rep ());
02010   ACE_Configuration_Section_IntId IntId;
02011 
02012   if (index_->find (ExtId, IntId, allocator_) != 0)
02013     {
02014       return -1;    // section does not exist
02015     }
02016 
02017 
02018   // See if it exists first
02019   ACE_Configuration_ExtId VExtId (t_name);
02020   ACE_Configuration_Value_IntId VIntId;
02021 
02022   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_) != 0)
02023     {
02024       return -1;    // unknown value
02025     }
02026 
02027   // Check type
02028   if (VIntId.type_ != ACE_Configuration::INTEGER)
02029     {
02030       errno = ENOENT;
02031       return -1;
02032     }
02033 
02034   // Everythings ok, return the data
02035   value = VIntId.data_.int_;
02036   return 0;
02037 }

int ACE_Configuration_Heap::get_string_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
ACE_TString value
[virtual]
 

Gets a string-typed value.

Parameters:
key Configuration section to get the value from.
name Name of the configuration value to get.
value Receives the configuration value if it exists and has type STRING.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1951 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_Configuration_Value_IntId::data_, ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, load_key(), ACE_Configuration_Value_IntId::type_, ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

01954 {
01955   ACE_ASSERT (this->allocator_);
01956   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
01957   if (validate_value_name (t_name))
01958     return -1;
01959 
01960   // Get the section name from the key
01961   ACE_TString section;
01962   if (load_key (key, section))
01963     return -1;
01964 
01965   // Find this section
01966   ACE_Configuration_ExtId ExtId (section.fast_rep ());
01967   ACE_Configuration_Section_IntId IntId;
01968   if (index_->find (ExtId, IntId, allocator_))
01969     return -1;    // section does not exist
01970 
01971   // See if it exists first
01972   ACE_Configuration_ExtId VExtId (t_name);
01973   ACE_Configuration_Value_IntId VIntId;
01974   if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_))
01975     return -1;    // unknown value
01976 
01977   // Check type
01978   if (VIntId.type_ != ACE_Configuration::STRING)
01979     {
01980       errno = ENOENT;
01981       return -1;
01982     }
01983 
01984   // everythings ok, return the data
01985   value = static_cast<ACE_TCHAR*> (VIntId.data_.ptr_);
01986   return 0;
01987 }

int ACE_Configuration_Heap::load_key const ACE_Configuration_Section_Key key,
ACE_TString name
[private]
 

Definition at line 1361 of file Configuration.cpp.

References ACE_ASSERT, ACE_TString, ACE_String_Base< CHAR >::assign_nocopy(), ACE_Configuration::get_internal_key(), and ACE_Configuration_Section_Key_Heap::path_.

Referenced by add_section(), find_value(), get_binary_value(), get_integer_value(), get_string_value(), open_simple_section(), remove_section(), remove_value(), set_binary_value(), set_integer_value(), and set_string_value().

01363 {
01364   ACE_ASSERT (this->allocator_);
01365   ACE_Configuration_Section_Key_Heap* pKey =
01366     dynamic_cast<ACE_Configuration_Section_Key_Heap*> (get_internal_key (key));
01367 
01368   if (!pKey)
01369     {
01370       return -1;
01371     }
01372 
01373   ACE_TString temp (pKey->path_, 0, false);
01374   name.assign_nocopy (temp);
01375   return 0;
01376 }

int ACE_Configuration_Heap::new_section const ACE_TString section,
ACE_Configuration_Section_Key result
[private]
 

Definition at line 1426 of file Configuration.cpp.

References ACE_ASSERT, ACE_NEW_RETURN, ACE_TCHAR, ACE_TString, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::bind(), default_map_size_, ACE_String_Base< CHAR >::fast_rep(), ACE_Allocator::free(), index_, ACE_String_Base< CHAR >::length(), ACE_Allocator::malloc(), section_open_helper(), ACE_OS::strcpy(), SUBSECTION_MAP, ACE_Allocator::sync(), VALUE_MAP, and value_open_helper().

Referenced by add_section(), and create_index().

01428 {
01429   ACE_ASSERT (this->allocator_);
01430   // Create a new section and add it to the global list
01431 
01432   // Allocate memory for items to be stored in the table.
01433   size_t section_len = section.length () + 1;
01434   ACE_TCHAR *ptr = (ACE_TCHAR*) this->allocator_->malloc (section_len * sizeof (ACE_TCHAR));
01435 
01436   int return_value = -1;
01437 
01438   if (ptr == 0)
01439     return -1;
01440   else
01441     {
01442       // Populate memory with data.
01443       ACE_OS::strcpy (ptr, section.fast_rep ());
01444 
01445       void *value_hash_map = 0;
01446       size_t map_size = sizeof (VALUE_MAP);
01447       value_hash_map = this->allocator_->malloc (map_size);
01448 
01449       // If allocation failed ...
01450       if (value_hash_map == 0)
01451         return -1;
01452 
01453       // Initialize allocated hash map through placement new.
01454       if (value_open_helper (default_map_size_, value_hash_map ) == -1)
01455         {
01456           this->allocator_->free (value_hash_map );
01457           return -1;
01458         }
01459 
01460       // create the section map
01461       void* section_hash_map = 0;
01462       map_size = sizeof (SUBSECTION_MAP);
01463       section_hash_map = this->allocator_->malloc (map_size);
01464 
01465       // If allocation failed
01466       if (section_hash_map == 0)
01467         return -1;
01468 
01469       // initialize allocated hash map through placement new
01470       if (section_open_helper (default_map_size_, section_hash_map) == -1)
01471         {
01472           this->allocator_->free (value_hash_map );
01473           this->allocator_->free (section_hash_map);
01474           return -1;
01475         }
01476 
01477       ACE_Configuration_ExtId name (ptr);
01478       ACE_Configuration_Section_IntId entry ((VALUE_MAP*) value_hash_map,
01479                                              (SUBSECTION_MAP*) section_hash_map);
01480 
01481       // Do a normal bind.  This will fail if there's already an
01482       // entry with the same name.
01483       return_value = this->index_->bind (name, entry, this->allocator_);
01484 
01485       if (return_value == 1      /* Entry already existed so bind failed. */
01486           || return_value == -1  /* Unable to bind for other reasons. */)
01487         {
01488           // Free our dynamically allocated memory.
01489           this->allocator_->free (static_cast<void *> (ptr));
01490           return return_value;
01491         }
01492 
01493       // If bind () succeed, it will automatically sync
01494       // up the map manager entry.  However, we must sync up our
01495       // name/value memory.
01496       this->allocator_->sync (ptr, section_len);
01497     }
01498 
01499   // set the result
01500   ACE_Configuration_Section_Key_Heap *temp;
01501   ACE_NEW_RETURN (temp,
01502                   ACE_Configuration_Section_Key_Heap (ptr),
01503                   -1);
01504   result = ACE_Configuration_Section_Key (temp);
01505   return return_value;
01506 }

int ACE_Configuration_Heap::open size_t  default_map_size = ACE_DEFAULT_CONFIG_SECTION_SIZE  ) 
 

Opens a heap based configuration.

Definition at line 1270 of file Configuration.cpp.

References ACE_NEW_RETURN, create_index(), default_map_size_, and HEAP_ALLOCATOR.

01271 {
01272   default_map_size_ = default_map_size;
01273   // Create the allocator with the appropriate options.
01274   // The name used for  the lock is the same as one used
01275   // for the file.
01276   ACE_NEW_RETURN (this->allocator_,
01277                   HEAP_ALLOCATOR (),
01278                   -1);
01279   return create_index ();
01280 }

int ACE_Configuration_Heap::open const ACE_TCHAR file_name,
void *  base_address = ACE_DEFAULT_BASE_ADDR,
size_t  default_map_size = ACE_DEFAULT_CONFIG_SECTION_SIZE
 

Opens a configuration based on a file name.

Definition at line 1284 of file Configuration.cpp.

References ACE_OS::access(), ACE_ERROR_RETURN, ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, create_index(), default_map_size_, F_OK, LM_ERROR, MAXNAMELEN, MAXPATHLEN, PERSISTENT_ALLOCATOR, and ACE_OS::strlen().

01287 {
01288   default_map_size_ = default_map_size;
01289 
01290   // Make sure that the file name is of the legal length.
01291   if (ACE_OS::strlen (file_name) >= MAXNAMELEN + MAXPATHLEN)
01292     {
01293       errno = ENAMETOOLONG;
01294       return -1;
01295     }
01296 
01297   ACE_MMAP_Memory_Pool::OPTIONS options (base_address);
01298 
01299   // Create the allocator with the appropriate options.  The name used
01300   // for  the lock is the same as one used for the file.
01301   ACE_NEW_RETURN (this->allocator_,
01302                   PERSISTENT_ALLOCATOR (file_name,
01303                                         file_name,
01304                                         &options),
01305                   -1);
01306 
01307 #if !defined (ACE_LACKS_ACCESS)
01308   // Now check if the backing store has been created successfully.
01309   if (ACE_OS::access (file_name, F_OK) != 0)
01310     ACE_ERROR_RETURN ((LM_ERROR,
01311                        ACE_TEXT ("create_index\n")),
01312                       -1);
01313 #endif /* ACE_LACKS_ACCESS */
01314 
01315   return create_index ();
01316 }

int ACE_Configuration_Heap::open_section const ACE_Configuration_Section_Key base,
const ACE_TCHAR sub_section,
int  create,
ACE_Configuration_Section_Key result
[virtual]
 

Opens a named section in an existing section.

Parameters:
base Existing section in which to open the named section.
sub_section Name of the section to open.
create If zero, the named section must exist. If non-zero, the named section will be created if it does not exist.
result Reference; receives the section key for the new section.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1527 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TEXT, ACE_TString, ACE_String_Base< CHAR >::c_str(), open_simple_section(), ACE_OS::strchr(), and ACE_Configuration::validate_name().

Referenced by remove_section().

01531 {
01532   ACE_ASSERT (this->allocator_);
01533   if (validate_name (sub_section, 1))    // 1 == allow_path
01534     return -1;
01535 
01536   result = base;
01537 
01538   for (const ACE_TCHAR* separator;
01539        (separator = ACE_OS::strchr (sub_section, ACE_TEXT ('\\'))) != 0;
01540        )
01541     {
01542       ACE_TString simple_section (sub_section, separator - sub_section);
01543       int ret_val =
01544         open_simple_section (result, simple_section.c_str (), create, result);
01545       if (ret_val)
01546         return ret_val;
01547       sub_section = separator + 1;
01548     }
01549 
01550   return open_simple_section (result, sub_section, create, result);
01551 }

int ACE_Configuration_Heap::open_simple_section const ACE_Configuration_Section_Key base,
const ACE_TCHAR sub_section,
int  create,
ACE_Configuration_Section_Key result
[private]
 

may not contain path separators

Definition at line 1554 of file Configuration.cpp.

References ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TString, add_section(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, ACE_String_Base< CHAR >::length(), and load_key().

Referenced by open_section().

01558 {
01559   ACE_TString section (0, 0, false);
01560 
01561   if (load_key (base, section))
01562     {
01563       return -1;
01564     }
01565 
01566   // Only add the \\ if were not at the root
01567   if (section.length ())
01568     {
01569       section += ACE_TEXT ("\\");
01570     }
01571 
01572   section += sub_section;
01573 
01574   // resolve the section
01575   ACE_Configuration_ExtId ExtId (section.fast_rep ());
01576   ACE_Configuration_Section_IntId IntId;
01577 
01578   if (index_->find (ExtId, IntId, allocator_))
01579     {
01580       if (!create)
01581         {
01582           errno = ENOENT;
01583           return -1;
01584         }
01585 
01586       return add_section (base, sub_section, result);
01587     }
01588 
01589   ACE_Configuration_Section_Key_Heap *temp;
01590   ACE_NEW_RETURN (temp,
01591                   ACE_Configuration_Section_Key_Heap (section.fast_rep ()),
01592                   -1);
01593   result = ACE_Configuration_Section_Key (temp);
01594   return 0;
01595 }

ACE_Configuration_Heap& ACE_Configuration_Heap::operator= const ACE_Configuration_Heap rhs  )  [private]
 

int ACE_Configuration_Heap::remove_section const ACE_Configuration_Section_Key key,
const ACE_TCHAR sub_section,
int  recursive
[virtual]
 

Removes a named section.

Parameters:
key Section key to remove the named section from.
sub_section Name of the section to remove.
recursive If non zero, any subkeys below sub_section are removed as well.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1598 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TEXT, ACE_TString, ACE_Hash_Map_Manager_Ex< ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Hash< ACE_Configuration_ExtId >, ACE_Equal_To< ACE_Configuration_ExtId >, ACE_Null_Mutex >::begin(), ACE_Hash_Map_Manager_Ex< ACE_Configuration_ExtId, ACE_Configuration_Value_IntId, ACE_Hash< ACE_Configuration_ExtId >, ACE_Equal_To< ACE_Configuration_ExtId >, ACE_Null_Mutex >::close(), enumerate_sections(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_Manager_Ex< ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Hash< ACE_Configuration_ExtId >, ACE_Equal_To< ACE_Configuration_ExtId >, ACE_Null_Mutex >::find(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Configuration_Section_IntId::free(), ACE_Configuration_ExtId::free(), index_, ACE_String_Base< CHAR >::length(), load_key(), open_section(), SECTION_HASH, ACE_Configuration_Section_IntId::section_hash_map_, SUBSECTION_HASH, ACE_Hash_Map_Manager_Ex< ACE_Configuration_ExtId, ACE_Configuration_Section_IntId, ACE_Hash< ACE_Configuration_ExtId >, ACE_Equal_To< ACE_Configuration_ExtId >, ACE_Null_Mutex >::unbind(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::unbind(), ACE_Configuration::validate_name(), and VALUE_HASH.

01601 {
01602   ACE_ASSERT (this->allocator_);
01603   if (validate_name (sub_section))
01604     return -1;
01605 
01606   ACE_TString section;
01607   if (load_key (key, section))
01608     return -1;
01609 
01610   // Find this key
01611   ACE_Configuration_ExtId ParentExtId (section.fast_rep ());
01612   ACE_Configuration_Section_IntId ParentIntId;
01613   if (index_->find (ParentExtId, ParentIntId, allocator_))
01614     return -1;// no parent key
01615 
01616   // Find this subkey
01617   if (section.length ())
01618     section += ACE_TEXT ("\\");
01619 
01620   section += sub_section;
01621   ACE_Configuration_ExtId SectionExtId (section.fast_rep ());
01622   SECTION_HASH::ENTRY* section_entry;
01623   SECTION_HASH* hashmap = index_;
01624   if (hashmap->find (SectionExtId, section_entry))
01625     return -1;
01626 
01627   if (recursive)
01628     {
01629       ACE_Configuration_Section_Key section;
01630       if (open_section (key, sub_section, 0, section))
01631         return -1;
01632 
01633       int index = 0;
01634       ACE_TString name;
01635       while (!enumerate_sections (section, index, name))
01636         {
01637           if (remove_section (section, name.fast_rep (), 1))
01638             return -1;
01639 
01640           ++index;
01641         }
01642     }
01643 
01644   // Now make sure we dont have any subkeys
01645   if (section_entry->int_id_.section_hash_map_->current_size ())
01646     {
01647       errno = ENOTEMPTY;
01648       return -1;
01649     }
01650 
01651   // Now remove subkey from parent key
01652   ACE_Configuration_ExtId SubSExtId (sub_section);
01653   SUBSECTION_HASH::ENTRY* subsection_entry;
01654   if (((SUBSECTION_HASH*)ParentIntId.section_hash_map_)->
01655       find (SubSExtId, subsection_entry))
01656     return -1;
01657 
01658   if (ParentIntId.section_hash_map_->unbind (SubSExtId, allocator_))
01659     return -1;
01660 
01661   subsection_entry->ext_id_.free (allocator_);
01662 
01663   // Remember the pointers so we can free them after we unbind
01664   ACE_Configuration_ExtId ExtIdToFree (section_entry->ext_id_);
01665   ACE_Configuration_Section_IntId IntIdToFree (section_entry->int_id_);
01666 
01667   // iterate over all values and free memory
01668   VALUE_HASH* value_hash_map = section_entry->int_id_.value_hash_map_;
01669   VALUE_HASH::ITERATOR value_iter = value_hash_map->begin ();
01670   while (!value_iter.done ())
01671     {
01672       VALUE_HASH::ENTRY* value_entry = 0;
01673       if (!value_iter.next (value_entry))
01674         return 1;
01675 
01676       value_entry->ext_id_.free (allocator_);
01677       value_entry->int_id_.free (allocator_);
01678 
01679       value_iter.advance ();
01680     }
01681 
01682   // remove it
01683   if (index_->unbind (SectionExtId, allocator_))
01684     return -1;
01685 
01686   value_hash_map->close ();
01687   section_entry->int_id_.section_hash_map_->close (allocator_);
01688 
01689   // Free the memory
01690   ExtIdToFree.free (allocator_);
01691   IntIdToFree.free (allocator_);
01692 
01693   return 0;
01694 }

int ACE_Configuration_Heap::remove_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name
[virtual]
 

Removes the the value name from key. returns non zero on error.

Implements ACE_Configuration.

Definition at line 2114 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), index_, load_key(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::unbind(), ACE_Configuration::validate_value_name(), VALUE_HASH, and ACE_Configuration_Section_IntId::value_hash_map_.

02116 {
02117   ACE_ASSERT (this->allocator_);
02118   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
02119   if (validate_value_name (t_name))
02120     return -1;
02121 
02122   // Get the section name from the key
02123   ACE_TString section;
02124   if (load_key (key, section))
02125     return -1;
02126 
02127   // Find this section
02128   ACE_Configuration_ExtId ExtId (section.fast_rep ());
02129   ACE_Configuration_Section_IntId IntId;
02130   if (index_->find (ExtId, IntId, allocator_))
02131     return -1;    // section does not exist
02132 
02133   // Find it
02134   ACE_Configuration_ExtId ValueExtId (t_name);
02135   VALUE_HASH::ENTRY* value_entry;
02136   if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry))
02137     return -1;
02138 
02139   // free it
02140   value_entry->ext_id_.free (allocator_);
02141   value_entry->int_id_.free (allocator_);
02142 
02143   // Unbind it
02144   if (IntId.value_hash_map_->unbind (ValueExtId, allocator_))
02145     return -1;
02146 
02147   return 0;
02148 }

int ACE_Configuration_Heap::section_open_helper size_t  hash_table_size,
void *  buffer
[private]
 

Definition at line 1518 of file Configuration.cpp.

References ACE_ASSERT, and SUBSECTION_MAP.

Referenced by new_section().

01520 {
01521   ACE_ASSERT (this->allocator_);
01522   new (buffer) SUBSECTION_MAP (hash_table_size, this->allocator_);
01523   return 0;
01524 }

int ACE_Configuration_Heap::set_binary_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
const void *  data,
size_t  length
[virtual]
 

Sets a binary-typed value.

Parameters:
key Configuration section to set the value in.
name Name of the configuration value to set. If a value with the specified name exists, it is replaced.
data Pointer to the binary data for the value.
length Number of bytes for the new value.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1893 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::bind(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Allocator::free(), index_, load_key(), ACE_Allocator::malloc(), ACE_OS::memcpy(), ACE_OS::strcpy(), ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

01897 {
01898   ACE_ASSERT (this->allocator_);
01899   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
01900   if (validate_value_name (t_name))
01901     return -1;
01902 
01903   // Get the section name from the key
01904   ACE_TString section;
01905   if (load_key (key, section))
01906     return -1;
01907 
01908   // Find this section
01909   ACE_Configuration_ExtId section_ext (section.fast_rep ());
01910   ACE_Configuration_Section_IntId section_int;
01911   if (index_->find (section_ext, section_int, allocator_))
01912     return -1;    // section does not exist
01913 
01914   // Get the entry for this item (if it exists)
01915   VALUE_HASH::ENTRY* entry;
01916   ACE_Configuration_ExtId item_name (t_name);
01917   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
01918     {
01919       // found item, replace it
01920       // Free the old value
01921       entry->int_id_.free (allocator_);
01922       // Allocate the new value in this heap
01923       ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length);
01924       ACE_OS::memcpy (pers_value, data, length);
01925       ACE_Configuration_Value_IntId new_value_int (pers_value, length);
01926       entry->int_id_ = new_value_int;
01927     }
01928   else
01929     {
01930       // it doesn't exist, bind it
01931       ACE_TCHAR* pers_name =
01932  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
01933       ACE_OS::strcpy (pers_name, t_name);
01934       ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length);
01935       ACE_OS::memcpy (pers_value, data, length);
01936       ACE_Configuration_ExtId item_name (pers_name);
01937       ACE_Configuration_Value_IntId item_value (pers_value, length);
01938       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
01939         {
01940           allocator_->free (pers_value);
01941           allocator_->free (pers_name);
01942           return -1;
01943         }
01944       return 0;
01945     }
01946 
01947   return 0;
01948 }

int ACE_Configuration_Heap::set_integer_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
u_int  value
[virtual]
 

Sets a integer-typed value.

Parameters:
key Configuration section to set the value in.
name Name of the configuration value to set. If a value with the specified name exists, it is replaced.
value The integer to set the configuration value to.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1844 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::bind(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Allocator::free(), index_, load_key(), ACE_Allocator::malloc(), ACE_OS::strcpy(), ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

01847 {
01848   ACE_ASSERT (this->allocator_);
01849   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
01850   if (validate_value_name (t_name))
01851     return -1;
01852 
01853   // Get the section name from the key
01854   ACE_TString section;
01855   if (load_key (key, section))
01856     return -1;
01857 
01858   // Find this section
01859   ACE_Configuration_ExtId section_ext (section.fast_rep ());
01860   ACE_Configuration_Section_IntId section_int;
01861   if (index_->find (section_ext, section_int, allocator_))
01862     return -1;  // section does not exist
01863 
01864   // Get the entry for this item (if it exists)
01865   VALUE_HASH::ENTRY* entry;
01866   ACE_Configuration_ExtId item_name (t_name);
01867   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
01868     {
01869       // found item, replace it
01870       ACE_Configuration_Value_IntId new_value_int (value);
01871       entry->int_id_ = new_value_int;
01872     }
01873   else
01874     {
01875       // it doesn't exist, bind it
01876       ACE_TCHAR* pers_name =
01877  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
01878       ACE_OS::strcpy (pers_name, t_name);
01879       ACE_Configuration_ExtId item_name (pers_name);
01880       ACE_Configuration_Value_IntId item_value (value);
01881       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
01882         {
01883           allocator_->free (pers_name);
01884           return -1;
01885         }
01886       return 0;
01887     }
01888 
01889   return 0;
01890 }

int ACE_Configuration_Heap::set_string_value const ACE_Configuration_Section_Key key,
const ACE_TCHAR name,
const ACE_TString value
[virtual]
 

Sets a string-typed value.

Parameters:
key Configuration section to set the value in.
name Name of the configuration value to set. If a value with the specified name exists, it is replaced.
value The string to set the configuration value to.
Return values:
0 for success.
-1 for error; ACE_OS::last_error() retrieves error code.

Implements ACE_Configuration.

Definition at line 1787 of file Configuration.cpp.

References ACE_ASSERT, ACE_TCHAR, ACE_TString, ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::bind(), ACE_String_Base< CHAR >::fast_rep(), ACE_Hash_Map_With_Allocator< EXT_ID, INT_ID >::find(), ACE_Allocator::free(), index_, ACE_String_Base< CHAR >::length(), load_key(), ACE_Allocator::malloc(), ACE_OS::strcpy(), ACE_Configuration::validate_value_name(), and ACE_Configuration_Section_IntId::value_hash_map_.

01790 {
01791   ACE_ASSERT (this->allocator_);
01792   const ACE_TCHAR *t_name = name ? name : &this->NULL_String_;
01793   if (validate_value_name (t_name))
01794     return -1;
01795 
01796   ACE_TString section;
01797   if (load_key (key, section))
01798     return -1;
01799 
01800   ACE_Configuration_ExtId section_ext (section.fast_rep ());
01801   ACE_Configuration_Section_IntId section_int;
01802   if (index_->find (section_ext, section_int, allocator_))
01803     return -1;
01804 
01805   // Get the entry for this item (if it exists)
01806   VALUE_HASH::ENTRY* entry;
01807   ACE_Configuration_ExtId item_name (t_name);
01808   if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0)
01809     {
01810       // found item, replace it
01811       // Free the old value
01812       entry->int_id_.free (allocator_);
01813       // Allocate the new value in this heap
01814       ACE_TCHAR* pers_value =
01815  (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR));
01816       ACE_OS::strcpy (pers_value, value.fast_rep ());
01817       ACE_Configuration_Value_IntId new_value_int (pers_value);
01818       entry->int_id_ = new_value_int;
01819     }
01820   else
01821     {
01822       // it doesn't exist, bind it
01823       ACE_TCHAR* pers_name =
01824  (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR));
01825       ACE_OS::strcpy (pers_name, t_name);
01826       ACE_TCHAR* pers_value =
01827  (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR));
01828       ACE_OS::strcpy (pers_value, value.fast_rep ());
01829       ACE_Configuration_ExtId item_name (pers_name);
01830       ACE_Configuration_Value_IntId item_value (pers_value);
01831       if (section_int.value_hash_map_->bind (item_name, item_value, allocator_))
01832         {
01833           allocator_->free (pers_value);
01834           allocator_->free (pers_name);
01835           return -1;
01836         }
01837       return 0;
01838     }
01839 
01840   return 0;
01841 }

int ACE_Configuration_Heap::value_open_helper size_t  hash_table_size,
void *  buffer
[private]
 

Definition at line 1509 of file Configuration.cpp.

References ACE_ASSERT, and VALUE_MAP.

Referenced by new_section().

01511 {
01512   ACE_ASSERT (this->allocator_);
01513   new (buffer) VALUE_MAP (hash_table_size, this->allocator_);
01514   return 0;
01515 }


Member Data Documentation

ACE_Allocator* ACE_Configuration_Heap::allocator_ [private]
 

Definition at line 884 of file Configuration.h.

size_t ACE_Configuration_Heap::default_map_size_ [private]
 

Definition at line 886 of file Configuration.h.

Referenced by new_section(), and open().

SECTION_MAP* ACE_Configuration_Heap::index_ [private]
 

Definition at line 885 of file Configuration.h.

Referenced by add_section(), create_index(), create_index_helper(), enumerate_sections(), enumerate_values(), find_value(), get_binary_value(), get_integer_value(), get_string_value(), new_section(), open_simple_section(), remove_section(), remove_value(), set_binary_value(), set_integer_value(), and set_string_value().


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