//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef PURLClassifierInfo_h
#define PURLClassifierInfo_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
#include "nsIURI.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ClassifierInfo|
//
namespace mozilla {
namespace dom {
class ClassifierInfo final
{
private:
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    ClassifierInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ClassifierInfo(
            const nsCString& _list,
            const nsCString& _provider,
            const nsCString& _fullhash) :
        list_(_list),
        provider_(_provider),
        fullhash_(_fullhash)
    {
    }

    MOZ_IMPLICIT ClassifierInfo(
            nsCString&& _list,
            nsCString&& _provider,
            nsCString&& _fullhash) :
        list_(std::move(_list)),
        provider_(std::move(_provider)),
        fullhash_(std::move(_fullhash))
    {
    }

    nsCString&
    list()
    {
        return list_;
    }
    const nsCString&
    list() const
    {
        return list_;
    }

    nsCString&
    provider()
    {
        return provider_;
    }
    const nsCString&
    provider() const
    {
        return provider_;
    }

    nsCString&
    fullhash()
    {
        return fullhash_;
    }
    const nsCString&
    fullhash() const
    {
        return fullhash_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> list_;
    ::mozilla::ipc::IPDLStructMember<nsCString> provider_;
    ::mozilla::ipc::IPDLStructMember<nsCString> fullhash_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ClassifierInfo>
{
    typedef ::mozilla::dom::ClassifierInfo paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct URLClassifierLocalResult|
//
namespace mozilla {
namespace dom {
class URLClassifierLocalResult final
{
private:
    typedef ::nsIURI nsIURI;
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    URLClassifierLocalResult() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT URLClassifierLocalResult(
            nsIURI* _uri,
            const nsCString& _featureName,
            const nsCString& _matchingList) :
        uri_(_uri),
        featureName_(_featureName),
        matchingList_(_matchingList)
    {
    }

    MOZ_IMPLICIT URLClassifierLocalResult(
            RefPtr<nsIURI>&& _uri,
            nsCString&& _featureName,
            nsCString&& _matchingList) :
        uri_(std::move(_uri)),
        featureName_(std::move(_featureName)),
        matchingList_(std::move(_matchingList))
    {
    }

    RefPtr<nsIURI>&
    uri()
    {
        return uri_;
    }
    nsIURI*
    uri() const
    {
        return uri_;
    }

    nsCString&
    featureName()
    {
        return featureName_;
    }
    const nsCString&
    featureName() const
    {
        return featureName_;
    }

    nsCString&
    matchingList()
    {
        return matchingList_;
    }
    const nsCString&
    matchingList() const
    {
        return matchingList_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> uri_;
    ::mozilla::ipc::IPDLStructMember<nsCString> featureName_;
    ::mozilla::ipc::IPDLStructMember<nsCString> matchingList_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::URLClassifierLocalResult>
{
    typedef ::mozilla::dom::URLClassifierLocalResult paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef PURLClassifierInfo_h
