/*---------------------------------------------------------------------------
  File: VSet.cpp

  Comments: Implementation of IVarSet interface.

  (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 19:44:06

 ---------------------------------------------------------------------------
*/

// VSet.cpp : Implementation of CVSet
#include "stdafx.h"

#ifdef STRIPPED_VARSET
   #include "NoMcs.h"
   #include <comdef.h>
   #include "Err.hpp"
   #include "Varset.h"
#else
#endif 

#include "VarSetI.h"
#include "VSet.h"
#include "VarMap.h"
#include "DotStr.hpp"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CVSet

  
/////////////////////////////////////////////////////////////////////
// IVarSet
/////////////////////////////////////////////////////////////////////
// Gets the number of items in the map and all sub-maps
STDMETHODIMP CVSet::get_Count(/* [retval][out] */long* retval)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_Count");
   
   if (retval == NULL)
   {
      MCSVERIFYSZ(FALSE,"get_Count:  output pointer was null, returning E_POINTER");
      return E_POINTER;
   }

	m_cs.Lock();
   *retval = m_nItems;
   MCSASSERTSZ(! m_nItems || m_nItems == m_data->CountItems() - (m_data->HasData()?0:1),"get_Count:Item count consistency check failed.");
   m_cs.Unlock();
	
   return S_OK;
}

STDMETHODIMP CVSet::get_NumChildren(/* [in] */BSTR parentKey,/* [out,retval] */long*count)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_NumChildren");

   HRESULT                   hr = S_OK;
   CVarData                * pVar;
   CString                   parent;

   parent = parentKey;
   if ( count == NULL )
   {
      MCSVERIFYSZ(FALSE,"get_NumChildren:  output pointer was null, returning E_POINTER");
      hr = E_POINTER;
   }
   else
   {
      m_cs.Lock();
      pVar = GetItem(parent,FALSE);
      if ( pVar )
      {
         if ( pVar->HasChildren() )
         {
            (*count) = pVar->GetChildren()->GetCount();
         }
         else
         {
            (*count) = 0;
         }
      }
      else
      {
         // The parent key does not exist
         (*count) = 0;
      }
      m_cs.Unlock();
   }
   return hr;
}

  
// Adds or changes a value in the map
STDMETHODIMP CVSet::putObject(/* [in] */BSTR property,/* [in] */VARIANT value)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::putObject");
   
   CVarData                * pVar = NULL;
   HRESULT                   hr = S_OK;

   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEDATA )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {
      m_cs.Lock();
      m_bNeedToSave = TRUE;
      pVar = GetItem(property,TRUE);
      if ( pVar )
      {
         MC_LOG("set value for " << McString::String(property));
         m_nItems+=pVar->SetData("",&value,FALSE,&hr);
      }
      else
      {
         MCSASSERTSZ(FALSE,"VarSet internal error creating or retrieving node");   
         // GetItem failed - cannot add item to property
         hr = E_FAIL;
      }
      m_cs.Unlock();
   }
   return hr;
}

  
// Adds or changes a value in the map
STDMETHODIMP CVSet::put(/* [in] */BSTR property,/* [in] */VARIANT value)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::put");
   
   CVarData                * pVar = NULL;
   HRESULT                   hr = S_OK;

   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEDATA )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {
      m_cs.Lock();
      m_bNeedToSave = TRUE;
      pVar = GetItem(property,TRUE);
      if ( pVar )
      {
         MC_LOG("set value for " << McString::String(property));
         m_nItems+=pVar->SetData("",&value,TRUE,&hr);
      }
      else
      {
         MCSASSERTSZ(FALSE,"VarSet internal error creating or retrieving node");   
         // GetItem failed - cannot add item to property
         hr = E_FAIL;
      }
      m_cs.Unlock();
   }
   return hr;
}

CVarData *                                 // ret- pointer to item in varset
   CVSet::GetItem(
      CString                str,          // in - key to look for
      BOOL                   addToMap,     // in - if TRUE, adds the key to the map if it does not exist 
      CVarData             * base          // in - starting point
   )
{
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_INTERNAL,"CVSet::GetItem");
   
   CVarData                * curr = base;
   CVarData                * result = NULL;
   CDottedString             s(str);
   CString                   seg;
   CString                   next;

   if ( ! curr )
   {
      curr = m_data;
      MC_LOG("No basepoint provided, using root element");
   }

   if ( str.IsEmpty() )
   {
      result = curr;
      MC_LOG("Returning current node");
   }
   else
   {
      for ( int i = 0 ; curr && i < s.NumSegments(); i++ )
      {
         s.GetSegment(i,seg);
         MC_LOG("Looking for key segment "<< McString::String(seg) );
         curr->SetCaseSensitive(m_CaseSensitive);
         if  ( ! curr->Lookup(seg,result) )
         {
            if ( addToMap )
            {
               MC_LOG(McString::String(seg) << " not found, creating new node");
               result = new CVarData;
			   if (!result)
				  break;
               result->SetCaseSensitive(m_CaseSensitive);
               result->SetIndexed(m_Indexed);
               curr->SetAt(seg,result);
               m_nItems++;
            }
            else
            {
               MC_LOG(McString::String(seg) << " not found, aborting");
               result = NULL;
               break;
            }
         }
         curr = result;
      }
   }
   return result;      
}

