QueryCallback Class Reference

#include "QueryCallback.h"

Classes
struct	QueryCallbackData

Public Member Functions
	QueryCallback (QueryResultFuture &&result)
	QueryCallback (PreparedQueryResultFuture &&result)
	QueryCallback (QueryCallback &&right) noexcept
QueryCallback &	operator= (QueryCallback &&right) noexcept
	~QueryCallback ()
QueryCallback &&	WithCallback (std::function< void(QueryResult)> &&callback)
QueryCallback &&	WithPreparedCallback (std::function< void(PreparedQueryResult)> &&callback)
QueryCallback &&	WithChainingCallback (std::function< void(QueryCallback &, QueryResult)> &&callback)
QueryCallback &&	WithChainingPreparedCallback (std::function< void(QueryCallback &, PreparedQueryResult)> &&callback)
void	SetNextQuery (QueryCallback &&next)
bool	InvokeIfReady ()

Private Member Functions
	QueryCallback (QueryCallback const &right)=delete
QueryCallback &	operator= (QueryCallback const &right)=delete

Private Attributes
union {
QueryResultFuture   _string
PreparedQueryResultFuture   _prepared
};
bool	_isPrepared
std::queue< QueryCallbackData, std::list< QueryCallbackData > >	_callbacks

Friends
template<typename T >
void	ConstructActiveMember (T *obj)
template<typename T >
void	DestroyActiveMember (T *obj)
template<typename T >
void	MoveFrom (T *to, T &&from)

Detailed Description

Constructor & Destructor Documentation

QueryCallback() [1/4]

QueryCallback::QueryCallback ( QueryResultFuture &&  result )

explicit

{
    _isPrepared = false;
    Construct(_string, std::move(result));
}

References _isPrepared, _string, and Construct().

QueryCallback() [2/4]

QueryCallback::QueryCallback ( PreparedQueryResultFuture &&  result )

explicit

{
    _isPrepared = true;
    Construct(_prepared, std::move(result));
}

References _isPrepared, _prepared, and Construct().

QueryCallback() [3/4]

QueryCallback::QueryCallback ( QueryCallback &&  right )

noexcept

{
    _isPrepared = right._isPrepared;
    ConstructActiveMember(this);
    MoveFrom(this, std::move(right));
    _callbacks = std::move(right._callbacks);
}

References _callbacks, _isPrepared, ConstructActiveMember(), and MoveFrom().

~QueryCallback()

QueryCallback::~QueryCallback

(

)

{
    DestroyActiveMember(this);
}

References DestroyActiveMember.

QueryCallback() [4/4]

QueryCallback::QueryCallback ( QueryCallback const &  right )

privatedelete

Member Function Documentation

InvokeIfReady()

bool QueryCallback::InvokeIfReady

(

)

{
    QueryCallbackData& callback = _callbacks.front();
    auto checkStateAndReturnCompletion = [this]()
    {
        _callbacks.pop();
        bool hasNext = !_isPrepared ? _string.valid() : _prepared.valid();
        if (_callbacks.empty())
        {
            ASSERT(!hasNext);
            return true;
        }
 
        // abort chain
        if (!hasNext)
            return true;
 
        ASSERT(_isPrepared == _callbacks.front()._isPrepared);
        return false;
    };
 
    if (!_isPrepared)
    {
        if (_string.valid() && _string.wait_for(0s) == std::future_status::ready)
        {
            QueryResultFuture f(std::move(_string));
            std::function<void(QueryCallback&, QueryResult)> cb(std::move(callback._string));
            cb(*this, f.get());
            return checkStateAndReturnCompletion();
        }
    }
    else
    {
        if (_prepared.valid() && _prepared.wait_for(0s) == std::future_status::ready)
        {
            PreparedQueryResultFuture f(std::move(_prepared));
            std::function<void(QueryCallback&, PreparedQueryResult)> cb(std::move(callback._prepared));
            cb(*this, f.get());
            return checkStateAndReturnCompletion();
        }
    }
 
    return false;
}

References _callbacks, _isPrepared, QueryCallback::QueryCallbackData::_prepared, _prepared, QueryCallback::QueryCallbackData::_string, _string, and ASSERT.

