/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     osl_EventFlag.h

  Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev: 12546 $
 *---------------------------------------------------------------------------*/

#ifndef NN_NET_OSL_OSL_EVENTFLAG_H_
#define NN_NET_OSL_OSL_EVENTFLAG_H_

//#define NN_NET_OSL_EVENTFLAG_IS_LIGHT

#include <nn/fnd/fnd_Interlocked.h>

#ifdef NN_NET_OSL_EVENTFLAG_IS_LIGHT
#include <nn/os/os_LightEvent.h>
#include <nn/os/os_Tick.h>
#include <nn/os/os_CriticalSection.h>
#else
#include <nn/os/os_Event.h>
#endif

typedef enum
{
    NN_NET_OSL_WAITMODE_AND,
    NN_NET_OSL_WAITMODE_OR
} nnnetOslWaitMode;

#ifdef __cplusplus

namespace nn{ namespace net{ namespace osl{

class EventFlag
{
#ifdef NN_NET_OSL_EVENTFLAG_IS_LIGHT
    typedef os::LightEvent  EventImpl;
#else
    typedef os::Event       EventImpl;
#endif

public:
    enum WaitMode
    {
        ModeAnd = NN_NET_OSL_WAITMODE_AND,
        ModeOr  = NN_NET_OSL_WAITMODE_OR
    };

    EventFlag()
    : m_flag(0)
    , m_indexForSleep(0)
    {
    }
    
    void Initialize(void);
    Result TryInitialize(void);

    void Signal(bit32 pattern);
    bit32 Wait(bit32 pattern, WaitMode mode, nn::fnd::TimeSpan timeout);
    inline bit32 Wait(bit32 pattern, WaitMode mode)
    {
        return Wait(pattern, mode, nn::fnd::TimeSpan::FromNanoSeconds(NN_OS_WAIT_INFINITE));
    }

    bit32 WaitAndClear(bit32 pattern, WaitMode mode, bit32 clear, nn::fnd::TimeSpan timeout);
    inline bit32 WaitAndClear(bit32 pattern, WaitMode mode, bit32 clear)
    {
        return WaitAndClear(pattern, mode, clear, nn::fnd::TimeSpan::FromNanoSeconds(NN_OS_WAIT_INFINITE));
    }

    void ClearSignal(bit32 pattern);
protected:
    void Notify();
    bool WaitEventWithTimeout(EventImpl& event, nn::fnd::TimeSpan& timeout);
    static void TimeoutHandler(EventFlag* pEventFlag, bool cancelled);

    static inline fnd::TimeSpan InfiniteTimeSpan()
    {
        return fnd::TimeSpan::FromNanoSeconds(-1);
    }

private:
    inline void AssertValid(void) const
    {
        NN_THIS_TASSERT_();
#ifndef NN_NET_OSL_EVENTFLAG_IS_LIGHT
        NN_TASSERT_(m_event[0].IsValid() && m_event[1].IsValid());
#endif
    }

    EventImpl                           m_event[2];
    nn::fnd::InterlockedVariable<bit32> m_flag;
    s32                                 m_indexForSleep;
};

}}} // namesapce nn::net::osl

#endif // __cplusplus

// 以下、C 用宣言

#include <nn/util/detail/util_CLibImpl.h>

#ifdef NN_NET_OSL_EVENTFLAG_IS_LIGHT
#define NN_NET_OSL_EVENTFLAG_SIZE                   16
#define NN_NET_OSL_EVENTFLAG_ALIGNMENT_HOLDER_TYPE  u32
#else
#define NN_NET_OSL_EVENTFLAG_SIZE                   16
#define NN_NET_OSL_EVENTFLAG_ALIGNMENT_HOLDER_TYPE  u32
#endif

NN_UTIL_DETAIL_CLIBIMPL_DEFINE_BUFFER_CLASS(nnnetOslEventFlag, nn::net::osl::EventFlag, NN_NET_OSL_EVENTFLAG_SIZE, NN_NET_OSL_EVENTFLAG_ALIGNMENT_HOLDER_TYPE);

NN_EXTERN_C void nnnetOslEventFlagInitialize(nnnetOslEventFlag* this_);
NN_EXTERN_C bool nnnetOslEventFlagTryInitialize(nnnetOslEventFlag* this_);
NN_EXTERN_C void nnnetOslEventFlagSignal(nnnetOslEventFlag* this_, bit32 pattern);
NN_EXTERN_C bit32 nnnetOslEventFlagWaitSignal(nnnetOslEventFlag* this_, bit32 pattern, nnnetOslWaitMode mode, s64 timeout);
NN_EXTERN_C void nnnetOslEventFlagClearSignal(nnnetOslEventFlag* this_, bit32 pattern);
NN_EXTERN_C bit32 nnnetOslEventFlagWaitAndClear(nnnetOslEventFlag* this_, bit32 pattern, nnnetOslWaitMode mode, bit32 clear, s64 timeout);
NN_EXTERN_C void nnnetOslEventFlagFinalize(nnnetOslEventFlag* this_);

#endif // NN_NET_OSL_OSL_EVENTFLAG_H_