ACE/ace/Registry_Name_Space.cpp

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