text: // $Id: Registry_Name_Space.cpp 2179 2013-05-28 22:16:51Z mesnierp $
  
  #include "ace/Registry_Name_Space.h"
  
  
  
  #if (defined (ACE_WIN32) && defined (ACE_USES_WCHAR))
  // This only works on Win32 platforms when ACE_USES_WCHAR is turned on
  
  ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  
  ACE_Registry_Name_Space::ACE_Registry_Name_Space (void)
  {
  }
  
  ACE_Registry_Name_Space::ACE_Registry_Name_Space (ACE_Name_Options *name_options)
  {
    if (this->open (name_options) != 0)
      ACELIB_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),
                  ACE_TEXT ("ACE_Registry_Name_Space::open")));
  }
  
  
  ACE_Registry_Name_Space::~ACE_Registry_Name_Space (void)
  {
  }
  
  
  int
  ACE_Registry_Name_Space::open (ACE_Name_Options *name_options)
  {
    const ACE_TCHAR *host = name_options->nameserver_host ();
    ACE_Registry::Naming_Context predefined;
  
    int result = ACE_Predefined_Naming_Contexts::connect (predefined,
                                                          HKEY_LOCAL_MACHINE,
                                                          host);
    if (result != 0)
      ACELIB_ERROR_RETURN ((LM_ERROR,  ACE_TEXT ("%p\n"),
                         ACE_TEXT ("ACE_Predefined_Naming_Context::connect")),
                        result);
    else
      {
        // Directory
        ACE_TString name = name_options->namespace_dir ();
        // Separator
        name += ACE_Registry::STRING_SEPARATOR;
        // Filename
        name += name_options->database ();
  
        // Create new context or bind to existing one
        result = predefined.bind_context (name,
                                          this->context_);
        if (result != 0)
          ACELIB_ERROR_RETURN ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_Registry::Naming_Context::bind_context")), result);
      }
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space::bind (const ACE_NS_WString &name,
                                 const ACE_NS_WString &value,
                                 const char *type)
  {
    ACE_UNUSED_ARG(type);
  
    // Pointer to data
    const ACE_WSTRING_TYPE *data = value.fast_rep ();
  
    // Size
    size_t size = value.length () * sizeof (ACE_WSTRING_TYPE);
  
    // Represent value as an ACE_Registry::Object
    ACE_Registry::Object object ((void *) data,
                                 static_cast<u_long> (size),
                                 REG_SZ);
    // Add new <key>/<value> pair
  #if defined ACE_USES_WCHAR
    return this->context_.bind (name.fast_rep(),
                                object);
  #else
    return this->context_.bind (name.char_rep(),
                                object);
  #endif /* ACE_HAS_WCHAR */
  }
  
  
  int
  ACE_Registry_Name_Space::rebind (const ACE_NS_WString &name,
                                   const ACE_NS_WString &value,
                                   const char *type)
  {
    ACE_UNUSED_ARG(type);
  
    // Pointer to data
    const ACE_WSTRING_TYPE *data = value.fast_rep ();
  
    // Size
    size_t size = value.length () * sizeof (ACE_WSTRING_TYPE);
  
    // Represent value as an ACE_Registry::Object
    ACE_Registry::Object object ((void *) data,
                                 static_cast<u_long> (size),
                                 REG_SZ);
    // Add new <key>/<value> pair
  #if defined (ACE_USES_WCHAR)
    return this->context_.rebind (name.fast_rep (),
                                  object);
  #else
    return this->context_.rebind (name.char_rep (),
                                  object);
  #endif /* ACE_USES_WCHAR */
  }
  
  
  int
  ACE_Registry_Name_Space::unbind (const ACE_NS_WString &name)
  {
  #if defined (ACE_USES_WCHAR)
    return this->context_.unbind (name.fast_rep ());
  #else
    return this->context_.unbind (name.char_rep ());
  #endif /* ACE_USES_WCHAR */
  }
  
  
  int
  ACE_Registry_Name_Space::resolve (const ACE_NS_WString &name,
                                    ACE_NS_WString &value,
                                    char *&type)
  {
    ACE_UNUSED_ARG(type);
  
    // This object will be used to query the size of the data.
    // Note: The query_object.data will be null for this invocation.
    ACE_Registry::Object query_object;
    int result =
  #if defined (ACE_USES_WCHAR)
      this->context_.resolve (name.fast_rep (), query_object);
  #else
      this->context_.resolve (name.char_rep (), query_object);
  #endif /* ACE_USES_WCHAR */
    if (result != 0)
      return result;
  
    // Resize the value passed by the user
    // Note: -1 is used because the size includes the null terminator
    value.resize ((query_object.size () - 1) / sizeof (ACE_WSTRING_TYPE));
  
    // Represent new space as an ACE_Registry::Object
    ACE_Registry::Object object ((void *) value.fast_rep (),
                                 query_object.size (),
                                 REG_SZ);
  
  #if defined (ACE_USES_WCHAR)
    result = this->context_.resolve (name.fast_rep (), object);
  #else
    result = this->context_.resolve (name.char_rep (), object);
  #endif /* ACE_USES_WCHAR */
    if (object.size () != query_object.size ())
      return -1;
    if (result != 0)
      return result;
  
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space:: list_names (ACE_WSTRING_SET &set,
                                        const ACE_NS_WString &pattern)
  {
    ACE_BINDING_SET binding_set;
    int result = this->list_name_entries (binding_set,
                                          pattern);
    if (result != 0)
      return result;
  
    ACE_BINDING_ITERATOR iterator (binding_set);
  
    for (ACE_Name_Binding *entry = 0;
         iterator.next (entry) !=0;
         iterator.advance())
      {
        set.insert (entry->name_);
      }
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space::list_values (ACE_WSTRING_SET &set,
                                        const ACE_NS_WString &pattern)
  {
    ACE_BINDING_SET binding_set;
    int result = this->list_name_entries (binding_set,
                                          pattern);
    if (result != 0)
      return result;
  
    ACE_BINDING_ITERATOR iterator (binding_set);
  
    for (ACE_Name_Binding *entry = 0;
         iterator.next (entry) !=0;
         iterator.advance())
      {
        set.insert (entry->value_);
      }
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space::list_types (ACE_WSTRING_SET &set,
                                       const ACE_NS_WString &pattern)
  {
    ACE_UNUSED_ARG(set);
    ACE_UNUSED_ARG(pattern);
  
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space::list_name_entries (ACE_BINDING_SET &set,
                                              const ACE_NS_WString &pattern)
  {
    ACE_UNUSED_ARG(pattern);
  
    ACE_Registry::Binding_List list;
    int result = this->context_.list (list);
    if (result != 0)
      return result;
  
    // Iterator through all entries
    for (ACE_Registry::Binding_List::iterator i = list.begin ();
         i != list.end ();
         i++)
      {
        // Yeeesss! STL rules!
        ACE_Registry::Binding &binding = *i;
  
        if (binding.type () == ACE_Registry::OBJECT)
          {
            // Key
            ACE_TString string = binding.name ();
            ACE_NS_WString key (string.c_str ());
  
            // Value
            ACE_NS_WString value;
            char *type = 0;
            result = this->resolve (key,
                                    value,
                                    type);
            if (result != 0)
              ACELIB_ERROR_RETURN ((LM_ERROR,
                                ACE_TEXT ("%p\n"),
                                ACE_TEXT ("ACE_Registry::Naming_Context::resolve")),
                                result);
  
            // Complete binding
            ACE_Name_Binding binding (key, value, type);
            set.insert (binding);
          }
      }
    return 0;
  }
  
  
  int
  ACE_Registry_Name_Space::list_value_entries (ACE_BINDING_SET &set,
                                               const ACE_NS_WString &pattern)
  {
    return this->list_name_entries (set, pattern);
  }
  
  
  int
  ACE_Registry_Name_Space::list_type_entries (ACE_BINDING_SET &set,
                                              const ACE_NS_WString &pattern)
  {
    return this->list_name_entries (set, pattern);
  }
  
  
  void
  ACE_Registry_Name_Space::dump (void) const
  {
  #if defined (ACE_HAS_DUMP)
  #endif /* ACE_HAS_DUMP */
  }
  
  ACE_END_VERSIONED_NAMESPACE_DECL
  
  #endif /* ACE_WIN32 && ACE_USES_WCHAR */
  