Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/server/src/pd_lib/pd_messages.h

1465 lines
31 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef RY_PD_MESSAGES_H
#define RY_PD_MESSAGES_H
/*
* NeL Includes
*/
#include <nel/misc/types_nl.h>
#include <nel/misc/common.h>
#include <nel/misc/time_nl.h>
#include <nel/misc/stream.h>
#include <nel/misc/entity_id.h>
#include <nel/misc/sheet_id.h>
#include <nel/misc/variable.h>
#include <nel/misc/hierarchical_timer.h>
/*
* PD Lib Includes
*/
#include "pd_utils.h"
#include "db_description_parser.h"
#include "timestamp.h"
namespace RY_PDS
{
#define MAX_MESSAGE_REMAP 32767
#define MESSAGE_REMAP_MASK 0x7fff
#define MESSAGE_REMAP_ENTITYID_PRESENT 0x8000
#define MESSAGE_SETPARENT_ENTITYID_PRESENT 0x8000
/**
* Object Circular Mapper
* Allows to map an object value through little sized uint (uint8 or uint16), allowing to reallocate
* mapping when all values are used.
* This is used to map long values (CEntityIds for instance) that are expected to appear frequently
* in a stream with short keys, without making sure all values fit in mapping table.
* For instance, if using uint8 as mapping key, when all 256 values are used, previously used key
* 0 is remapped to the new object value that appears in stream and so on (reallocations are done
* circularly through key values). Mask value is for test purposes only, not to be changed!
*/
template<typename Key, typename Object, int Mask = 0xffffffff, typename TBackMap = std::map<Object, Key> >
class CObjCircMapper
{
public:
CObjCircMapper()
{
_Next = 0;
_Max = 0;
// prepare mapping table
_FrontMap.resize(getMappingSize()+1);
}
/**
* Serialise object from stream
*/
void serial(NLMISC::IStream& s, Object& o)
{
Key fakeFlags = 0;
serial(s, o, fakeFlags);
}
/**
* Serialise object from stream, with flags added to msbits
* WARNING: flags should NEVER interfere with Mask!
* WARNING: when stream is reading, lower bits of flags are unspecified!
*/
void serial(NLMISC::IStream& s, Object& o, Key& flags)
{
if (s.isReading())
{
Key k;
s.serial(flags);
// remove flags from read key
k = (flags & Mask);
// if key is next value to be mapped
if (k == _Next)
{
// serial in object value to map
_Next = ((_Next+1)&Mask);
s.serial(o);
// and map it to key
_FrontMap[k] = o;
}
else
{
// already seen key? just copy object value
o = _FrontMap[k];
}
}
else
{
// search for object value in map
typename TBackMap::iterator it = _BackMap.find(o);
// not yet found or mapping key is just next key to alloc
if (it == _BackMap.end() || (*it).second == _Next)
{
// if mapping key is next, we have to force reallocation
// as serial in code can't know if value is new or not...
Key k = _Next;
_Next = ((_Next+1)&Mask);
// if new key as already circle'd down, unmap previous association
if (k < _Max)
{
#ifdef NL_DEBUG
typename TBackMap::iterator it = _BackMap.find(_FrontMap[k]);
nlassert(it != _BackMap.end() && (*it).second == k);
_BackMap.erase(it);
#else
_BackMap.erase(_FrontMap[k]);
#endif
}
else
{
// else just increase max seen key...
_Max = ((uint)k)+1;
}
// do mapping
_BackMap[o] = k;
_FrontMap[k] = o;
// serial mapping
k |= (flags & (~Mask));
s.serial(k);
s.serial(o);
}
else
{
// mapping found and correct, only serial key out
Key k = ((*it).second | (flags & (~Mask)));
s.serial(k);
}
}
}
private:
/// Back Mapping, from object values to keys
TBackMap _BackMap;
/// Front Mapping, from keys to object values
typedef typename std::vector<Object> TFrontMap;
TFrontMap _FrontMap;
/// Next Key to map
Key _Next;
/// Max mapped Key
uint _Max;
uint getMappingSize() const
{
return (((uint)1)<<(sizeof(Key)*8))-1;
}
};
typedef CObjCircMapper<uint8, NLMISC::CEntityId> TEntityIdCircMapper;
class CMsgObjectIndex
{
public:
CMsgObjectIndex() : Raw(0) {}
CMsgObjectIndex(uint8 table, uint32 row)
{
Raw = 0;
set(table, row);
}
void set(uint8 table, uint32 row)
{
Table = table;
Row = row;
}
union
{
uint64 Raw;
struct
{
uint32 Row;
uint8 Table;
};
};
void serial(NLMISC::IStream& f) { f.serial(Table, Row); }
bool operator < (const CMsgObjectIndex& a) const
{
return Raw < a.Raw;
}
};
typedef CObjCircMapper<uint8, CMsgObjectIndex, 0x7f> TObjectIndexCircMapper;
/**
* Database update message
*/
class CDbMessage
{
public:
CDbMessage() : Selected(false), ContextDepth(0), _ObjectIdPresent(false) { }
/// Type of message, 4bits -> 16 message types available
enum THeaderType
{
UpdateValue = 0,
SetParent = 1,
AllocRow = 2,
DeallocRow = 3,
ReleaseRow = 4,
EndRemapMessages = 4,
LoadRow = 5,
AddString = 6,
UnmapString = 7,
Log = 8,
PushContext = 9,
PopContext = 10,
LogChat = 11,
End
};
/// \name setup message methods
// @{
/// update value
template<typename T>
void updateValue(TColumnIndex column, const T& value)
{
setHeader(UpdateValue);
uint sz = 0;
// update 20101119 by packpro
if (sizeof(value) == 1)
{
sz = 0;
memcpy(&(_Value0[0]), &value, sizeof(value));
}
else if (sizeof(value) == 2)
{
sz = 1;
memcpy(&(_Value1[0]), &value, sizeof(value));
}
else if (sizeof(value) == 4)
{
sz = 2;
memcpy(&(_Value2[0]), &value, sizeof(value));
}
else if (sizeof(value) == 8)
{
sz = 3;
memcpy(&(_Value3[0]), &value, sizeof(value));
}
//if (sizeof(value) == 1) { sz = 0; _Value0[0] = *(uint8*)(&value); }
//else if (sizeof(value) == 2) { sz = 1; _Value1[0] = *(uint16*)(&value); }
//else if (sizeof(value) == 4) { sz = 2; _Value2[0] = *(uint32*)(&value); }
//else if (sizeof(value) == 8) { sz = 3; _Value3[0] = *(uint64*)(&value); }
_ColumnAndSize = (uint16)(column | (sz << 14));
}
/// update value
template<typename T>
void updateValue(TColumnIndex column, const T& value, const NLMISC::CEntityId& objectId)
{
setHeader(UpdateValue);
uint sz;
// update 20101119 by packpro
if (sizeof(value) == 1)
{
sz = 0;
memcpy(&(_Value0[0]), &value, sizeof(value));
}
else if (sizeof(value) == 2)
{
sz = 1;
memcpy(&(_Value1[0]), &value, sizeof(value));
}
else if (sizeof(value) == 4)
{
sz = 2;
memcpy(&(_Value2[0]), &value, sizeof(value));
}
else if (sizeof(value) == 8)
{
sz = 3;
memcpy(&(_Value3[0]), &value, sizeof(value));
}
//if (sizeof(value) == 1) { sz = 0; _Value0[0] = *(uint8*)(&value); }
//else if (sizeof(value) == 2) { sz = 1; _Value1[0] = *(uint16*)(&value); }
//else if (sizeof(value) == 4) { sz = 2; _Value2[0] = *(uint32*)(&value); }
//else if (sizeof(value) == 8) { sz = 3; _Value3[0] = *(uint64*)(&value); }
_ColumnAndSize = (uint16)(column | (sz << 14));
//_MapTableRow |= MESSAGE_REMAP_ENTITYID_PRESENT;
_ObjectIdPresent = true;
_ObjectId = objectId;
}
/// set parent
void setParent(TColumnIndex column, const CObjectIndex& parent)
{
setHeader(SetParent);
_ColumnAndSize = (uint16)column;
_Value3[0] = *(uint64*)(&parent);
}
/// set parent, only child object has an entityId as key
void setParent(TColumnIndex column, const CObjectIndex& parent, const NLMISC::CEntityId& objectId)
{
setHeader(SetParent);
_ColumnAndSize = (uint16)column;
_Value3[0] = *(uint64*)(&parent);
//_MapTableRow |= MESSAGE_REMAP_ENTITYID_PRESENT;
_ObjectIdPresent = true;
_ObjectId = objectId;
}
/// set parent, only parent object has an entityId as key
void setParent(TColumnIndex column, const CObjectIndex& parent, const NLMISC::CEntityId& newParentId, const NLMISC::CEntityId& previousParentId)
{
setHeader(SetParent);
_ColumnAndSize = (uint16)column;
_Value3[0] = *(uint64*)(&parent);
_ColumnAndSize |= MESSAGE_SETPARENT_ENTITYID_PRESENT;
_NewParentId = newParentId;
_PreviousParentId = previousParentId;
}
/// set parent, both child and parent objects have an entityId as key
void setParent(TColumnIndex column, const CObjectIndex& parent, const NLMISC::CEntityId& objectId, const NLMISC::CEntityId& newParentId, const NLMISC::CEntityId& previousParentId)
{
setHeader(SetParent);
_ColumnAndSize = (uint16)column;
_Value3[0] = *(uint64*)(&parent);
//_MapTableRow |= MESSAGE_REMAP_ENTITYID_PRESENT;
_ObjectIdPresent = true;
_ObjectId = objectId;
_ColumnAndSize |= MESSAGE_SETPARENT_ENTITYID_PRESENT;
_NewParentId = newParentId;
_PreviousParentId = previousParentId;
}
/// Is Object EntityId present
bool objectEntityIdPresent() const
{
//return (_MapTableRow & MESSAGE_REMAP_ENTITYID_PRESENT) != 0;
return _ObjectIdPresent;
}
/// Are Parents EntityId present
bool parentsEntityIdPresent() const
{
return (_ColumnAndSize & MESSAGE_SETPARENT_ENTITYID_PRESENT) != 0;
}
/// allocate row
void allocRow(uint64 key)
{
setHeader(AllocRow);
_Value3[0] = key;
}
/// deallocate row
void deallocRow()
{
setHeader(DeallocRow);
}
/// allocate row
void allocRow(uint64 key, const NLMISC::CEntityId& objectId)
{
setHeader(AllocRow);
//_MapTableRow |= MESSAGE_REMAP_ENTITYID_PRESENT;
_ObjectIdPresent = true;
_ObjectId = objectId;
_Value3[0] = key;
}
/// deallocate row
void deallocRow(const NLMISC::CEntityId& objectId)
{
setHeader(DeallocRow);
//_MapTableRow |= MESSAGE_REMAP_ENTITYID_PRESENT;
_ObjectIdPresent = true;
_ObjectId = objectId;
}
/// load row
void loadRow(TTableIndex table, uint64 key)
{
setHeader(LoadRow);
_ObjectIndex.set((uint8)table, 0);
//_Table = (uint8)table;
_Value3[0] = key;
}
/// Add string
void addString(uint64 skey, const ucstring& str)
{
setHeader(AddString);
_Value3[0] = skey;
_String = str;
}
/// Add string
void unmapString(uint64 skey)
{
setHeader(UnmapString);
_Value3[0] = skey;
}
/// Release a row in memory
void releaseRow()
{
setHeader(ReleaseRow);
}
/// Log message
void log(uint logId, uint bufferByteSize)
{
setHeader(Log);
_LogId = logId;
_LogBuffer.resize(bufferByteSize);
}
/// Push Log Parameter
template<typename T>
void pushParameter(uint byteOffset, const T& parameter)
{
nlassertex(byteOffset+sizeof(T) <= _LogBuffer.size(), ("Internal error! failed to push parameter at %d (size=%d), beyond buffer limit (%d)", byteOffset, sizeof(T), _LogBuffer.size()));
memcpy(&(_LogBuffer[byteOffset]), &parameter, sizeof(parameter));
}
/// Push Log Parameter (string)
void pushParameter(uint byteOffset, const std::string& parameter)
{
nlassertex(byteOffset+sizeof(uint16) <= _LogBuffer.size(), ("Internal error! failed to push parameter at %d (size=%d), beyond buffer limit (%d)", byteOffset, sizeof(uint16), _LogBuffer.size()));
// get current string index
uint16 bo = (uint16)_ExtLogBuffer.size();
_ExtLogBuffer.resize(bo+parameter.size()+1);
memcpy(&(_ExtLogBuffer[bo]), parameter.c_str(), parameter.size()+1);
memcpy(&(_LogBuffer[byteOffset]), &bo, sizeof(uint16));
}
/// Push Log Context
void pushContext()
{
setHeader(PushContext);
}
/// Pop Log Context
void popContext()
{
setHeader(PopContext);
}
/// Log Chat sentence
void logChat(const ucstring& sentence, const NLMISC::CEntityId& sender, const std::vector<NLMISC::CEntityId>& receivers)
{
setHeader(LogChat);
_String = sentence;
*(NLMISC::CEntityId*)(&(_Value3[0])) = sender;
uint bufferSize = (uint)receivers.size()*sizeof(NLMISC::CEntityId);
if (bufferSize > 0)
{
_LogBuffer.resize(bufferSize);
NLMISC::CEntityId* srcBuffer = (NLMISC::CEntityId*)(&(receivers[0]));
NLMISC::CEntityId* dstBuffer = (NLMISC::CEntityId*)(&(_LogBuffer[0]));
memcpy(dstBuffer, srcBuffer, bufferSize);
}
else
{
_LogBuffer.clear();
}
}
// @}
/// Get message type
THeaderType getType() const { return _Type; }
/// Set Type of message
void setType(THeaderType type) { _Type = type; }
/// \name common part methods
// @{
TTableIndex getTable() const { return (TTableIndex)_ObjectIndex.Table; }
TRowIndex getRow() const { return (TRowIndex)_ObjectIndex.Row; }
uint32 getStringId() const { return _StringId; }
// @}
/// \name Update database value specific methods
// @{
TColumnIndex getColumn() const { return (TColumnIndex)(_ColumnAndSize&0x3fff); }
const void* getData() const { return &_Value0[0]; }
uint getDatasize() const { return 1 << (_ColumnAndSize>>14); }
uint8 getValue8bits() const { return _Value0[0]; }
uint16 getValue16bits() const { return _Value1[0]; }
uint32 getValue32bits() const { return _Value2[0]; }
uint64 getValue64bits() const { return _Value3[0]; }
CObjectIndex getObjectIndex() const { return *(CObjectIndex*)(&(_Value3[0])); }
const ucstring& getString() const { return _String; }
bool asBool() const { return _Value0[0] != 0; }
char asChar() const { return (char)_Value0[0]; }
ucchar asUCChar() const { return (ucchar)_Value1[0]; }
uint8 asUint8() const { return (uint8)_Value0[0]; }
uint16 asUint16() const { return (uint16)_Value1[0]; }
uint32 asUint32() const { return (uint32)_Value2[0]; }
uint64 asUint64() const { return (uint64)_Value3[0]; }
sint8 asSint8() const { return (sint8)_Value0[0]; }
sint16 asSint16() const { return (sint16)_Value1[0]; }
sint32 asSint32() const { return (sint32)_Value2[0]; }
sint64 asSint64() const { return (sint64)_Value3[0]; }
float asFloat() const { return *(float*)(&_Value2[0]); }
double asDouble() const { return *(double*)(&_Value3[0]); }
const NLMISC::CSheetId& asSheetId() const { return *(NLMISC::CSheetId*)(&_Value2[0]); }
const NLMISC::CEntityId& asEntityId() const { return *(NLMISC::CEntityId*)(&_Value3[0]); }
const NLMISC::CEntityId& getObjectId() const { return _ObjectId; }
const NLMISC::CEntityId& getNewParentId() const { return _NewParentId; }
const NLMISC::CEntityId& getPreviousParentId() const { return _PreviousParentId; }
uint16 getLogId() const { return _LogId; }
const std::vector<uint8>& getLogBuffer() const { return _LogBuffer; }
void setupTableAndRow(TTableIndex table, TRowIndex row)
{
_ObjectIndex.set((uint8)table, (uint32)row);
}
// @}
/// \name Log analysis/display
// @{
/// Dump Message content to string as a human readable message
void getHRContent(const CDBDescriptionParser& description, std::string& result) const;
/// Does message contains CEntityId?
bool contains(const CDBDescriptionParser& description, const NLMISC::CEntityId& id);
/// Does message contains string?
bool contains(const CDBDescriptionParser& description, const std::string& str);
/// Build Log string
std::string buildLogString(const CDBDescriptionParser& description) const;
/// Is Value modified
bool valueModified(uint table, uint column)
{
return ((getType() == UpdateValue || getType() == SetParent) && getTable() == table && getColumn() == column);
}
/// Is message selected
bool Selected;
/// Message context depth
uint16 ContextDepth;
// @}
/// \name Serializing
// @{
/// Serial message
void serial(NLMISC::IStream &f, TObjectIndexCircMapper& indexMapper, TEntityIdCircMapper& eidMapper);
/// Get Message Header Size
uint32 getMessageHeaderSize();
// @}
private:
/**
* Type of message
* Type is not serialised directly in message, but in containing folder
*/
THeaderType _Type;
/**
* Message Id
* Refers to the 'entity' used/updated by the message
*/
union // 32 bits
{
uint32 _StringId;
uint16 _LogId;
};
/// \name Extra info
// @{
uint16 _ColumnAndSize;
CMsgObjectIndex _ObjectIndex;
union // 64 bits
{
uint8 _Value0[8];
uint16 _Value1[4];
uint32 _Value2[2];
uint64 _Value3[1];
};
bool _ObjectIdPresent;
NLMISC::CEntityId _ObjectId;
NLMISC::CEntityId _NewParentId;
NLMISC::CEntityId _PreviousParentId;
ucstring _String;
std::vector<uint8> _LogBuffer;
std::vector<uint8> _ExtLogBuffer;
// @}
void setHeader(THeaderType type) { _Type = type; }
};
/**
* A Folder a Db Messages, all of the same kind.
* Based on the assumption that update value messages are the main kind of messages
* and that the follow in series...
* Thus, it should save one byte per message...
*/
class CDbMessageFolder
{
public:
CDbMessageFolder()
{
_Type = 0xff;
_NumMessages = 0;
}
/**
* Constructor
*/
CDbMessageFolder(uint8 type)
{
_Type = type;
_NumMessages = 0;
}
/**
* Get Folder Type
*/
uint8 getType() const { return _Type; }
/**
* Get Number of messages in folder
*/
uint32 getNumMessages() const { return _NumMessages; }
/**
* Folder is full
*/
bool full() const { return _NumMessages == MAX_MESSAGE_REMAP; }
/**
* Add a message to folder
*/
void addMessage(const CDbMessage& msg)
{
nlassert(_NumMessages < MAX_MESSAGE_REMAP);
nlassert(msg.getType() == _Type);
++_NumMessages;
}
/**
* Serialise folder
*/
void serial(NLMISC::IStream& f)
{
f.serial(_Type, _NumMessages);
nlassert(_Type < CDbMessage::End);
}
private:
/// Type of messages in folder
uint8 _Type;
/// Number of messages in folder
uint16 _NumMessages;
};
/**
* A Queue of messages
*/
class CDbMessageQueue
{
public:
/**
* Constructor
*/
CDbMessageQueue()
{
clear();
}
/**
* Clear
*/
void clear()
{
_Messages.clear();
_Folders.clear();
}
/**
* Get Next Message to be written
*/
CDbMessage& nextMessage()
{
_Messages.resize(_Messages.size()+1);
return _Messages.back();
}
/**
* Get Current Message to be written
*/
CDbMessage& currentMessage()
{
nlassert(!_Messages.empty());
return _Messages.back();
}
/**
* Get Number of Messages in queue
*/
uint32 getNumMessages() const
{
return (uint32)_Messages.size();
}
/**
* Get Message
*/
CDbMessage& getMessage(uint32 message)
{
nlassert(message < _Messages.size());
return _Messages[message];
}
/**
* Serialise message queue
*/
void serial(NLMISC::IStream& f)
{
H_AUTO(PDLIB_MsgQueue_serial);
// build folders first if writing to stream
if (!f.isReading())
{
buildFolders();
}
uint32 numFolders = (uint32)_Folders.size();
uint32 numMessages = (uint32)_Messages.size();
f.serial(numFolders);
f.serial(numMessages);
if (f.isReading())
{
_Folders.resize(numFolders);
_Messages.resize(numMessages);
}
//f.serialCont(_BackRemap);
TEntityIdCircMapper EIdMapper;
TObjectIndexCircMapper IndexMapper;
// for each folder, write message stored in it
uint i, message = 0;
for (i=0; i<_Folders.size(); ++i)
{
CDbMessageFolder& folder = _Folders[i];
f.serial(folder);
uint j;
for (j=0; j<folder.getNumMessages(); ++j)
{
nlassert(message < numMessages);
CDbMessage& msg = _Messages[message++];
msg.setType((CDbMessage::THeaderType)folder.getType());
msg.serial(f, IndexMapper, EIdMapper);
}
}
// remap messages
if (f.isReading())
{
uint currentDepth = 0;
for (i=0; i<_Messages.size(); ++i)
{
CDbMessage& msg = _Messages[i];
if (msg.getType() == CDbMessage::PopContext)
--currentDepth;
msg.ContextDepth = currentDepth;
if (msg.getType() == CDbMessage::PushContext)
++currentDepth;
}
}
}
private:
/// List of messages
std::vector<CDbMessage> _Messages;
/// List of folders
std::vector<CDbMessageFolder> _Folders;
/**
* Build message folders
*/
void buildFolders()
{
_Folders.clear();
uint i;
for (i=0; i<_Messages.size(); ++i)
{
if (_Folders.empty() || _Folders.back().full() || _Messages[i].getType() != _Folders.back().getType())
_Folders.push_back(CDbMessageFolder(_Messages[i].getType()));
_Folders.back().addMessage(_Messages[i]);
}
}
};
/**
* A Split Queue
* Handle multiple queues, so one update may be splitted into multiple messages
*/
class CDbMessageSplitQueue
{
public:
/**
* Constructor
*/
CDbMessageSplitQueue()
{
}
/**
* Clearup
*/
void clear()
{
_Queues.clear();
}
/**
* Get Next Message to be written, no mapping to be done
*/
CDbMessage& nextMessage()
{
if (empty())
forceNextQueue();
return _Queues.back().nextMessage();
}
/**
* Get Next Remappable Message to be written
*/
CDbMessage& nextMessage(uint8 table, uint32 row)
{
if (empty())
forceNextQueue();
// here, queue allows to map message
CDbMessage& msg = _Queues.back().nextMessage();
msg.setupTableAndRow(table, row);
// and return it
return msg;
}
/**
* Get Current Message
*/
CDbMessage& currentMessage()
{
return _Queues.back().currentMessage();
}
/**
* Force MsgQueue to fill next queue
*/
void forceNextQueue()
{
if (_Queues.empty() || _Queues.back().getNumMessages() > 0)
{
_Queues.push_back(CDbMessageQueue());
}
}
/**
* Is Queue Empty?
*/
bool empty() const
{
return _Queues.empty();
}
/**
* Number of message in queue
*/
uint32 getNumMessagesEnqueued() const
{
std::list<CDbMessageQueue>::const_iterator it;
uint32 totalMessages = 0;
for (it=_Queues.begin(); it!=_Queues.end(); ++it)
totalMessages += (*it).getNumMessages();
return totalMessages;
}
/**
* begin()
*/
std::list<CDbMessageQueue>::iterator begin() { return _Queues.begin(); }
/**
* end()
*/
std::list<CDbMessageQueue>::iterator end() { return _Queues.end(); }
/**
* size()
*/
uint size() const { return (uint)_Queues.size(); }
/**
* get()
*/
CDbMessageQueue& get(uint i)
{
std::list<CDbMessageQueue>::iterator it = _Queues.begin();
while (i-- > 0)
++it;
return (*it);
}
private:
/// Used Queues
std::list<CDbMessageQueue> _Queues;
};
class CUpdateLog
{
public:
CUpdateLog() : UpdateId(0xffffffff), _OwnUpdates(false), _Updates(NULL) { }
~CUpdateLog();
/// UpdateId sent by client for this update
uint32 UpdateId;
/// Start date for this update
CTimestamp StartStamp;
/// Start date for this update
CTimestamp EndStamp;
/// Serial log
void serial(NLMISC::IStream& f);
/// Display UpdateLog content (using a database description)
void display(const CDBDescriptionParser& description, NLMISC::CLog& log, bool onlySelected = false);
/**
* Check log timestamp boundaries
*/
bool checkTimestampBoundaries(const CTimestamp& begin, const CTimestamp& end);
/**
* Is Empty
*/
bool isEmpty();
/**
* Select contexts and messages containing a given entityId
* return true if there were at least one message selected
*/
bool selectMessages(const CDBDescriptionParser& description, const NLMISC::CEntityId& id);
/**
* Select contexts and messages containing a given string
* return true if there were at least one message selected
*/
bool selectMessages(const CDBDescriptionParser& description, const std::string& str);
/**
* Select contexts and messages containing modification of a value for a given entityId
* return true if there were at least one message selected
*/
bool selectMessages(const CDBDescriptionParser& description, const NLMISC::CEntityId& id, const std::string& valuePath);
/**
* Select contexts and messages containing a list of entityIds (limited at most to 32 entityIds)
* return true if there were at least one message selected
*/
bool selectMessages(const CDBDescriptionParser& description, const std::vector<NLMISC::CEntityId>& ids);
class CLogProcessor
{
public:
/// process log, return true if some messages were selected
virtual bool processLog(CUpdateLog& log, const CDBDescriptionParser& description) = 0;
};
/**
* Apply process on log files
*/
static void processLogs(const std::string& path,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
CLogProcessor* processor,
float* progress = NULL);
/**
* Display log for a given entity id, between 2 dates
*/
static void displayLogs(const CDBDescriptionParser& description,
const NLMISC::CEntityId& id,
const CTimestamp& begin,
const CTimestamp& end,
const std::string& path,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Display log between 2 dates
*/
static void displayLogs(const std::string& path,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Display log for a given entity id, between 2 dates
*/
static void displayLogs(const std::string& path,
const NLMISC::CEntityId& id,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Display log for a given entity id and a specified value to be modified, between 2 dates
*/
static void displayLogs(const std::string& path,
const NLMISC::CEntityId& id,
const std::string& valuePath,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Display log for a list of given entity id, between 2 dates
*/
static void displayLogs(const std::string& path,
const std::vector<NLMISC::CEntityId>& ids,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Display log for a list of given entity id, between 2 dates
*/
static void displayLogs(const std::string& path,
const std::string& str,
const CTimestamp& begin,
const CTimestamp& end,
NLMISC::CLog& log,
float* progress = NULL);
/**
* Elect matching description
*/
static std::string electDescription(const std::string& logFile);
/**
* Set updates
*/
void setUpdates(CDbMessageQueue* updates);
/**
* Create updates
*/
void createUpdates();
/**
* Get Updates
*/
CDbMessageQueue* getUpdates() { return _Updates; }
private:
bool _OwnUpdates;
/// Updates contained in message
CDbMessageQueue* _Updates;
/// Release Updates (and delete if owned)
void releaseUpdates()
{
if (_OwnUpdates && _Updates != NULL)
delete _Updates;
_Updates = NULL;
_OwnUpdates = false;
}
};
//
// CDbMessage inline methods
//
inline void CDbMessage::serial(NLMISC::IStream &f, TObjectIndexCircMapper& indexMapper, TEntityIdCircMapper& eidMapper)
{
switch (_Type)
{
case UpdateValue:
{
uint8 flags = (objectEntityIdPresent() ? 0x80 : 0);
indexMapper.serial(f, _ObjectIndex, flags);
_ObjectIdPresent = ((flags & 0x80) != 0);
f.serial(_ColumnAndSize);
switch (_ColumnAndSize & 0xc000)
{
case 0x0000: f.serial(_Value0[0]); break;
case 0x4000: f.serial(_Value1[0]); break;
case 0x8000: f.serial(_Value2[0]); break;
case 0xc000: f.serial(_Value3[0]); break;
}
// serial owner CEntityId if present
if (objectEntityIdPresent())
eidMapper.serial(f, _ObjectId);
}
break;
case SetParent:
{
uint8 flags = (objectEntityIdPresent() ? 0x80 : 0);
indexMapper.serial(f, _ObjectIndex, flags);
_ObjectIdPresent = ((flags & 0x80) != 0);
f.serial(_ColumnAndSize);
f.serial(_Value3[0]);
// serial object CEntityId if present
if (objectEntityIdPresent())
eidMapper.serial(f, _ObjectId);
// serial parents CEntityId if present
if ((_ColumnAndSize & MESSAGE_SETPARENT_ENTITYID_PRESENT) != 0)
{
eidMapper.serial(f, _NewParentId);
eidMapper.serial(f, _PreviousParentId);
}
}
break;
case AllocRow:
{
uint8 flags = (objectEntityIdPresent() ? 0x80 : 0);
indexMapper.serial(f, _ObjectIndex, flags);
_ObjectIdPresent = ((flags & 0x80) != 0);
f.serial(_Value3[0]);
// serial owner CEntityId if present
if (objectEntityIdPresent())
eidMapper.serial(f, _ObjectId);
}
break;
case DeallocRow:
{
uint8 flags = (objectEntityIdPresent() ? 0x80 : 0);
indexMapper.serial(f, _ObjectIndex, flags);
_ObjectIdPresent = ((flags & 0x80) != 0);
// serial owner CEntityId if present
if (objectEntityIdPresent())
eidMapper.serial(f, _ObjectId);
}
break;
case LoadRow:
f.serial(_ObjectIndex.Table);
f.serial(_Value3[0]);
break;
case AddString:
f.serial(_Value3[0]);
f.serial(_String);
break;
case UnmapString:
f.serial(_Value3[0]);
break;
case ReleaseRow:
indexMapper.serial(f, _ObjectIndex);
break;
case Log:
{
f.serial(_LogId);
if (f.isReading())
{
uint8 sz;
f.serial(sz);
_LogBuffer.resize(sz);
if (sz > 0)
f.serialBuffer(&(_LogBuffer[0]), sz);
f.serial(sz);
_ExtLogBuffer.resize(sz);
if (sz > 0)
f.serialBuffer(&(_ExtLogBuffer[0]), sz);
}
else
{
uint8 sz;
nlassert(_LogBuffer.size() <= 255);
sz = (uint8)_LogBuffer.size();
f.serial(sz);
if (sz > 0)
f.serialBuffer(&(_LogBuffer[0]), sz);
nlassert(_ExtLogBuffer.size() <= 255);
sz = (uint8)_ExtLogBuffer.size();
f.serial(sz);
if (sz > 0)
f.serialBuffer(&(_ExtLogBuffer[0]), sz);
}
}
break;
case PushContext:
break;
case PopContext:
break;
case LogChat:
// serial chat sentence
f.serial(_String);
// serial sender
f.serial(_Value3[0]);
// serial receivers list (whole buffer as uint8*)
f.serialCont(_LogBuffer);
break;
default:
nlerror("CDbMessage::serial(): unable to serial message type '%d'", _Type);
break;
}
}
/*
* Get Message Header Size
*/
inline uint32 CDbMessage::getMessageHeaderSize()
{
uint size = 0;
switch (_Type)
{
case UpdateValue:
case SetParent:
size += sizeof(_ObjectIndex.Table)+sizeof(_ObjectIndex.Row);
size += sizeof(_ColumnAndSize);
break;
case AllocRow:
size += sizeof(_ObjectIndex.Table)+sizeof(_ObjectIndex.Row);
break;
case DeallocRow:
size += sizeof(_ObjectIndex.Table)+sizeof(_ObjectIndex.Row);
break;
case LoadRow:
size += sizeof(_ObjectIndex.Table);
size += sizeof(_Value3[0]);
break;
case ReleaseRow:
size += sizeof(_ObjectIndex.Table)+sizeof(_ObjectIndex.Row);
break;
case Log:
size += sizeof(_LogId);
size += 2;
break;
default:
break;
}
return size;
}
/*
* Serial log
*/
inline void CUpdateLog::serial(NLMISC::IStream& f)
{
f.serialCheck(NELID("ULOG"));
uint version = f.serialVersion(1);
f.serial(UpdateId);
if (version >= 1)
{
f.serial(StartStamp);
f.serial(EndStamp);
}
if (f.isReading())
{
releaseUpdates();
_Updates = new RY_PDS::CDbMessageQueue();
_OwnUpdates = true;
}
f.serial(*_Updates);
}
}; // RY_PDS
#endif //RY_PD_MESSAGES_H
Reference in a new issue View git blame Copy permalink