#include "InventoryBound.h"

Inheritance diagram for InventoryBound:

Collaboration diagram for InventoryBound:

Public Member Functions
	InventoryBound (PyServiceMgr *mgr, InventoryItemRef item, EVEItemFlags flag, uint32 ownerID, bool passive)

virtual	~InventoryBound ()

virtual void	Release ()

	PyCallable_DECL_CALL (List)

	PyCallable_DECL_CALL (Add)

	PyCallable_DECL_CALL (MultiAdd)

	PyCallable_DECL_CALL (GetItem)

	PyCallable_DECL_CALL (RemoveChargeToCargo)

	PyCallable_DECL_CALL (RemoveChargeToHangar)

	PyCallable_DECL_CALL (MultiMerge)

	PyCallable_DECL_CALL (StackAll)

	PyCallable_DECL_CALL (StripFitting)

	PyCallable_DECL_CALL (DestroyFitting)

	PyCallable_DECL_CALL (SetPassword)

	PyCallable_DECL_CALL (CreateBookmarkVouchers)

	PyCallable_DECL_CALL (RunRefiningProcess)

	PyCallable_DECL_CALL (ImportExportWithPlanet)

	PyCallable_DECL_CALL (TakeOutTrash)

	PyCallable_DECL_CALL (ListDroneBay)

Public Member Functions inherited from PyBoundObject
	PyBoundObject (PyServiceMgr *mgr)

virtual	~PyBoundObject ()

uint32	nodeID () const

uint32	bindID () const

std::string	GetBindStr () const

const char *	GetName () const

virtual PyResult	Call (const std::string &method, PyCallArgs &args)

Public Member Functions inherited from PyCallable
	PyCallable ()

virtual	~PyCallable ()

Protected Member Functions
std::vector< int32 >	CatSortItems (std::vector< InventoryItemRef > &itemVec)

PyRep *	MoveItems (Client *pClient, std::vector< int32 > &items, EVEItemFlags toFlag, int32 quantity, bool manyFlags, float capacity)

Protected Member Functions inherited from PyBoundObject
void	_SetNodeBindID (uint32 nodeID, uint32 bindID)

Protected Member Functions inherited from PyCallable
void	_SetCallDispatcher (CallDispatcher *d)

Protected Attributes
bool	m_passive

EVEItemFlags	m_flag

uint32	m_itemID

uint32	m_ownerID

Dispatcher *const	m_dispatch

Inventory *	pInventory

InventoryItemRef	m_self

Protected Attributes inherited from PyBoundObject
PyServiceMgr *const	m_manager

std::string	m_strBoundObjectName

Detailed Description

Definition at line 32 of file InventoryBound.h.

Constructor & Destructor Documentation

InventoryBound::InventoryBound	(	PyServiceMgr *	mgr,
		InventoryItemRef	item,
		EVEItemFlags	flag,
		uint32	ownerID,
		bool	passive
	)

InventoryBound::~InventoryBound ( )

virtual

Definition at line 79 of file InventoryBound.cpp.

References m_dispatch.

 {
     delete m_dispatch;
 }

Member Function Documentation

std::vector< int32 > InventoryBound::CatSortItems ( std::vector< InventoryItemRef > & itemVec )

protected

Definition at line 666 of file InventoryBound.cpp.

