2 * Copyright (C) 2007, 2008 Apple Inc. All Rights Reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #ifndef COMVariantSetter_h
27 #define COMVariantSetter_h
29 #include <WebCore/BString.h>
30 #include <WebCore/COMPtr.h>
31 #include <wtf/Assertions.h>
32 #include <wtf/Forward.h>
34 template<typename T> struct COMVariantSetter {};
36 template<typename T> struct COMVariantSetterBase
38 static inline VARENUM variantType(const T&)
40 return COMVariantSetter<T>::VariantType;
44 template<> struct COMVariantSetter<WTF::String> : COMVariantSetterBase<WTF::String>
46 static const VARENUM VariantType = VT_BSTR;
48 static void setVariant(VARIANT* variant, const WTF::String& value)
50 ASSERT(V_VT(variant) == VT_EMPTY);
52 V_VT(variant) = VariantType;
53 V_BSTR(variant) = WebCore::BString(value).release();
57 template<> struct COMVariantSetter<bool> : COMVariantSetterBase<bool>
59 static const VARENUM VariantType = VT_BOOL;
61 static void setVariant(VARIANT* variant, bool value)
63 ASSERT(V_VT(variant) == VT_EMPTY);
65 V_VT(variant) = VariantType;
66 V_BOOL(variant) = value;
70 template<> struct COMVariantSetter<unsigned long long> : COMVariantSetterBase<unsigned long long>
72 static const VARENUM VariantType = VT_UI8;
74 static void setVariant(VARIANT* variant, unsigned long long value)
76 ASSERT(V_VT(variant) == VT_EMPTY);
78 V_VT(variant) = VariantType;
79 V_UI8(variant) = value;
83 template<> struct COMVariantSetter<int> : COMVariantSetterBase<int>
85 static const VARENUM VariantType = VT_I4;
87 static void setVariant(VARIANT* variant, int value)
89 ASSERT(V_VT(variant) == VT_EMPTY);
91 V_VT(variant) = VariantType;
92 V_I4(variant) = value;
96 template<> struct COMVariantSetter<float> : COMVariantSetterBase<float>
98 static const VARENUM VariantType = VT_R4;
100 static void setVariant(VARIANT* variant, float value)
102 ASSERT(V_VT(variant) == VT_EMPTY);
104 V_VT(variant) = VariantType;
105 V_R4(variant) = value;
109 template<typename T> struct COMVariantSetter<COMPtr<T> > : COMVariantSetterBase<COMPtr<T> >
111 static const VARENUM VariantType = VT_UNKNOWN;
113 static void setVariant(VARIANT* variant, const COMPtr<T>& value)
115 ASSERT(V_VT(variant) == VT_EMPTY);
117 V_VT(variant) = VariantType;
118 V_UNKNOWN(variant) = value.get();
123 template<typename COMType, typename UnderlyingType>
124 struct COMIUnknownVariantSetter : COMVariantSetterBase<UnderlyingType>
126 static const VARENUM VariantType = VT_UNKNOWN;
128 static void setVariant(VARIANT* variant, const UnderlyingType& value)
130 ASSERT(V_VT(variant) == VT_EMPTY);
132 V_VT(variant) = VariantType;
133 V_UNKNOWN(variant) = COMType::createInstance(value);
141 ::VariantInit(&m_variant);
144 template<typename UnderlyingType>
145 COMVariant(UnderlyingType value)
147 ::VariantInit(&m_variant);
148 COMVariantSetter<UnderlyingType>::setVariant(&m_variant, value);
153 ::VariantClear(&m_variant);
156 COMVariant(const COMVariant& other)
158 ::VariantInit(&m_variant);
159 other.copyTo(&m_variant);
162 COMVariant& operator=(const COMVariant& other)
164 other.copyTo(&m_variant);
168 void copyTo(VARIANT* dest) const
170 ::VariantCopy(dest, const_cast<VARIANT*>(&m_variant));
173 VARENUM variantType() const { return static_cast<VARENUM>(V_VT(&m_variant)); }
179 template<> struct COMVariantSetter<COMVariant>
181 static inline VARENUM variantType(const COMVariant& value)
183 return value.variantType();
186 static void setVariant(VARIANT* variant, const COMVariant& value)
188 ASSERT(V_VT(variant) == VT_EMPTY);
190 value.copyTo(variant);
194 #endif // COMVariantSetter