The Tor Browser / file revision

xpcom/ds/nsVariant.h@6474c204b198

xpcom/ds/nsVariant.h

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-

     2  *

     3  * This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 

     7 /* The long avoided variant support for xpcom. */

     8 

     9 #ifndef nsVariant_h

    10 #define nsVariant_h

    11 

    12 #include "nsIVariant.h"

    13 #include "nsStringFwd.h"

    14 #include "mozilla/Attributes.h"

    15 

    16 class nsCycleCollectionTraversalCallback;

    17 

    18 /** 

    19  * Map the nsAUTF8String, nsUTF8String classes to the nsACString and

    20  * nsCString classes respectively for now.  These defines need to be removed

    21  * once Jag lands his nsUTF8String implementation.

    22  */

    23 #define nsAUTF8String nsACString

    24 #define nsUTF8String nsCString

    25 #define PromiseFlatUTF8String PromiseFlatCString

    26 

    27 /**

    28  * nsDiscriminatedUnion is a type that nsIVariant implementors *may* use 

    29  * to hold underlying data. It has no methods. So, its use requires no linkage

    30  * to the xpcom module.

    31  */

    32 

    33 struct nsDiscriminatedUnion

    34 {

    35     union {

    36         int8_t         mInt8Value;

    37         int16_t        mInt16Value;

    38         int32_t        mInt32Value;

    39         int64_t        mInt64Value;

    40         uint8_t        mUint8Value;

    41         uint16_t       mUint16Value;

    42         uint32_t       mUint32Value;

    43         uint64_t       mUint64Value;

    44         float          mFloatValue;

    45         double         mDoubleValue;

    46         bool           mBoolValue;

    47         char           mCharValue;

    48         char16_t      mWCharValue;

    49         nsIID          mIDValue;

    50         nsAString*     mAStringValue;

    51         nsAUTF8String* mUTF8StringValue;

    52         nsACString*    mCStringValue;

    53         struct {

    54             nsISupports* mInterfaceValue;

    55             nsIID        mInterfaceID;

    56         } iface;

    57         struct {

    58             nsIID        mArrayInterfaceID;

    59             void*        mArrayValue;

    60             uint32_t     mArrayCount;

    61             uint16_t     mArrayType;

    62         } array;

    63         struct {

    64             char*        mStringValue;

    65             uint32_t     mStringLength;

    66         } str;

    67         struct {

    68             char16_t*   mWStringValue;

    69             uint32_t     mWStringLength;

    70         } wstr;

    71     } u;

    72     uint16_t       mType;

    73 };

    74 

    75 /**

    76  * nsVariant implements the generic variant support. The xpcom module registers

    77  * a factory (see NS_VARIANT_CONTRACTID in nsIVariant.idl) that will create 

    78  * these objects. They are created 'empty' and 'writable'. 

    79  *

    80  * nsIVariant users won't usually need to see this class.

    81  *

    82  * This class also has static helper methods that nsIVariant *implementors* can

    83  * use to help them do all the 'standard' nsIVariant data conversions.

    84  */

    85 

    86 class nsVariant MOZ_FINAL : public nsIWritableVariant

    87 {

    88 public:

    89     NS_DECL_ISUPPORTS

    90     NS_DECL_NSIVARIANT

    91     NS_DECL_NSIWRITABLEVARIANT

    92 

    93     nsVariant();

    94 

    95     static nsresult Initialize(nsDiscriminatedUnion* data);

    96     static nsresult Cleanup(nsDiscriminatedUnion* data);

    97 

    98     static nsresult ConvertToInt8(const nsDiscriminatedUnion& data, uint8_t *_retval);

    99     static nsresult ConvertToInt16(const nsDiscriminatedUnion& data, int16_t *_retval);

   100     static nsresult ConvertToInt32(const nsDiscriminatedUnion& data, int32_t *_retval);

   101     static nsresult ConvertToInt64(const nsDiscriminatedUnion& data, int64_t *_retval);

   102     static nsresult ConvertToUint8(const nsDiscriminatedUnion& data, uint8_t *_retval);

   103     static nsresult ConvertToUint16(const nsDiscriminatedUnion& data, uint16_t *_retval);

   104     static nsresult ConvertToUint32(const nsDiscriminatedUnion& data, uint32_t *_retval);

   105     static nsresult ConvertToUint64(const nsDiscriminatedUnion& data, uint64_t *_retval);

   106     static nsresult ConvertToFloat(const nsDiscriminatedUnion& data, float *_retval);

   107     static nsresult ConvertToDouble(const nsDiscriminatedUnion& data, double *_retval);

   108     static nsresult ConvertToBool(const nsDiscriminatedUnion& data, bool *_retval);

   109     static nsresult ConvertToChar(const nsDiscriminatedUnion& data, char *_retval);

   110     static nsresult ConvertToWChar(const nsDiscriminatedUnion& data, char16_t *_retval);

   111     static nsresult ConvertToID(const nsDiscriminatedUnion& data, nsID * _retval);

   112     static nsresult ConvertToAString(const nsDiscriminatedUnion& data, nsAString & _retval);

   113     static nsresult ConvertToAUTF8String(const nsDiscriminatedUnion& data, nsAUTF8String & _retval);

   114     static nsresult ConvertToACString(const nsDiscriminatedUnion& data, nsACString & _retval);

   115     static nsresult ConvertToString(const nsDiscriminatedUnion& data, char **_retval);

   116     static nsresult ConvertToWString(const nsDiscriminatedUnion& data, char16_t **_retval);

   117     static nsresult ConvertToISupports(const nsDiscriminatedUnion& data, nsISupports **_retval);

   118     static nsresult ConvertToInterface(const nsDiscriminatedUnion& data, nsIID * *iid, void * *iface);

   119     static nsresult ConvertToArray(const nsDiscriminatedUnion& data, uint16_t *type, nsIID* iid, uint32_t *count, void * *ptr);

   120     static nsresult ConvertToStringWithSize(const nsDiscriminatedUnion& data, uint32_t *size, char **str);

   121     static nsresult ConvertToWStringWithSize(const nsDiscriminatedUnion& data, uint32_t *size, char16_t **str);

   122 

   123     static nsresult SetFromVariant(nsDiscriminatedUnion* data, nsIVariant* aValue);

   124 

   125     static nsresult SetFromInt8(nsDiscriminatedUnion* data, uint8_t aValue);

   126     static nsresult SetFromInt16(nsDiscriminatedUnion* data, int16_t aValue);

   127     static nsresult SetFromInt32(nsDiscriminatedUnion* data, int32_t aValue);

   128     static nsresult SetFromInt64(nsDiscriminatedUnion* data, int64_t aValue);

   129     static nsresult SetFromUint8(nsDiscriminatedUnion* data, uint8_t aValue);

   130     static nsresult SetFromUint16(nsDiscriminatedUnion* data, uint16_t aValue);

   131     static nsresult SetFromUint32(nsDiscriminatedUnion* data, uint32_t aValue);

   132     static nsresult SetFromUint64(nsDiscriminatedUnion* data, uint64_t aValue);

   133     static nsresult SetFromFloat(nsDiscriminatedUnion* data, float aValue);

   134     static nsresult SetFromDouble(nsDiscriminatedUnion* data, double aValue);

   135     static nsresult SetFromBool(nsDiscriminatedUnion* data, bool aValue);

   136     static nsresult SetFromChar(nsDiscriminatedUnion* data, char aValue);

   137     static nsresult SetFromWChar(nsDiscriminatedUnion* data, char16_t aValue);

   138     static nsresult SetFromID(nsDiscriminatedUnion* data, const nsID & aValue);

   139     static nsresult SetFromAString(nsDiscriminatedUnion* data, const nsAString & aValue);

   140     static nsresult SetFromAUTF8String(nsDiscriminatedUnion* data, const nsAUTF8String & aValue);

   141     static nsresult SetFromACString(nsDiscriminatedUnion* data, const nsACString & aValue);

   142     static nsresult SetFromString(nsDiscriminatedUnion* data, const char *aValue);

   143     static nsresult SetFromWString(nsDiscriminatedUnion* data, const char16_t *aValue);

   144     static nsresult SetFromISupports(nsDiscriminatedUnion* data, nsISupports *aValue);

   145     static nsresult SetFromInterface(nsDiscriminatedUnion* data, const nsIID& iid, nsISupports *aValue);

   146     static nsresult SetFromArray(nsDiscriminatedUnion* data, uint16_t type, const nsIID* iid, uint32_t count, void * aValue);

   147     static nsresult SetFromStringWithSize(nsDiscriminatedUnion* data, uint32_t size, const char *aValue);

   148     static nsresult SetFromWStringWithSize(nsDiscriminatedUnion* data, uint32_t size, const char16_t *aValue);

   149 

   150     static nsresult SetToVoid(nsDiscriminatedUnion* data);

   151     static nsresult SetToEmpty(nsDiscriminatedUnion* data);

   152     static nsresult SetToEmptyArray(nsDiscriminatedUnion* data);

   153 

   154     static void Traverse(const nsDiscriminatedUnion& data,

   155                          nsCycleCollectionTraversalCallback &cb);

   156 

   157 private:

   158     ~nsVariant();

   159 

   160 protected:

   161     nsDiscriminatedUnion mData;

   162     bool                 mWritable;

   163 };

   164 

   165 /**

   166  * Users of nsIVariant should be using the contractID and not this CID.

   167  *  - see NS_VARIANT_CONTRACTID in nsIVariant.idl.

   168  */

   169 

   170 #define NS_VARIANT_CID \

   171 { /* 0D6EA1D0-879C-11d5-90EF-0010A4E73D9A */ \

   172     0xd6ea1d0,                               \

   173     0x879c,                                  \

   174     0x11d5,                                  \

   175     {0x90, 0xef, 0x0, 0x10, 0xa4, 0xe7, 0x3d, 0x9a}}

   176 

   177 #endif // nsVariant_h

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial