#include "CachedObjectMgr.h"

Collaboration diagram for PyCachedObjectDecoder:

Public Member Functions
	PyCachedObjectDecoder ()

	~PyCachedObjectDecoder ()

void	Dump (FILE into, const char pfx, bool contents_too=false)

bool	Decode (PySubStream **ss)

PyObject *	EncodeHint ()

Public Attributes
int64	timestamp

int32	version

uint32	nodeID

bool	shared

PySubStream *	cache

bool	compressed

PyRep *	objectID

Detailed Description

Definition at line 151 of file CachedObjectMgr.h.

Constructor & Destructor Documentation

PyCachedObjectDecoder::PyCachedObjectDecoder ( )

Definition at line 574 of file CachedObjectMgr.cpp.

 : timestamp(0),
   version(0),
   nodeID(0),
   shared(false),
   cache(nullptr),
   compressed(false),
   objectID(nullptr)
 {
 }

PyCachedObjectDecoder::~PyCachedObjectDecoder ( )

Definition at line 585 of file CachedObjectMgr.cpp.

References cache, objectID, and PySafeDecRef.

 {
     PySafeDecRef( cache );
     PySafeDecRef( objectID );
 }

Member Function Documentation

bool PyCachedObjectDecoder::Decode ( PySubStream ** ss )

Definition at line 657 of file CachedObjectMgr.cpp.

References args, PyObject::arguments(), cache, compressed, PySubStream::decoded(), PySubStream::DecodeData(), if(), PyRep::IsObject(), PyRep::IsTuple(), PyTuple::items, nodeID, objectID, PyDecRef, PySafeDecRef, shared, sLog, timestamp, PyRep::TypeString(), PyInt::value(), and version.

Referenced by CachedObjectMgr::LoadCachedObject(), and CachedObjectMgr::UpdateCacheFromSS().

 {
     PySubStream *ss = *in_ss;    //consume
     *in_ss = nullptr;
 
     PySafeDecRef( cache );
     PySafeDecRef( objectID );
 
     ss->DecodeData();
     if (ss->decoded() == nullptr) {
         sLog.Error("PyCachedObjectDecoder","Unable to decode initial stream for PycachedObject");
 
         PyDecRef( ss );
         return false;
     }
 
     if (!ss->decoded()->IsObject()) {
         sLog.Error("PyCachedObjectDecoder","Cache substream does not contain an object: %s", ss->decoded()->TypeString());
 
         PyDecRef( ss );
         return false;
     }
     PyObject *po = (PyObject *) ss->decoded();
     //TODO: could check type string, dont care... (should be objectCaching.CachedObject)
 
     if (!po->arguments()->IsTuple()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's args is not a tuple: %s", po->arguments()->TypeString());
 
         PyDecRef( ss );
         return false;
     }
     PyTuple *args = (PyTuple *) po->arguments();
 
     if (args->items.size() != 7) {
         sLog.Error("PyCachedObjectDecoder","Cache object's args tuple has %lu elements instead of 7", args->items.size());
 
         PyDecRef( ss );
         return false;
     }
 
     if (!args->items[0]->IsTuple()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's arg %d is not a Tuple: %s", 0, args->items[0]->TypeString());
 
         PyDecRef( ss );
         return false;
     }
     //ignore unknown [1]
     /*if (!args->items[1]->IsInt()) {
         _log(SERVICE__ERROR, "Cache object's arg %d is not a None: %s", 1, args->items[1]->TypeString());
 
         PyDecRef( ss );
         return false;
     }*/
     if (!args->items[2]->IsInt()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's arg %d is not an Integer: %s", 2, args->items[2]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     if (!args->items[3]->IsInt()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's arg %d is not an Integer: %s", 3, args->items[3]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     if (!args->items[5]->IsInt()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's arg %d is not a : %s", 5, args->items[5]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     PyTuple *objVt = (PyTuple *) args->items[0];
     if (!objVt->items[0]->IsInt()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's version tuple %d is not an Integer: %s", 0, objVt->items[0]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     if (!objVt->items[1]->IsInt()) {
         sLog.Error("PyCachedObjectDecoder","Cache object's version tuple %d is not an Integer: %s", 1, objVt->items[1]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     PyInt *nodeidr = (PyInt *) args->items[2];
     PyInt *sharedr = (PyInt *) args->items[3];
     PyInt *compressedr = (PyInt *) args->items[5];
     PyInt *timer = (PyInt *) objVt->items[0];
     PyInt *versionr = (PyInt *) objVt->items[1];
 
     timestamp = timer->value();
     version = versionr->value();
     nodeID = nodeidr->value();
     shared = ( sharedr->value() != 0 );
     compressed = ( compressedr->value() != 0 );
 
     //content (do this as the last thing, since its the heavy lifting):
     if (args->items[4]->IsSubStream()) {
         cache = (PySubStream *) args->items[4];
         //take it
         args->items[4] = nullptr;
     } else if (args->items[4]->IsBuffer()) {
         //this is a data buffer, likely compressed.
         PyBuffer* buf = args->items[4]->AsBuffer();
         cache = new PySubStream( buf );
     } else if (args->items[4]->IsString()) {
         //this is a data buffer, likely compressed, not sure why it comes through as a string...
         PyString* str = args->items[4]->AsString();
         cache = new PySubStream( new PyBuffer( *str ) );
     } else {
         sLog.Error("PyCachedObjectMgr", "Cache object's arg %d is not a substream or buffer: %s", 4, args->items[4]->TypeString());
         PyDecRef( ss );
         return false;
     }
 
     objectID = args->items[6]->Clone();
 
     PyDecRef( ss );
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PyCachedObjectDecoder::Dump	(	FILE *	into,
		const char *	pfx,
		bool	contents_too = `false`
	)

Definition at line 621 of file CachedObjectMgr.cpp.

References cache, compressed, PyRep::Dump(), nodeID, objectID, PRIu64, shared, timestamp, and version.

 {
     std::string s(pfx);
     s += "    ";
     fprintf(into, "%sCached Object:\n", pfx);
     fprintf(into, "%s  ObjectID:\n", pfx);
     objectID->Dump(into, s.c_str());
     fprintf(into, "%s  Version Time: %" PRIu64 "\n", pfx, timestamp);
     fprintf(into, "%s  Version: %u\n", pfx, version);
     fprintf(into, "%s  NodeID: %u\n", pfx, nodeID);
     fprintf(into, "%s  Shared: %s\n", pfx, shared?"yes":"no");
     fprintf(into, "%s  Compressed: %s\n", pfx, compressed?"yes":"no");
     if (contents_too) {
         fprintf(into, "%s  Contents:\n", pfx);
             cache->Dump(into, s.c_str());
     }
 }

Here is the call graph for this function:

PyObject * PyCachedObjectDecoder::EncodeHint ( )

Definition at line 815 of file CachedObjectMgr.cpp.

References PyRep::Clone(), PyTuple::items, nodeID, objectID, timestamp, and version.

                                             {
     PyTuple *versiont = new PyTuple(2);
         versiont->items[0] = new PyLong(timestamp);
         versiont->items[1] = new PyInt(version);
     PyTuple *arg_tuple = new PyTuple(3);
         arg_tuple->items[0] = objectID->Clone();
         arg_tuple->items[1] = new PyInt(nodeID);
         arg_tuple->items[2] = versiont;
 
     return new PyObject( "util.CachedObject", arg_tuple );
 }