// Retrieves a value from the map
STDMETHODIMP CVSet::get(/* [in] */BSTR property,/* [retval][out] */VARIANT * value)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get");

   CVarData                * pVar;
   HRESULT                   hr = S_OK;
   CComVariant               var;
   CString                   s;
                       
   if (property == NULL )
   {
      MCSVERIFYSZ(FALSE,"CVSet::get - output pointer is NULL, returning E_POINTER");
      hr = E_POINTER; 
   }
   else
   {
      m_cs.Lock();
      s = property;
      pVar = GetItem(s);
      var.Attach(value);
      if ( pVar )
      {
         MC_LOG("got value for " << McString::String(property));
         var.Copy(pVar->GetData());
      }
      else
      {
         MC_LOG("CVSet::get " << McString::String(property) << " was not found, returning empty variant");
      }
      // if the item was not found, set the variant to VT_EMPTY
      var.Detach(value);
      m_cs.Unlock();
   }
   return hr;
}

STDMETHODIMP CVSet::put_CaseSensitive(/* [in] */BOOL newVal)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::put_CaseSensitive");
   
   HRESULT                   hr = S_OK;

   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEPROPS )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {
      m_cs.Lock();
      m_bNeedToSave = TRUE;
      m_CaseSensitive = newVal;
      m_cs.Unlock();
   }
   return hr;
}

STDMETHODIMP CVSet::get_CaseSensitive(/* [retval][out] */BOOL * isCaseSensitive)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_CaseSensitive");
   
   if ( ! isCaseSensitive )
   {
      MCSVERIFYSZ(FALSE,"CVSet::get_CaseSensitive - output pointer is NULL, returning E_POINTER");
      return E_POINTER;
   }
   else
   {
      m_cs.Lock();
      (*isCaseSensitive) = m_CaseSensitive;
      m_cs.Unlock();
   }
   return S_OK;
}


// This function is used to sort the keys being returned from an enum.
 int __cdecl SortComVariantStrings(const void * v1, const void * v2)
{
   CComVariant             * var1 = (CComVariant*)v1;
   CComVariant             * var2 = (CComVariant*)v2;

   if ( var1->vt == VT_BSTR && var2->vt == VT_BSTR )
   {
      return wcscmp(var1->bstrVal,var2->bstrVal);
   }
   return 0;
}


// This returns an IEnumVARIANT interface.  It is used by the VB For Each command.
// This enumerates only the keys, not the values.  It is not very efficient, especially for large sets.
STDMETHODIMP CVSet::get__NewEnum(/* [retval][out] */IUnknown** retval)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_NewEnum");
   
   if (retval == NULL)
   {
      MCSVERIFYSZ(FALSE,"CVSet::get_NewEnum - output pointer is NULL, returning E_POINTER");
      return E_POINTER;
   }

	// initialize output parameter
   (*retval) = NULL;

	typedef CComObject<CComEnum<IEnumVARIANT, &IID_IEnumVARIANT, VARIANT,
		_Copy<VARIANT> > > enumvar;

	HRESULT                   hRes = S_OK;

   enumvar * p = new enumvar;
   
	if (p == NULL)
   {
      MCSVERIFYSZ(FALSE,"CVSet::get_NewEnum - Could not create IEnumVARIANT object");
      hRes = E_OUTOFMEMORY;
   }
	else
	{
		hRes = p->FinalConstruct();
		if (hRes == S_OK)
		{
			m_cs.Lock();
         
         CVarData                 * map = m_data;
         CString                    start;
         CString                    seg;
       
                  // Build an array of variants to hold the keys
         CComVariant       * pVars = new CComVariant[m_data->CountItems()+1];
         CString             key;
         int                 offset = 0;

         key = _T("");
         if ( map->GetData() && map->GetData()->vt != VT_EMPTY )
         {
            pVars[offset] = key;
            offset++;
         }
         if ( map->HasChildren() )
         {
            BuildVariantKeyArray(key,map->GetChildren(),pVars,&offset);
         }
      
         if ( ! m_Indexed )
         {
            // Sort the results
            qsort(pVars,offset,(sizeof CComVariant),&SortComVariantStrings);
         }

         hRes = p->Init(pVars, &pVars[offset], NULL,AtlFlagCopy);
			if (hRes == S_OK)
				hRes = p->QueryInterface(IID_IUnknown, (void**)retval);
         
         delete [] pVars;
         m_cs.Unlock();
   	}
	}
	if (hRes != S_OK)
		delete p;
   
   return hRes;
}

