You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
506 lines
14 KiB
506 lines
14 KiB
/*---------------------------------------------------------------------------
|
|
File: VarData.cpp
|
|
|
|
Comments: CVarData represents one level in the VarSet. It has a variant
|
|
value, and a map containing one or more subvalues.
|
|
|
|
(c) Copyright 1995-1998, Mission Critical Software, Inc., All Rights Reserved
|
|
Proprietary and confidential to Mission Critical Software, Inc.
|
|
|
|
REVISION LOG ENTRY
|
|
Revision By: Christy Boles
|
|
Revised on 11/19/98 17:24:56
|
|
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "VarData.h"
|
|
#include "VarMap.h"
|
|
#include "DotStr.hpp"
|
|
|
|
#ifdef STRIPPED_VARSET
|
|
#include "Varset.h"
|
|
#include "NoMcs.h"
|
|
#else
|
|
#include <VarSet.h>
|
|
#include "McString.h"
|
|
#include "McLog.h"
|
|
using namespace McString;
|
|
#endif
|
|
#include "VSet.h"
|
|
#include <comdef.h>
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
int
|
|
CVarData::SetData(
|
|
CString key, // in - key value
|
|
VARIANT * var, // in - data value
|
|
BOOL bCoerce, // in - flag, whether to coerce to a persistable value
|
|
HRESULT * pResult // out- optional return code
|
|
)
|
|
{
|
|
int nCreated = 0;
|
|
_variant_t newVal(var);
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( key.IsEmpty() )
|
|
{
|
|
m_cs.Lock();
|
|
// set my data value
|
|
if ( ! bCoerce )
|
|
{
|
|
m_var.Copy(&newVal);
|
|
}
|
|
else
|
|
{
|
|
// need to coerce the value to an appropriate type
|
|
|
|
if ( var->vt == VT_DISPATCH || var->vt == VT_UNKNOWN )
|
|
{
|
|
// if it's an IUnknown, see if it supports IDispatch
|
|
IDispatchPtr pDisp;
|
|
|
|
pDisp = newVal;
|
|
|
|
if ( pDisp != NULL )
|
|
{
|
|
// the object supports IDispatch
|
|
// try to get the default property
|
|
_variant_t defPropVar;
|
|
DISPPARAMS dispParamsNoArgs = {NULL, NULL, 0, 0};
|
|
|
|
hr = pDisp->Invoke(0,
|
|
IID_NULL,
|
|
LOCALE_USER_DEFAULT,
|
|
DISPATCH_PROPERTYGET,
|
|
&dispParamsNoArgs,
|
|
&defPropVar,
|
|
NULL,
|
|
NULL);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
// we got the default property
|
|
newVal = defPropVar;
|
|
}
|
|
else
|
|
{
|
|
MC_LOG("VarSet::put - unable to retrieve default property for IDispatch object. Put operation failed, hr=" << hr << "returning E_INVALIDARG");
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
}
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( newVal.vt & VT_BYREF )
|
|
{
|
|
if ( newVal.vt == (VT_VARIANT | VT_BYREF) )
|
|
{
|
|
m_var.Copy(newVal.pvarVal);
|
|
}
|
|
else
|
|
{
|
|
hr = ::VariantChangeType(&newVal,&newVal,0,newVal.vt & ~VT_BYREF);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
m_var.Copy(&newVal);
|
|
}
|
|
else
|
|
{
|
|
MC_LOG("VarSet::put - failed to dereference variant of type " << newVal.vt << ". Put operation failed, hr=" <<hr);
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_var.Copy(&newVal);
|
|
}
|
|
}
|
|
}
|
|
m_cs.Unlock();
|
|
}
|
|
else
|
|
{
|
|
// set the value for a child
|
|
|
|
CDottedString s(key);
|
|
CString seg;
|
|
CVarData * pObj;
|
|
CVarData * pChild;
|
|
|
|
s.GetSegment(0,seg);
|
|
|
|
m_cs.Lock();
|
|
if ( ! m_children )
|
|
{
|
|
// create the child map if it does not exist
|
|
m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(), AllowRehashing() );
|
|
if (!m_children)
|
|
{
|
|
m_cs.Unlock();
|
|
return nCreated;
|
|
}
|
|
}
|
|
// look for the first segment of the entry in the child map
|
|
if ( ! m_children->Lookup(seg,pObj) )
|
|
{
|
|
// add it if it doesn't exist
|
|
pChild = new CVarData;
|
|
if (!pChild)
|
|
{
|
|
m_cs.Unlock();
|
|
return nCreated;
|
|
}
|
|
try {
|
|
pChild->SetCaseSensitive(IsCaseSensitive());
|
|
pChild->SetAllowRehashing(AllowRehashing());
|
|
pChild->SetIndexed(IsIndexed());
|
|
m_children->SetAt(seg,pChild);
|
|
nCreated++; // we added a new node
|
|
}
|
|
catch(...) {
|
|
delete pChild;
|
|
pChild = NULL;
|
|
m_cs.Unlock();
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pChild = (CVarData*)pObj;
|
|
}
|
|
// strip off the first segment from the property name, and call SetData
|
|
// recursively on the child item
|
|
nCreated += pChild->SetData(key.Right(key.GetLength() - seg.GetLength()-1),var,bCoerce,&hr);
|
|
m_cs.Unlock();
|
|
}
|
|
if ( pResult )
|
|
{
|
|
(*pResult) = hr;
|
|
}
|
|
return nCreated;
|
|
}
|
|
|
|
void
|
|
CVarData::RemoveAll()
|
|
{
|
|
// remove all children from the map
|
|
m_cs.Lock();
|
|
if ( m_children && ! m_children->IsEmpty() )
|
|
{
|
|
// Enumerate the MAP and delete each object
|
|
POSITION pos;
|
|
CString key;
|
|
CVarData * pObj;
|
|
|
|
pos = m_children->GetStartPosition();
|
|
|
|
while ( pos )
|
|
{
|
|
m_children->GetNextAssoc(pos,key,pObj);
|
|
if ( pObj )
|
|
{
|
|
delete pObj;
|
|
}
|
|
}
|
|
m_children->RemoveAll();
|
|
}
|
|
if ( m_children )
|
|
{
|
|
delete m_children;
|
|
m_children = NULL;
|
|
}
|
|
m_cs.Unlock();
|
|
}
|
|
|
|
BOOL // ret- TRUE if key exists in the map
|
|
CVarData::Lookup(
|
|
LPCTSTR key, // in - key to search for
|
|
CVarData *& rValue // out- value
|
|
)
|
|
{
|
|
if ( m_children )
|
|
{
|
|
return m_children->Lookup(key,rValue);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL // ret- TRUE if there are sub-items for this node
|
|
CVarData::HasChildren()
|
|
{
|
|
return m_children && !m_children->IsEmpty();
|
|
}
|
|
|
|
void
|
|
CVarData::SetAt(
|
|
LPCTSTR key, // in - key
|
|
CVarData * newValue // in - new value
|
|
)
|
|
{
|
|
if ( ! m_children )
|
|
{
|
|
// create map to hold children if it doesn't already exist
|
|
m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(),AllowRehashing());
|
|
if (!m_children)
|
|
return;
|
|
}
|
|
m_children->SetAt(key,newValue);
|
|
}
|
|
|
|
void
|
|
CVarData::SetIndexed(
|
|
BOOL nVal
|
|
)
|
|
{
|
|
if ( m_children )
|
|
{
|
|
m_children->SetIndexed(nVal);
|
|
}
|
|
if ( nVal )
|
|
{
|
|
m_options |= CVARDATA_INDEXED;
|
|
}
|
|
else
|
|
{
|
|
m_options &= ~CVARDATA_INDEXED;
|
|
}
|
|
}
|
|
|
|
void
|
|
CVarData::SetCaseSensitive(
|
|
BOOL nVal // in - whether to make lookups case-sensitive
|
|
)
|
|
{
|
|
if ( m_children )
|
|
{
|
|
m_children->SetCaseSensitive(nVal);
|
|
}
|
|
if ( nVal )
|
|
{
|
|
m_options |= CVARDATA_CASE_SENSITIVE;
|
|
}
|
|
else
|
|
{
|
|
m_options &= ~CVARDATA_CASE_SENSITIVE;
|
|
}
|
|
}
|
|
|
|
void
|
|
CVarData::SetAllowRehashing(
|
|
BOOL nVal // in - whether to allow the table to be rehashed for better performance
|
|
)
|
|
{
|
|
if ( m_children )
|
|
{
|
|
m_children->SetAllowRehash(nVal);
|
|
}
|
|
if ( nVal )
|
|
{
|
|
m_options |= CVARDATA_ALLOWREHASH;
|
|
}
|
|
else
|
|
{
|
|
m_options &= ~CVARDATA_ALLOWREHASH;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
HRESULT
|
|
CVarData::WriteToStream(
|
|
LPSTREAM pS // in - stream to write data to
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL hasChildren = (m_children != NULL);
|
|
|
|
// save the variant
|
|
hr = m_var.WriteToStream(pS);
|
|
|
|
if (SUCCEEDED(hr) )
|
|
{
|
|
// save children, if any
|
|
ULONG result;
|
|
hr = pS->Write(&hasChildren,(sizeof hasChildren),&result);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( m_children )
|
|
{
|
|
hr = m_children->WriteToStream(pS);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT
|
|
CVarData::ReadFromStream(
|
|
LPSTREAM pS // in - stream to read data from
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL hasChildren;
|
|
ULONG result;
|
|
|
|
// read the variant
|
|
hr = m_var.ReadFromStream(pS);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
hr = pS->Read(&hasChildren,(sizeof hasChildren),&result);
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
if ( hasChildren )
|
|
{
|
|
// create the child array
|
|
m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(),AllowRehashing());
|
|
if (!m_children)
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
|
hr = m_children->ReadFromStream(pS);
|
|
}
|
|
}
|
|
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
DWORD // ret- Length, in bytes to write the data to a stream
|
|
CVarData::CalculateStreamedLength()
|
|
{
|
|
HRESULT hr =S_OK;
|
|
DWORD len = sizeof (VARTYPE);
|
|
|
|
// Calculate size needed for root data value
|
|
|
|
int cbWrite = 0;
|
|
switch (m_var.vt)
|
|
{
|
|
case VT_UNKNOWN:
|
|
case VT_DISPATCH:
|
|
{
|
|
CComQIPtr<IPersistStream> spStream = m_var.punkVal;
|
|
if( spStream )
|
|
{
|
|
len += sizeof(CLSID);
|
|
ULARGE_INTEGER uiSize = { 0 };
|
|
hr = spStream->GetSizeMax(&uiSize);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
len += uiSize.LowPart;
|
|
}
|
|
}
|
|
break;
|
|
case VT_UI1:
|
|
case VT_I1:
|
|
cbWrite = sizeof(BYTE);
|
|
break;
|
|
case VT_I2:
|
|
case VT_UI2:
|
|
case VT_BOOL:
|
|
cbWrite = sizeof(short);
|
|
break;
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
case VT_R4:
|
|
case VT_INT:
|
|
case VT_UINT:
|
|
case VT_ERROR:
|
|
cbWrite = sizeof(long);
|
|
break;
|
|
case VT_R8:
|
|
case VT_CY:
|
|
case VT_DATE:
|
|
cbWrite = sizeof(double);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
CComBSTR bstrWrite;
|
|
CComVariant varBSTR;
|
|
|
|
if (m_var.vt != VT_BSTR)
|
|
{
|
|
hr = VariantChangeType(&varBSTR, &m_var, VARIANT_NOVALUEPROP, VT_BSTR);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
bstrWrite = varBSTR.bstrVal;
|
|
}
|
|
else
|
|
{
|
|
bstrWrite = m_var.bstrVal;
|
|
}
|
|
len += 4 + (static_cast<BSTR>(bstrWrite) ? SysStringByteLen(bstrWrite) : 0) + 2;
|
|
if ( SUCCEEDED(hr) )
|
|
{
|
|
len += cbWrite;
|
|
}
|
|
|
|
// Add sizes of children
|
|
len += (sizeof BOOL); // has children?
|
|
if ( m_children )
|
|
{
|
|
len += m_children->CalculateStreamedLength();
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
long // ret- number of data items
|
|
CVarData::CountItems()
|
|
{
|
|
long count = 1;
|
|
|
|
if ( m_children )
|
|
{
|
|
count += m_children->CountItems();
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
void
|
|
CVarData::McLogInternalDiagnostics(
|
|
CString keyname // in - Key name for this subtree, so the complete name can be displayed
|
|
)
|
|
{
|
|
CString value;
|
|
|
|
switch ( m_var.vt )
|
|
{
|
|
case VT_EMPTY:
|
|
value = _T("<Empty>");
|
|
break;
|
|
case VT_NULL:
|
|
value = _T("<Null>");
|
|
break;
|
|
case VT_I2:
|
|
case VT_I4:
|
|
value.Format(_T("%ld"),m_var.iVal);
|
|
break;
|
|
case VT_BSTR:
|
|
value = m_var.bstrVal;
|
|
break;
|
|
default:
|
|
value.Format(_T("variant type=0x%lx"),m_var.vt);
|
|
break;
|
|
}
|
|
MC_LOG(String(keyname) << "-->"<< String(value) << (m_children ? " (Has Children)" : " (No Children)") << " Options = " << makeStr(m_options) << " CaseSensitive=" << ( IsCaseSensitive()?"TRUE":"FALSE") << " Indexed=" << (IsIndexed()?"TRUE":"FALSE") );
|
|
|
|
if ( m_children )
|
|
{
|
|
m_children->McLogInternalDiagnostics(keyname);
|
|
}
|
|
}
|