winreg.cpp

linux下的一款播放器

{
    _CListReverseIteratorCHXString_ lriocRet(*this);

    ++(*this);

    return lriocRet;
}

_CListReverseIteratorCHXString_&
_CListReverseIteratorCHXString_::operator--()
{
    if(!m_plocCurrent)
	return *this;

    m_plocCurrent = m_plocCurrent->next();

    return *this;
}

const _CListReverseIteratorCHXString_
_CListReverseIteratorCHXString_::operator--(int)
{
    _CListReverseIteratorCHXString_ lriocRet(*this);

    --(*this);

    return lriocRet;
}

BOOL operator==
(
    const _CListReverseIteratorCHXString_& rlriocLeft,
    const _CListReverseIteratorCHXString_& rlriocRight
)
{
    return (rlriocLeft.m_plocCurrent == rlriocRight.m_plocCurrent);
}

BOOL operator!=
(
    const _CListReverseIteratorCHXString_& rlriocLeft,
    const _CListReverseIteratorCHXString_& rlriocRight
)
{
    return (rlriocLeft.m_plocCurrent != rlriocRight.m_plocCurrent);
}

CWinRegKey::CWinRegKey()
    : m_hkRoot(NULL)
    , m_hkThis(NULL)
    , m_dwKeyEnumPos(0)
    , m_dwValueEnumPos(0)
    , m_rsAccess(KEY_READ)
    , m_bOpen(FALSE)
{
}

CWinRegKey::~CWinRegKey()
{
    Close();
}

HX_RESULT 
CWinRegKey::Open()
{
    if(!m_hkRoot || m_sPath.IsEmpty())
    {
	return HXR_UNEXPECTED;
    }

    Close();

    HX_RESULT pnrRes = HXR_FAIL;
    if
    (
	SUCCEEDED
	(
	    pnrRes = HRESULT_FROM_WIN32
	    (
		RegOpenKeyEx
		(
		    m_hkRoot,
		    OS_STRING(m_sPath),
		    0,
		    m_rsAccess,
		    &m_hkThis
		)
	    )
	)
    )
    {
	m_bOpen = TRUE;
    }

    return pnrRes;
}

HX_RESULT 
CWinRegKey::Create(const char* szClass, DWORD dwOptions)
{
    if(!m_hkRoot || m_sPath.IsEmpty())
    {
	return HXR_UNEXPECTED;
    }

    Close();

    DWORD dwIngnored;

    if
    (
	RegCreateKeyEx
	(
	    m_hkRoot,
	    OS_STRING(m_sPath),
	    0,
	    OS_STRING(szClass),
	    dwOptions,
	    m_rsAccess,
	    NULL,
	    &m_hkThis,
	    &dwIngnored
	)
	==
	ERROR_SUCCESS
    )
    {
	m_bOpen = TRUE;

	return HXR_OK;
    }

    return HXR_FAIL;
}

HX_RESULT 
CWinRegKey::Close()
{
    if(!m_bOpen)
    {
	return HXR_UNEXPECTED;
    }

    if
    (
	RegCloseKey(m_hkThis)
	==
	ERROR_SUCCESS
    )
    {
	m_bOpen = FALSE;

	return HXR_OK;
    }

    return HXR_FAIL;
}

HX_RESULT 
CWinRegKey::Flush()
{
    if(!m_bOpen)
    {
	return HXR_UNEXPECTED;
    }

    if
    (
	RegFlushKey(m_hkThis)
	==
	ERROR_SUCCESS
    )
    {
	return HXR_OK;
    }

    return HXR_FAIL;
}

HX_RESULT 
CWinRegKey::DeleteSubKey(const char* szName)
{
    if(!m_bOpen)
    {
	return HXR_UNEXPECTED;
    }

    HX_RESULT	pnrRes = HXR_FAIL;
    CWinRegKey wrkExpired;
    CWinRegKey wrkSub;

    wrkExpired.SetRootKey(m_hkThis);
    wrkExpired.SetRelativePath(szName);
    wrkExpired.SetDesiredAccess(KEY_ENUMERATE_SUB_KEYS|KEY_CREATE_SUB_KEY);

    if (SUCCEEDED(pnrRes = wrkExpired.Open()))
    {
	wrkExpired.ResetKeyEnumerator();

	while(wrkExpired.GetNextKey(wrkSub))
	{
	    wrkExpired.DeleteSubKey(wrkSub.GetRelativePath());
	    wrkExpired.ResetKeyEnumerator();
	}

	wrkExpired.Close();

	pnrRes = HRESULT_FROM_WIN32(RegDeleteKey(m_hkThis, OS_STRING(szName)));
    }

    return pnrRes;
}


BOOL 
CWinRegKey::DoesExist()
{
    if(m_bOpen)
    {
	return TRUE;
    }

    if(SUCCEEDED(Open()))
    {
	Close();
	return TRUE;
    }
    return FALSE;
}

BOOL 
CWinRegKey::SetDesiredAccess(REGSAM rsNew)
{
    if(m_bOpen)
    {
	return FALSE;
    }

    m_rsAccess = rsNew;

    return TRUE;
}