// Helper function for get__NewEnum
// copies all the keys in the map, and all sub-maps, into a CComVariant array.
// the values are then sorted if necessary.
void 
   CVSet::BuildVariantKeyArray(
      CString                prefix,       // in - string to tack on to the beginning of each key (used when enumerating subkeys)
      CMapStringToVar      * map,          // in - map containing data
      CComVariant          * pVars,        // i/o- array that will contain all the keys
      int                  * offset        // i/o- number of keys copied to pVars (index to use for next insertion)
   )
{
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_INTERNAL,"CVSet::BuildVariantKeyArray");
  
   int                       i;
   int                       nItems;
   CVarData                * pObj;
   CString                   key;
   CComVariant               var;
   CString                   val;

   if ( ! map )
      return;  // no data =>no work to do

   nItems = map->GetCount();
   
   if ( ! m_Indexed )
   {
      POSITION                  pos;
      
      pos = map->GetStartPosition();
      for ( i = 0 ; pos &&  i < nItems ; i++ )
      {
         map->GetNextAssoc(pos,key,pObj);
         if ( ! prefix.IsEmpty() )
         {
            var = prefix + L"." + key;
         }
         else
         {
            var = key;
         }
         // add each key to the array
         var.Detach(&pVars[(*offset)]);
         (*offset)++;
         if ( pObj->HasChildren() )
         {
            // Recursively do the sub-map
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyArray(prefix+L"."+key,pObj->GetChildren(),pVars,offset);
            }
            else
            {
               BuildVariantKeyArray(key,pObj->GetChildren(),pVars,offset);
            }
         }
      }
   }
   else
   {
      CIndexItem           * item;
      CIndexTree           * index = map->GetIndex();

      ASSERT(index);
      
      if ( ! index )
         return;
      
      item = index->GetFirstItem();

      for ( i = 0 ; item &&  i < nItems ; i++ )
      {
         key = item->GetKey();
         pObj = item->GetValue();

         if ( ! prefix.IsEmpty() )
         {
            var = prefix + L"." + key;
         }
         else
         {
            var = key;
         }
         // add each key to the array
         var.Detach(&pVars[(*offset)]);
         (*offset)++;
         if ( pObj->HasChildren() )
         {
            // Recursively do the sub-map
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyArray(prefix+L"."+key,pObj->GetChildren(),pVars,offset);
            }
            else
            {
               BuildVariantKeyArray(key,pObj->GetChildren(),pVars,offset);
            }
         }
         item = index->GetNextItem(item);
      }
   }
   
}

STDMETHODIMP 
   CVSet::getItems2(
      /* [in] */VARIANT      basepoint,     // in - if specified, only children of this node will be enumerated
      /* [in] */VARIANT      startAfter,    // in - the enumeration will begin with the next item in the map following this key.
      /* [in] */VARIANT      bRecursive,    // in - TRUE includes all sub-items, FALSE enumerates one level only.
      /* [in] */VARIANT      bSize,         // in - max number of elements to return (the size of the arrays)
      /* [out] */VARIANT   * keyVar,        // out- array of keys
      /* [out] */VARIANT   * valVar,        // out- array of values
      /* [in,out] */VARIANT* nReturned      // out- number of items copied
   )
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::getItems2");
  
   HRESULT                   hr = S_OK;
   LONG                      n = 0;
   LONG                      size = bSize.pvarVal->iVal;
   
   // TODO:  Verify that all the arguments are the correct type!

   // Allocate SAFEARRAYs for the keys and values
   SAFEARRAY               * keys = NULL; 
   SAFEARRAY               * values= NULL;
   _variant_t                key;
   _variant_t                val;
   _variant_t                num;

   if ( ! keys || !values )
   {
      hr = E_OUTOFMEMORY;      
   }
   else
   {
      hr = getItems(basepoint.bstrVal,startAfter.bstrVal,bRecursive.boolVal,size,&keys,&values,&n);
      key.vt = VT_ARRAY | VT_VARIANT;
      key.parray = keys;
      val.vt = VT_ARRAY | VT_VARIANT;
      val.parray = values;
      num.vt = VT_I4;
      num.lVal = n;
      (*keyVar) = key.Detach();
      (*valVar) = val.Detach();
      (*nReturned) = num.Detach();
   }
   return hr;

}