operator=() [1/2]

QueryCallback & QueryCallback::operator= ( QueryCallback &&  right )

noexcept

{
    if (this != &right)
    {
        if (_isPrepared != right._isPrepared)
        {
            DestroyActiveMember(this);
            _isPrepared = right._isPrepared;
            ConstructActiveMember(this);
        }
 
        MoveFrom(this, std::move(right));
        _callbacks = std::move(right._callbacks);
    }
 
    return *this;
}

References _callbacks, _isPrepared, ConstructActiveMember(), DestroyActiveMember(), and MoveFrom().

operator=() [2/2]

QueryCallback & QueryCallback::operator= ( QueryCallback const &  right )

privatedelete

SetNextQuery()

void QueryCallback::SetNextQuery

(

QueryCallback &&

next

)

{
    MoveFrom(this, std::move(next));
}

References MoveFrom.

Referenced by WorldSession::HandleCharCreateOpcode().

WithCallback()

QueryCallback && QueryCallback::WithCallback

(

std::function< void(QueryResult)> &&

callback

)

{
    return WithChainingCallback([callback](QueryCallback& /*this*/, QueryResult result) { callback(std::move(result)); });
}

References WithChainingCallback().

WithChainingCallback()

QueryCallback && QueryCallback::WithChainingCallback

(

std::function< void(QueryCallback &, QueryResult)> &&

callback

)

{
    ASSERT(!_callbacks.empty() || !_isPrepared, "Attempted to set callback function for string query on a prepared async query");
    _callbacks.emplace(std::move(callback));
    return std::move(*this);
}

References _callbacks, _isPrepared, and ASSERT.

Referenced by WithCallback().

WithChainingPreparedCallback()

QueryCallback && QueryCallback::WithChainingPreparedCallback

(

std::function< void(QueryCallback &, PreparedQueryResult)> &&

callback

)

{
    ASSERT(!_callbacks.empty() || _isPrepared, "Attempted to set callback function for prepared query on a string async query");
    _callbacks.emplace(std::move(callback));
    return std::move(*this);
}

References _callbacks, _isPrepared, and ASSERT.

Referenced by WithPreparedCallback().

WithPreparedCallback()

QueryCallback && QueryCallback::WithPreparedCallback

(

std::function< void(PreparedQueryResult)> &&

callback

)

{
    return WithChainingPreparedCallback([callback](QueryCallback& /*this*/, PreparedQueryResult result) { callback(std::move(result)); });
}

References WithChainingPreparedCallback().

Friends And Related Function Documentation

ConstructActiveMember

template<typename T >

void ConstructActiveMember ( T *  obj )

friend

{
    if (!obj->_isPrepared)
        Construct(obj->_string);
    else
        Construct(obj->_prepared);
}

DestroyActiveMember

template<typename T >

void DestroyActiveMember ( T *  obj )

friend

{
    if (!obj->_isPrepared)
        Destroy(obj->_string);
    else
        Destroy(obj->_prepared);
}

Referenced by ~QueryCallback().

MoveFrom

template<typename T >

void MoveFrom ( T *  to, T &&  from  )

friend

{
    ASSERT(to->_isPrepared == from._isPrepared);
 
    if (!to->_isPrepared)
        to->_string = std::move(from._string);
    else
        to->_prepared = std::move(from._prepared);
}

Referenced by SetNextQuery().

Member Data Documentation

union { ... } QueryCallback::@5

_callbacks

std::queue<QueryCallbackData, std::list<QueryCallbackData> > QueryCallback::_callbacks

private

Referenced by InvokeIfReady(), operator=(), QueryCallback(), WithChainingCallback(), and WithChainingPreparedCallback().

_isPrepared

bool QueryCallback::_isPrepared

private

Referenced by InvokeIfReady(), operator=(), QueryCallback(), WithChainingCallback(), and WithChainingPreparedCallback().

_prepared

PreparedQueryResultFuture QueryCallback::_prepared

Referenced by InvokeIfReady(), and QueryCallback().

_string

QueryResultFuture QueryCallback::_string

Referenced by InvokeIfReady(), and QueryCallback().