AuctionHouseSearcher Class Reference

#include "AuctionHouseSearcher.h"

Public Member Functions
	AuctionHouseSearcher ()
	~AuctionHouseSearcher ()
void	Update ()
void	QueueSearchRequest (AuctionSearcherRequest *searchRequestInfo)
void	AddAuction (AuctionEntry const *auctionEntry)
void	RemoveAuction (AuctionEntry const *auctionEntry)
void	UpdateBid (AuctionEntry const *auctionEntry)
void	NotifyAllWorkers (std::shared_ptr< AuctionSearcherUpdate > const auctionSearchUpdate)
void	NotifyOneWorker (std::shared_ptr< AuctionSearcherUpdate > const auctionSearchUpdate)

Private Attributes
ProducerConsumerQueue< AuctionSearcherRequest * >	_requestQueue
MPSCQueue< AuctionSearcherResponse >	_responseQueue
std::vector< std::unique_ptr< AuctionHouseWorkerThread > >	_workerThreads

Detailed Description

Constructor & Destructor Documentation

AuctionHouseSearcher()

AuctionHouseSearcher::AuctionHouseSearcher

(

)

{
    for (uint32 i = 0; i < sWorld->getIntConfig(CONFIG_AUCTIONHOUSE_WORKERTHREADS); ++i)
        _workerThreads.push_back(std::make_unique<AuctionHouseWorkerThread>(&_requestQueue, &_responseQueue));
}

References _requestQueue, _responseQueue, _workerThreads, CONFIG_AUCTIONHOUSE_WORKERTHREADS, and sWorld.

~AuctionHouseSearcher()

AuctionHouseSearcher::~AuctionHouseSearcher

(

)

{
    _requestQueue.Cancel();
    for (std::unique_ptr<AuctionHouseWorkerThread> const& workerThread : _workerThreads)
        workerThread->Stop();
}

References _requestQueue, _workerThreads, and ProducerConsumerQueue< T >::Cancel().

Member Function Documentation

AddAuction()

void AuctionHouseSearcher::AddAuction

(

AuctionEntry const *

auctionEntry

)

{
    Item* item = sAuctionMgr->GetAItem(auctionEntry->item_guid);
    if (!item)
        return;
 
    // SearchableAuctionEntry is a shared_ptr as it will be shared among all the worker threads and needs to be self-managed
    std::shared_ptr<SearchableAuctionEntry> searchableAuctionEntry = std::make_shared<SearchableAuctionEntry>();
    searchableAuctionEntry->Id = auctionEntry->Id;
 
    // Auction info
    searchableAuctionEntry->ownerGuid = auctionEntry->owner;
    sCharacterCache->GetCharacterNameByGuid(auctionEntry->owner, searchableAuctionEntry->ownerName);
    searchableAuctionEntry->startbid = auctionEntry->startbid;
    searchableAuctionEntry->buyout = auctionEntry->buyout;
    searchableAuctionEntry->expire_time = auctionEntry->expire_time;
    searchableAuctionEntry->listFaction = auctionEntry->GetFactionId();
    searchableAuctionEntry->bid = auctionEntry->bid;
    searchableAuctionEntry->bidderGuid = auctionEntry->bidder;
 
    // Item info
    searchableAuctionEntry->item.entry = item->GetEntry();
 
    for (uint8 i = 0; i < MAX_INSPECTED_ENCHANTMENT_SLOT; ++i)
    {
        searchableAuctionEntry->item.enchants[i].id = item->GetEnchantmentId(EnchantmentSlot(i));
        searchableAuctionEntry->item.enchants[i].duration = item->GetEnchantmentDuration(EnchantmentSlot(i));
        searchableAuctionEntry->item.enchants[i].charges = item->GetEnchantmentCharges(EnchantmentSlot(i));
    }
 
    searchableAuctionEntry->item.randomPropertyId = item->GetItemRandomPropertyId();
    searchableAuctionEntry->item.suffixFactor = item->GetItemSuffixFactor();
    searchableAuctionEntry->item.count = item->GetCount();
    searchableAuctionEntry->item.spellCharges = item->GetSpellCharges();
    searchableAuctionEntry->item.itemTemplate = item->GetTemplate();
 
    searchableAuctionEntry->SetItemNames();
 
    // Let the worker threads know we have a new auction
    NotifyAllWorkers(std::make_shared<AuctionSearchAdd>(searchableAuctionEntry));
}

References AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::buyout, AuctionEntry::expire_time, Item::GetCount(), Item::GetEnchantmentCharges(), Item::GetEnchantmentDuration(), Item::GetEnchantmentId(), Object::GetEntry(), AuctionEntry::GetFactionId(), Item::GetItemRandomPropertyId(), Item::GetItemSuffixFactor(), Item::GetSpellCharges(), Item::GetTemplate(), AuctionEntry::Id, AuctionEntry::item_guid, MAX_INSPECTED_ENCHANTMENT_SLOT, NotifyAllWorkers(), AuctionEntry::owner, sAuctionMgr, sCharacterCache, and AuctionEntry::startbid.

NotifyAllWorkers()

void AuctionHouseSearcher::NotifyAllWorkers

(

std::shared_ptr< AuctionSearcherUpdate > const

auctionSearchUpdate

)

{
    for (std::unique_ptr<AuctionHouseWorkerThread> const& workerThread : _workerThreads)
        workerThread->AddAuctionSearchUpdateToQueue(auctionSearchUpdate);
}

References _workerThreads.

Referenced by AddAuction(), and RemoveAuction().

NotifyOneWorker()

void AuctionHouseSearcher::NotifyOneWorker

(

std::shared_ptr< AuctionSearcherUpdate > const

auctionSearchUpdate

)

{
    // Just notify the first worker in the list, no big deal which
    (*_workerThreads.begin())->AddAuctionSearchUpdateToQueue(auctionSearchUpdate);
}

References _workerThreads.

Referenced by UpdateBid().

QueueSearchRequest()

void AuctionHouseSearcher::QueueSearchRequest

(

AuctionSearcherRequest *

searchRequestInfo

)

{
    _requestQueue.Push(searchRequestInfo);
}

References _requestQueue, and ProducerConsumerQueue< T >::Push().

RemoveAuction()

void AuctionHouseSearcher::RemoveAuction

(

AuctionEntry const *

auctionEntry

)

{
    NotifyAllWorkers(std::make_shared<AuctionSearchRemove>(auctionEntry->Id, auctionEntry->GetFactionId()));
}

References AuctionEntry::GetFactionId(), AuctionEntry::Id, and NotifyAllWorkers().

Update()

void AuctionHouseSearcher::Update

(

)

{
    AuctionSearcherResponse* response = nullptr;
    while (_responseQueue.Dequeue(response))
    {
        Player* player = ObjectAccessor::FindConnectedPlayer(response->playerGuid);
        if (player)
            player->SendDirectMessage(&response->packet);
 
        delete response;
    }
}

References _responseQueue, ObjectAccessor::FindConnectedPlayer(), AuctionSearcherResponse::packet, AuctionSearcherResponse::playerGuid, and Player::SendDirectMessage().

Referenced by AuctionHouseMgr::Update().

UpdateBid()

void AuctionHouseSearcher::UpdateBid

(

AuctionEntry const *

auctionEntry

)

{
    // Updating bids is a bit unique, we really only need to update a single worker as every worker thread contains
    // a map of shared pointers to the same SearchableAuctionEntry's, so updating one will update them all.
    NotifyOneWorker(std::make_shared<AuctionSearchUpdateBid>(auctionEntry->Id, auctionEntry->GetFactionId(), auctionEntry->bid, auctionEntry->bidder));
}

References AuctionEntry::bid, AuctionEntry::bidder, AuctionEntry::GetFactionId(), AuctionEntry::Id, and NotifyOneWorker().

Member Data Documentation

_requestQueue

ProducerConsumerQueue<AuctionSearcherRequest*> AuctionHouseSearcher::_requestQueue

private

Referenced by AuctionHouseSearcher(), QueueSearchRequest(), and ~AuctionHouseSearcher().

_responseQueue

MPSCQueue<AuctionSearcherResponse> AuctionHouseSearcher::_responseQueue

private

Referenced by AuctionHouseSearcher(), and Update().

_workerThreads

std::vector<std::unique_ptr<AuctionHouseWorkerThread> > AuctionHouseSearcher::_workerThreads

private

Referenced by AuctionHouseSearcher(), NotifyAllWorkers(), NotifyOneWorker(), and ~AuctionHouseSearcher().

---

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