STDMETHODIMP 
   CVSet::getItems(
      /* [in] */BSTR          basepoint,     // in - if specified, only children of this node will be enumerated
      /* [in] */BSTR          startAfter,    // in - the enumeration will begin with the next item in the map following this key.
      /* [in] */BOOL          bRecursive,    // in - TRUE includes all sub-items, FALSE enumerates one level only.
      /* [in] */ULONG         bSize,         // in - max number of elements to return (the size of the arrays)
      /* [out] */SAFEARRAY ** keys,          // out- array of keys
      /* [out] */SAFEARRAY ** values,        // out- array of values
      /* [out] */LONG       * nReturned      // out- number of items copied
   )
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::getItems");
  
   HRESULT                   hr = S_OK;

   (*nReturned) = 0;
   (*keys) = 0;
   (*values) = 0;

   m_cs.Lock();
   
   CVarData                * map = m_data;
   CString                   base;
   CString                   start;
   CString                   seg;
 

   // Find the map to enumerate
   base = basepoint;
   if ( base.GetLength() > 0 )
   {
      map = GetItem(base);
   }
   
   if ( ! map )
   {
         // not found
      (*nReturned) = 0;
   }
   else
   {
      // Build an array of variants to hold the keys
      int                 offset = 0;

      SAFEARRAYBOUND            bound[1];
      LONG                      n = 0;
      LONG                      size = bSize;
   
      bound[0].lLbound = 0;
      bound[0].cElements = size;

      
      // Allocate SAFEARRAYs for the keys and values
      (*keys) = SafeArrayCreate(VT_VARIANT, 1, bound);
      (*values) = SafeArrayCreate(VT_VARIANT, 1, bound);
  
      start = startAfter;
      
      if ( base.GetLength() && start.GetLength() )
      {
         // ASSERT( that LEFT(start,LEN(base)) = base
         //start = start.Right(start.GetLength() - base.GetLength() - 1);
      }
      
      if ( base.IsEmpty() && start.IsEmpty() )
      {
         if ( map->GetData() && map->GetData()->vt != VT_EMPTY )
         {
            long             index[1];

            index[0] = 0;
            // add the root element to the results
            if ( (*keys)->fFeatures & FADF_BSTR  )
            {
               SafeArrayPutElement((*keys),index,_T(""));
            }
            else
            {
               // VBScript can only use VARIANT arrays (see getItems2)
               _variant_t tempKey;
               tempKey = _T("");
               SafeArrayPutElement((*keys),index,&tempKey);
            }
         
            SafeArrayPutElement((*values),index,map->GetData());
            offset++;
         }
         
      }
      if ( map->HasChildren() )
      {
         BuildVariantKeyValueArray(base,start,map->GetChildren(),(*keys),
            (*values),&offset,bSize,bRecursive);
      }
      (*nReturned) = offset;
   }
   m_cs.Unlock();
	

	return hr;
}

