timer.h

Go to the documentation of this file.

/********************************************************************************************
* Twitch Broadcasting SDK
*
* This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
* may not be copied or used except in accordance with the terms of that agreement
* Copyright (c) 2012-2016 Twitch Interactive, Inc.
*********************************************************************************************/

#pragma once

#include "twitchsdk/core/types/coretypes.h"

#include <vector>

namespace ttv
{
    class WaitForEventWithTimeout;
    class WaitForExpiry;
    class RetryBackoffTable;
    class RetryTimer;

    uint64_t JitterTime(uint64_t baseMs, uint64_t width);
}


class ttv::WaitForEventWithTimeout
{
public:
    enum eWaitState
    {
        WFEWT_Waiting,
        WFEWT_Complete,
        WFEWT_TimedOut,
    };

public:
    WaitForEventWithTimeout();

    void Reset(uint64_t timeout);
    void Complete();
    eWaitState GetState();

    bool IsTimedOut() { return GetState() == WFEWT_TimedOut; }
    bool IsComplete() { return GetState() == WFEWT_Complete; }

private:
    uint64_t mExpiryTime;
    eWaitState mState;
};


class ttv::WaitForExpiry
{
public:
    WaitForExpiry();

    void Set(uint64_t milliseconds);
    void SetWithJitter(uint64_t milliseconds, uint64_t jitterWidthMs);
    void AdjustDuration(uint64_t milliseconds);
    bool Check(bool clearWhenExpired);
    void Clear();
    bool IsSet() const { return mStartTime != 0; }
    
    uint64_t GetStartTime() const { return mStartTime; }
    uint64_t GetEndTime() const { return mEndTime; }
    uint64_t GetRemainingTime() const;
    uint64_t GetElapsedTime() const;

private:
    uint64_t mStartTime;
    uint64_t mEndTime;
};


class ttv::RetryBackoffTable
{
public:
    RetryBackoffTable();
    RetryBackoffTable(const std::vector<uint64_t>& tableMilliseconds, uint64_t retryJitterWidthMs);
    RetryBackoffTable(uint64_t maxInterval, uint64_t retryJitterWidthMs);

    void Advance();
    void Reset();
    uint64_t GetInterval() const;

private:
    void CreateTable(uint64_t maxInterval);

    std::vector<uint64_t> mBackOffTableMilliseconds;
    uint64_t mJitterMilliseconds;
    uint32_t mNextAttemptNumber;
};


class ttv::RetryTimer
{
public:
    RetryTimer();
    RetryTimer(const std::vector<uint64_t>& backOffTableMs, uint64_t retryJitterWidthMs);
    RetryTimer(uint64_t maxInterval, uint64_t retryJitterWidthMs);

    void SetBackoffTable(const std::vector<uint64_t>& backOffTableMs, uint64_t retryJitterWidthMs);
    void SetBackoffTable(uint64_t maxInterval, uint64_t retryJitterWidthMs);

    void ScheduleNextRetry();
    bool CheckNextRetry();
    void Clear();

    void StartGlobalReset(uint64_t milliseconds);
    bool CheckGlobalReset();
    void ClearGlobalReset();

    bool IsRetrySet() const { return mNextRetry.IsSet(); }
    bool IsGlobalSet() const { return mGlobalResetTimer.IsSet(); }

protected:
    uint64_t GetNextAttempt();

    WaitForExpiry mNextRetry;
    WaitForExpiry mGlobalResetTimer; 
    std::vector<uint64_t> mBackOffTable;
    uint64_t mRetryJitter;
    uint32_t mNextAttemptNumber;
};