#include "CachedObjectMgr.h"

Collaboration diagram for PyCachedObject:

Public Member Functions
	PyCachedObject ()

	~PyCachedObject ()

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

PyObject *	Encode ()

PyCachedObject *	Clone () const

Public Attributes
int64	timestamp

uint32	version

uint32	nodeID

bool	shared

PyRep *	cache

bool	compressed

PyRep *	objectID

Detailed Description

Definition at line 125 of file CachedObjectMgr.h.

Constructor & Destructor Documentation

PyCachedObject::PyCachedObject ( )

Definition at line 591 of file CachedObjectMgr.cpp.

Referenced by Clone().

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

Here is the caller graph for this function:

PyCachedObject::~PyCachedObject ( )

Definition at line 602 of file CachedObjectMgr.cpp.

References cache, objectID, and PySafeDecRef.

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

Member Function Documentation

PyCachedObject * PyCachedObject::Clone ( ) const

Definition at line 608 of file CachedObjectMgr.cpp.

References cache, PyRep::Clone(), compressed, nodeID, objectID, PyCachedObject(), shared, timestamp, and version.

 {
     PyCachedObject *res = new PyCachedObject();
     res->timestamp = timestamp;
     res->version  = version;
     res->nodeID  = nodeID;
     res->shared = shared;
     res->cache = (PyBuffer *) cache->Clone();
     res->compressed = compressed;
     res->objectID = objectID->Clone();
     return res;
 }

Here is the call graph for this function:

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

Definition at line 639 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 * PyCachedObject::Encode ( )

Definition at line 778 of file CachedObjectMgr.cpp.

References cache, PyRep::Clone(), compressed, PyTuple::items, new_tuple(), nodeID, objectID, shared, timestamp, and version.

Referenced by CachedObjectMgr::GetCachedObject().

 {
     PyTuple *arg_tuple = new PyTuple(7);
     arg_tuple->items[0] = new_tuple(new PyLong(timestamp), new PyInt(version));
     arg_tuple->items[1] = new PyNone();
     arg_tuple->items[2] = new PyInt(nodeID);
     arg_tuple->items[3] = new PyInt(shared?1:0);
 
     //compression or not, we want to encode this into bytes so it doesn't
     //get cloned in object form just to be encoded later
 /*  cache->EncodeData();
     if (compressed) {
         uint8 *buf = new uint8[cache->length];
         uint32 deflen = DeflatePacket(cache->data, cache->length, buf, cache->length);
         if (deflen == 0 || deflen >= cache->length) {
             //failed to deflate or it did no good (client checks this)
             memcpy(buf, cache->data, cache->length);
             deflen = cache->length;
             compressed = false;
         }
         //buf is consumed:
         arg_tuple->items[4] = new PyBuffer(&buf, deflen);
     } else {
         //TODO: we dont really need to clone this if we can figure out a way to say "this is read only"
         //or if we can change this encode method to consume the PyCachedObject (which will almost always be the case)
         arg_tuple->items[4] = cache->Clone();
     }*/
     //TODO: we don't really need to clone this if we can figure out a way to say "this is read only"
     //or if we can change this encode method to consume the PyCachedObject (which will almost always be the case)
     arg_tuple->items[4] = cache->Clone();
     arg_tuple->items[5] = new PyInt(compressed?1:0);
     //same cloning statement as above.
     arg_tuple->items[6] = objectID->Clone();
 
     return new PyObject( "objectCaching.CachedObject", arg_tuple );
 }