Quelle nsWindowsRegKey.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include <windows.h>
#include "nsCOMPtr.h"
#include "nsWindowsRegKey.h"
#include "mozilla/RefPtr.h"
#include "mozilla/widget/WinRegistry.h"

//-----------------------------------------------------------------------------

using namespace mozilla::widget;

class nsWindowsRegKey final : public nsIWindowsRegKey {
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIWINDOWSREGKEY

  nsWindowsRegKey() = default;

private:
  ~nsWindowsRegKey() = default;

  WinRegistry::Key mKey;
};

NS_IMPL_ISUPPORTS(nsWindowsRegKey, nsIWindowsRegKey)

NS_IMETHODIMP
nsWindowsRegKey::Close() {
  mKey = WinRegistry::Key();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::Open(uint32_t aRootKey, const nsAString& aPath,
                      uint32_t aMode) {
  mKey = WinRegistry::Key((HKEY)(uintptr_t)(aRootKey), PromiseFlatString(aPath),
                          WinRegistry::KeyMode(aMode));
  return mKey ? NS_OK : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::Create(uint32_t aRootKey, const nsAString& aPath,
                        uint32_t aMode) {
  mKey =
      WinRegistry::Key((HKEY)(uintptr_t)(aRootKey), PromiseFlatString(aPath),
                       WinRegistry::KeyMode(aMode), WinRegistry::Key::Create);
  return mKey ? NS_OK : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::OpenChild(const nsAString& aPath, uint32_t aMode,
                           nsIWindowsRegKey** aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  RefPtr<nsWindowsRegKey> child = new nsWindowsRegKey();
  child->mKey = WinRegistry::Key(mKey, PromiseFlatString(aPath),
                                 WinRegistry::KeyMode(aMode));
  if (!child->mKey) {
    return NS_ERROR_FAILURE;
  }
  child.forget(aResult);
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::CreateChild(const nsAString& aPath, uint32_t aMode,
                             nsIWindowsRegKey** aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }

  RefPtr<nsWindowsRegKey> child = new nsWindowsRegKey();
  child->mKey =
      WinRegistry::Key(mKey, PromiseFlatString(aPath),
                       WinRegistry::KeyMode(aMode), WinRegistry::Key::Create);
  if (!child->mKey) {
    return NS_ERROR_FAILURE;
  }
  child.forget(aResult);
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::GetChildCount(uint32_t* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  *aResult = mKey.GetChildCount();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::GetChildName(uint32_t aIndex, nsAString& aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.GetChildName(aIndex, aResult) ? NS_OK : NS_ERROR_NOT_AVAILABLE;
}

NS_IMETHODIMP
nsWindowsRegKey::HasChild(const nsAString& aName, bool* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  // Check for the existence of a child key by opening the key with minimal
  // rights.  Perhaps there is a more efficient way to do this?
  *aResult = !!WinRegistry::Key(mKey, PromiseFlatString(aName),
                                WinRegistry::KeyMode::Read);
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::GetValueCount(uint32_t* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  *aResult = mKey.GetValueCount();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::GetValueName(uint32_t aIndex, nsAString& aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.GetValueName(aIndex, aResult) ? NS_OK : NS_ERROR_NOT_AVAILABLE;
}

NS_IMETHODIMP
nsWindowsRegKey::HasValue(const nsAString& aName, bool* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  *aResult = mKey.GetValueType(PromiseFlatString(aName)) !=
             WinRegistry::ValueType::None;
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::RemoveChild(const nsAString& aName) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.RemoveChildKey(PromiseFlatString(aName)) ? NS_OK
                                                       : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::RemoveValue(const nsAString& aName) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.RemoveValue(PromiseFlatString(aName)) ? NS_OK : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::GetValueType(const nsAString& aName, uint32_t* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  *aResult = uint32_t(mKey.GetValueType(PromiseFlatString(aName)));
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::ReadStringValue(const nsAString& aName, nsAString& aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  constexpr auto kFlags = WinRegistry::StringFlags::Sz |
                          WinRegistry::StringFlags::ExpandSz |
                          WinRegistry::StringFlags::LegacyMultiSz |
                          WinRegistry::StringFlags::ExpandEnvironment;
  auto value = mKey.GetValueAsString(PromiseFlatString(aName), kFlags);
  if (!value) {
    return NS_ERROR_FAILURE;
  }
  aResult = value.extract();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::ReadIntValue(const nsAString& aName, uint32_t* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  auto value = mKey.GetValueAsDword(PromiseFlatString(aName));
  if (!value) {
    return NS_ERROR_FAILURE;
  }
  *aResult = value.extract();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::ReadInt64Value(const nsAString& aName, uint64_t* aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  auto value = mKey.GetValueAsQword(PromiseFlatString(aName));
  if (!value) {
    return NS_ERROR_FAILURE;
  }
  *aResult = value.extract();
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::ReadBinaryValue(const nsAString& aName, nsACString& aResult) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  auto value = mKey.GetValueAsBinary(PromiseFlatString(aName));
  if (!value) {
    return NS_ERROR_FAILURE;
  }
  nsTArray<uint8_t> data = value.extract();
  if (!aResult.Assign((const char*)data.Elements(), data.Length(),
                      mozilla::fallible)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  return NS_OK;
}

NS_IMETHODIMP
nsWindowsRegKey::WriteStringValue(const nsAString& aName,
                                  const nsAString& aValue) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.WriteValueAsString(PromiseFlatString(aName),
                                 PromiseFlatString(aValue))
             ? NS_OK
             : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::WriteIntValue(const nsAString& aName, uint32_t aValue) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.WriteValueAsDword(PromiseFlatString(aName), aValue)
             ? NS_OK
             : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::WriteInt64Value(const nsAString& aName, uint64_t aValue) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.WriteValueAsQword(PromiseFlatString(aName), aValue)
             ? NS_OK
             : NS_ERROR_FAILURE;
}

NS_IMETHODIMP
nsWindowsRegKey::WriteBinaryValue(const nsAString& aName,
                                  const nsACString& aValue) {
  if (NS_WARN_IF(!mKey)) {
    return NS_ERROR_NOT_INITIALIZED;
  }
  return mKey.WriteValueAsBinary(PromiseFlatString(aName), aValue)
             ? NS_OK
             : NS_ERROR_FAILURE;
}

//-----------------------------------------------------------------------------

void NS_NewWindowsRegKey(nsIWindowsRegKey** aResult) {
  RefPtr<nsWindowsRegKey> key = new nsWindowsRegKey();
  key.forget(aResult);
}

//-----------------------------------------------------------------------------

nsresult nsWindowsRegKeyConstructor(const nsIID& aIID, void** aResult) {
  nsCOMPtr<nsIWindowsRegKey> key;
  NS_NewWindowsRegKey(getter_AddRefs(key));
  return key->QueryInterface(aIID, aResult);
}

quality100%

¤ Dauer der Verarbeitung: 0.22 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.