AuctionHouseWorkerThread Class Reference

#include "AuctionHouseSearcher.h"

Public Member Functions
	AuctionHouseWorkerThread (ProducerConsumerQueue< AuctionSearcherRequest * > *requestQueue, MPSCQueue< AuctionSearcherResponse > *responseQueue)
void	Stop ()
void	AddAuctionSearchUpdateToQueue (std::shared_ptr< AuctionSearcherUpdate > const auctionSearchUpdate)

Private Member Functions
void	Run ()
void	ProcessSearchUpdates ()
void	SearchUpdateAdd (AuctionSearchAdd const &auctionAdd)
void	SearchUpdateRemove (AuctionSearchRemove const &auctionRemove)
void	SearchUpdateBid (AuctionSearchUpdateBid const &auctionUpdateBid)
void	ProcessSearchRequests ()
void	SearchListRequest (AuctionSearchListRequest const &searchListRequest)
void	SearchOwnerListRequest (AuctionSearchOwnerListRequest const &searchOwnerListRequest)
void	SearchBidderListRequest (AuctionSearchBidderListRequest const &searchBidderListRequest)
void	BuildListAuctionItems (AuctionSearchListRequest const &searchRequest, SortableAuctionEntriesList &auctionEntries, SearchableAuctionEntriesMap const &auctionMap) const
SearchableAuctionEntriesMap &	GetSearchableAuctionMap (AuctionHouseFaction faction)

Private Attributes
SearchableAuctionEntriesMap	_searchableAuctionMap [MAX_AUCTION_HOUSE_FACTIONS]
LockedQueue< std::shared_ptr< AuctionSearcherUpdate > >	_auctionUpdatesQueue
ProducerConsumerQueue< AuctionSearcherRequest * > *	_requestQueue
MPSCQueue< AuctionSearcherResponse > *	_responseQueue
std::thread	_workerThread
std::atomic< bool >	_stopped

Detailed Description

Constructor & Destructor Documentation

AuctionHouseWorkerThread()

AuctionHouseWorkerThread::AuctionHouseWorkerThread	(	ProducerConsumerQueue< AuctionSearcherRequest * > *	requestQueue,
		MPSCQueue< AuctionSearcherResponse > *	responseQueue
	)

{
    _workerThread = std::thread(&AuctionHouseWorkerThread::Run, this);
    _requestQueue = requestQueue;
    _responseQueue = responseQueue;
    _stopped = false;
}

References _requestQueue, _responseQueue, _stopped, _workerThread, and Run().

Member Function Documentation

AddAuctionSearchUpdateToQueue()

void AuctionHouseWorkerThread::AddAuctionSearchUpdateToQueue

(

std::shared_ptr< AuctionSearcherUpdate > const

auctionSearchUpdate

)

{
    _auctionUpdatesQueue.add(auctionSearchUpdate);
}

References _auctionUpdatesQueue, and LockedQueue< T, StorageType >::add().

BuildListAuctionItems()

void AuctionHouseWorkerThread::BuildListAuctionItems ( AuctionSearchListRequest const &  searchRequest, SortableAuctionEntriesList &  auctionEntries, SearchableAuctionEntriesMap const &  auctionMap  ) const

private

