author Kris Maglione <maglione.k@gmail.com>
Thu, 10 May 2018 10:36:53 -0700
changeset 473641 1becc594554c1a273535ed175895e801667735e9
parent 466676 8a94faa5cc60495da5d80d4b3c07bf5877d2e6d8
child 477364 00ae61d464066c27a4485e5f0dae02a7b78243ac
permissions -rw-r--r--
Bug 1460600: Remove unsupported --enable-system-hunspell flag. r=glandium Our bundled Hunspell now significantly differs from upstream Hunspell. Most importantly, it supports loading dictionaries from jar: URIs, which is now a requirement for loading bundled and extension dictionaries. This means that system Hunspell libraries are no longer compatible with our spell checker code. We should remove the option to use them so that users don't fall into the trap of trying to use them. MozReview-Commit-ID: 2ihJe6YOnGf

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsVariant_h
#define nsVariant_h

#include "nsIVariant.h"
#include "nsStringFwd.h"
#include "mozilla/Attributes.h"
#include "nsCycleCollectionParticipant.h"

 * Map the nsAUTF8String, nsUTF8String classes to the nsACString and
 * nsCString classes respectively for now.  These defines need to be removed
 * once Jag lands his nsUTF8String implementation.
#define nsAUTF8String nsACString
#define nsUTF8String nsCString
#define PromiseFlatUTF8String PromiseFlatCString

 * nsDiscriminatedUnion is a class that nsIVariant implementors can use
 * to hold the underlying data.