// helper function for getItems.  Fills SAFEARRAYs of keys and values
// if the varset is indexed, the items will be returned in sorted order, o.w. they will be in arbitrary (but consistent) order.
void 
   CVSet::BuildVariantKeyValueArray(
      CString                prefix,         // in - string to tack on to the beginning of each key (used when enumerating subkeys)
      CString                startAfter,     // in - optional, enumerates only those items that alphabetically follow this one.
      CMapStringToVar      * map,            // in - map containing the data
      SAFEARRAY            * keys,           // i/o- array that will contain the key values for the requested items
      SAFEARRAY            * pVars,          // i/o- array that will contain the data values for the requested items
      int                  * offset,         // i/o- number of items copied to the arrays (index to use for next insertion)
      int                    maxOffset,      // in - allocated size of the arrays
      BOOL                   bRecurse        // in - whether to recursively process children
   )
{
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_INTERNAL,"CVSet::BuildVariantKeyValueArray");
  
   int                 i;
   int                 nItems;
   CVarData          * pObj;
   CString             key;   // last segment of key name 
   POSITION            pos;
   
   CComBSTR            val;   // fully qualified key name to add to array (val = prefix.key)
   CComVariant         var;   // value to add to array
   BOOL                includeSomeChildrenOnly;

   CDottedString       dBase(prefix);
   CDottedString       dStartItem(startAfter);
   
   int                 depth = dBase.NumSegments();
    
   if ( ! map )   
      return; // no data => nothing to do

   if ( (*offset) >= maxOffset )
      return; // the arrays are full
   
   includeSomeChildrenOnly = dStartItem.NumSegments() > depth;

   nItems = map->GetCount();
   // If we're not using an index, the items will be returned in arbitrary order
   if ( ! m_Indexed )
   {
      if ( includeSomeChildrenOnly && bRecurse )
      {
         // the startAfter item is in a subtree.  Find the appropriate element at this level and recursively continue the search   
         dStartItem.GetSegment(depth,key);
         if ( map->Lookup(key,pObj) )
         {
            // found the object
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyValueArray(prefix+_T(".")+key,startAfter,pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            else
            {
               BuildVariantKeyValueArray(key,startAfter,pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
         }
         // we've included the children of this item that come after 'startAfter',
         // now process the rest of the items at this level
         // make sure there's still room
         if ( (*offset) >= maxOffset )
            return; // the arrays are full
      }
      
      // this is the usual case.  process the items at this level, starting with the element following StartAfter.
      
      // Get a pointer to that first element
      if ( startAfter.GetLength() > prefix.GetLength())
      {
         CString startItem;
         dStartItem.GetSegment(depth,startItem);
         // this returns the position before startItem
         pos = (POSITION)map->GetPositionAt(startItem);
		 if (!pos)
	        return;
         map->GetNextAssoc(pos,key,pObj);
      }
      else 
      {
         pos = map->GetStartPosition();
      }

      for ( i = 0 ; pos &&  i < nItems ; i++ )
      {
         map->GetNextAssoc(pos,key,pObj);
         if ( ! prefix.IsEmpty() )
         {
            val = prefix + L"." + key;
         }
         else
         {
            val = key;
         }
         // copy each item into the arrays
         ASSERT((*offset) < maxOffset);
         var.Copy(pObj->GetData());
         LONG                index[1];
         index[0] = (*offset);
         SafeArrayPutElement(pVars,index,&var);
         if ( keys->fFeatures & FADF_BSTR  )
         {
            SafeArrayPutElement(keys,index,val);
         }
         else
         {
            // VBScript can only use VARIANT arrays (see getItems2)
            _variant_t tempKey;
            tempKey = val;
            SafeArrayPutElement(keys,index,&tempKey);
         }

         var.Clear();
         (*offset)++;
         if ( *offset >= maxOffset )
            break; // arrays are full - stop
      
         if ( bRecurse && pObj->HasChildren() )
         {
            // Recursively do the sub-map
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyValueArray(prefix+L"."+key,"",pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            else
            {
               BuildVariantKeyValueArray(key,"",pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            if ( *offset >= maxOffset )
               break; // arrays are full - stop
         }
      }
   }
   else
   {
      // Use the index to enumerate the items in alphabetical order
      
      CIndexItem           * curr;
      CIndexTree           * ndx = map->GetIndex();
      
      ASSERT (ndx != NULL);

      if ( includeSomeChildrenOnly && bRecurse )
      {
         // the startAfter item is in a subtree.  Find the appropriate element at this level and recursively continue the search   
         dStartItem.GetSegment(depth,key);
         if ( map->Lookup(key,pObj) )
         {
            // found the object
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyValueArray(prefix+_T(".")+key,startAfter,pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            else
            {
               BuildVariantKeyValueArray(key,startAfter,pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
         }
         // we've included the children of this item that come after 'startAfter',
         // now process the rest of the items at this level
         // make sure there's still room
         if ( (*offset) >= maxOffset )
            return; // the arrays are full
      }
      
      // Get a pointer to the first item at this level AFTER startAfter
      if ( startAfter.GetLength() > prefix.GetLength() )
      {
         CString startItem;
         dStartItem.GetSegment(depth,startItem);
         // if a starting item is specified, try using the hash function to find it in the table
         curr = map->GetIndexAt(startItem);
         if ( curr )
         {
            curr = ndx->GetNextItem(curr);
         }
         else
         {
            // The startAfter item is not in the table.  Search the tree to find 
            // the first item that would follow it if it were there
            curr = ndx->GetFirstAfter(startItem);
         }
      }
      else
      {
         curr = ndx->GetFirstItem();  
      }
      // Process all the items
      while ( curr )
      {
         pObj = curr->GetValue();
         key = curr->GetKey();

         curr = ndx->GetNextItem(curr);
         if ( ! prefix.IsEmpty() )
         {
            val = prefix + L"." + key;
         }
         else
         {
            val = key;
         }
         // add each item to the arrays
         ASSERT((*offset) < maxOffset);
         
         var.Copy(pObj->GetData());
         
         LONG                index[1];
         
         index[0] = (*offset);
         SafeArrayPutElement(pVars,index,&var);
         if ( keys->fFeatures & FADF_BSTR  )
         {
            SafeArrayPutElement(keys,index,val);
         }
         else
         {
            // VBScript can only use VARIANT arrays (see getItems2)
            _variant_t tempKey;
            tempKey = val;
            SafeArrayPutElement(keys,index,&tempKey);
         }

         var.Clear();         
         (*offset)++;
         
         if ( *offset >= maxOffset )
            break; // arrays are full - stop
         
         if ( bRecurse && pObj->HasChildren() )
         {
            // Recursively do the sub-map
            if ( ! prefix.IsEmpty() )
            {
               BuildVariantKeyValueArray(prefix+L"."+key,"",pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            else
            {
               BuildVariantKeyValueArray(key,"",pObj->GetChildren(),keys,pVars,offset,maxOffset,bRecurse);
            }
            if ( *offset >= maxOffset )
               break; // arrays are full - stop
         }
      }
   }
}

        
STDMETHODIMP CVSet::Clear()
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::Clear");
  
   HRESULT                   hr = S_OK;
   
   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEDATA )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {
      m_cs.Lock();
      m_bNeedToSave = TRUE;
      m_data->RemoveAll();
      m_data->GetData()->Clear();
      m_data->GetData()->ChangeType(VT_EMPTY);
      m_nItems = 0;
      m_cs.Unlock();
   }
   
   return hr;
}

//////////////IPersistStreamInit//////////////////////////////////////////////////////

STDMETHODIMP CVSet::GetClassID(CLSID __RPC_FAR *pClassID)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   (*pClassID) = CLSID_VarSet;
   
   return S_OK;
}

STDMETHODIMP CVSet::IsDirty()
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   if ( m_bNeedToSave )
   {
      return S_OK;
   }
   else
   {
      return S_FALSE;
   }
}
     
STDMETHODIMP CVSet::Load(LPSTREAM pStm)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   ULONG                result = 0;
   HRESULT              hr;

   m_cs.Lock();

   do {  // once

      hr = pStm->Read(&m_nItems,(sizeof m_nItems),&result);
      if ( FAILED(hr) )
         break;
      hr = pStm->Read(&m_CaseSensitive,(sizeof m_CaseSensitive),&result);
      if ( FAILED(hr) )
         break;
      hr = pStm->Read(&m_Indexed,(sizeof m_Indexed),&result);
      if ( FAILED(hr) )
         break;
      hr = m_data->ReadFromStream(pStm);
      m_bNeedToSave = FALSE;
      m_bLoaded = TRUE;
   }
   while (FALSE);

   m_cs.Unlock();

   return hr;
}
     
STDMETHODIMP CVSet::Save(LPSTREAM pStm,BOOL fClearDirty)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   ULONG             result = 0;
   HRESULT           hr;

   m_cs.Lock();

   do {   // once
      hr = pStm->Write(&m_nItems,(sizeof m_nItems),&result);
      if ( FAILED(hr) )
         break;
      hr = pStm->Write(&m_CaseSensitive,(sizeof m_CaseSensitive),&result);
      if ( FAILED(hr) )
         break;
      hr = pStm->Write(&m_Indexed,(sizeof m_Indexed),&result);
      if ( FAILED(hr) )
         break;
      hr = m_data->WriteToStream(pStm);
      if ( fClearDirty )
      {
         m_bNeedToSave = FALSE;
      }
   }while (FALSE);

   m_cs.Unlock();
   return hr;
}

STDMETHODIMP CVSet::GetSizeMax(ULARGE_INTEGER __RPC_FAR *pCbSize)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_INTERNAL,"VarSet GetSizeMax");

   HRESULT                   hr = S_OK;

   if ( pCbSize == NULL )
   {
      return E_POINTER;
   }
   else
   {
      LPSTREAM               pStr = NULL;
      DWORD                  rc;
      STATSTG                stats;
      DWORD                  requiredLength = 0; 


      rc = CreateStreamOnHGlobal(NULL,TRUE,&pStr);
      if ( ! rc )
      {
         hr = Save(pStr,FALSE);
         if (SUCCEEDED(hr) )
         {
            hr = pStr->Stat(&stats,STATFLAG_NONAME);
            if (SUCCEEDED(hr) )
            {
               requiredLength = stats.cbSize.LowPart;
            }
         }
         pStr->Release();
      }

      pCbSize->LowPart = requiredLength;
      MC_LOG("Size is " << McString::makeStr(requiredLength) );
      pCbSize->HighPart = 0;
   }
   
   return hr;
}
    
STDMETHODIMP CVSet::InitNew()
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   if ( m_bLoaded )
   {
      return E_UNEXPECTED;
   }
   else
   {
      m_cs.Lock();
      InitProperties();
      m_cs.Unlock();
      return S_OK;
   }
}

STDMETHODIMP CVSet::ImportSubTree(/*[in] */ BSTR key, /* [in] */ IVarSet * pVarSet)
{

   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::ImportSubTree");

   HRESULT                   hr = S_OK;
   VARIANT                   value;
   ULONG                     nGot;
   _bstr_t                   keyB;
   _bstr_t                   newkey;
   // make sure the varset is valid
                   
   // enumerate the varset, inserting each item into the tree as key.item
   IEnumVARIANT            * varEnum = NULL;
   IUnknown                * pUnk = NULL;

   // TODO:  need to speed this up by using getItems
   hr = pVarSet->get__NewEnum(&pUnk);
   if ( SUCCEEDED(hr) )
   {
      hr = pUnk->QueryInterface(IID_IEnumVARIANT,(void**)&varEnum);
      pUnk->Release();
   }
   if ( SUCCEEDED(hr))
   {
      value.vt = VT_EMPTY;
      while ( SUCCEEDED(hr = varEnum->Next(1,&value,&nGot)) )
      {
         if ( nGot==1 )
         {
            keyB = value.bstrVal;
            newkey = key;
            if ( newkey.length() )
            {
               newkey += _T(".");
            }
            newkey += keyB;
            hr = pVarSet->get(keyB,&value);
            if ( SUCCEEDED(hr )  )
            {
               hr = put(newkey,value);
            }
         }
         else
         {
            break;
         }
         if ( FAILED(hr) )
            break;
      }
      if ( varEnum )
         varEnum->Release();
   }
   varEnum = NULL;
  // clean up
   return hr;
}

STDMETHODIMP CVSet::getReference( /* [in] */ BSTR key, /* [out,retval] */IVarSet ** ppVarSet)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::getReference");

   HRESULT                   hr = S_OK;
   CVarData                * item = GetItem(key);
   
   typedef CComObject<CVSet> myvset;

   myvset                  * pVarSet;

   if ( ! ppVarSet )
   {
      hr = E_POINTER;
   }
   else
   {
      if ( item )
      {
         pVarSet = new myvset; 
         AddRef();
         ((CVSet*)pVarSet)->SetData(this,item,m_Restrictions);
         hr = pVarSet->QueryInterface(IID_IVarSet,(void**)ppVarSet);
      }
      else
      {
         hr = TYPE_E_ELEMENTNOTFOUND;
      }
   }
   return hr;
}

