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

#ifndef ProfilerTypes_h
#define ProfilerTypes_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 "ProfileAdditionalInformation.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/ipc/IPDLStructMember.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ProfilerInitParams|
//
namespace mozilla {
class ProfilerInitParams final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    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
    ProfilerInitParams() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT ProfilerInitParams(
            const bool& _enabled,
            const uint32_t& _entries,
            const mozilla::Maybe<double>& _duration,
            const double& _interval,
            const uint32_t& _features,
            const uint64_t& _activeTabID,
            const nsTArray<nsCString>& _filters) :
        enabled_(_enabled),
        duration_(_duration),
        filters_(_filters),
        interval_(_interval),
        activeTabID_(_activeTabID),
        entries_(_entries),
        features_(_features)
    {
    }

    MOZ_IMPLICIT ProfilerInitParams(
            bool&& _enabled,
            uint32_t&& _entries,
            mozilla::Maybe<double>&& _duration,
            double&& _interval,
            uint32_t&& _features,
            uint64_t&& _activeTabID,
            nsTArray<nsCString>&& _filters) :
        enabled_(std::move(_enabled)),
        duration_(std::move(_duration)),
        filters_(std::move(_filters)),
        interval_(std::move(_interval)),
        activeTabID_(std::move(_activeTabID)),
        entries_(std::move(_entries)),
        features_(std::move(_features))
    {
    }

    bool&
    enabled()
    {
        return enabled_;
    }
    const bool&
    enabled() const
    {
        return enabled_;
    }

    uint32_t&
    entries()
    {
        return entries_;
    }
    const uint32_t&
    entries() const
    {
        return entries_;
    }

    mozilla::Maybe<double>&
    duration()
    {
        return duration_;
    }
    const mozilla::Maybe<double>&
    duration() const
    {
        return duration_;
    }

    double&
    interval()
    {
        return interval_;
    }
    const double&
    interval() const
    {
        return interval_;
    }

    uint32_t&
    features()
    {
        return features_;
    }
    const uint32_t&
    features() const
    {
        return features_;
    }

    uint64_t&
    activeTabID()
    {
        return activeTabID_;
    }
    const uint64_t&
    activeTabID() const
    {
        return activeTabID_;
    }