References InventoryItem::categoryID(), GetTimeUSeconds(), items, sConfig, and sLog.

 {
     /* 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 is called on fitting a group of modules from MultiAdd
      *   -allan
      */
     std::vector<int32> items;
     if (itemVec.size() < 2) {
         items.push_back(itemVec.at(0)->itemID());
         return items;
     }
 
     uint16 count(0);
     double start(0.0);
     if (sConfig.debug.IsTestServer and sConfig.debug.UseProfiling)
         start = GetTimeUSeconds();
 
     //begin basic sort
     bool done(false);
     InventoryItemRef tmp(nullptr);
     while (!done) {
         done = true;  //assume sorted
         //iterate though list
         for (int i = 0, i2 = 1; (i < itemVec.size()) and (i2 < itemVec.size()); ++i, ++i2) {
             //check if each pair is sorted by category.   modules -> charges -> subsystems
             if (itemVec[i]->categoryID() < itemVec[i2]->categoryID()) {
                 //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;
         }
     }
 
     for (auto cur : itemVec)
         items.push_back(cur->itemID());
 
     if (sConfig.debug.IsTestServer and sConfig.debug.UseProfiling)
         sLog.Warning("IB::CatSortItems", "%u items sorted in %.3fus with %u loops.", items.size(), (GetTimeUSeconds() - start), count);
 
     return items;  //returns sorted list
 }

Here is the call graph for this function:

PyRep * InventoryBound::MoveItems	(	Client *	pClient,
		std::vector< int32 > &	items,
		EVEItemFlags	toFlag,
		int32	quantity,
		bool	manyFlags,
		float	capacity
	)

protected

Definition at line 410 of file InventoryBound.cpp.

 {   // complete method rewrite -allan 21Dec17
     ShipItem* pShip = pClient->GetShip().get();
     bool donating = false, ship = false, customs = false;
     int32 origQty = quantity;
 
     // we will need to check *this for specific item-moving rules
     switch (m_self->categoryID()) {
         // specific container-type categories that may move items in/out
         case EVEDB::invCategories::Trading: {
             // this shouldnt hit.  trading is handled in separate system
             codelog(INV__ERROR, "IB::MoveItems() - Trading Category called.");
             EvE::traceStack();
         } break;
         case EVEDB::invCategories::Structure: {
             // this is all POS groups.  use corp donating checks
             donating = true;
             // may have to reset flags based on type
             switch (m_self->groupID()) {
                 case EVEDB::invGroups::Control_Tower: {
                     // flag 0 = fuel bay, flag = 122 strontium bay (2nd storage)
                 } break;
                 case EVEDB::invGroups::Mobile_Missile_Sentry:
                 case EVEDB::invGroups::Mobile_Projectile_Sentry:
                 case EVEDB::invGroups::Mobile_Laser_Sentry:
                 case EVEDB::invGroups::Mobile_Hybrid_Sentry: {
                     // flag 27 = hislot0 using ammo capy
                 } break;
                 case EVEDB::invGroups::Electronic_Warfare_Battery:
                 case EVEDB::invGroups::Sensor_Dampening_Battery:
                 case EVEDB::invGroups::Stasis_Webification_Battery:
                 case EVEDB::invGroups::Warp_Scrambling_Battery:
                 case EVEDB::invGroups::Energy_Neutralizing_Battery:
                 case EVEDB::invGroups::Target_Painting_Battery: {
                 } break;
                 case EVEDB::invGroups::Refining_Array:
                 case EVEDB::invGroups::Ship_Maintenance_Array:
                 case EVEDB::invGroups::Assembly_Array:
                 case EVEDB::invGroups::Shield_Hardening_Array:
                 case EVEDB::invGroups::Corporate_Hangar_Array:
                 case EVEDB::invGroups::Stealth_Emitter_Array:
                 case EVEDB::invGroups::Scanner_Array:
                 case EVEDB::invGroups::Logistics_Array:
                 case EVEDB::invGroups::Cynosural_Generator_Array:
                 case EVEDB::invGroups::Structure_Repair_Array: {
                 } break;
                 default: {
                 } break;
             }
         } break;
         case EVEDB::invCategories::Station: {
             switch (m_self->groupID()) {
                 case EVEDB::invGroups::Station: {
                     // standard station hangar
                     if (toFlag == flagCorpMarket)
                         donating = true;
                     if (toFlag == flagImpounded)
                         donating = true;
                     //if (toFlag == flagDelivery)
                     //    donating = true;
                     if (toFlag == flagLocked) {
                         ; // do tests here for moving locked items (corp role config and ??)
                     }
                 } break;
                 case EVEDB::invGroups::Station_Services: {
                     // station offices, office and factory folders.
                     if (m_self->typeID() == EVEDB::invTypes::Office) //office.  use corp donating checks
                         donating = true;
                 } break;
             }
         } break;
         case EVEDB::invCategories::Orbitals: {
             switch (m_self->groupID()) {
                 case EVEDB::invGroups::Orbital_Construction_Platform: {
                         ; // not sure what to do here yet
                 } break;
                 case EVEDB::invGroups::Orbital_Infrastructure: {
                     // orbital command centers and customs offices
                     // we dont change owners of xfered items
                     customs = true;
                 } break;
             }
         } break;
         case EVEDB::invCategories::Celestial: {
             // containers, wrecks, construction platform, station improve/upgrade platform,
             if (IsPlayerCorp(m_ownerID))
                 donating = true;
         } break;
         case EVEDB::invCategories::Ship: {
             // do module checks and specific removeItem() for these items
             ship = true;
             // will need to add checks on from container to verify donating flag here.
             //donating = true;
         } break;
     }
 
     EVEItemFlags fromFlag(flagNone);
     EVEItemFlags origFlag(toFlag);
     InventoryItemRef iRef(nullptr);
     sItemFactory.SetUsingClient(pClient);
 
     std::vector<int32>::const_iterator itr = items.begin();
     for (; itr != items.end(); ++itr) {
         // reset vars for adding multiple items
         toFlag = origFlag;
         quantity = origQty;
 
         iRef = sItemFactory.GetItem(*itr);
         if (iRef.get() == nullptr) {
             _log(INV__ERROR, "IB::MoveItems() - item %i not found.  continuing.", (*itr));
             continue;
         }
 
         if (iRef->typeID() == EVEDB::invTypes::Bookmark) {
             // update this to keep owner/creator and other data
             iRef->Donate(m_ownerID, m_itemID, toFlag);
             continue;
         }
 
         fromFlag = iRef->flag();
 
         if (moveStack)
             quantity = iRef->quantity();
 
         // if client send capy, it is TOTAL space in this container, NOT current space.
         if (capacity > 0) {
             if (quantity < 1)
                 quantity = iRef->quantity();    // assume all.
         } else if (quantity < 1) {
             _log(INV__ERROR, "IB::MoveItems() - Quantity < 1.  Setting quantity = 1.");
             quantity = 1;
         }
 
         // check for items that need specific handling
         if (IsRigSlot(fromFlag)) //  cant remove rigs like this.  send error.
             throw UserError ("CannotRemoveUpgradeManually");
         else if (IsModuleSlot(fromFlag)) {
             // can we remove modules from an inactive ship?  not yet...
             if (pShip == nullptr)
                 throw CustomError ("Ship not found. The %s wasnt moved.  Ref: ServerError 63290", iRef->name());
 
             //if (sDataMgr.IsSolarSystem(pShip->locationID()))
             //    throw CustomError ("You cannot remove modules in space.");
 
             // verify module isnt active here (before we get too far in processing)
             GenericModule* pMod = pShip->GetModule(fromFlag);
             if (pMod == nullptr)
                 throw CustomError ("That module was not found.  Chances are this is a server error, and either docking or reloging will correct it.");
             if (pMod->IsActive())
                 throw CustomError ("Your %s is currently active.  You must wait for the cycle to complete before it can be removed.", pMod->GetSelf()->name());
 
             if (IsModuleSlot(toFlag)) {
                 if (sDataMgr.IsSolarSystem(pShip->locationID()))
                     throw CustomError ("You cannot exchange module slots in space.");
                 //ModulesNotLoadableInSpace  <-- this needs {device} but i dont know what module it is
 
                 // we are wanting to change slots on a fitted module.
                 pShip->MoveModuleSlot(fromFlag, toFlag);
                 Call_SingleIntegerArg result;
                 result.arg = iRef->itemID();
                 return result.Encode();
             } else {
                 // are we just unloading charges?
                 if (iRef->categoryID() == EVEDB::invCategories::Charge) {
                     pShip->UnloadModule(pMod);
                     return nullptr;
                 }
                 pShip->RemoveItem(iRef);
             }
         }
 
         if (!moveStack and (quantity < iRef->quantity())) {
             InventoryItemRef newItem = iRef->Split(quantity);
             if (newItem.get() == nullptr) {
                 _log(INV__ERROR, "IB::MoveItems() - Error splitting item %u. Skipping.", iRef->itemID());
                 continue;
             }
             iRef = newItem;
             if (iRef.get() == nullptr) {
                 _log(INV__ERROR, "IB::MoveItems() - Error getting split item. Skipping.");
                 continue;
             }
             if (iRef->quantity() > quantity) {
                 _log(INV__ERROR, "IB::MoveItems() - Split item %u qty(%u) > requested qty of %u.  Continuing.", \
                             iRef->itemID(), iRef->quantity(), quantity);
             }
         }
 
         if (donating) {
             iRef->Donate(m_ownerID, m_itemID, toFlag);
             continue;
         }
 
         // move item to new location
         if (ship) {
             // are we adding module to ship using autoFit?
             if (toFlag == flagNone) {
                // assert(iRef->categoryID() != EVEDB::invCategories::Charge); // crash here...this should NOT happen.
                 if (iRef->categoryID() == EVEDB::invCategories::Module) {
                     toFlag = pShip->FindAvailableModuleSlot(iRef);
                     if (toFlag == flagIllegal) {
                         pClient->SendNotifyMsg("Your ship has no available slots to fit this module.  Putting the %s in your CargoHold.", iRef->name());
                         toFlag = flagCargoHold;
                     }
                 } else {
                     // this needs work to verify mFlag is correct for application and that it is init'd correctly
                     toFlag = m_flag;
                 }
             }
 
             // verify item is allowed in container first
             m_self->GetShipItem()->VerifyHoldType(toFlag, iRef, pClient); // this will throw if it fails
 
             // then check for module limits
             if (IsModuleSlot(toFlag)) {
                 m_self->GetShipItem()->TryModuleLimitChecks(toFlag, iRef); // this will throw if it fails
             } else if (IsCargoHoldFlag(toFlag) or IsHangarFlag(toFlag) or (toFlag == flagDroneBay)) {
                 pInventory->ValidateAddItem(toFlag, iRef);  // this will throw if it fails
             }
 
             // check adding item to ship...if it fails, return to previous container
             if (m_self->GetShipItem()->AddItemByFlag(toFlag, iRef, pClient) < 1) {
                 //ALL items *should* have a loaded container item.
                 InventoryItemRef contRef = sItemFactory.GetItemContainer(*itr);
                 if (contRef.get() != nullptr) {
                     contRef->AddItem(iRef);
                 } else {
                     _log(INV__ERROR, "IB::MoveItems() - previous container for item %i not found.  continuing.", (*itr));
                 }
                 continue;
             }
         } else if (customs) {
             pInventory->ValidateAddItem(toFlag, iRef);  // this will throw if it fails
             StructureItemRef sRef = StructureItemRef::StaticCast(m_self);
             sRef->AddItem(iRef);// this will throw if it fails
         } else {
             pInventory->ValidateAddItem(toFlag, iRef);  // this will throw if it fails
             iRef->Donate(m_ownerID, m_itemID, toFlag);
         }
     }
 
     sItemFactory.UnsetUsingClient();
 
     if (iRef.get() == nullptr)
         return nullptr;
 
     if (items.size() == 1) {
         //call returns itemID for single-item adds...not sure about others
         Call_SingleIntegerArg result;
         result.arg = iRef->itemID();
         return result.Encode();
     }
 
     return nullptr;
 }

Here is the call graph for this function:

InventoryBound::PyCallable_DECL_CALL ( List )

InventoryBound::PyCallable_DECL_CALL ( Add )

InventoryBound::PyCallable_DECL_CALL ( MultiAdd )

InventoryBound::PyCallable_DECL_CALL ( GetItem )

InventoryBound::PyCallable_DECL_CALL ( RemoveChargeToCargo )

InventoryBound::PyCallable_DECL_CALL ( RemoveChargeToHangar )

InventoryBound::PyCallable_DECL_CALL ( MultiMerge )

InventoryBound::PyCallable_DECL_CALL ( StackAll )

InventoryBound::PyCallable_DECL_CALL ( StripFitting )

InventoryBound::PyCallable_DECL_CALL ( DestroyFitting )

InventoryBound::PyCallable_DECL_CALL ( SetPassword )

InventoryBound::PyCallable_DECL_CALL ( CreateBookmarkVouchers )

InventoryBound::PyCallable_DECL_CALL ( RunRefiningProcess )

InventoryBound::PyCallable_DECL_CALL ( ImportExportWithPlanet )

InventoryBound::PyCallable_DECL_CALL ( TakeOutTrash )

InventoryBound::PyCallable_DECL_CALL ( ListDroneBay )

virtual void InventoryBound::Release ( )

inlinevirtual

Implements PyBoundObject.

Definition at line 39 of file InventoryBound.h.

                            {
         //I hate this statement
         delete this;
     }

Member Data Documentation

Dispatcher* const InventoryBound::m_dispatch

protected

Definition at line 69 of file InventoryBound.h.

Referenced by ~InventoryBound().

EVEItemFlags InventoryBound::m_flag

protected

Definition at line 64 of file InventoryBound.h.

Referenced by MoveItems().

uint32 InventoryBound::m_itemID

protected

Definition at line 66 of file InventoryBound.h.

Referenced by MoveItems().

uint32 InventoryBound::m_ownerID

protected

Definition at line 67 of file InventoryBound.h.

Referenced by MoveItems().

bool InventoryBound::m_passive

protected

Definition at line 63 of file InventoryBound.h.

InventoryItemRef InventoryBound::m_self

protected

Definition at line 73 of file InventoryBound.h.

Referenced by MoveItems().

Inventory* InventoryBound::pInventory

protected

Definition at line 71 of file InventoryBound.h.

Referenced by MoveItems().

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

/backups/local/src/eve/EvEmu_Crucible/src/eve-server/inventory/InventoryBound.h
/backups/local/src/eve/EvEmu_Crucible/src/eve-server/inventory/InventoryBound.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation