dep/ACE_wrappers/ace/Registry_Name_Space.cpp

   1 // $Id: Registry_Name_Space.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/Registry_Name_Space.h"
   4
   5 ACE_RCSID(ace, Registry_Name_Space, "$Id: Registry_Name_Space.cpp 80826 2008-03-04 14:51:23Z wotte $")
   6
   7 #if (defined (ACE_WIN32) && defined (ACE_USES_WCHAR))
   8 // This only works on Win32 platforms when ACE_USES_WCHAR is turned on
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 ACE_Registry_Name_Space::ACE_Registry_Name_Space (void)
  13 {
  14 }
  15
  16 ACE_Registry_Name_Space::ACE_Registry_Name_Space (ACE_Name_Options *name_options)
  17 {
  18   if (this->open (name_options) != 0)
  19     ACE_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),
  20                 ACE_TEXT ("ACE_Registry_Name_Space::open")));
  21 }
  22
  23
  24 ACE_Registry_Name_Space::~ACE_Registry_Name_Space (void)
  25 {
  26 }
  27
  28
  29 int
  30 ACE_Registry_Name_Space::open (ACE_Name_Options *name_options)
  31 {
  32   const ACE_TCHAR *host = name_options->nameserver_host ();
  33   ACE_Registry::Naming_Context predefined;
  34
  35   int result = ACE_Predefined_Naming_Contexts::connect (predefined,
  36                                                         HKEY_LOCAL_MACHINE,
  37                                                         host);
  38   if (result != 0)
  39     ACE_ERROR_RETURN ((LM_ERROR,  ACE_TEXT ("%p\n"),
  40                        ACE_TEXT ("ACE_Predefined_Naming_Context::connect")),
  41                       result);
  42   else
  43     {
  44       // Directory
  45       ACE_TString name = name_options->namespace_dir ();
  46       // Separator
  47       name += ACE_Registry::STRING_SEPARATOR;
  48       // Filename
  49       name += name_options->database ();
  50
  51       // Create new context or bind to existing one
  52       result = predefined.bind_context (name,
  53                                         this->context_);
  54       if (result != 0)
  55         ACE_ERROR_RETURN ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Registry::Naming_Context::bind_context")), result);
  56     }
  57   return 0;
  58 }
  59
  60
  61 int
  62 ACE_Registry_Name_Space::bind (const ACE_NS_WString &name,
  63                                const ACE_NS_WString &value,
  64                                const char *type)
  65 {
  66   ACE_UNUSED_ARG(type);
  67
  68   // Pointer to data
  69   const ACE_WSTRING_TYPE *data = value.fast_rep ();
  70
  71   // Size
  72   size_t size = value.length () * sizeof (ACE_WSTRING_TYPE);
  73
  74   // Represent value as an ACE_Registry::Object
  75   ACE_Registry::Object object ((void *) data,
  76                                static_cast<u_long> (size),
  77                                REG_SZ);
  78   // Add new <key>/<value> pair
  79 #if defined ACE_USES_WCHAR
  80   return this->context_.bind (name.fast_rep(),
  81                               object);
  82 #else
  83   return this->context_.bind (name.char_rep(),
  84                               object);
  85 #endif /* ACE_HAS_WCHAR */
  86 }
  87
  88
  89 int
  90 ACE_Registry_Name_Space::rebind (const ACE_NS_WString &name,
  91                                  const ACE_NS_WString &value,
  92                                  const char *type)
  93 {
  94   ACE_UNUSED_ARG(type);
  95
  96   // Pointer to data
  97   const ACE_WSTRING_TYPE *data = value.fast_rep ();
  98
  99   // Size
 100   size_t size = value.length () * sizeof (ACE_WSTRING_TYPE);
 101
 102   // Represent value as an ACE_Registry::Object
 103   ACE_Registry::Object object ((void *) data,
 104                                static_cast<u_long> (size),
 105                                REG_SZ);
 106   // Add new <key>/<value> pair
 107 #if defined (ACE_USES_WCHAR)
 108   return this->context_.rebind (name.fast_rep (),
 109                                 object);
 110 #else
 111   return this->context_.rebind (name.char_rep (),
 112                                 object);
 113 #endif /* ACE_USES_WCHAR */
 114 }
 115
 116
 117 int
 118 ACE_Registry_Name_Space::unbind (const ACE_NS_WString &name)
 119 {
 120 #if defined (ACE_USES_WCHAR)
 121   return this->context_.unbind (name.fast_rep ());
 122 #else
 123   return this->context_.unbind (name.char_rep ());
 124 #endif /* ACE_USES_WCHAR */
 125 }
 126
 127
 128 int
 129 ACE_Registry_Name_Space::resolve (const ACE_NS_WString &name,
 130                                   ACE_NS_WString &value,
 131                                   char *&type)
 132 {
 133   ACE_UNUSED_ARG(type);
 134
 135   // This object will be used to query the size of the data.
 136   // Note: The query_object.data will be null for this invocation.
 137   ACE_Registry::Object query_object;
 138   int result =
 139 #if defined (ACE_USES_WCHAR)
 140     this->context_.resolve (name.fast_rep (), query_object);
 141 #else
 142     this->context_.resolve (name.char_rep (), query_object);
 143 #endif /* ACE_USES_WCHAR */
 144   if (result != 0)
 145     return result;
 146
 147   // Resize the value passed by the user
 148   // Note: -1 is used because the size includes the null terminator
 149   value.resize ((query_object.size () - 1) / sizeof (ACE_WSTRING_TYPE));
 150
 151   // Represent new space as an ACE_Registry::Object
 152   ACE_Registry::Object object ((void *) value.fast_rep (),
 153                                query_object.size (),
 154                                REG_SZ);
 155
 156 #if defined (ACE_USES_WCHAR)
 157   result = this->context_.resolve (name.fast_rep (), object);
 158 #else
 159   result = this->context_.resolve (name.char_rep (), object);
 160 #endif /* ACE_USES_WCHAR */
 161   if (object.size () != query_object.size ())
 162     return -1;
 163   if (result != 0)
 164     return result;
 165
 166   return 0;
 167 }
 168
 169
 170 int
 171 ACE_Registry_Name_Space:: list_names (ACE_WSTRING_SET &set,
 172                                       const ACE_NS_WString &pattern)
 173 {
 174   ACE_BINDING_SET binding_set;
 175   int result = this->list_name_entries (binding_set,
 176                                         pattern);
 177   if (result != 0)
 178     return result;
 179
 180   ACE_BINDING_ITERATOR iterator (binding_set);
 181
 182   for (ACE_Name_Binding *entry = 0;
 183        iterator.next (entry) !=0;
 184        iterator.advance())
 185     {
 186       set.insert (entry->name_);
 187     }
 188   return 0;
 189 }
 190
 191
 192 int
 193 ACE_Registry_Name_Space::list_values (ACE_WSTRING_SET &set,
 194                                       const ACE_NS_WString &pattern)
 195 {
 196   ACE_BINDING_SET binding_set;
 197   int result = this->list_name_entries (binding_set,
 198                                         pattern);
 199   if (result != 0)
 200     return result;
 201
 202   ACE_BINDING_ITERATOR iterator (binding_set);
 203
 204   for (ACE_Name_Binding *entry = 0;
 205        iterator.next (entry) !=0;
 206        iterator.advance())
 207     {
 208       set.insert (entry->value_);
 209     }
 210   return 0;
 211 }
 212
 213
 214 int
 215 ACE_Registry_Name_Space::list_types (ACE_WSTRING_SET &set,
 216                                      const ACE_NS_WString &pattern)
 217 {
 218   ACE_UNUSED_ARG(set);
 219   ACE_UNUSED_ARG(pattern);
 220
 221   return 0;
 222 }
 223
 224
 225 int
 226 ACE_Registry_Name_Space::list_name_entries (ACE_BINDING_SET &set,
 227                                             const ACE_NS_WString &pattern)
 228 {
 229   ACE_UNUSED_ARG(pattern);
 230
 231   ACE_Registry::Binding_List list;
 232   int result = this->context_.list (list);
 233   if (result != 0)
 234     return result;
 235
 236   // Iterator through all entries
 237   for (ACE_Registry::Binding_List::iterator i = list.begin ();
 238        i != list.end ();
 239        i++)
 240     {
 241       // Yeeesss! STL rules!
 242       ACE_Registry::Binding &binding = *i;
 243
 244       if (binding.type () == ACE_Registry::OBJECT)
 245         {
 246           // Key
 247           ACE_TString string = binding.name ();
 248           ACE_NS_WString key (string.c_str ());
 249
 250           // Value
 251           ACE_NS_WString value;
 252           char *type = 0;
 253           result = this->resolve (key,
 254                                   value,
 255                                   type);
 256           if (result != 0)
 257             ACE_ERROR_RETURN ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Registry::Naming_Context::resolve")), result);
 258
 259           // Complete binding
 260           ACE_Name_Binding binding (key, value, type);
 261           set.insert (binding);
 262         }
 263     }
 264   return 0;
 265 }
 266
 267
 268 int
 269 ACE_Registry_Name_Space::list_value_entries (ACE_BINDING_SET &set,
 270                                              const ACE_NS_WString &pattern)
 271 {
 272   return this->list_name_entries (set, pattern);
 273 }
 274
 275
 276 int
 277 ACE_Registry_Name_Space::list_type_entries (ACE_BINDING_SET &set,
 278                                             const ACE_NS_WString &pattern)
 279 {
 280   return this->list_name_entries (set, pattern);
 281 }
 282
 283
 284 void
 285 ACE_Registry_Name_Space::dump (void) const
 286 {
 287 #if defined (ACE_HAS_DUMP)
 288 #endif /* ACE_HAS_DUMP */
 289 }
 290
 291 ACE_END_VERSIONED_NAMESPACE_DECL
 292
 293 #endif /* ACE_WIN32 && ACE_USES_WCHAR */