    nsTArray<nsCString>&
    filters()
    {
        return filters_;
    }
    const nsTArray<nsCString>&
    filters() const
    {
        return filters_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<bool> enabled_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<double>> duration_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<nsCString>> filters_;
    ::mozilla::ipc::IPDLStructMember<double> interval_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> activeTabID_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> entries_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> features_;
};
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::ProfilerInitParams>
{
    typedef ::mozilla::ProfilerInitParams 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 ProfileBufferChunkMetadata|
//
namespace mozilla {
class ProfileBufferChunkMetadata final
{
private:
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::uint32_t uint32_t;

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

    MOZ_IMPLICIT ProfileBufferChunkMetadata(
            const TimeStamp& _doneTimeStamp,
            const uint32_t& _bufferBytes) :
        doneTimeStamp_(_doneTimeStamp),
        bufferBytes_(_bufferBytes)
    {
    }

    MOZ_IMPLICIT ProfileBufferChunkMetadata(
            TimeStamp&& _doneTimeStamp,
            uint32_t&& _bufferBytes) :
        doneTimeStamp_(std::move(_doneTimeStamp)),
        bufferBytes_(std::move(_bufferBytes))
    {
    }

    TimeStamp&
    doneTimeStamp()
    {
        return doneTimeStamp_;
    }
    const TimeStamp&
    doneTimeStamp() const
    {
        return doneTimeStamp_;
    }

    uint32_t&
    bufferBytes()
    {
        return bufferBytes_;
    }
    const uint32_t&
    bufferBytes() const
    {
        return bufferBytes_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<TimeStamp> doneTimeStamp_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> bufferBytes_;
};
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::ProfileBufferChunkMetadata>
{
    typedef ::mozilla::ProfileBufferChunkMetadata 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 ProfileBufferChunkManagerUpdate|
//
namespace mozilla {
class ProfileBufferChunkManagerUpdate final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::TimeStamp TimeStamp;
    typedef ::mozilla::ProfileBufferChunkMetadata ProfileBufferChunkMetadata;

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

    MOZ_IMPLICIT ProfileBufferChunkManagerUpdate(
            const uint64_t& _unreleasedBytes,
            const uint64_t& _releasedBytes,
            const TimeStamp& _oldestDoneTimeStamp,
            const nsTArray<ProfileBufferChunkMetadata>& _newlyReleasedChunks) :
        oldestDoneTimeStamp_(_oldestDoneTimeStamp),
        newlyReleasedChunks_(_newlyReleasedChunks),
        unreleasedBytes_(_unreleasedBytes),
        releasedBytes_(_releasedBytes)
    {
    }

    MOZ_IMPLICIT ProfileBufferChunkManagerUpdate(
            uint64_t&& _unreleasedBytes,
            uint64_t&& _releasedBytes,
            TimeStamp&& _oldestDoneTimeStamp,
            nsTArray<ProfileBufferChunkMetadata>&& _newlyReleasedChunks) :
        oldestDoneTimeStamp_(std::move(_oldestDoneTimeStamp)),
        newlyReleasedChunks_(std::move(_newlyReleasedChunks)),
        unreleasedBytes_(std::move(_unreleasedBytes)),
        releasedBytes_(std::move(_releasedBytes))
    {
    }

    uint64_t&
    unreleasedBytes()
    {
        return unreleasedBytes_;
    }
    const uint64_t&
    unreleasedBytes() const
    {
        return unreleasedBytes_;
    }

    uint64_t&
    releasedBytes()
    {
        return releasedBytes_;
    }
    const uint64_t&
    releasedBytes() const
    {
        return releasedBytes_;
    }

    TimeStamp&
    oldestDoneTimeStamp()
    {
        return oldestDoneTimeStamp_;
    }
    const TimeStamp&
    oldestDoneTimeStamp() const
    {
        return oldestDoneTimeStamp_;
    }

    nsTArray<ProfileBufferChunkMetadata>&
    newlyReleasedChunks()
    {
        return newlyReleasedChunks_;
    }
    const nsTArray<ProfileBufferChunkMetadata>&
    newlyReleasedChunks() const
    {
        return newlyReleasedChunks_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<TimeStamp> oldestDoneTimeStamp_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<ProfileBufferChunkMetadata>> newlyReleasedChunks_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> unreleasedBytes_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> releasedBytes_;
};
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::ProfileBufferChunkManagerUpdate>
{
    typedef ::mozilla::ProfileBufferChunkManagerUpdate 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 GatherProfileProgress|
//
namespace mozilla {
class GatherProfileProgress final
{
private:
    typedef ::uint32_t uint32_t;
    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
    GatherProfileProgress() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GatherProfileProgress(
            const uint32_t& _progressProportionValueUnderlyingType,
            const nsCString& _progressLocation) :
        progressLocation_(_progressLocation),
        progressProportionValueUnderlyingType_(_progressProportionValueUnderlyingType)
    {
    }

    MOZ_IMPLICIT GatherProfileProgress(
            uint32_t&& _progressProportionValueUnderlyingType,
            nsCString&& _progressLocation) :
        progressLocation_(std::move(_progressLocation)),
        progressProportionValueUnderlyingType_(std::move(_progressProportionValueUnderlyingType))
    {
    }

    uint32_t&
    progressProportionValueUnderlyingType()
    {
        return progressProportionValueUnderlyingType_;
    }
    const uint32_t&
    progressProportionValueUnderlyingType() const
    {
        return progressProportionValueUnderlyingType_;
    }

    nsCString&
    progressLocation()
    {
        return progressLocation_;
    }
    const nsCString&
    progressLocation() const
    {
        return progressLocation_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> progressLocation_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> progressProportionValueUnderlyingType_;
};
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::GatherProfileProgress>
{
    typedef ::mozilla::GatherProfileProgress 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 IPCProfileAndAdditionalInformation|
//
namespace mozilla {
class IPCProfileAndAdditionalInformation final
{
private:
    typedef ::mozilla::ipc::Shmem Shmem;
    typedef ::mozilla::ProfileGenerationAdditionalInformation ProfileGenerationAdditionalInformation;

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

    MOZ_IMPLICIT IPCProfileAndAdditionalInformation(
            Shmem& _profileShmem,
            mozilla::Maybe<ProfileGenerationAdditionalInformation>&& _additionalInformation) :
        profileShmem_(_profileShmem),
        additionalInformation_(std::move(_additionalInformation))
    {
    }

    MOZ_IMPLICIT IPCProfileAndAdditionalInformation(
            Shmem&& _profileShmem,
            mozilla::Maybe<ProfileGenerationAdditionalInformation>&& _additionalInformation) :
        profileShmem_(std::move(_profileShmem)),
        additionalInformation_(std::move(_additionalInformation))
    {
    }

    Shmem&
    profileShmem()
    {
        return profileShmem_;
    }
    Shmem&
    profileShmem() const
    {
        return const_cast<Shmem&>(profileShmem_);
    }

    mozilla::Maybe<ProfileGenerationAdditionalInformation>&
    additionalInformation()
    {
        return additionalInformation_;
    }
    const mozilla::Maybe<ProfileGenerationAdditionalInformation>&
    additionalInformation() const
    {
        return additionalInformation_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<Shmem> profileShmem_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<ProfileGenerationAdditionalInformation>> additionalInformation_;
};
} // namespace mozilla

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

#endif // ifndef ProfilerTypes_h
