| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| // RegistryValueImpl.cpp: Implementierung der Klasse RegistryValueImpl. |
| // |
| ////////////////////////////////////////////////////////////////////// |
| |
| #include "registryvalueimpl.hxx" |
| |
| #ifdef _MSC_VER |
| #pragma warning(push, 1) /* disable warnings within system headers */ |
| #endif |
| #include <windows.h> |
| #ifdef _MSC_VER |
| #pragma warning(pop) |
| #endif |
| |
| #include <malloc.h> |
| #include <assert.h> |
| |
| #include "stringconverter.hxx" |
| |
| //################################# |
| // Creation/Destruction |
| //################################# |
| |
| //-------------------------------------------- |
| /** |
| */ |
| RegistryValueImpl::RegistryValueImpl(const std::wstring& Name, int Value) : |
| m_Name(Name), |
| m_Type(REG_DWORD), |
| m_IntData(Value) |
| { |
| } |
| |
| //-------------------------------------------- |
| /** |
| */ |
| RegistryValueImpl::RegistryValueImpl(const std::wstring& Name, const std::wstring& Value) : |
| m_Name(Name), |
| m_Type(REG_SZ), |
| m_StringData(Value), |
| m_IntData(0) |
| { |
| } |
| |
| //-------------------------------------------- |
| /** |
| */ |
| RegistryValueImpl::RegistryValueImpl(const std::wstring& Name, const std::string& Value) : |
| m_Name(Name), |
| m_Type(REG_SZ), |
| m_IntData(0) |
| { |
| m_StringData = AnsiToUnicodeString(Value); |
| } |
| |
| #if (_MSC_VER >= 1300) |
| RegistryValueImpl::RegistryValueImpl(const RegistryValueImpl& s) : |
| m_Name(s.m_Name), |
| m_Type(s.m_Type), |
| m_StringData(s.m_StringData), |
| m_IntData(s.m_IntData) |
| { |
| } |
| #endif |
| //-------------------------------------------- |
| /** |
| */ |
| RegistryValueImpl::~RegistryValueImpl() |
| { |
| } |
| |
| //################################# |
| // Query |
| //################################# |
| |
| //-------------------------------------------- |
| /** Returns the name of the value |
| */ |
| std::wstring RegistryValueImpl::GetName() const |
| { |
| return m_Name; |
| } |
| |
| //-------------------------------------------- |
| /** Return the size of data held |
| */ |
| size_t RegistryValueImpl::GetDataSize() const |
| { |
| size_t size = 0; |
| |
| if (REG_DWORD == m_Type) |
| size = sizeof(m_IntData); |
| else if (REG_SZ == m_Type) |
| size = m_StringData.length() ? ((m_StringData.length() + 1) * sizeof(wchar_t)) : 0; |
| |
| return size; |
| } |
| |
| //-------------------------------------------- |
| /** Get a pointer to the data buffer |
| in order to copy the data |
| */ |
| const void* RegistryValueImpl::GetDataBuffer() const |
| { |
| const void* pData = 0; |
| |
| if (REG_DWORD == m_Type) |
| pData = reinterpret_cast<const void*>(&m_IntData); |
| else if (REG_SZ == m_Type) |
| pData = reinterpret_cast<const void*>(m_StringData.c_str()); |
| |
| return pData; |
| } |
| |
| //-------------------------------------------- |
| /** Returns the data as string |
| */ |
| std::wstring RegistryValueImpl::GetDataAsUniString() const |
| { |
| assert(REG_SZ == m_Type); |
| return m_StringData; |
| } |
| |
| //-------------------------------------------- |
| /** Returns the data as string |
| */ |
| std::string RegistryValueImpl::GetDataAsAnsiString() const |
| { |
| assert(REG_SZ == m_Type); |
| return UnicodeToAnsiString(m_StringData); |
| } |
| |
| //-------------------------------------------- |
| /** Returns the data as number |
| */ |
| int RegistryValueImpl::GetDataAsInt() const |
| { |
| assert(REG_DWORD == m_Type); |
| return m_IntData; |
| } |
| |
| //-------------------------------------------- |
| /** Returns the type of the data |
| */ |
| int RegistryValueImpl::GetType() const |
| { |
| return m_Type; |
| } |
| |
| |
| //################################# |
| // Command |
| //################################# |
| |
| |
| //-------------------------------------------- |
| /** Set a new name |
| */ |
| void RegistryValueImpl::SetName(const std::wstring& NewName) |
| { |
| m_Name = NewName; |
| } |
| |
| //-------------------------------------------- |
| /** |
| */ |
| void RegistryValueImpl::SetValue(const std::wstring& NewValue) |
| { |
| m_Type = REG_SZ; |
| m_StringData = NewValue; |
| } |
| |
| //-------------------------------------------- |
| /** |
| */ |
| void RegistryValueImpl::SetValue(const std::string& NewValue) |
| { |
| m_Type = REG_SZ; |
| m_StringData = AnsiToUnicodeString(NewValue); |
| } |
| |
| //-------------------------------------------- |
| /** |
| */ |
| void RegistryValueImpl::SetValue(int NewValue) |
| { |
| m_Type = REG_DWORD; |
| m_IntData = NewValue; |
| } |