{
    // pussywizard: optimization, this is a simplified case for the default search state (no filters)
    if (searchRequest.searchInfo.itemClass == 0xffffffff && searchRequest.searchInfo.itemSubClass == 0xffffffff
        && searchRequest.searchInfo.inventoryType == 0xffffffff && searchRequest.searchInfo.quality == 0xffffffff
        && searchRequest.searchInfo.levelmin == 0x00 && searchRequest.searchInfo.levelmax == 0x00
        && searchRequest.searchInfo.usable == 0x00 && searchRequest.searchInfo.wsearchedname.empty())
    {
        for (auto const& pair : auctionMap)
            auctionEntries.push_back(pair.second.get());
 
        return;
    }
 
    for (auto const& pair : auctionMap)
    {
        std::shared_ptr<SearchableAuctionEntry> const& Aentry = pair.second;
        SearchableAuctionEntryItem const& Aitem = Aentry->item;
        ItemTemplate const* proto = Aitem.itemTemplate;
 
        if (searchRequest.searchInfo.itemClass != 0xffffffff && proto->Class != searchRequest.searchInfo.itemClass)
            continue;
 
        if (searchRequest.searchInfo.itemSubClass != 0xffffffff && proto->SubClass != searchRequest.searchInfo.itemSubClass)
            continue;
 
        if (searchRequest.searchInfo.inventoryType != 0xffffffff && proto->InventoryType != searchRequest.searchInfo.inventoryType)
        {
            // xinef: exception, robes are counted as chests
            if (searchRequest.searchInfo.inventoryType != INVTYPE_CHEST || proto->InventoryType != INVTYPE_ROBE)
                continue;
        }
 
        if (searchRequest.searchInfo.quality != 0xffffffff && proto->Quality < searchRequest.searchInfo.quality)
            continue;
 
        if (searchRequest.searchInfo.levelmin != 0x00 && (proto->RequiredLevel < searchRequest.searchInfo.levelmin
            || (searchRequest.searchInfo.levelmax != 0x00 && proto->RequiredLevel > searchRequest.searchInfo.levelmax)))
        {
            continue;
        }
 
        if (searchRequest.searchInfo.usable != 0x00)
        {
            if (!searchRequest.playerInfo.usablePlayerInfo.value().PlayerCanUseItem(proto))
                continue;
        }
 
        // Allow search by suffix (ie: of the Monkey) or partial name (ie: Monkey)
        // No need to do any of this if no search term was entered
        if (!searchRequest.searchInfo.wsearchedname.empty())
        {
            if (Aitem.itemName[searchRequest.playerInfo.loc_idx].find(searchRequest.searchInfo.wsearchedname) == std::wstring::npos)
                continue;
        }
 
        auctionEntries.push_back(Aentry.get());
    }
}

References ItemTemplate::Class, AuctionHouseSearchInfo::inventoryType, ItemTemplate::InventoryType, INVTYPE_CHEST, INVTYPE_ROBE, AuctionHouseSearchInfo::itemClass, SearchableAuctionEntryItem::itemName, AuctionHouseSearchInfo::itemSubClass, SearchableAuctionEntryItem::itemTemplate, AuctionHouseSearchInfo::levelmax, AuctionHouseSearchInfo::levelmin, AuctionHousePlayerInfo::loc_idx, AuctionSearchListRequest::playerInfo, AuctionHouseSearchInfo::quality, ItemTemplate::Quality, ItemTemplate::RequiredLevel, AuctionSearchListRequest::searchInfo, ItemTemplate::SubClass, AuctionHouseSearchInfo::usable, AuctionHousePlayerInfo::usablePlayerInfo, and AuctionHouseSearchInfo::wsearchedname.

Referenced by SearchListRequest().

GetSearchableAuctionMap()

SearchableAuctionEntriesMap & AuctionHouseWorkerThread::GetSearchableAuctionMap ( AuctionHouseFaction  faction )

inlineprivate

{ return _searchableAuctionMap[static_cast<uint8>(faction)]; };

References _searchableAuctionMap.

Referenced by SearchBidderListRequest(), SearchListRequest(), SearchOwnerListRequest(), SearchUpdateAdd(), SearchUpdateBid(), and SearchUpdateRemove().

ProcessSearchRequests()

void AuctionHouseWorkerThread::ProcessSearchRequests ( )

private

{
    AuctionSearcherRequest* searchRequest;
    while (_requestQueue->Pop(searchRequest))
    {
        switch (searchRequest->requestType)
        {
        case AuctionSearcherRequest::Type::LIST:
        {
            AuctionSearchListRequest const* searchListRequest = static_cast<AuctionSearchListRequest*>(searchRequest);
            SearchListRequest(*searchListRequest);
            break;
        }
        case AuctionSearcherRequest::Type::OWNER_LIST:
        {
            AuctionSearchOwnerListRequest const* searchOwnerListRequest = static_cast<AuctionSearchOwnerListRequest*>(searchRequest);
            SearchOwnerListRequest(*searchOwnerListRequest);
            break;
        }
        case AuctionSearcherRequest::Type::BIDDER_LIST:
        {
            AuctionSearchBidderListRequest const* searchBidderListRequest = static_cast<AuctionSearchBidderListRequest*>(searchRequest);
            SearchBidderListRequest(*searchBidderListRequest);
            break;
        }
        default:
            break;
        }
 
        delete searchRequest;
    }
}

References _requestQueue, AuctionSearcherRequest::BIDDER_LIST, AuctionSearcherRequest::LIST, AuctionSearcherRequest::OWNER_LIST, ProducerConsumerQueue< T >::Pop(), AuctionSearcherRequest::requestType, SearchBidderListRequest(), SearchListRequest(), and SearchOwnerListRequest().

Referenced by Run().