REGSAM 
CWinRegKey::GetDesiredAccess()
{
    return m_rsAccess;
}

BOOL 
CWinRegKey::SetRootKey(HKEY hkRoot)
{
    if(m_bOpen)
    {
	return FALSE;
    }

    m_hkRoot = hkRoot;

    return TRUE;
}

HKEY 
CWinRegKey::GetRootKey()
{
    return m_hkRoot;
}


HKEY 
CWinRegKey::GetHandle()
{
    return m_hkThis;
}


// According to Article ID: Q117261
//
// A call to RegCreateKeyEx() is successful under Windows NT version 3.1 
// and Windows 95, but the call fails with error 161 (ERROR_BAD_PATHNAME) 
// under Windows NT version 3.5 and later. 
//
// This is by design. Windows NT version 3.1 and Windows 95 allow the 
// subkey to begin with a backslash ("\"), however Windows NT version 3.5 
// and later do not. The subkey is given as the second parameter to 
// RegCreateKeyEx(). 
//

BOOL 
CWinRegKey::SetRelativePath(const char* szPath)
{
    if(m_bOpen)
    {
	return FALSE;
    }

    if (*szPath == '\\')
    {
	m_sPath = szPath+1;
    }
    else
    {
	m_sPath = szPath;
    }

    return TRUE;
}

CHXString& 
CWinRegKey::GetRelativePath()
{
    return m_sPath;
}

BOOL 
CWinRegKey::GetValue
(
    const char* szName, 
    AWinRegValue** ppwrvOut, 
    UINT32 ulType
)
{
    if
    (
	!m_bOpen 
	|| 
	!szName 
	|| 
	!(*szName)
	||
	!ppwrvOut
    )
    {
	return FALSE;
    }

    *ppwrvOut = NULL;

    if (!ulType)
    {
	if
	(
	    RegQueryValueEx
	    (
		m_hkThis,
		OS_STRING(szName),
		NULL,
		&ulType,
		NULL,
		NULL
	    )
	    !=
	    ERROR_SUCCESS
	)
	{
	    return FALSE;
	}
    }

    switch(ulType)
    {
    case REG_DWORD:
	{
	    *ppwrvOut = (AWinRegValue*)new CWinRegDWORDValue
	    (
		szName, 
		m_hkThis
	    );
	}
	break;
    case REG_SZ:
	{
	    *ppwrvOut = (AWinRegValue*)new CWinRegStringValue
	    (
		szName, 
		m_hkThis
	    );
	}
	break;
    case REG_MULTI_SZ:
	{
	    *ppwrvOut = (AWinRegValue*)new CWinRegStringArrayValue
	    (
		szName, 
		m_hkThis
	    );
	}
	break;
    default:
	{
	}
	break;
    };
    
    return (*ppwrvOut)?TRUE:FALSE;
}

void 
CWinRegKey::FreeValue(AWinRegValue*& pwrvExpired)
{
    delete pwrvExpired;
    pwrvExpired = NULL;
}

BOOL 
CWinRegKey::ResetKeyEnumerator()
{
    if(!m_bOpen)
    {
	return FALSE;
    }

    m_dwKeyEnumPos = 0;

    return TRUE;
}

BOOL 
CWinRegKey::GetNextKey(CWinRegKey& rwrkNext)
{
    if(!m_bOpen)
    {
	return FALSE;
    }
    
    char	szName[128]; /* Flawfinder: ignore */
    UINT32	ulSizeName=128;
    char	szClass[128]; /* Flawfinder: ignore */
    UINT32	ulSizeClass=128;
    FILETIME	ftLastWrite;

    if
    (
	RegEnumKeyEx
	(
	    m_hkThis,
	    m_dwKeyEnumPos,
	    OS_STRING2(szName, ulSizeName),
	    &ulSizeName,
	    NULL,
	    OS_STRING2(szClass, ulSizeClass),
	    &ulSizeClass,
	    &ftLastWrite
	)
	==
	ERROR_SUCCESS
    )
    {
	++m_dwKeyEnumPos;

	rwrkNext.SetRootKey(m_hkThis);
	rwrkNext.SetRelativePath(szName);
	rwrkNext.SetDesiredAccess(m_rsAccess);

	return TRUE;
    }

    return FALSE;
}


BOOL 
CWinRegKey::ResetValueEnumerator()
{
    if(!m_bOpen)
    {
	return FALSE;
    }

    m_dwValueEnumPos = 0;

    return TRUE;
}

BOOL 
CWinRegKey::GetNextValue(AWinRegValue** ppwrvNext)
{
    if(!m_bOpen)
    {
	return FALSE;
    }

    char	szName[128]; /* Flawfinder: ignore */
    UINT32	ulSizeName=128;
    UINT32	ulType;

    if
    (
	RegEnumValue
	(
	    m_hkThis,
	    m_dwValueEnumPos,
	    OS_STRING2(szName, ulSizeName),
	    &ulSizeName,
	    NULL,
	    &ulType,
	    NULL,
	    NULL
	)
	==
	ERROR_SUCCESS
    )
    {
	++m_dwValueEnumPos;

	return GetValue(szName, ppwrvNext, ulType);
    }

    return FALSE;
}