#include "Inventory.h"

Collaboration diagram for Inventory:

Public Member Functions
	Inventory (InventoryItemRef iRef)

virtual	~Inventory () noexcept

void	Reset ()

void	Unload ()

void	AddItem (InventoryItemRef iRef)

void	RemoveItem (InventoryItemRef iRef)

void	DeleteContents ()

void	GetInventoryMap (std::map< uint32, InventoryItemRef > &invMap)

void	GetInventoryVec (std::vector< InventoryItemRef > &itemVec)

void	StackAll (EVEItemFlags flag, uint32 ownerID=0)

bool	IsEmpty ()

bool	LoadContents ()

bool	ValidateAddItem (EVEItemFlags flag, InventoryItemRef iRef) const

bool	ValidateIHubUpgrade (InventoryItemRef iRef) const

bool	HasAvailableSpace (EVEItemFlags flag, InventoryItemRef iRef) const

bool	ContentsLoaded () const

bool	ContainsItem (uint32 itemID) const

bool	ContainsTypeQty (uint16 typeID, uint32 qty=0) const

bool	ContainsTypeQtyByFlag (uint16 typeID, EVEItemFlags flag=flagNone, uint32 qty=0) const

bool	ContainsTypeByFlag (uint16 typeID, EVEItemFlags flag=flagNone) const

float	GetCapacity (EVEItemFlags flag) const

float	GetStoredVolume (EVEItemFlags flag, bool combined=true) const

float	GetCorpHangerCapyUsed () const

float	GetRemainingCapacity (EVEItemFlags flag) const

InventoryItemRef	GetByID (uint32 id) const

InventoryItemRef	GetByTypeFlag (uint32 typeID, EVEItemFlags flag) const

bool	IsEmptyByFlag (EVEItemFlags flag) const

bool	GetSingleItemByFlag (EVEItemFlags flag, InventoryItemRef &iRef) const

bool	GetTypesByFlag (EVEItemFlags flag, std::map< uint16, InventoryItemRef > &items)

uint32	GetItemsByFlag (EVEItemFlags flag, std::vector< InventoryItemRef > &items) const

uint32	GetItemsByFlagRange (EVEItemFlags low_flag, EVEItemFlags high_flag, std::vector< InventoryItemRef > &items) const

uint32	GetItemsByFlagSet (std::set< EVEItemFlags > flags, std::vector< InventoryItemRef > &items) const

InventoryItemRef	FindFirstByFlag (EVEItemFlags flag) const

InventoryItemRef	GetItemByTypeFlag (uint16 typeID, EVEItemFlags flag=flagNone)

CRowSet *	List (EVEItemFlags flag, uint32 ownerID=0) const

void	GetInvForOwner (uint32 ownerID, std::vector< InventoryItemRef > &items)

void	GetCargoList (std::multimap< uint8, InventoryItemRef > &cargoMap)

Protected Member Functions
bool	GetItems (OwnerData od, std::vector< uint32 > &into)

void	List (CRowSet *into, EVEItemFlags flag, uint32 ownerID=0) const

Protected Attributes
InventoryDB	m_db

InventoryItemRef	m_self

Private Member Functions
std::vector< InventoryItemRef >	SortVector (std::vector< InventoryItemRef > &itemVec)

Private Attributes
bool	mContentsLoaded

uint32	m_myID

std::map< EVEItemFlags, double >	m_itemsByFlag

std::map< uint32, InventoryItemRef >	mContents

std::multimap< uint8, InventoryItemRef >	m_contentsByFlag

Friends
class	InventoryItem

Detailed Description

Definition at line 37 of file Inventory.h.

Constructor & Destructor Documentation

Inventory::Inventory ( InventoryItemRef iRef )

Definition at line 49 of file Inventory.cpp.

References m_myID, m_self, and mContentsLoaded.

 {
     mContentsLoaded = false;
     m_self = iRef;
     m_myID = iRef->itemID();
 }

virtual Inventory::~Inventory ( )

inlinevirtualnoexcept

Definition at line 42 of file Inventory.h.

42 { /* do nothing here*/ }

Member Function Documentation

void Inventory::AddItem ( InventoryItemRef iRef )

Definition at line 203 of file Inventory.cpp.

References _log, flagSkill, flagStructureActive, RefPtr< X >::get(), EVEDB::invTypes::InfrastructureHub, IsCharacterID, m_contentsByFlag, m_myID, m_self, mContents, sDataMgr, and EVEDB::invCategories::Skill.