STDMETHODIMP CVSet::DumpToFile(BSTR filename)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())

   HRESULT                   hr = S_OK;

#ifdef STRIPPED_VARSET
   
   USES_CONVERSION;
   
   TError                    errLog;
   
   errLog.LogOpen((WCHAR*)filename,1,0);

   errLog.MsgWrite(0,L"VarSet");
   errLog.MsgWrite(0,L"Case Sensitive: %s, Indexed: %s",(m_CaseSensitive ? L"Yes" : L"No"),(m_Indexed ? L"Yes" : L"No") );
   errLog.MsgWrite(0,L"User Data ( %ld ) items",m_nItems);
#else
  
#endif     
   m_cs.Lock();
         
   CVarData                * map = m_data;
   CString                   start;
   CString                   seg;
 
                  // Build an array of variants to hold the keys
   CComVariant             * pVars = new CComVariant[m_data->CountItems()+1];
   CString                   key;
   int                       offset = 1;
   
   key = _T("");
   
   if (!pVars)
   {
      m_cs.Unlock();
      return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
   }

   // include the root item in the list
   
   pVars[0] = key;
   if ( map->HasChildren() )
   {
      BuildVariantKeyArray(key,map->GetChildren(),pVars,&offset);
   }
   
   m_cs.Unlock();

   if ( ! m_Indexed )
   {
       // Sort the results
      qsort(pVars,offset,(sizeof CComVariant),&SortComVariantStrings);
   }

   
   for ( int i = 0 ; i < offset ; i++ )
   {
      CVarData             * data;
      CString                value;
      CString                key;

      key = pVars[i].bstrVal;

      data = GetItem(key);

      if ( data )
      {
         switch ( data->GetData()->vt )
         {
         case VT_EMPTY:      
            value = _T("<Empty>");
            break;
         case VT_NULL:
            value = _T("<Null>");
            break;
         case VT_I2:
            value.Format(_T("%ld"),data->GetData()->iVal);
            break;
         case VT_I4:
            value.Format(_T("%ld"),data->GetData()->lVal);
            break;
         case VT_BSTR:
            value = data->GetData()->bstrVal;
            break;
         default:
            value.Format(_T("variant type=0x%lx"),data->GetData()->vt);
            break;
         }
#ifdef STRIPPED_VARSET
         errLog.MsgWrite(0,L" [%ls] %ls",key.GetBuffer(0),value.GetBuffer(0));
#else
 
#endif
      }
      else
      {
#ifdef STRIPPED_VARSET
         errLog.MsgWrite(0,L" [%ls] <No Value>",key.GetBuffer(0));
#else
#endif 
      }
   }
   delete [] pVars;
   return hr;
}

STDMETHODIMP CVSet::get_Indexed(BOOL *pVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_Indexed");
   if ( pVal == NULL )
      return E_POINTER;
   
   m_cs.Lock();
   (*pVal) = m_Indexed;
   m_cs.Unlock();

   return S_OK;
}

STDMETHODIMP CVSet::put_Indexed(BOOL newVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::put_Indexed");
   
   HRESULT                   hr = S_OK;
   
   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEPROPS )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {
      m_cs.Lock();
      m_bNeedToSave = TRUE;
      m_Indexed = newVal;  
      m_data->SetIndexed(m_Indexed);
      m_cs.Unlock();
   }
   return hr;
}


STDMETHODIMP CVSet::get_AllowRehashing(BOOL *pVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::get_AllowRehashing");
   if ( pVal == NULL )
      return E_POINTER;
   
   m_cs.Lock();
   (*pVal) = m_AllowRehashing;
   m_cs.Unlock();

   return S_OK;
}

STDMETHODIMP CVSet::put_AllowRehashing(BOOL newVal)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   MC_LOGBLOCKIF(VARSET_LOGLEVEL_CLIENT,"CVSet::put_AllowRehashing");
   
   HRESULT                   hr = S_OK;
   
   if ( m_Restrictions & VARSET_RESTRICT_NOCHANGEPROPS )
   {
      hr = E_ACCESSDENIED;
   }
   else
   {

      m_cs.Lock();
   
      m_bNeedToSave = TRUE;
   
      m_AllowRehashing = newVal;
      m_data->SetAllowRehashing(newVal);

      m_cs.Unlock();
   }   
   return hr;
}         