ProcessSearchUpdates()

void AuctionHouseWorkerThread::ProcessSearchUpdates ( )

private

{
    std::shared_ptr<AuctionSearcherUpdate> auctionSearchUpdate;
    while (_auctionUpdatesQueue.next(auctionSearchUpdate))
    {
        switch (auctionSearchUpdate->updateType)
        {
        case AuctionSearcherUpdate::Type::ADD:
        {
            std::shared_ptr<AuctionSearchAdd> const auctionAdd = std::static_pointer_cast<AuctionSearchAdd>(auctionSearchUpdate);
            SearchUpdateAdd(*auctionAdd.get());
            break;
        }
        case AuctionSearcherUpdate::Type::REMOVE:
        {
            std::shared_ptr<AuctionSearchRemove> const auctionRemove = std::static_pointer_cast<AuctionSearchRemove>(auctionSearchUpdate);
            SearchUpdateRemove(*auctionRemove.get());
            break;
        }
        case AuctionSearcherUpdate::Type::UPDATE_BID:
        {
            std::shared_ptr<AuctionSearchUpdateBid> const auctionUpdateBid = std::static_pointer_cast<AuctionSearchUpdateBid>(auctionSearchUpdate);
            SearchUpdateBid(*auctionUpdateBid.get());
            break;
        }
        default:
            break;
        }
    }
}

References _auctionUpdatesQueue, AuctionSearcherUpdate::ADD, LockedQueue< T, StorageType >::next(), AuctionSearcherUpdate::REMOVE, SearchUpdateAdd(), SearchUpdateBid(), SearchUpdateRemove(), and AuctionSearcherUpdate::UPDATE_BID.

Referenced by Run().

Run()

void AuctionHouseWorkerThread::Run ( )

private

{
    while (!_stopped)
    {
        std::this_thread::sleep_for(Milliseconds(25));
 
        ProcessSearchUpdates();
        ProcessSearchRequests();
    }
}

References _stopped, ProcessSearchRequests(), and ProcessSearchUpdates().

Referenced by AuctionHouseWorkerThread().

SearchBidderListRequest()

void AuctionHouseWorkerThread::SearchBidderListRequest ( AuctionSearchBidderListRequest const &  searchBidderListRequest )

private

{
    SearchableAuctionEntriesMap const& searchableAuctionMap = GetSearchableAuctionMap(searchBidderListRequest.listFaction);
 
    AuctionSearcherResponse* searchResponse = new AuctionSearcherResponse();
    searchResponse->playerGuid = searchBidderListRequest.ownerGuid;
    searchResponse->packet.Initialize(SMSG_AUCTION_BIDDER_LIST_RESULT, (4 + 4 + 4));
    searchResponse->packet << (uint32)0;                                     //add 0 as count
 
    uint32 count = 0;
    uint32 totalcount = 0;
 
    for (uint32 const auctionId : searchBidderListRequest.outbiddedAuctionIds)
    {
        SearchableAuctionEntriesMap::const_iterator itr = searchableAuctionMap.find(auctionId);
        if (itr == searchableAuctionMap.end())
            continue;
 
        std::shared_ptr<SearchableAuctionEntry> const& auctionEntry = itr->second;
        auctionEntry->BuildAuctionInfo(searchResponse->packet);
        ++count;
        ++totalcount;
    }
 
    for (auto const& pair : searchableAuctionMap)
    {
        if (pair.second->bidderGuid != searchBidderListRequest.ownerGuid)
            continue;
 
        std::shared_ptr<SearchableAuctionEntry> const& auctionEntry = pair.second;
        auctionEntry->BuildAuctionInfo(searchResponse->packet);
        ++count;
        ++totalcount;
    }
 
    searchResponse->packet.put<uint32>(0, count);                           // add count to placeholder
    searchResponse->packet << totalcount;
    searchResponse->packet << uint32(AUCTION_SEARCH_DELAY);
 
    _responseQueue->Enqueue(searchResponse);
}

References _responseQueue, AUCTION_SEARCH_DELAY, GetSearchableAuctionMap(), WorldPacket::Initialize(), AuctionSearcherRequest::listFaction, AuctionSearchBidderListRequest::outbiddedAuctionIds, AuctionSearchBidderListRequest::ownerGuid, AuctionSearcherResponse::packet, AuctionSearcherResponse::playerGuid, ByteBuffer::put(), and SMSG_AUCTION_BIDDER_LIST_RESULT.

Referenced by ProcessSearchRequests().

SearchListRequest()

void AuctionHouseWorkerThread::SearchListRequest ( AuctionSearchListRequest const &  searchListRequest )

private

{
    SearchableAuctionEntriesMap const& searchableAuctionMap = GetSearchableAuctionMap(searchListRequest.listFaction);
    uint32 count = 0, totalCount = 0;
 
    AuctionSearcherResponse* searchResponse = new AuctionSearcherResponse();
    searchResponse->playerGuid = searchListRequest.playerInfo.playerGuid;
    searchResponse->packet.Initialize(SMSG_AUCTION_LIST_RESULT, (4 + 4 + 4));
    searchResponse->packet << (uint32)0;
 
    if (!searchListRequest.searchInfo.getAll)
    {
        SortableAuctionEntriesList auctionEntries;
        BuildListAuctionItems(searchListRequest, auctionEntries, searchableAuctionMap);
 
        if (!searchListRequest.searchInfo.sorting.empty() && auctionEntries.size() > MAX_AUCTIONS_PER_PAGE)
        {
            AuctionSorter sorter(&searchListRequest.searchInfo.sorting, searchListRequest.playerInfo.loc_idx);
            std::sort(auctionEntries.begin(), auctionEntries.end(), sorter);
        }
 
        SortableAuctionEntriesList::const_iterator itr = auctionEntries.begin();
        if (searchListRequest.searchInfo.listfrom)
        {
            if (searchListRequest.searchInfo.listfrom > auctionEntries.size())
                itr = auctionEntries.end();
            else
                itr += searchListRequest.searchInfo.listfrom;
        }
 
        for (; itr != auctionEntries.end(); ++itr)
        {
            (*itr)->BuildAuctionInfo(searchResponse->packet);
 
            if (++count >= MAX_AUCTIONS_PER_PAGE)
                break;
        }
 
        totalCount = auctionEntries.size();
    }
    else
    {
        // getAll handling
        for (auto const& pair : searchableAuctionMap)
        {
            std::shared_ptr<SearchableAuctionEntry> const& Aentry = pair.second;
            ++count;
            Aentry->BuildAuctionInfo(searchResponse->packet);
 
            if (count >= MAX_GETALL_RETURN)
                break;
        }
 
        totalCount = searchableAuctionMap.size();
    }
 
    searchResponse->packet.put<uint32>(0, count);
    searchResponse->packet << totalCount;
    searchResponse->packet << uint32(AUCTION_SEARCH_DELAY);
 
    _responseQueue->Enqueue(searchResponse);
}

References _responseQueue, AUCTION_SEARCH_DELAY, BuildListAuctionItems(), AuctionHouseSearchInfo::getAll, GetSearchableAuctionMap(), WorldPacket::Initialize(), AuctionSearcherRequest::listFaction, AuctionHouseSearchInfo::listfrom, AuctionHousePlayerInfo::loc_idx, MAX_AUCTIONS_PER_PAGE, MAX_GETALL_RETURN, AuctionSearcherResponse::packet, AuctionHousePlayerInfo::playerGuid, AuctionSearcherResponse::playerGuid, AuctionSearchListRequest::playerInfo, ByteBuffer::put(), AuctionSearchListRequest::searchInfo, SMSG_AUCTION_LIST_RESULT, and AuctionHouseSearchInfo::sorting.

Referenced by ProcessSearchRequests().

SearchOwnerListRequest()

void AuctionHouseWorkerThread::SearchOwnerListRequest ( AuctionSearchOwnerListRequest const &  searchOwnerListRequest )

private

{
    SearchableAuctionEntriesMap const& searchableAuctionMap = GetSearchableAuctionMap(searchOwnerListRequest.listFaction);
 
    AuctionSearcherResponse* searchResponse = new AuctionSearcherResponse();
    searchResponse->playerGuid = searchOwnerListRequest.ownerGuid;
    searchResponse->packet.Initialize(SMSG_AUCTION_OWNER_LIST_RESULT, (4 + 4 + 4));
    searchResponse->packet << (uint32)0;                                     // amount place holder
 
    uint32 count = 0;
    uint32 totalcount = 0;
 
    for (auto const& pair : searchableAuctionMap)
    {
        if (pair.second->ownerGuid != searchOwnerListRequest.ownerGuid)
            continue;
 
        std::shared_ptr<SearchableAuctionEntry> const& auctionEntry = pair.second;
        auctionEntry->BuildAuctionInfo(searchResponse->packet);
        ++count;
        ++totalcount;
    }
 
    searchResponse->packet.put<uint32>(0, count);
    searchResponse->packet << (uint32)totalcount;
    searchResponse->packet << uint32(AUCTION_SEARCH_DELAY);
 
    _responseQueue->Enqueue(searchResponse);
}