Referenced by InventoryItem::AddItem(), and LoadContents().

                                              {
     //segfault check
     if (iRef.get() == nullptr)
         return;
 
     std::map<uint32, InventoryItemRef>::iterator itr = mContents.find(iRef->itemID());
     std::pair <std::_Rb_tree_iterator <std::pair <const uint32, InventoryItemRef > >, bool > test;
     if (itr == mContents.end())
         test = mContents.emplace(iRef->itemID(), iRef);
 
     if (test.second) {
         _log(INV__TRACE, "Inventory::AddItem() - Updated %s(%u) to contain (%u) %s(%u) in %s.", \
                 m_self->name(), m_myID, iRef->quantity(), iRef->name(), iRef->itemID(), sDataMgr.GetFlagName(iRef->flag()));
     } else {
         _log(INV__TRACE, "Inventory::AddItem() - %s(%u) already contains %s(%u) in %s.", \
                 m_self->name(), m_myID, iRef->name(), iRef->itemID(), sDataMgr.GetFlagName(iRef->flag()));
     }
 
     // need to find and remove skill in training flag here for proper skill search
     if (IsCharacterID(m_myID)) {
         if (iRef->categoryID() == EVEDB::invCategories::Skill) {
             m_contentsByFlag.emplace(flagSkill, iRef);
         } else {
             m_contentsByFlag.emplace(iRef->flag(), iRef);
         }
     } else {
         m_contentsByFlag.emplace(iRef->flag(), iRef);
     }
 
     // Apply iHub upgrades
     if (m_self->typeID() == EVEDB::invTypes::InfrastructureHub) {
         _log(SOV__DEBUG, "Applying system upgrade %s to system %s...", iRef->name(), m_self->locationID());
 
         // For now, all we need to do is mark the upgrade active,
         // but in the future upgrades for military and resource harvesting
         // will need to be 'activated' here
         iRef->SetFlag(EVEItemFlags::flagStructureActive, true);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::ContainsItem ( uint32 itemID ) const

inline

Definition at line 63 of file Inventory.h.

References mContents.

63 { return mContents.find( itemID ) != mContents.end(); }

Inventory::mContents

std::map< uint32, InventoryItemRef > mContents

Definition: Inventory.h:114

itemID

typeID Spawn an NPC with the specified type text Search for items matching the specified query() type()() itemID() copy() materialLevel()() itemID(attributeID)-Retrieves attribute value." ) COMMAND( setattr

bool Inventory::ContainsTypeByFlag	(	uint16	typeID,
		EVEItemFlags	flag = `flagNone`
	)		const

Definition at line 561 of file Inventory.cpp.

References GetItemsByFlag().

 {
     std::vector<InventoryItemRef> itemVec;
     if (GetItemsByFlag(flag, itemVec) < 1)
         return false;
 
     for (auto cur : itemVec)
         if (cur->typeID() == typeID)
             return true;
 
     return false;
 }

Here is the call graph for this function:

bool Inventory::ContainsTypeQty	(	uint16	typeID,
		uint32	qty = `0`
	)		const

Definition at line 526 of file Inventory.cpp.

References mContents.

Referenced by StructureSE::SetAnchor().

 {
     uint32 count(0);
     for (auto cur : mContents) {
         if (cur.second->typeID() == typeID ) {
             if (cur.second->quantity() >= qty) {
                 return true;
             } else {
                 count += cur.second->quantity();
             }
         }
     }
 
     return (count >= qty);
 }

Here is the caller graph for this function:

bool Inventory::ContainsTypeQtyByFlag	(	uint16	typeID,
		EVEItemFlags	flag = `flagNone`,
		uint32	qty = `0`
	)		const

Definition at line 542 of file Inventory.cpp.

References GetItemsByFlag().

Referenced by ActiveModule::CanActivate(), and ActiveModule::DoCycle().

 {
     uint32 count(0);
     std::vector<InventoryItemRef> itemVec;
     if (GetItemsByFlag(flag, itemVec) < 1)
         return false;
 
     for (auto cur : itemVec) {
         if (cur->quantity() >= qty) {
             return true;
         } else {
             count += cur->quantity();
         }
     }
 
     return (count >= qty);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::ContentsLoaded ( ) const

inline

Definition at line 62 of file Inventory.h.

References mContentsLoaded.

Referenced by ShipItem::GetChargeState(), Character::GetCharInfo(), and ShipItem::GetShipState().

62 { return mContentsLoaded; }

Inventory::mContentsLoaded

bool mContentsLoaded

Definition: Inventory.h:107

Here is the caller graph for this function:

void Inventory::DeleteContents ( )

Definition at line 273 of file Inventory.cpp.

References m_contentsByFlag, mContents, and mContentsLoaded.

Referenced by StructureItem::Delete(), CargoContainer::Delete(), ShipItem::Delete(), WreckContainer::Delete(), and Character::Delete().

 {
     if (!mContentsLoaded)
         return;
     InventoryItemRef iRef(nullptr);
     std::map<uint32, InventoryItemRef>::iterator cur = mContents.begin();
     while (cur != mContents.end()) {
         iRef = cur->second;
         ++cur;
         iRef->Delete();
     }
 
     mContents.clear();
     m_contentsByFlag.clear();
     mContentsLoaded = false;
 }

Here is the caller graph for this function:

InventoryItemRef Inventory::FindFirstByFlag ( EVEItemFlags flag ) const

Definition at line 436 of file Inventory.cpp.

References mContents.

                                                                    {
     for (auto cur : mContents)
         if (cur.second->flag() == flag)
             return cur.second;
 
         return InventoryItemRef(nullptr);
 }

InventoryItemRef Inventory::GetByID ( uint32 id ) const

Definition at line 415 of file Inventory.cpp.

References mContents.

Referenced by SystemManager::GetContainerFromInventory(), StationItem::GetContainerFromInventory(), RepairService::GetDamageReports(), SystemManager::GetShipFromInventory(), StationItem::GetShipFromInventory(), and SystemManager::GetStationFromInventory().

                                                    {
     std::map<uint32, InventoryItemRef>::const_iterator res = mContents.find(id);
     if (res != mContents.end())
         return res->second;
 
     return InventoryItemRef(nullptr);
 }

Here is the caller graph for this function:

InventoryItemRef Inventory::GetByTypeFlag	(	uint32	typeID,
		EVEItemFlags	flag
	)		const

Definition at line 444 of file Inventory.cpp.

References m_contentsByFlag.

Referenced by Client::ContainsTypeQty(), ActiveModule::DoCycle(), Character::GetSkill(), InventoryItem::MergeTypesInCargo(), Client::RemoveMissionItem(), and ModuleManager::UnloadCharge().

                                                                                 {
     auto range = m_contentsByFlag.equal_range(flag);
     for ( auto itr = range.first; itr != range.second; ++itr )
         if (itr->second->typeID() == typeID)
             return itr->second;
 
     return InventoryItemRef(nullptr);
 }

Here is the caller graph for this function:

float Inventory::GetCapacity ( EVEItemFlags flag ) const

Todo:: finish these for POS

Definition at line 642 of file Inventory.cpp.

References _log, AttrAmmoCapacity, AttrAmmoHoldCapacity, AttrCapacity, AttrCommandCenterHoldCapacity, AttrCorporateHangarCapacity, AttrDroneCapacity, AttrFuelBayCapacity, AttrGasHoldCapacity, AttrHasCorporateHangars, AttrIndustrialShipHoldCapacity, AttrLargeShipHoldCapacity, AttrMediumShipHoldCapacity, AttrMineralHoldCapacity, AttrOreHoldCapacity, AttrPlanetaryCommoditiesHoldCapacity, AttrQuafeHoldCapacity, AttrSalvageHoldCapacity, AttrSecondaryCapacity, AttrShipHoldCapacity, AttrShipMaintenanceBayCapacity, AttrSmallShipHoldCapacity, flagAmmoHold, flagCargoHold, flagCommandCenterHold, flagCorpHangar2, flagCorpHangar3, flagCorpHangar4, flagCorpHangar5, flagCorpHangar6, flagCorpHangar7, flagCorpMarket, flagDroneBay, flagFuelBay, flagGasHold, flagHangar, flagHiSlot0, flagImpounded, flagIndustrialShipHold, flagLargeShipHold, flagMediumShipHold, flagMineralHold, flagNone, flagOffice, flagOreHold, flagPlanetaryCommoditiesHold, flagProperty, flagQuafeBay, flagSalvageHold, flagSecondaryStorage, flagShipHangar, flagShipHold, flagSmallShipHold, m_myID, m_self, maxHangarCapy, and sDataMgr.

Referenced by Command_cargo(), CargoContainer::GetCapacity(), WreckContainer::GetCapacity(), GetRemainingCapacity(), and ValidateAddItem().

                                                     {
     // added hangar capy for all hangar types
     // are we missing any hangar types here?  POS types?  yes...see next line
     //   IsFlagCapacityLocationWide   item.groupID in (const.groupCorporateHangarArray, const.groupAssemblyArray, const.groupMobileLaboratory):
 
     switch( flag ) {
         case flagOffice:
         case flagProperty:
         //case flagDelivery:
         case flagImpounded:
         case flagCorpMarket:                    return maxHangarCapy;
         case flagNone:
         case flagCargoHold:                     return m_self->GetAttribute(AttrCapacity).get_float();
         case flagDroneBay:                      return m_self->GetAttribute(AttrDroneCapacity).get_float();
         case flagShipHangar:                    return m_self->GetAttribute(AttrShipMaintenanceBayCapacity).get_float();
         case flagSecondaryStorage:              return m_self->GetAttribute(AttrSecondaryCapacity).get_float();
         case flagFuelBay:                       return m_self->GetAttribute(AttrFuelBayCapacity).get_float();
         case flagOreHold:                       return m_self->GetAttribute(AttrOreHoldCapacity).get_float();
         case flagGasHold:                       return m_self->GetAttribute(AttrGasHoldCapacity).get_float();
         case flagAmmoHold:                      return m_self->GetAttribute(AttrAmmoHoldCapacity).get_float();
         case flagShipHold:                      return m_self->GetAttribute(AttrShipHoldCapacity).get_float();
         case flagMineralHold:                   return m_self->GetAttribute(AttrMineralHoldCapacity).get_float();
         case flagSalvageHold:                   return m_self->GetAttribute(AttrSalvageHoldCapacity).get_float();
         case flagSmallShipHold:                 return m_self->GetAttribute(AttrSmallShipHoldCapacity).get_float();
         case flagMediumShipHold:                return m_self->GetAttribute(AttrMediumShipHoldCapacity).get_float();
         case flagLargeShipHold:                 return m_self->GetAttribute(AttrLargeShipHoldCapacity).get_float();
         case flagIndustrialShipHold:            return m_self->GetAttribute(AttrIndustrialShipHoldCapacity).get_float();
         // for PI
         case flagCommandCenterHold:             return m_self->GetAttribute(AttrCommandCenterHoldCapacity).get_float();
         case flagPlanetaryCommoditiesHold:      return m_self->GetAttribute(AttrPlanetaryCommoditiesHoldCapacity).get_float();
         // for pos battery/array
         case flagHiSlot0:                       return m_self->GetAttribute(AttrAmmoCapacity).get_float();
         // still not sure where/why this is used....
         case flagQuafeBay:                      return m_self->GetAttribute(AttrQuafeHoldCapacity).get_float();
         // these can be in station OR on ship....
         case flagCorpHangar2:
         case flagCorpHangar3:
         case flagCorpHangar4:
         case flagCorpHangar5:
         case flagCorpHangar6:
         case flagCorpHangar7: {
             if (sDataMgr.IsStation(m_myID))
                 return maxHangarCapy;
             //for ship, this is TOTAL capy for all corp hangars (they share capy)
             if (m_self->HasAttribute(AttrHasCorporateHangars))
                 return m_self->GetAttribute(AttrCorporateHangarCapacity).get_float();
         }
         case flagHangar: {
             if (sDataMgr.IsStation(m_myID))
                 return maxHangarCapy;
             if (m_self->HasAttribute(AttrHasCorporateHangars))
                 return m_self->GetAttribute(AttrCorporateHangarCapacity).get_float();
             //for cargo container, this is 27k5m3.
             return m_self->GetAttribute(AttrCapacity).get_float();
         }
     }
 
     _log(INV__WARNING, "Inventory::GetCapacity() - Unsupported flag %s(%u) called for %s(%u)", \
                 sDataMgr.GetFlagName(flag), flag, m_self->name(), m_myID);
     return 0.0f;
 }

Here is the caller graph for this function:

void Inventory::GetCargoList ( std::multimap< uint8, InventoryItemRef > & cargoMap )

Definition at line 332 of file Inventory.cpp.

References mContents.

Referenced by Command_cargo().

                                                                              {
     for (auto cur : mContents)
         cargoMap.emplace(cur.second->flag(), cur.second);
 }

Here is the caller graph for this function:

float Inventory::GetCorpHangerCapyUsed ( ) const

Definition at line 337 of file Inventory.cpp.

References AttrVolume, IsHangarFlag, and mContents.

Referenced by Command_cargo().

                                              {
     float totalVolume(0.0f);
     for (auto cur : mContents)
         if (IsHangarFlag(cur.second->flag()))
             totalVolume += cur.second->quantity() * cur.second->GetAttribute(AttrVolume).get_float();
     return totalVolume;
 }

Here is the caller graph for this function:

void Inventory::GetInventoryMap ( std::map< uint32, InventoryItemRef > & invMap )

Definition at line 453 of file Inventory.cpp.

References mContents.

Referenced by Command_inventory(), Command_shipinventory(), Command_skilllist(), Prospector::DropSalvage(), ShipItem::EmptyCargo(), ShipItem::GetModuleItemVec(), CustomsSE::Killed(), StructureSE::Killed(), ShipSE::Killed(), TradeService::TransferContainerContents(), and ShipItem::UpdateMass().

                                                                             {
     for (auto cur : mContents)
         invMap.emplace(cur.first, cur.second);
 }

Here is the caller graph for this function:

void Inventory::GetInventoryVec ( std::vector< InventoryItemRef > & itemVec )

Definition at line 345 of file Inventory.cpp.

References mContents, and SortVector().

Referenced by ModuleManager::Initialize().

                                                                     {
     std::vector<InventoryItemRef> itemVecTmp;
     itemVecTmp.clear();
     for (auto cur : mContents)
         itemVecTmp.push_back(cur.second);
     /* sorting method to put modules first, charges second, and cargo last
      *  this is needed to correctly fit modules BEFORE trying to load charges
      */
     itemVec = SortVector(itemVecTmp);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Inventory::GetInvForOwner	(	uint32	ownerID,
		std::vector< InventoryItemRef > &	items
	)

Definition at line 425 of file Inventory.cpp.

References _log, IsOfficeID, m_myID, m_self, mContents, sDataMgr, and EvE::traceStack().

Referenced by StationItem::HasShip().

 {
     if (!IsOfficeID(m_myID) and !sDataMgr.IsStation(m_myID)) {
         _log(INV__ERROR, "GetInvForOwner called on non-station item %s(%u)", m_self->name(), m_myID);
         EvE::traceStack();
     }
     for (auto cur : mContents)
         if (cur.second->ownerID() == ownerID)
             items.push_back(cur.second);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

InventoryItemRef Inventory::GetItemByTypeFlag	(	uint16	typeID,
		EVEItemFlags	flag = `flagNone`
	)

Definition at line 476 of file Inventory.cpp.

References GetItemsByFlag(), and items.

 {
     std::vector<InventoryItemRef> items;
     if (GetItemsByFlag(flag, items) < 1)
         return InventoryItemRef(nullptr);
 
     for (auto cur : items)
         if (cur->typeID() == typeID )
             return cur;
 
     return InventoryItemRef(nullptr);
 }

Here is the call graph for this function:

bool Inventory::GetItems	(	OwnerData	od,
		std::vector< uint32 > &	into
	)

protected

Definition at line 109 of file Inventory.cpp.

References InventoryDB::GetItemContents(), and m_db.

Referenced by LoadContents().

                                                                  {
     return m_db.GetItemContents(od, into);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Inventory::GetItemsByFlag	(	EVEItemFlags	flag,
		std::vector< InventoryItemRef > &	items
	)		const

Definition at line 458 of file Inventory.cpp.

References m_contentsByFlag.

Referenced by Character::ClearSkillFlags(), ContainsTypeByFlag(), ContainsTypeQtyByFlag(), RamMethods::EncodeMissingMaterials(), RamMethods::GetBOMItems(), Character::GetCharInfo(), GetItemByTypeFlag(), Character::GetSkillsList(), Character::GetTotalSP(), Character::ProcessEffects(), Character::ResetModifiers(), and Character::VerifySP().

                                                                                             {
     auto range = m_contentsByFlag.equal_range(flag);
     for ( auto itr = range.first; itr != range.second; ++itr )
             items.push_back(itr->second);
     return items.size();
 }

Here is the caller graph for this function:

uint32 Inventory::GetItemsByFlagRange	(	EVEItemFlags	low_flag,
		EVEItemFlags	high_flag,
		std::vector< InventoryItemRef > &	items
	)		const

Definition at line 502 of file Inventory.cpp.

References mContents.

Referenced by ShipItem::GetShipInfo(), and ShipSE::MakeSlimItem().

 {
     // i dont yet see a better way to do this one...
     uint32 count = 0;
     for (auto cur : mContents)
         if (cur.second->flag() >= lowflag && cur.second->flag() <= highflag) {
             items.push_back(cur.second);
             ++count;
         }
     return count;
 }

Here is the caller graph for this function:

uint32 Inventory::GetItemsByFlagSet	(	std::set< EVEItemFlags >	flags,
		std::vector< InventoryItemRef > &	items
	)		const

Definition at line 514 of file Inventory.cpp.

References mContents.

 {
     // i dont yet see a better way to do this one...
     uint32 count = 0;
     for (auto cur : mContents)
         if (flags.find(cur.second->flag()) != flags.end()) {
             items.push_back(cur.second);
             ++count;
         }
     return count;
 }

float Inventory::GetRemainingCapacity ( EVEItemFlags flag ) const

inline

Definition at line 72 of file Inventory.h.

References GetCapacity(), and GetStoredVolume().

Referenced by ShipItem::GetRemainingVolumeByFlag(), HasAvailableSpace(), and ValidateAddItem().

72 { return GetCapacity( flag ) - GetStoredVolume( flag ); }

Inventory::GetCapacity

float GetCapacity(EVEItemFlags flag) const

Definition: Inventory.cpp:642

Inventory::GetStoredVolume

float GetStoredVolume(EVEItemFlags flag, bool combined=true) const

Definition: Inventory.cpp:609

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::GetSingleItemByFlag	(	EVEItemFlags	flag,
		InventoryItemRef &	iRef
	)		const

Definition at line 489 of file Inventory.cpp.

References m_contentsByFlag.

Referenced by ShipItem::GetShipState().

                                                                                    {
     auto range = m_contentsByFlag.equal_range(flag);
     for ( auto itr = range.first; itr != range.second; ++itr ) {
         iRef = itr->second;
         return true;
     }
     return false;
 }

Here is the caller graph for this function:

float Inventory::GetStoredVolume	(	EVEItemFlags	flag,
		bool	combined = `true`
	)		const

Definition at line 609 of file Inventory.cpp.

References AttrVolume, IsHangarFlag, m_contentsByFlag, and mContents.

Referenced by Command_cargo(), GetRemainingCapacity(), and ValidateAddItem().

 {
     float totalVolume(0.0f);
     if (IsHangarFlag(flag) and combined) {
         for (auto cur : mContents)
             if (IsHangarFlag(cur.second->flag()))
                 totalVolume += cur.second->quantity() * cur.second->GetAttribute(AttrVolume).get_float();
     } else {
         auto range = m_contentsByFlag.equal_range(flag);
         for ( auto itr = range.first; itr != range.second; ++itr )
             totalVolume += itr->second->quantity() * itr->second->GetAttribute(AttrVolume).get_float();
             // This formula is a hybrid of both old and new ones...and it works \o/
     }
     return totalVolume;
 }

Here is the caller graph for this function:

bool Inventory::GetTypesByFlag	(	EVEItemFlags	flag,
		std::map< uint16, InventoryItemRef > &	items
	)

Definition at line 465 of file Inventory.cpp.

References m_contentsByFlag.

Referenced by RamMethods::GetBOMItemsMap().

 {
     auto range = m_contentsByFlag.equal_range(flag);
     for ( auto itr = range.first; itr != range.second; ++itr )
         items.emplace(itr->second->typeID(), itr->second);
 
     if (items.size() > 0)
         return true;
     return false;
 }

Here is the caller graph for this function:

bool Inventory::HasAvailableSpace	(	EVEItemFlags	flag,
		InventoryItemRef	iRef
	)		const

Definition at line 625 of file Inventory.cpp.

References _log, AttrVolume, GetRemainingCapacity(), is_log_enabled, m_self, and sDataMgr.

Referenced by MiningLaser::ProcessCycle(), ModuleManager::UnloadCharge(), and StationOffice::ValidateAddItem().

                                                                                 {
 
     float capacity(GetRemainingCapacity(flag));
     float volume(iRef->quantity() * iRef->GetAttribute(AttrVolume).get_float());
 
     if (is_log_enabled(INV__CAPY))
         _log(INV__CAPY, "Inventory::HasAvailableSpace() - Testing %s's %s available capy of %.2f to add %u %s at %.2f (%.3f each)", \
                 m_self->name(), sDataMgr.GetFlagName(flag), capacity, iRef->quantity(), iRef->name(), \
                 volume, iRef->GetAttribute(AttrVolume).get_float());
 
     // check capy for all units
     if (volume > capacity)
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::IsEmpty ( )

inline

Definition at line 55 of file Inventory.h.

References mContents.

Referenced by Prospector::DropSalvage(), CargoContainer::IsEmpty(), WreckContainer::IsEmpty(), CargoContainer::RemoveItem(), and WreckContainer::RemoveItem().

55 { return mContents.empty(); }

Inventory::mContents

std::map< uint32, InventoryItemRef > mContents

Definition: Inventory.h:114

Here is the caller graph for this function:

bool Inventory::IsEmptyByFlag ( EVEItemFlags flag ) const

Todo:: update to use m_usedVolumeByFlag container?

Definition at line 498 of file Inventory.cpp.

References m_contentsByFlag.

                                                      {
     return (m_contentsByFlag.find(flag) == m_contentsByFlag.end());
 }

CRowSet * Inventory::List	(	EVEItemFlags	flag,
		uint32	ownerID = `0`
	)		const

Definition at line 290 of file Inventory.cpp.

References PyRep::Dump(), is_log_enabled, and sDataMgr.

 {
     DBRowDescriptor* header = sDataMgr.CreateHeader();
     CRowSet* rowset = new CRowSet(&header);
     List(rowset, flag, ownerID);
 
     if (is_log_enabled(INV__LIST))
         rowset->Dump(INV__LIST, "    ");
     return rowset;
 }

Here is the call graph for this function:

void Inventory::List	(	CRowSet *	into,
		EVEItemFlags	flag,
		uint32	ownerID = `0`
	)		const

protected

Definition at line 301 of file Inventory.cpp.

References EVEDB::invCategories::Charge, flagNone, IsCharacterID, IsFittingSlot, IsOfficeID, m_myID, m_self, mContents, CRowSet::NewRow(), sDataMgr, and EVEDB::invCategories::Ship.

                                                                            {
     //there has to be a better way to build this...
     PyPackedRow* row(nullptr);
     // office hangars list ALL items.  client separates by division flag
     if (IsOfficeID(m_myID) or IsCharacterID(m_myID)) {
         for (auto cur : mContents) {
             row = into->NewRow();
             cur.second->GetItemRow(row);
         }
     } else if (m_self->categoryID() == EVEDB::invCategories::Ship) {
         bool space = sDataMgr.IsSolarSystem(m_self->locationID());
         for (auto cur : mContents) {
             // this also fills module/charges in fit window when docked.
             //  charges not sent like this in space (uses subLocation sent via shipInfo())
             if (space and IsFittingSlot(cur.second->flag()))
                 if (cur.second->categoryID() == EVEDB::invCategories::Charge)
                     continue;
             row = into->NewRow();
             cur.second->GetItemRow(row);
         }
     } else {
         for (auto cur : mContents) {
             if (((ownerID == 0)        or (cur.second->ownerID() == ownerID))
             and ((flag == flagNone) or (cur.second->flag() == flag))) {
                 row = into->NewRow();
                 cur.second->GetItemRow(row);
             }
         }
     }
 }

Here is the call graph for this function:

bool Inventory::LoadContents ( )

Definition at line 113 of file Inventory.cpp.

References _log, AddItem(), Client::AddStationHangar(), OwnerData::corpID, RefPtr< X >::get(), GetItems(), GetTimeUSeconds(), IsAgent, IsOfficeID, IsPlayerCorp, Profile::itemload, items, itoa(), StationDB::LoadOffices(), OwnerData::locID, m_myID, m_self, mContentsLoaded, OwnerData::ownerID, sConfig, sDataMgr, sItemFactory, sProfiler, and RefPtr< StationItem >::StaticCast().

Referenced by StructureItem::_Load(), CargoContainer::_Load(), StationItem::_Load(), ShipItem::_Load(), WreckContainer::_Load(), Character::_Load(), DynamicEntityFactory::BuildEntity(), CargoContainer::CargoContainerGetInfo(), CargoContainer::Delete(), WreckContainer::Delete(), ShipItem::GetChargeState(), Character::GetCharInfo(), ShipItem::GetShipInfo(), ShipItem::GetShipState(), Client::LoadStationHangar(), Reset(), ShipItem::ShipGetModuleList(), StationOffice::StationOfficeGetInfo(), StructureItem::StructureGetInfo(), and WreckContainer::WreckContainerGetInfo().

                              {
     if (IsAgent(m_myID))
         return true;
     double profileStartTime(GetTimeUSeconds());
     /* rewrote logic, optimized, and fixed "empty inventory" for new chars in existing systems  -allan 22.2.16 */
     Client* pClient(sItemFactory.GetUsingClient());
 
     // test for character creation (which throws errors) and station loading
     if (pClient != nullptr) {
         if (pClient->IsCharCreation())
             return true;
         if (sDataMgr.IsStation(m_myID)) {
             if (pClient->IsHangarLoaded(m_myID))
                 return true;
             pClient->AddStationHangar(m_myID);
             mContentsLoaded = false;
         }
     }
 
     // check if the contents has already been loaded
     if (mContentsLoaded) {
         _log(INV__INFO, "Inventory::LoadContents() - inventory %u(%p) already loaded.", m_myID, this);
         return true;
     }
 
     OwnerData od = OwnerData();
         od.ownerID = 1;
         od.locID = m_myID;
 
     std::vector<uint32> items;
     if (pClient != nullptr) {
         if (pClient->IsValidSession())
             od.corpID = pClient->GetCorporationID();
         if (sDataMgr.IsStation(m_myID)) {
             if (!StationItemRef::StaticCast(m_self)->IsLoaded())
                 StationDB::LoadOffices(od, items);
             if (IsPlayerCorp(od.corpID)) {
                 /* this will load all non-NPC corp items in this station */
                 od.ownerID = od.corpID;
                 _log(INV__TRACE, "Inventory::LoadContents()::IsPlayerCorp() - Loading inventory %u(%p) with owner %u", m_myID, this , od.ownerID);
                 GetItems(od, items);
             }
         } else if (IsOfficeID(m_myID)) {
             if (IsPlayerCorp(od.corpID)) {
                 /* this will load corp hangars' inventory for this station */
                 od.ownerID = od.corpID;
                 _log(INV__TRACE, "Inventory::LoadContents() - Loading office inventory %u(%p) for corp %u in station %s",\
                             m_myID, this , od.ownerID, (pClient->IsValidSession() ? itoa(pClient->GetStationID()) : "(invalid)"));
                 GetItems(od, items);
             } else {
                 // make error for loading office and NOT a PC corp
                 _log(INV__WARNING, "Inventory::LoadContents() - inventory of officeID %u using corpID %u. Continuing...", m_myID, od.corpID);
             }
         }
         if (pClient->IsValidSession()) {
             od.ownerID = pClient->GetCharacterID();
         } else {
             od.ownerID = pClient->GetCharID();
         }
     }
 
     _log(INV__TRACE, "Inventory::LoadContents() - Loading inventory of %s(%u) with owner %u", m_self->name(), m_myID, od.ownerID);
     if (!GetItems(od, items)) {
         _log(INV__ERROR, "Inventory::LoadContents() - Failed to get inventory items for %s(%u)", m_self->name(), m_myID);
         if ((pClient != nullptr) and sDataMgr.IsStation(m_myID))
             pClient->RemoveStationHangar(m_myID);
         return false;
     }
 
     for (auto cur : items) {
         if ((cur == od.ownerID) or (cur == od.locID) or (cur == m_myID))
             continue;
         InventoryItemRef iRef = sItemFactory.GetItem(cur);
         if (iRef.get() == nullptr) {
             _log(INV__WARNING, "Inventory::LoadContents() - Failed to load item %u contained in %u. Skipping.", cur, m_myID);
             continue;
         } else {
             AddItem(iRef);
             Client* pClient(sItemFactory.GetUsingClient());
         }
     }
 
     if (sConfig.debug.UseProfiling)
         sProfiler.AddTime(Profile::itemload, GetTimeUSeconds() - profileStartTime);
 
     mContentsLoaded = true;
 
     return mContentsLoaded;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Inventory::RemoveItem ( InventoryItemRef iRef )

Todo:

Note: this isnt working right, and im not sure why yet...

Definition at line 243 of file Inventory.cpp.

References _log, RefPtr< X >::get(), m_contentsByFlag, m_myID, m_self, mContents, and sDataMgr.

Referenced by ProbeItem::Delete(), InventoryItem::Delete(), ShipItem::LogOut(), InventoryItem::RemoveItem(), ShipItem::SetPlayer(), and InventoryItem::ToVirtual().

                                                 {
     //segfault check
     if (iRef.get() == nullptr)
         return;
 
     std::map<uint32, InventoryItemRef>::iterator itr = mContents.find(iRef->itemID());
     if (itr != mContents.end()) {
         mContents.erase(itr);
         _log(INV__TRACE, "Inventory::RemoveItem(1) - Updated %s(%u) to no longer contain %s(%u) in %s.", \
                 m_self->name(), m_myID, iRef->name(), iRef->itemID(), sDataMgr.GetFlagName(iRef->flag()));
     } else {
         _log(INV__WARNING,"Inventory::RemoveItem(1) - %s(%u) contents does not contain %s(%u) in %s.", \
                 m_self->name(), m_myID, iRef->name(), iRef->itemID(), sDataMgr.GetFlagName(iRef->flag()));
     }
 
     auto range = m_contentsByFlag.equal_range(iRef->flag());
     for (auto cur = range.first; cur != range.second; ++cur) {
         if (cur->second == iRef) {
             m_contentsByFlag.erase(cur);
             _log(INV__TRACE, "Inventory::RemoveItem(2) - %s(%u) removed from %s(%u) flagMap at %s.", \
                     iRef->name(), iRef->itemID(), m_self->name(), m_myID, sDataMgr.GetFlagName(iRef->flag()));
             return;
         }
     }
 
     _log(INV__WARNING,"Inventory::RemoveItem(2) - %s(%u) flagMap does not contain %s(%u) in %s.", \
             m_self->name(), m_myID, iRef->name(), iRef->itemID(), sDataMgr.GetFlagName(iRef->flag()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Inventory::Reset ( )

Definition at line 56 of file Inventory.cpp.

References LoadContents(), and Unload().

 {
     Unload();
     LoadContents();
 }

Here is the call graph for this function:

std::vector< InventoryItemRef > Inventory::SortVector ( std::vector< InventoryItemRef > & itemVec )

private

Definition at line 356 of file Inventory.cpp.

References _log, GetTimeUSeconds(), IsCargoHoldFlag, IsModuleSlot, and sConfig.

Referenced by GetInventoryVec().

 {
     // my sort
     //15:53:09 [ItemTrace] Inventory::SortVector: 41 items sorted in 0.177us with 480 loops.  <<-- dunno when/where this was run
     //15:40:20 [ItemTrace] Inventory::SortVector() - 30 items sorted in 28.250us with 87 loops.i
     //22:09:28 [InvTrace] Inventory::SortVector() - 47 items sorted in 129.250us with 644 loops.
 
 
     // std::swap
     //12:57:36 [ItemTrace] Inventory::SortVector() - 21 items sorted in 16.000us with 60 loops.
     //13:00:55 [ItemTrace] Inventory::SortVector() - 15 items sorted in 20.750us with 28 loops.
     //13:01:20 [ItemTrace] Inventory::SortVector() - 19 items sorted in 46.000us with 90 loops.
     /* sorts a vector of items by category, with loaded modules first (in slot order), then loaded charges (in slot order), then cargo
      * if there is only one item, no sorting required...
      *  this should only be called by ships
      *   -allan
      */
     if (itemVec.size() < 2)
         return itemVec;
 
     uint16 count(0);
     double start(GetTimeUSeconds());
 
     //begin basic sort
     bool done(false);
     InventoryItemRef tmp(nullptr);
 
     while (!done) { //check if sorted
         done = true;  //assume sorted
         //iterate though list
         for (int i = 0, i2 = 1; (i < itemVec.size()) && (i2 < itemVec.size()); ++i, ++i2) {
             if ((IsModuleSlot(itemVec[i]->flag())) && (IsModuleSlot(itemVec[i2]->flag()))) {
                 //check if each pair is sorted by category.  subsystems > charges > modules
                 if (itemVec[i]->categoryID() > itemVec[i2]->categoryID()) {
                     //it's not, so flip the values
                     //std::swap(itemVec[i],itemVec[i2]);  // this is ~100x slower on dev server
                     tmp = itemVec[i];
                     itemVec[i] = itemVec[i2];
                     itemVec[i2] = tmp;
                     done = false;  //we weren't sorted, so now go back and check if we are
                 }
             //check if each pair is sorted by flag.  cargo > module
             } else if ((IsCargoHoldFlag(itemVec[i]->flag())) && (IsModuleSlot(itemVec[i2]->flag()))) {
                 //it's not, so flip the values
                 tmp = itemVec[i];
                 itemVec[i] = itemVec[i2];
                 itemVec[i2] = tmp;
                 done = false;  //we weren't sorted, so now go back and check if we are
             }
             ++count;
         }
     }
 
     if (sConfig.debug.IsTestServer)
         _log(INV__TRACE, "Inventory::SortVector() - %u items sorted in %.3fus with %u loops.", itemVec.size(), (GetTimeUSeconds() - start), count);
 
     return itemVec;  //returns sorted list
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Inventory::StackAll	(	EVEItemFlags	flag,
		uint32	ownerID = `0`
	)

Definition at line 575 of file Inventory.cpp.

References IsModuleSlot, and m_contentsByFlag.

 {
     InventoryItemRef iRef(nullptr);
     std::vector<InventoryItemRef> delVec;
     std::map<uint16, InventoryItemRef> types;
     std::map<uint16, InventoryItemRef>::iterator tItr = types.end();
 
     auto range = m_contentsByFlag.equal_range(locFlag);
     for (auto itr = range.first; itr != range.second; ++itr) {
         iRef = itr->second;
         // check to avoid removing modules (and their charges) from ship
         if (IsModuleSlot(iRef->flag()))
             continue;
         // singletons dont stack
         if (iRef->isSingleton())
             continue;
         if ((ownerID == 0) or (ownerID == iRef->ownerID())) {
             tItr = types.find(iRef->typeID());
             if (tItr == types.end()) {
                 // insert type into map for later comparison (existing stack to merge into)
                 types.emplace(iRef->typeID(), iRef);
             } else {
                 // found another stack of this type.
                 delVec.push_back(iRef);
                 // fake merge as calling II::Merge() will invalidate iterator
                 tItr->second->SetQuantity(tItr->second->quantity() + iRef->quantity(), true, false);
             }
         }
     }
 
     for (auto cur : delVec)
         cur->Delete();
 }

void Inventory::Unload ( )

Definition at line 62 of file Inventory.cpp.

References Inv::SaveData::contraband, Inv::SaveData::customInfo, Inv::SaveData::flag, flagSkill, IsPlayerItem, Inv::SaveData::itemID, items, Inv::SaveData::locationID, m_contentsByFlag, mContents, mContentsLoaded, Inv::SaveData::ownerID, Inv::SaveData::position, Inv::SaveData::quantity, ItemDB::SaveItems(), sConsole, Inv::SaveData::singleton, sItemFactory, Inv::SaveData::typeID, and Unload().

Referenced by ShipItem::LogOut(), Character::LogOut(), Reset(), Unload(), StationSE::UnloadStation(), SystemManager::UnloadSystem(), CargoContainer::~CargoContainer(), SolarSystem::~SolarSystem(), StationItem::~StationItem(), StationOffice::~StationOffice(), and WreckContainer::~WreckContainer().

 {
     if (!mContentsLoaded)
         return;
 
     //  save contents on the off-chance they have changed, but not on shutdown. (saved in ItemFactory::Close())
     Inventory* inv(nullptr);
     if (!sConsole.IsShutdown()) {
         std::vector<Inv::SaveData> items;
         items.clear();
         std::map<uint32, InventoryItemRef>::iterator itr = mContents.begin();
         while (itr != mContents.end()) {
             // test for item contents and unload as required
             inv = itr->second->GetMyInventory();
             if (inv != nullptr)
                 inv->Unload();
             if (IsPlayerItem(itr->first)) {   // only save player items (except skills - saved in Character::SaveAll())
                 if (itr->second->flag() == flagSkill) {
                     sItemFactory.RemoveItem(itr->first);
                     itr = mContents.erase(itr);
                     continue;
                 }
 
                 Inv::SaveData data = Inv::SaveData();
                     data.itemID = itr->first;
                     data.contraband = itr->second->contraband();
                     data.flag = itr->second->flag();
                     data.locationID = itr->second->locationID();
                     data.ownerID = itr->second->ownerID();
                     data.position = itr->second->position();
                     data.quantity = itr->second->quantity();
                     data.singleton = itr->second->isSingleton();
                     data.typeID = itr->second->typeID();
                     data.customInfo = itr->second->customInfo();
                 items.push_back(data);
             }
             sItemFactory.RemoveItem(itr->first);
             itr = mContents.erase(itr);
         }
 
         ItemDB::SaveItems(items);
     }
     mContents.clear();
     m_contentsByFlag.clear();
     mContentsLoaded = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::ValidateAddItem	(	EVEItemFlags	flag,
		InventoryItemRef	iRef
	)		const

modify checks for splitting items in same container or moving items between a container's corp hangars flag and iRef->flag() will be same (or same type). add requested move volume to container's available capy before other checks this will show item being removed from container to allow subsequent additions

Definition at line 747 of file Inventory.cpp.

References _log, UserError::AddAmount(), UserError::AddFormatValue(), UserError::AddLocationName(), args, AttrMaxOperationalDistance, AttrVolume, EVEDB::invGroups::Cargo_Container, flagDroneBay, flagShipHangar, GetCapacity(), GetRemainingCapacity(), GetStoredVolume(), EVEDB::invTypes::InfrastructureHub, IsCargoHoldFlag, IsHangarFlag, IsModuleSlot, IsSpecialHoldFlag, m_self, sDataMgr, sItemFactory, EVEDB::invCategories::Station, EVEDB::invCategories::StructureUpgrade, and ValidateIHubUpgrade().

Referenced by InventoryBound::MoveItems(), and CargoContainer::ValidateAddItem().

 {
     if (m_self->typeID() == EVEDB::invTypes::InfrastructureHub)
         if (iRef->categoryID() == EVEDB::invCategories::StructureUpgrade)
             return ValidateIHubUpgrade(iRef);
 
     // i dont think we need to check shit in stations...yet
     if (m_self->categoryID() == EVEDB::invCategories::Station)
         return true;
 
     Client* pClient(sItemFactory.GetUsingClient());
 
     // check that we're close enough if a container in space
     if (m_self->groupID() == EVEDB::invGroups::Cargo_Container && sDataMgr.IsSolarSystem(m_self->locationID())) {
         GVector direction (m_self->position(), pClient->GetShip()->position());
         float maxDistance = 2500.0f;
 
         if (m_self->HasAttribute (AttrMaxOperationalDistance) == true)
             maxDistance = m_self->GetAttribute (AttrMaxOperationalDistance).get_float ();
 
         if (direction.length() > maxDistance)
             throw UserError ("NotCloseEnoughToAdd")
                     .AddAmount ("maxdist", maxDistance);
     }
 
     // check if where the item is coming from was a cargo container
     InventoryItemRef cRef = sItemFactory.GetItem(iRef->locationID());
     if (cRef->groupID() == EVEDB::invGroups::Cargo_Container && sDataMgr.IsSolarSystem(cRef->locationID())) {
         GVector direction (cRef->position(), pClient->GetShip()->position());
         float maxDistance(2500.0f);
         if (cRef->HasAttribute (AttrMaxOperationalDistance) == true)
             maxDistance = cRef->GetAttribute(AttrMaxOperationalDistance).get_float ();
 
         if (direction.length() > maxDistance)
             throw UserError("NotCloseEnoughToLoot")
                 .AddAmount("maxdist", maxDistance);
     }
     // can this be coded to check weapon capy?   im sure it can. just a flag, right?
 
     float capacity = GetRemainingCapacity(flag);
     float volume = iRef->GetAttribute(AttrVolume).get_float();
     float totalVolume = iRef->quantity() * volume;
 
     _log(INV__CAPY, "Inventory::ValidateAddItem() - Testing %s's %s available capy of %.2f to add %i %s at %.2f (%.3f each)",
          m_self->name(), sDataMgr.GetFlagName(flag), capacity, iRef->quantity(), iRef->name(), totalVolume, volume);
 
     if (m_self->itemID() == iRef->locationID())
         if ((flag == iRef->flag())
         or  (IsHangarFlag(flag) and IsHangarFlag(iRef->flag()))) {
             // possible item split.  will have to molest the shit outta this one to verify nullablity of exploits
             capacity += totalVolume;
             _log(INV__CAPY, "Inventory::ValidateAddItem() - flag() %s (%u) == iRef->flag() %s (%u) - test capacity changed to %.2f",
                     sDataMgr.GetFlagName(flag), flag, sDataMgr.GetFlagName(iRef->flag()), iRef->flag(), capacity);
     }
 
     // check capy for single unit
     if (capacity < volume) { // smallest volume is 0.0025
         if (pClient != nullptr) {
             std::map<std::string, PyRep *> args;
             args["volume"] = new PyFloat(volume);
             sItemFactory.UnsetUsingClient();
             if (IsCargoHoldFlag(flag))
                 throw UserError ("NotEnoughCargoSpace")
                         .AddAmount ("volume", volume)
                         .AddAmount ("available", capacity);
             else if (flag == flagShipHangar)
                 throw UserError ("NotEnoughCargoSpaceFor1Unit")
                         .AddAmount ("volume", volume)
                         .AddFormatValue ("type", new PyInt (iRef->itemID ()))
                         .AddAmount ("required", volume)
                         .AddAmount ("free", capacity);
             else if (IsSpecialHoldFlag(flag))
                 throw UserError ("NotEnoughSpecialBaySpaceOverload")
                         .AddAmount ("volume", volume)
                         .AddFormatValue ("item", new PyInt (iRef->itemID ()))
                         .AddAmount ("maximum", GetCapacity (flag))
                         .AddAmount ("user", GetStoredVolume (flag));
             else if (IsModuleSlot(flag))
                 throw UserError ("NotEnoughChargeSpace")
                         .AddAmount ("volume", volume)
                         .AddAmount ("capacity", GetCapacity (flag));
             else if (IsHangarFlag(flag))
                 throw UserError ("NotEnoughSpaceOverload")
                         .AddAmount ("volume", volume)
                         .AddLocationName ("item", iRef->itemID ())
                         .AddAmount ("maximum", GetCapacity (flag))
                         .AddAmount ("user", GetStoredVolume (flag));
             else if (flag == flagDroneBay)
                 throw UserError ("NotEnoughDroneBaySpaceOverload")
                         .AddAmount ("volume", volume)
                         .AddLocationName ("item", iRef->itemID ())
                         .AddAmount ("maximum", GetCapacity (flag))
                         .AddAmount ("used", GetStoredVolume (flag));
             else
                 throw UserError ("NoSpaceForThatOverload")
                         .AddAmount ("volume", volume)
                         .AddFormatValue ("item", new PyInt (iRef->itemID ()))
                         .AddAmount ("maximum", GetCapacity (flag))
                         .AddAmount ("used", GetStoredVolume (flag));
         }
         return false;
     }
 
     // check capy for all units
     if (totalVolume > capacity) {
         if (IsSpecialHoldFlag(flag))
             throw UserError ("NotEnoughSpecialBaySpace")
                     .AddAmount ("volume", totalVolume)
                     .AddAmount ("available", capacity);
         else if (flag == flagDroneBay)
             throw UserError ("NotEnoughDroneBaySpace")
                     .AddAmount ("volume", totalVolume)
                     .AddAmount ("available", capacity);
         else if (IsHangarFlag(flag))
             throw UserError ("NotEnoughCargoSpaceOverload")
                     .AddAmount ("volume", totalVolume)
                     .AddLocationName ("item", iRef->itemID ())
                     .AddAmount ("maximum", GetCapacity (flag))
                     .AddAmount ("used", GetStoredVolume (flag));
         else if (IsCargoHoldFlag(flag))
             throw UserError ("NotEnoughCargoSpace")
                     .AddAmount ("volume", totalVolume)
                     .AddAmount ("available", capacity);
         else
             throw UserError ("NoSpaceForThat")
                     .AddAmount ("volume", totalVolume)
                     .AddFormatValue ("itemTypeName", new PyInt (iRef->itemID ()))
                     .AddAmount ("itemVolume", totalVolume)
                     .AddAmount ("volumeAvailable", capacity);
         return false;
     }
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Inventory::ValidateIHubUpgrade ( InventoryItemRef iRef ) const

Definition at line 706 of file Inventory.cpp.

References _log, SovereigntyData::claimTime, GetFileTimeNow(), m_self, sItemFactory, svDataMgr, EVEDB::invTypes::UpgAdvancedLogisticsNetwork, EVEDB::invTypes::UpgCynosuralNavigation, EVEDB::invTypes::UpgCynosuralSuppression, and Win32Time_Day.

Referenced by ValidateAddItem().

                                                                {
     // Get days since claim for strategic development index
     SovereigntyData sovData = svDataMgr.GetSovereigntyData(m_self->locationID());
     double daysSinceClaim = (GetFileTimeNow() - sovData.claimTime) / Win32Time_Day;
 
     // Get client who currently owns the item
     Client* pClient(sItemFactory.GetUsingClient());
     //Client* pClient = sEntityList.FindClientByCharID(iRef->ownerID());
 
     switch (iRef->typeID()) {
         case EVEDB::invTypes::UpgCynosuralNavigation:
             if (daysSinceClaim > 2.0f) {
                 break;
             } else {
                 _log(INV__WARNING, "Inventory::ValidateIHubUpgrade() - Upgrade %s requires a higher development index.", iRef->name());
                 throw CustomError("%s requires a development index of 2", iRef->name());
             }
             break;
         case EVEDB::invTypes::UpgCynosuralSuppression:
         case EVEDB::invTypes::UpgAdvancedLogisticsNetwork:
             if (daysSinceClaim > 3.0f) {
                 break;
             } else {
                 _log(INV__WARNING, "Inventory::ValidateIHubUpgrade() - Upgrade %s requires a higher development index.", iRef->name());
                 throw CustomError("%s requires a development index of 3", iRef->name());
             }
             break;
         default:
             _log(INV__WARNING, "Inventory::ValidateIHubUpgrade() - Upgrade %s is not supported currently.", iRef->name());
             throw CustomError("%s is not currently supported.", iRef->name());
     }
     if (m_self->GetMyInventory()->ContainsItem(iRef->itemID())) {
         _log(INV__WARNING, "Inventory::ValidateIHubUpgrade() - Upgrade %s is already installed.", iRef->name());
         throw CustomError("%s is already installed.", iRef->name());
     }
 
     // If we didn't hit anything above, it must be okay to insert item
     return true;
 
 }