class nsDiscriminatedUnion

  nsDiscriminatedUnion() : mType(nsIDataType::VTYPE_EMPTY) {}
  nsDiscriminatedUnion(const nsDiscriminatedUnion&) = delete;
  nsDiscriminatedUnion(nsDiscriminatedUnion&&) = delete;

  ~nsDiscriminatedUnion() { Cleanup(); }

  nsDiscriminatedUnion& operator=(const nsDiscriminatedUnion&) = delete;
  nsDiscriminatedUnion& operator=(nsDiscriminatedUnion&&) = delete;

  void Cleanup();

  uint16_t GetType() const { return mType; }

  MOZ_MUST_USE nsresult ConvertToInt8(uint8_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToInt16(int16_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToInt32(int32_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToInt64(int64_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToUint8(uint8_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToUint16(uint16_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToUint32(uint32_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToUint64(uint64_t* aResult) const;
  MOZ_MUST_USE nsresult ConvertToFloat(float* aResult) const;
  MOZ_MUST_USE nsresult ConvertToDouble(double* aResult) const;
  MOZ_MUST_USE nsresult ConvertToBool(bool* aResult) const;
  MOZ_MUST_USE nsresult ConvertToChar(char* aResult) const;
  MOZ_MUST_USE nsresult ConvertToWChar(char16_t* aResult) const;

  MOZ_MUST_USE nsresult ConvertToID(nsID* aResult) const;

  MOZ_MUST_USE nsresult ConvertToAString(nsAString& aResult) const;
  MOZ_MUST_USE nsresult ConvertToAUTF8String(nsAUTF8String& aResult) const;
  MOZ_MUST_USE nsresult ConvertToACString(nsACString& aResult) const;
  MOZ_MUST_USE nsresult ConvertToString(char** aResult) const;
  MOZ_MUST_USE nsresult ConvertToWString(char16_t** aResult) const;
  MOZ_MUST_USE nsresult ConvertToStringWithSize(uint32_t* aSize, char** aStr) const;
  MOZ_MUST_USE nsresult ConvertToWStringWithSize(uint32_t* aSize, char16_t** aStr) const;

  MOZ_MUST_USE nsresult ConvertToISupports(nsISupports** aResult) const;
  MOZ_MUST_USE nsresult ConvertToInterface(nsIID** aIID, void** aInterface) const;
  MOZ_MUST_USE nsresult ConvertToArray(uint16_t* aType, nsIID* aIID,
                                       uint32_t* aCount, void** aPtr) const;

  MOZ_MUST_USE nsresult SetFromVariant(nsIVariant* aValue);

  void SetFromInt8(uint8_t aValue);
  void SetFromInt16(int16_t aValue);
  void SetFromInt32(int32_t aValue);
  void SetFromInt64(int64_t aValue);
  void SetFromUint8(uint8_t aValue);
  void SetFromUint16(uint16_t aValue);
  void SetFromUint32(uint32_t aValue);
  void SetFromUint64(uint64_t aValue);
  void SetFromFloat(float aValue);
  void SetFromDouble(double aValue);
  void SetFromBool(bool aValue);
  void SetFromChar(char aValue);
  void SetFromWChar(char16_t aValue);
  void SetFromID(const nsID& aValue);
  void SetFromAString(const nsAString& aValue);
  void SetFromDOMString(const nsAString& aValue);
  void SetFromAUTF8String(const nsAUTF8String& aValue);
  void SetFromACString(const nsACString& aValue);
  MOZ_MUST_USE nsresult SetFromString(const char* aValue);
  MOZ_MUST_USE nsresult SetFromWString(const char16_t* aValue);
  void SetFromISupports(nsISupports* aValue);
  void SetFromInterface(const nsIID& aIID, nsISupports* aValue);
  MOZ_MUST_USE nsresult SetFromArray(uint16_t aType, const nsIID* aIID,
                                     uint32_t aCount, void* aValue);
  MOZ_MUST_USE nsresult SetFromStringWithSize(uint32_t aSize,
                                              const char* aValue);
  MOZ_MUST_USE nsresult SetFromWStringWithSize(uint32_t aSize,
                                               const char16_t* aValue);

  // Like SetFromWStringWithSize, but leaves the string uninitialized. It does
  // does write the null-terminator.
  void AllocateWStringWithSize(uint32_t aSize);

  void SetToVoid();
  void SetToEmpty();
  void SetToEmptyArray();

  void Traverse(nsCycleCollectionTraversalCallback& aCb) const;

  MOZ_MUST_USE nsresult
  ToManageableNumber(nsDiscriminatedUnion* aOutData) const;
  void FreeArray();
  MOZ_MUST_USE bool String2ID(nsID* aPid) const;
  MOZ_MUST_USE nsresult ToString(nsACString& aOutString) const;

    int8_t         mInt8Value;
    int16_t        mInt16Value;
    int32_t        mInt32Value;
    int64_t        mInt64Value;
    uint8_t        mUint8Value;
    uint16_t       mUint16Value;
    uint32_t       mUint32Value;
    uint64_t       mUint64Value;
    float          mFloatValue;
    double         mDoubleValue;
    bool           mBoolValue;
    char           mCharValue;
    char16_t       mWCharValue;
    nsIID          mIDValue;
    nsAString*     mAStringValue;
    nsAUTF8String* mUTF8StringValue;
    nsACString*    mCStringValue;
      // This is an owning reference that cannot be an nsCOMPtr because
      // nsDiscriminatedUnion needs to be POD.  AddRef/Release are manually
      // called on this.
      nsISupports* MOZ_OWNING_REF mInterfaceValue;
      nsIID        mInterfaceID;
    } iface;
      nsIID        mArrayInterfaceID;
      void*        mArrayValue;
      uint32_t     mArrayCount;
      uint16_t     mArrayType;
    } array;
      char*        mStringValue;
      uint32_t     mStringLength;
    } str;
      char16_t*    mWStringValue;
      uint32_t     mWStringLength;
    } wstr;
  } u;
  uint16_t       mType;

 * nsVariant implements the generic variant support. The xpcom module registers
 * a factory (see NS_VARIANT_CONTRACTID in nsIVariant.idl) that will create
 * these objects. They are created 'empty' and 'writable'.
 * nsIVariant users won't usually need to see this class.
class nsVariantBase : public nsIWritableVariant


  ~nsVariantBase() {};

  nsDiscriminatedUnion mData;
  bool mWritable;

class nsVariant final : public nsVariantBase

  nsVariant() {};

  ~nsVariant() {};

class nsVariantCC final : public nsVariantBase

  nsVariantCC() {};

  ~nsVariantCC() {};

 * Users of nsIVariant should be using the contractID and not this CID.
 *  - see NS_VARIANT_CONTRACTID in nsIVariant.idl.

#define NS_VARIANT_CID \
{ /* 0D6EA1D0-879C-11d5-90EF-0010A4E73D9A */ \
    0xd6ea1d0,                               \
    0x879c,                                  \
    0x11d5,                                  \
    {0x90, 0xef, 0x0, 0x10, 0xa4, 0xe7, 0x3d, 0x9a}}

#endif // nsVariant_h