STDMETHODIMP CVSet::get_Restrictions(DWORD * restrictions)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   HRESULT                   hr = S_OK;

   if ( restrictions == NULL )
   {
      hr = E_POINTER;
   }
   else
   {
      (*restrictions) = m_Restrictions;
   }
   return hr;
}

STDMETHODIMP CVSet::put_Restrictions(DWORD newRestrictions)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   HRESULT                   hr = S_OK;
   DWORD                     rAdding = newRestrictions & ~m_Restrictions;
   DWORD                     rRemoving = ~newRestrictions & m_Restrictions;


   // Can't remove any restrictions passed down from parent.
   if ( ( rRemoving & m_ImmutableRestrictions) )
   {
      hr = E_ACCESSDENIED;
   }
   else if ( rAdding & ! VARSET_RESTRICT_ALL )
   {
      hr = E_NOTIMPL;
   }
   else
   {
      // the change is OK.
      m_Restrictions = newRestrictions;
   }
   return hr;
}

// IMarshal implemention
// This marshals the varset to a stream that is then sent across the wire
STDMETHODIMP CVSet::GetUnmarshalClass(REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   *pCid = GetObjectCLSID();
   
   return S_OK;
}
 
STDMETHODIMP CVSet::GetMarshalSizeMax(REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   HRESULT                   hr = S_OK; 
   ULARGE_INTEGER            uli;
   
   hr = GetSizeMax(&uli);

   if (SUCCEEDED(hr))
   {
      *pSize = uli.LowPart;
   }
   
   return hr;
}
 
STDMETHODIMP CVSet::MarshalInterface(IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestCtx, DWORD mshlflags)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   HRESULT                   hr = S_OK;
   
   // Save the varset's data to a stream
   hr = Save(pStm, FALSE);
     
   return hr;
}
 
STDMETHODIMP CVSet::UnmarshalInterface(IStream *pStm, REFIID riid, void **ppv)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   HRESULT                 hr = S_OK;
     
   // Load up the data from the stream using our IPersistStream implementation
   hr = Load(pStm);

   if ( SUCCEEDED(hr) )
   {
      hr = QueryInterface(riid,ppv);
   }
     
   return hr;
}
 
STDMETHODIMP CVSet::ReleaseMarshalData(IStream * /*pStmNotNeeded*/)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   // we don't keep any state data, so there's nothing to release
   // since we just read the object from the stream, the stream's pointer should already be at the end,
   // so there's nothing left for us to do here
   return S_OK;
}
 
STDMETHODIMP CVSet::DisconnectObject(DWORD /*dwReservedNotUsed*/)
{
   AFX_MANAGE_STATE(AfxGetStaticModuleState())
   
   return S_OK;
}