References _responseQueue, AUCTION_SEARCH_DELAY, GetSearchableAuctionMap(), WorldPacket::Initialize(), AuctionSearcherRequest::listFaction, AuctionSearchOwnerListRequest::ownerGuid, AuctionSearcherResponse::packet, AuctionSearcherResponse::playerGuid, ByteBuffer::put(), and SMSG_AUCTION_OWNER_LIST_RESULT.

Referenced by ProcessSearchRequests().

SearchUpdateAdd()

void AuctionHouseWorkerThread::SearchUpdateAdd ( AuctionSearchAdd const &  auctionAdd )

private

{
    SearchableAuctionEntriesMap& searchableAuctionMap = GetSearchableAuctionMap(auctionAdd.listFaction);
    searchableAuctionMap.insert(std::make_pair(auctionAdd.searchableAuctionEntry->Id, auctionAdd.searchableAuctionEntry));
}

References GetSearchableAuctionMap(), AuctionSearcherUpdate::listFaction, and AuctionSearchAdd::searchableAuctionEntry.

Referenced by ProcessSearchUpdates().

SearchUpdateBid()

void AuctionHouseWorkerThread::SearchUpdateBid ( AuctionSearchUpdateBid const &  auctionUpdateBid )

private

{
    SearchableAuctionEntriesMap const& searchableAuctionMap = GetSearchableAuctionMap(auctionUpdateBid.listFaction);
    SearchableAuctionEntriesMap::const_iterator itr = searchableAuctionMap.find(auctionUpdateBid.auctionId);
    if (itr != searchableAuctionMap.end())
    {
        itr->second->bid = auctionUpdateBid.bid;
        itr->second->bidderGuid = auctionUpdateBid.bidderGuid;
    }
}

References AuctionSearchUpdateBid::auctionId, AuctionSearchUpdateBid::bid, AuctionSearchUpdateBid::bidderGuid, GetSearchableAuctionMap(), and AuctionSearcherUpdate::listFaction.

Referenced by ProcessSearchUpdates().

SearchUpdateRemove()

void AuctionHouseWorkerThread::SearchUpdateRemove ( AuctionSearchRemove const &  auctionRemove )

private

{
    SearchableAuctionEntriesMap& searchableAuctionMap = GetSearchableAuctionMap(auctionRemove.listFaction);
    searchableAuctionMap.erase(auctionRemove.auctionId);
}

References AuctionSearchRemove::auctionId, GetSearchableAuctionMap(), and AuctionSearcherUpdate::listFaction.

Referenced by ProcessSearchUpdates().

Stop()

void AuctionHouseWorkerThread::Stop

(

)

{
    _stopped = true;
    _workerThread.join();
}

References _stopped, and _workerThread.

Member Data Documentation

_auctionUpdatesQueue

LockedQueue<std::shared_ptr<AuctionSearcherUpdate> > AuctionHouseWorkerThread::_auctionUpdatesQueue

private

Referenced by AddAuctionSearchUpdateToQueue(), and ProcessSearchUpdates().

_requestQueue

ProducerConsumerQueue<AuctionSearcherRequest*>* AuctionHouseWorkerThread::_requestQueue

private

Referenced by AuctionHouseWorkerThread(), and ProcessSearchRequests().

_responseQueue

MPSCQueue<AuctionSearcherResponse>* AuctionHouseWorkerThread::_responseQueue

private

Referenced by AuctionHouseWorkerThread(), SearchBidderListRequest(), SearchListRequest(), and SearchOwnerListRequest().

_searchableAuctionMap

SearchableAuctionEntriesMap AuctionHouseWorkerThread::_searchableAuctionMap[MAX_AUCTION_HOUSE_FACTIONS]

private

Referenced by GetSearchableAuctionMap().

_stopped

std::atomic<bool> AuctionHouseWorkerThread::_stopped

private

Referenced by AuctionHouseWorkerThread(), Run(), and Stop().

_workerThread

std::thread AuctionHouseWorkerThread::_workerThread

private

Referenced by AuctionHouseWorkerThread(), and Stop().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/AuctionHouse/AuctionHouseSearcher.h
• azerothcore-wotlk/src/server/game/AuctionHouse/AuctionHouseSearcher.cpp