embedding/browser/activex/src/common/PropertyList.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Adam Lock <adamlock@eircom.net>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38 #ifndef PROPERTYLIST_H
  39 #define PROPERTYLIST_H
  40
  41 // A simple array class for managing name/value pairs typically fed to controls
  42 // during initialization by IPersistPropertyBag
  43
  44 class PropertyList
  45 {
  46     struct Property {
  47         BSTR    bstrName;
  48         VARIANT vValue;
  49     } *mProperties;
  50     unsigned long mListSize;
  51     unsigned long mMaxListSize;
  52
  53     bool EnsureMoreSpace()
  54     {
  55         // Ensure enough space exists to accomodate a new item
  56         const unsigned long kGrowBy = 10;
  57         if (!mProperties)
  58         {
  59             mProperties = (Property *) malloc(sizeof(Property) * kGrowBy);
  60             if (!mProperties)
  61                 return false;
  62             mMaxListSize = kGrowBy;
  63         }
  64         else if (mListSize == mMaxListSize)
  65         {
  66             Property *pNewProperties;
  67             pNewProperties = (Property *) realloc(mProperties, sizeof(Property) * (mMaxListSize + kGrowBy));
  68             if (!pNewProperties)
  69                 return false;
  70             mProperties = pNewProperties;
  71             mMaxListSize += kGrowBy;
  72         }
  73         return true;
  74     }
  75
  76 public:
  77     PropertyList() :
  78       mProperties(NULL),
  79       mListSize(0),
  80       mMaxListSize(0)
  81     {
  82     }
  83     ~PropertyList()
  84     {
  85     }
  86     void Clear()
  87     {
  88         if (mProperties)
  89         {
  90             for (unsigned long i = 0; i < mListSize; i++)
  91             {
  92                 SysFreeString(mProperties[i].bstrName); // Safe even if NULL
  93                 VariantClear(&mProperties[i].vValue);
  94             }
  95             free(mProperties);
  96             mProperties = NULL;
  97         }
  98         mListSize = 0;
  99         mMaxListSize = 0;
 100     }
 101     unsigned long GetSize() const
 102     {
 103         return mListSize;
 104     }
 105     const BSTR GetNameOf(unsigned long nIndex) const
 106     {
 107         if (nIndex > mListSize)
 108         {
 109             return NULL;
 110         }
 111         return mProperties[nIndex].bstrName;
 112     }
 113     const VARIANT *GetValueOf(unsigned long nIndex) const
 114     {
 115         if (nIndex > mListSize)
 116         {
 117             return NULL;
 118         }
 119         return &mProperties[nIndex].vValue;
 120     }
 121     bool AddOrReplaceNamedProperty(const BSTR bstrName, const VARIANT &vValue)
 122     {
 123         if (!bstrName)
 124             return false;
 125         for (unsigned long i = 0; i < GetSize(); i++)
 126         {
 127             // Case insensitive
 128             if (wcsicmp(mProperties[i].bstrName, bstrName) == 0)
 129             {
 130                 return SUCCEEDED(
 131                     VariantCopy(&mProperties[i].vValue, const_cast<VARIANT *>(&vValue)));
 132             }
 133         }
 134         return AddNamedProperty(bstrName, vValue);
 135     }
 136     bool AddNamedProperty(const BSTR bstrName, const VARIANT &vValue)
 137     {
 138         if (!bstrName || !EnsureMoreSpace())
 139             return false;
 140         Property *pProp = &mProperties[mListSize];
 141         pProp->bstrName = ::SysAllocString(bstrName);
 142         if (!pProp->bstrName)
 143         {
 144             return false;
 145         }
 146         VariantInit(&pProp->vValue);
 147         if (FAILED(VariantCopy(&pProp->vValue, const_cast<VARIANT *>(&vValue))))
 148         {
 149             SysFreeString(pProp->bstrName);
 150             return false;
 151         }
 152         mListSize++;
 153         return true;
 154     }
 155 };
 156
 157 #endif