#ifndef dom_plugins_ipc_ipdltuple_h

#define dom_plugins_ipc_ipdltuple_h

#include "mozilla/plugins/FunctionBrokerIPCUtils.h"

#include "mozilla/Variant.h"

namespace mozilla {

namespace plugins {

/**

 * IpdlTuple is used by automatic function brokering to pass parameter

 * lists for brokered functions.  It supports a limited set of types

 * (see IpdlTuple::IpdlTupleElement).

 */

class IpdlTuple

{

public:

  uint32_t NumElements() const { return mTupleElements.Length(); }

  template<typename EltType>

  EltType* Element(uint32_t index)

  {

    if ((index >= mTupleElements.Length()) ||

        !mTupleElements[index].GetVariant().is<EltType>()) {

      return nullptr;

    }

    return &mTupleElements[index].GetVariant().as<EltType>();

  }

  template<typename EltType>

  const EltType* Element(uint32_t index) const

  {

    return const_cast<IpdlTuple*>(this)->Element<EltType>(index);

  }

  template <typename EltType>

  void AddElement(const EltType& aElt)

  {

    IpdlTupleElement* newEntry = mTupleElements.AppendElement();

    newEntry->Set(aElt);

  }

private:

  struct InvalidType {};

  // Like Variant but with a default constructor.

  template <typename ... Types>

  struct MaybeVariant

  {

  public:

    MaybeVariant() : mValue(InvalidType()) {}

    MaybeVariant(MaybeVariant&& o) : mValue(std::move(o.mValue)) {}

    template <typename Param> void Set(const Param& aParam)

    {

      mValue = mozilla::AsVariant(aParam);

    }

    typedef mozilla::Variant<InvalidType, Types...> MaybeVariantType;

    MaybeVariantType& GetVariant() { return mValue; }

    const MaybeVariantType& GetVariant() const { return mValue; }

  private:

    MaybeVariantType mValue;

  };

#if defined(XP_WIN)

  typedef MaybeVariant<int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,

                       int64_t,uint64_t,nsCString,bool,OpenFileNameIPC,

                       OpenFileNameRetIPC,NativeWindowHandle,

                       IPCSchannelCred,IPCInternetBuffers,StringArray,

                       IPCPrintDlg> IpdlTupleElement;

#else

  typedef MaybeVariant<int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,

                       int64_t,uint64_t,nsCString,bool> IpdlTupleElement;

#endif // defined(XP_WIN)

  friend struct IPC::ParamTraits<IpdlTuple>;

  friend struct IPC::ParamTraits<IpdlTuple::IpdlTupleElement>;

  friend struct IPC::ParamTraits<IpdlTuple::InvalidType>;

  nsTArray<IpdlTupleElement> mTupleElements;

};

template <> template<>

inline void IpdlTuple::IpdlTupleElement::Set<nsDependentCSubstring>(const nsDependentCSubstring& aParam)

{

  mValue = MaybeVariantType(mozilla::VariantType<nsCString>(), aParam);

}

} // namespace plugins

} // namespace mozilla

namespace IPC {

using namespace mozilla::plugins;

template <>

struct ParamTraits<IpdlTuple>

{

  typedef IpdlTuple paramType;

  static void Write(Message* aMsg, const paramType& aParam)

  {

    WriteParam(aMsg, aParam.mTupleElements);

  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,

                   paramType* aParam)

  {

    return ReadParam(aMsg, aIter, &aParam->mTupleElements);

  }

  static void Log(const paramType& aParam, std::wstring* aLog)

  {

    LogParam(aParam.mTupleElements, aLog);

  }

};

template<>

struct ParamTraits<IpdlTuple::IpdlTupleElement>

{

  typedef IpdlTuple::IpdlTupleElement paramType;

  static void Write(Message* aMsg, const paramType& aParam)

  {

    MOZ_RELEASE_ASSERT(!aParam.GetVariant().is<IpdlTuple::InvalidType>());

    WriteParam(aMsg, aParam.GetVariant());

  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,

                   paramType* aParam)

  {

    bool ret = ReadParam(aMsg, aIter, &aParam->GetVariant());

    MOZ_RELEASE_ASSERT(!aParam->GetVariant().is<IpdlTuple::InvalidType>());

    return ret;

  }

  struct LogMatcher

  {

    explicit LogMatcher(std::wstring* aLog) : mLog(aLog) {}

    template <typename EntryType>

    void match(const EntryType& aParam)

    {

      LogParam(aParam, mLog);

    }

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<mozilla::plugins::IpdlTuple::InvalidType>(mozilla::plugins::IpdlTuple::InvalidType const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<signed char>(signed char const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<unsigned char>(unsigned char const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<short>(short const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<unsigned short>(unsigned short const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<int>(int const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<unsigned int>(unsigned int const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<long>(long const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<unsigned long>(unsigned long const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<nsTString<char> >(nsTString<char> const&)

Unexecuted instantiation: void IPC::ParamTraits<mozilla::plugins::IpdlTuple::MaybeVariant<signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, nsTString<char>, bool> >::LogMatcher::match<bool>(bool const&)

  private:

    std::wstring* mLog;

  };

  static void Log(const paramType& aParam, std::wstring* aLog)

  {

    aParam.GetVariant().match(LogMatcher(aLog));

  }

};

template<>

struct ParamTraits<IpdlTuple::InvalidType>

{

  typedef IpdlTuple::InvalidType paramType;

  static void Write(Message* aMsg, const paramType& aParam)

  {

    MOZ_ASSERT_UNREACHABLE("Attempt to serialize an invalid tuple element");

  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,

                   paramType* aParam)

  {

    MOZ_ASSERT_UNREACHABLE("Attempt to deserialize an invalid tuple element");

    return false;

  }

  static void Log(const paramType& aParam, std::wstring* aLog)

  {

    aLog->append(L"<Invalid Tuple Entry>");

  }

};

} // namespace IPC

#endif /* dom_plugins_ipc_ipdltuple_h */