Resolve "Toggle Free Look with Hotkey"

[ryzomcore.git] / ryzom / server / src / shard_unifier_service / database_mapping.h

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010-2021  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/>.

/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////

#ifndef DATABASE_MAPPING
#define DATABASE_MAPPING
#include "nel/misc/types_nl.h"
#include <memory>
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/string_conversion.h"
#include "nel/net/message.h"
#include "nel/net/module.h"
#include "nel/net/module_builder_parts.h"
#include "nel/net/module_message.h"
#include "nel/net/module_gateway.h"

#include "nel/misc/string_common.h"
#include "server_share/mysql_wrapper.h"

#include "ring_session_manager.h"
        
#include "game_share/ring_session_manager_itf.h"
        
#include "game_share/character_sync_itf.h"
        
namespace RSMGR
{
        
        class CKnownUser;

        class CKnownUserPtr;
        class CSessionParticipant;

        class CSessionParticipantPtr;
        class CCharacter;

        class CCharacterPtr;
        class CRingUser;

        class CRingUserPtr;
        class CSession;

        class CSessionPtr;
        class CShard;

        class CShardPtr;
        class CGuild;

        class CGuildPtr;
        class CGuildInvite;

        class CGuildInvitePtr;
        class CPlayerRating;

        class CPlayerRatingPtr;
        class CJournalEntry;

        class CJournalEntryPtr;
        class CFolder;

        class CFolderPtr;
        class CFolderAccess;

        class CFolderAccessPtr;
        class CScenario;

        class CScenarioPtr;
        class CSessionLog;

        class CSessionLogPtr;
        class CGmStatus;

        class CGmStatusPtr;



        class CKnownUserPtr
        {
                friend class CKnownUser;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CKnownUserPtr   *_NextPtr;
                CKnownUserPtr   *_PrevPtr;

                CKnownUser      *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CKnownUserPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CKnownUserPtr(const CKnownUserPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CKnownUserPtr(const CKnownUserPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CKnownUserPtr(CKnownUser *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CKnownUserPtr &assign(const CKnownUserPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CKnownUserPtr()
                {
                        unlinkPtr();
                }

                CKnownUserPtr &assign(CKnownUser *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CKnownUserPtr &operator =(const CKnownUserPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CKnownUser *operator ->()
                {
                        return _Ptr;
                }
                const CKnownUser *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CKnownUserPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CKnownUserPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CKnownUser *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CKnownUser *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CKnownUserPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CKnownUserPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CSessionParticipantPtr
        {
                friend class CSessionParticipant;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CSessionParticipantPtr  *_NextPtr;
                CSessionParticipantPtr  *_PrevPtr;

                CSessionParticipant     *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CSessionParticipantPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CSessionParticipantPtr(const CSessionParticipantPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionParticipantPtr(const CSessionParticipantPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionParticipantPtr(CSessionParticipant *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CSessionParticipantPtr &assign(const CSessionParticipantPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CSessionParticipantPtr()
                {
                        unlinkPtr();
                }

                CSessionParticipantPtr &assign(CSessionParticipant *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CSessionParticipantPtr &operator =(const CSessionParticipantPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CSessionParticipant *operator ->()
                {
                        return _Ptr;
                }
                const CSessionParticipant *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CSessionParticipantPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CSessionParticipantPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CSessionParticipant *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CSessionParticipant *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CSessionParticipantPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CSessionParticipantPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CCharacterPtr
        {
                friend class CCharacter;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CCharacterPtr   *_NextPtr;
                CCharacterPtr   *_PrevPtr;

                CCharacter      *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CCharacterPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CCharacterPtr(const CCharacterPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CCharacterPtr(const CCharacterPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CCharacterPtr(CCharacter *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CCharacterPtr &assign(const CCharacterPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CCharacterPtr()
                {
                        unlinkPtr();
                }

                CCharacterPtr &assign(CCharacter *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CCharacterPtr &operator =(const CCharacterPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CCharacter *operator ->()
                {
                        return _Ptr;
                }
                const CCharacter *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CCharacterPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CCharacterPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CCharacter *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CCharacter *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CCharacterPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CCharacterPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CRingUserPtr
        {
                friend class CRingUser;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CRingUserPtr    *_NextPtr;
                CRingUserPtr    *_PrevPtr;

                CRingUser       *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CRingUserPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CRingUserPtr(const CRingUserPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CRingUserPtr(const CRingUserPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CRingUserPtr(CRingUser *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CRingUserPtr &assign(const CRingUserPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CRingUserPtr()
                {
                        unlinkPtr();
                }

                CRingUserPtr &assign(CRingUser *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CRingUserPtr &operator =(const CRingUserPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CRingUser *operator ->()
                {
                        return _Ptr;
                }
                const CRingUser *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CRingUserPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CRingUserPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CRingUser *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CRingUser *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CRingUserPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CRingUserPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CSessionPtr
        {
                friend class CSession;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CSessionPtr     *_NextPtr;
                CSessionPtr     *_PrevPtr;

                CSession        *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CSessionPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CSessionPtr(const CSessionPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionPtr(const CSessionPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionPtr(CSession *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CSessionPtr &assign(const CSessionPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CSessionPtr()
                {
                        unlinkPtr();
                }

                CSessionPtr &assign(CSession *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CSessionPtr &operator =(const CSessionPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CSession *operator ->()
                {
                        return _Ptr;
                }
                const CSession *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CSessionPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CSessionPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CSession *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CSession *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CSessionPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CSessionPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CShardPtr
        {
                friend class CShard;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CShardPtr       *_NextPtr;
                CShardPtr       *_PrevPtr;

                CShard  *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CShardPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CShardPtr(const CShardPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CShardPtr(const CShardPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CShardPtr(CShard *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CShardPtr &assign(const CShardPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CShardPtr()
                {
                        unlinkPtr();
                }

                CShardPtr &assign(CShard *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CShardPtr &operator =(const CShardPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CShard *operator ->()
                {
                        return _Ptr;
                }
                const CShard *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CShardPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CShardPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CShard *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CShard *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CShardPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CShardPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CGuildPtr
        {
                friend class CGuild;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CGuildPtr       *_NextPtr;
                CGuildPtr       *_PrevPtr;

                CGuild  *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CGuildPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CGuildPtr(const CGuildPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGuildPtr(const CGuildPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGuildPtr(CGuild *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CGuildPtr &assign(const CGuildPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CGuildPtr()
                {
                        unlinkPtr();
                }

                CGuildPtr &assign(CGuild *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CGuildPtr &operator =(const CGuildPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CGuild *operator ->()
                {
                        return _Ptr;
                }
                const CGuild *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CGuildPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CGuildPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CGuild *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CGuild *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CGuildPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CGuildPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CGuildInvitePtr
        {
                friend class CGuildInvite;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CGuildInvitePtr *_NextPtr;
                CGuildInvitePtr *_PrevPtr;

                CGuildInvite    *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CGuildInvitePtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CGuildInvitePtr(const CGuildInvitePtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGuildInvitePtr(const CGuildInvitePtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGuildInvitePtr(CGuildInvite *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CGuildInvitePtr &assign(const CGuildInvitePtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CGuildInvitePtr()
                {
                        unlinkPtr();
                }

                CGuildInvitePtr &assign(CGuildInvite *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CGuildInvitePtr &operator =(const CGuildInvitePtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CGuildInvite *operator ->()
                {
                        return _Ptr;
                }
                const CGuildInvite *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CGuildInvitePtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CGuildInvitePtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CGuildInvite *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CGuildInvite *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CGuildInvitePtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CGuildInvitePtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CPlayerRatingPtr
        {
                friend class CPlayerRating;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CPlayerRatingPtr        *_NextPtr;
                CPlayerRatingPtr        *_PrevPtr;

                CPlayerRating   *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CPlayerRatingPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CPlayerRatingPtr(const CPlayerRatingPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CPlayerRatingPtr(const CPlayerRatingPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CPlayerRatingPtr(CPlayerRating *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CPlayerRatingPtr &assign(const CPlayerRatingPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CPlayerRatingPtr()
                {
                        unlinkPtr();
                }

                CPlayerRatingPtr &assign(CPlayerRating *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CPlayerRatingPtr &operator =(const CPlayerRatingPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CPlayerRating *operator ->()
                {
                        return _Ptr;
                }
                const CPlayerRating *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CPlayerRatingPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CPlayerRatingPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CPlayerRating *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CPlayerRating *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CPlayerRatingPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CPlayerRatingPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CJournalEntryPtr
        {
                friend class CJournalEntry;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CJournalEntryPtr        *_NextPtr;
                CJournalEntryPtr        *_PrevPtr;

                CJournalEntry   *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CJournalEntryPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CJournalEntryPtr(const CJournalEntryPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CJournalEntryPtr(const CJournalEntryPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CJournalEntryPtr(CJournalEntry *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CJournalEntryPtr &assign(const CJournalEntryPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CJournalEntryPtr()
                {
                        unlinkPtr();
                }

                CJournalEntryPtr &assign(CJournalEntry *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CJournalEntryPtr &operator =(const CJournalEntryPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CJournalEntry *operator ->()
                {
                        return _Ptr;
                }
                const CJournalEntry *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CJournalEntryPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CJournalEntryPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CJournalEntry *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CJournalEntry *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CJournalEntryPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CJournalEntryPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CFolderPtr
        {
                friend class CFolder;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CFolderPtr      *_NextPtr;
                CFolderPtr      *_PrevPtr;

                CFolder *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CFolderPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CFolderPtr(const CFolderPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CFolderPtr(const CFolderPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CFolderPtr(CFolder *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CFolderPtr &assign(const CFolderPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CFolderPtr()
                {
                        unlinkPtr();
                }

                CFolderPtr &assign(CFolder *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CFolderPtr &operator =(const CFolderPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CFolder *operator ->()
                {
                        return _Ptr;
                }
                const CFolder *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CFolderPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CFolderPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CFolder *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CFolder *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CFolderPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CFolderPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CFolderAccessPtr
        {
                friend class CFolderAccess;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CFolderAccessPtr        *_NextPtr;
                CFolderAccessPtr        *_PrevPtr;

                CFolderAccess   *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CFolderAccessPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CFolderAccessPtr(const CFolderAccessPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CFolderAccessPtr(const CFolderAccessPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CFolderAccessPtr(CFolderAccess *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CFolderAccessPtr &assign(const CFolderAccessPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CFolderAccessPtr()
                {
                        unlinkPtr();
                }

                CFolderAccessPtr &assign(CFolderAccess *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CFolderAccessPtr &operator =(const CFolderAccessPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CFolderAccess *operator ->()
                {
                        return _Ptr;
                }
                const CFolderAccess *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CFolderAccessPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CFolderAccessPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CFolderAccess *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CFolderAccess *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CFolderAccessPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CFolderAccessPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CScenarioPtr
        {
                friend class CScenario;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CScenarioPtr    *_NextPtr;
                CScenarioPtr    *_PrevPtr;

                CScenario       *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CScenarioPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CScenarioPtr(const CScenarioPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CScenarioPtr(const CScenarioPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CScenarioPtr(CScenario *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CScenarioPtr &assign(const CScenarioPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CScenarioPtr()
                {
                        unlinkPtr();
                }

                CScenarioPtr &assign(CScenario *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CScenarioPtr &operator =(const CScenarioPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CScenario *operator ->()
                {
                        return _Ptr;
                }
                const CScenario *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CScenarioPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CScenarioPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CScenario *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CScenario *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CScenarioPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CScenarioPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CSessionLogPtr
        {
                friend class CSessionLog;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CSessionLogPtr  *_NextPtr;
                CSessionLogPtr  *_PrevPtr;

                CSessionLog     *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CSessionLogPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CSessionLogPtr(const CSessionLogPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionLogPtr(const CSessionLogPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CSessionLogPtr(CSessionLog *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CSessionLogPtr &assign(const CSessionLogPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CSessionLogPtr()
                {
                        unlinkPtr();
                }

                CSessionLogPtr &assign(CSessionLog *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CSessionLogPtr &operator =(const CSessionLogPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CSessionLog *operator ->()
                {
                        return _Ptr;
                }
                const CSessionLog *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CSessionLogPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CSessionLogPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CSessionLog *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CSessionLog *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CSessionLogPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CSessionLogPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };





        class CGmStatusPtr
        {
                friend class CGmStatus;

                const   char    *_FileName;
                uint32                  _LineNum;

                // linked list of smart ptr
                CGmStatusPtr    *_NextPtr;
                CGmStatusPtr    *_PrevPtr;

                CGmStatus       *_Ptr;

                void linkPtr();

                void unlinkPtr();

        public:
                CGmStatusPtr()
                        : _FileName(NULL),
                        _LineNum(0),
                        _Ptr(NULL),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                }

                CGmStatusPtr(const CGmStatusPtr &other, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGmStatusPtr(const CGmStatusPtr &other)
                        : _FileName(other._FileName),
                        _LineNum(other._LineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        // point the same object
                        _Ptr = other._Ptr;
                        // insert the pointer in the list
                        linkPtr();
                }

                CGmStatusPtr(CGmStatus *objectPtr, const char *filename, uint32 lineNum)
                        : _FileName(filename),
                        _LineNum(lineNum),
                        _NextPtr(NULL),
                        _PrevPtr(NULL)
                {
                        _Ptr = objectPtr;

                        linkPtr();
                }

                CGmStatusPtr &assign(const CGmStatusPtr &other, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = other._Ptr;
                        linkPtr();

                        return *this;
                }

                ~CGmStatusPtr()
                {
                        unlinkPtr();
                }

                CGmStatusPtr &assign(CGmStatus *objectPtr, const char *filename, uint32 lineNum)
                {
                        _FileName = filename;
                        _LineNum = lineNum;

                        unlinkPtr();
                        _Ptr = objectPtr;
                        linkPtr();

                        return *this;
                }

                CGmStatusPtr &operator =(const CGmStatusPtr &other)
                {
                        return assign(other, __FILE__, __LINE__);
                }

                CGmStatus *operator ->()
                {
                        return _Ptr;
                }
                const CGmStatus *operator ->() const
                {
                        return _Ptr;
                }

                bool operator == (const CGmStatusPtr &other) const
                {
                        return _Ptr == other._Ptr;
                }
                bool operator != (const CGmStatusPtr &other) const
                {
                        return !operator ==(other);
                }

                bool operator == (const CGmStatus *object) const
                {
                        return _Ptr == object;
                }
                bool operator != (const CGmStatus *object) const
                {
                        return !operator ==(object);
                }

                /// Less then comparator : comparison on pointer object address
                bool operator < (const CGmStatusPtr &other) const
                {
                        return _Ptr < other._Ptr;
                }

                /// Used to walk thrue the linked list of pointer
                CGmStatusPtr *getNextPtr()
                {
                        return _NextPtr;
                }
        };




        struct TUserType
        {
                enum TValues
                {
                        ut_character = 1,
                        ut_pioneer,
                        /// the highest valid value in the enum
                        last_enum_item = ut_pioneer,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 2
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(ut_character, 0));
                                indexTable.insert(std::make_pair(ut_pioneer, 1));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ut_character)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ut_pioneer)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TUserType()
                        : _Value(invalid_val)
                {
                }
                TUserType(TValues value)
                        : _Value(value)
                {
                }

                TUserType(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TUserType &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TUserType &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TUserType &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TUserType &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TUserType &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TUserType &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TKnownUserRelation
        {
                enum TValues
                {
                        rt_friend = 1,
                        rt_banned,
                        rt_friend_dm,
                        /// the highest valid value in the enum
                        last_enum_item = rt_friend_dm,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 3
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(rt_friend, 0));
                                indexTable.insert(std::make_pair(rt_banned, 1));
                                indexTable.insert(std::make_pair(rt_friend_dm, 2));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rt_friend)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rt_banned)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rt_friend_dm)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TKnownUserRelation()
                        : _Value(invalid_val)
                {
                }
                TKnownUserRelation(TValues value)
                        : _Value(value)
                {
                }

                TKnownUserRelation(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TKnownUserRelation &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TKnownUserRelation &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TKnownUserRelation &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TKnownUserRelation &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TKnownUserRelation &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TKnownUserRelation &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CKnownUser
        {
        protected:
                // 
                uint32  _RelationId;
                // 
                uint32  _OwnerId;
                // 
                uint32  _TargetUser;
                // 
                uint32  _TargetCharacter;
                // 
                TKnownUserRelation      _Relation;
                // 
                std::string     _Comments;
        public:
                // 
                uint32 getOwnerId() const
                {
                        return _OwnerId;
                }

                void setOwnerId(uint32 value)
                {

                        if (_OwnerId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _OwnerId = value;

                        }

                }
                        // 
                uint32 getTargetUser() const
                {
                        return _TargetUser;
                }

                void setTargetUser(uint32 value)
                {

                        if (_TargetUser != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _TargetUser = value;

                        }

                }
                        // 
                uint32 getTargetCharacter() const
                {
                        return _TargetCharacter;
                }

                void setTargetCharacter(uint32 value)
                {

                        if (_TargetCharacter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _TargetCharacter = value;

                        }

                }
                        // 
                TKnownUserRelation getRelation() const
                {
                        return _Relation;
                }

                void setRelation(TKnownUserRelation value)
                {

                        if (_Relation != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Relation = value;

                        }

                }
                        // 
                const std::string &getComments() const
                {
                        return _Comments;
                }



                void setComments(const std::string &value)
                {

                        if (_Comments != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Comments = value;

                                
                        }

                }
        
                bool operator == (const CKnownUser &other) const
                {
                        return _RelationId == other._RelationId
                                && _OwnerId == other._OwnerId
                                && _TargetUser == other._TargetUser
                                && _TargetCharacter == other._TargetCharacter
                                && _Relation == other._Relation
                                && _Comments == other._Comments;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CKnownUser()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _RelationId(NOPE::INVALID_OBJECT_ID)
                {

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CKnownUser();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CKnownUserPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CKnownUserPtr(new CKnownUser(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CKnownUserPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CRingUser and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCRingUser(MSW::CConnection &connection, uint32 parentId, std::vector < CKnownUserPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CCharacter and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCCharacter(MSW::CConnection &connection, uint32 parentId, std::vector < CKnownUserPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CKnownUserPtr;

                typedef std::map<uint32, CKnownUser*>   TObjectCache;
                typedef std::set<CKnownUser*>                   TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CKnownUserPtr           *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CKnownUser *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CKnownUserPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CKnownUserPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _RelationId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_RelationId == NOPE::INVALID_OBJECT_ID);
                        _RelationId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CSessionParticipant
        {
        protected:
                // 
                uint32  _Id;
                // 
                TSessionId      _SessionId;
                // 
                uint32  _CharId;
                // 
                TSessionPartStatus      _Status;
                // 
                bool    _Kicked;
        public:
                // 
                TSessionId getSessionId() const
                {
                        return _SessionId;
                }

                void setSessionId(TSessionId value)
                {

                        if (_SessionId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SessionId = value;

                        }

                }
                        // 
                uint32 getCharId() const
                {
                        return _CharId;
                }

                void setCharId(uint32 value)
                {

                        if (_CharId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CharId = value;

                        }

                }
                        // 
                TSessionPartStatus getStatus() const
                {
                        return _Status;
                }

                void setStatus(TSessionPartStatus value)
                {

                        if (_Status != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Status = value;

                        }

                }
                        // 
                bool getKicked() const
                {
                        return _Kicked;
                }

                void setKicked(bool value)
                {

                        if (_Kicked != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Kicked = value;

                        }

                }
        
                bool operator == (const CSessionParticipant &other) const
                {
                        return _Id == other._Id
                                && _SessionId == other._SessionId
                                && _CharId == other._CharId
                                && _Status == other._Status
                                && _Kicked == other._Kicked;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CSessionParticipant()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _Kicked = false;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CSessionParticipant();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CSessionParticipantPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CSessionParticipantPtr(new CSessionParticipant(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CSessionParticipantPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CCharacter and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCCharacter(MSW::CConnection &connection, uint32 parentId, std::vector < CSessionParticipantPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CSession and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCSession(MSW::CConnection &connection, uint32 parentId, std::vector < CSessionParticipantPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CSessionParticipantPtr;

                typedef std::map<uint32, CSessionParticipant*>  TObjectCache;
                typedef std::set<CSessionParticipant*>                  TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CSessionParticipantPtr          *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CSessionParticipant *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CSessionParticipantPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CSessionParticipantPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CCharacter
        {
        protected:
                // 
                uint32  _CharId;
                // 
                std::string     _CharName;
                // 
                uint32  _UserId;
                // 
                uint32  _GuildId;
                // 
                uint32  _BestCombatLevel;
                // 
                uint32  _HomeMainlandSessionId;
                // 
                std::string     _RingAccess;
                // 
                CHARSYNC::TRace _Race;
                // 
                CHARSYNC::TCivilisation _Civilisation;
                // 
                CHARSYNC::TCult _Cult;
                // 
                uint32  _CurrentSession;
                // 
                uint32  _RRPAM;
                // 
                uint32  _RRPMasterless;
                // 
                uint32  _RRPAuthor;
                // 
                bool    _Newcomer;
                // 
                uint32  _CreationDate;
                // 
                uint32  _LastPlayedDate;

                friend class CSession;

                std::vector < CSessionPtr >     *_Sessions;

                friend class CSessionParticipant;

                std::vector < CSessionParticipantPtr >  *_SessionParticipants;

                friend class CKnownUser;

                std::vector < CKnownUserPtr >   *_KnownBy;

                friend class CPlayerRating;

                std::vector < CPlayerRatingPtr >        *_PlayerRatings;
        public:
                // 
                const std::string &getCharName() const
                {
                        return _CharName;
                }



                void setCharName(const std::string &value)
                {

                        if (_CharName != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _CharName = value;

                                
                        }

                }
                        // 
                uint32 getUserId() const
                {
                        return _UserId;
                }

                void setUserId(uint32 value)
                {

                        if (_UserId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _UserId = value;

                        }

                }
                        // 
                uint32 getGuildId() const
                {
                        return _GuildId;
                }

                void setGuildId(uint32 value)
                {

                        if (_GuildId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _GuildId = value;

                        }

                }
                        // 
                uint32 getBestCombatLevel() const
                {
                        return _BestCombatLevel;
                }

                void setBestCombatLevel(uint32 value)
                {

                        if (_BestCombatLevel != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _BestCombatLevel = value;

                        }

                }
                        // 
                uint32 getHomeMainlandSessionId() const
                {
                        return _HomeMainlandSessionId;
                }

                void setHomeMainlandSessionId(uint32 value)
                {

                        if (_HomeMainlandSessionId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _HomeMainlandSessionId = value;

                        }

                }
                        // 
                const std::string &getRingAccess() const
                {
                        return _RingAccess;
                }



                void setRingAccess(const std::string &value)
                {

                        if (_RingAccess != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _RingAccess = value;

                                
                        }

                }
                        // 
                CHARSYNC::TRace getRace() const
                {
                        return _Race;
                }

                void setRace(CHARSYNC::TRace value)
                {

                        if (_Race != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Race = value;

                        }

                }
                        // 
                CHARSYNC::TCivilisation getCivilisation() const
                {
                        return _Civilisation;
                }

                void setCivilisation(CHARSYNC::TCivilisation value)
                {

                        if (_Civilisation != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Civilisation = value;

                        }

                }
                        // 
                CHARSYNC::TCult getCult() const
                {
                        return _Cult;
                }

                void setCult(CHARSYNC::TCult value)
                {

                        if (_Cult != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Cult = value;

                        }

                }
                        // 
                uint32 getCurrentSession() const
                {
                        return _CurrentSession;
                }

                void setCurrentSession(uint32 value)
                {

                        if (_CurrentSession != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentSession = value;

                        }

                }
                        // 
                uint32 getRRPAM() const
                {
                        return _RRPAM;
                }

                void setRRPAM(uint32 value)
                {

                        if (_RRPAM != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RRPAM = value;

                        }

                }
                        // 
                uint32 getRRPMasterless() const
                {
                        return _RRPMasterless;
                }

                void setRRPMasterless(uint32 value)
                {

                        if (_RRPMasterless != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RRPMasterless = value;

                        }

                }
                        // 
                uint32 getRRPAuthor() const
                {
                        return _RRPAuthor;
                }

                void setRRPAuthor(uint32 value)
                {

                        if (_RRPAuthor != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RRPAuthor = value;

                        }

                }
                        // 
                bool getNewcomer() const
                {
                        return _Newcomer;
                }

                void setNewcomer(bool value)
                {

                        if (_Newcomer != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Newcomer = value;

                        }

                }
                        // 
                uint32 getCreationDate() const
                {
                        return _CreationDate;
                }

                void setCreationDate(uint32 value)
                {

                        if (_CreationDate != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CreationDate = value;

                        }

                }
                        // 
                uint32 getLastPlayedDate() const
                {
                        return _LastPlayedDate;
                }

                void setLastPlayedDate(uint32 value)
                {

                        if (_LastPlayedDate != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _LastPlayedDate = value;

                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CSessionPtr> &getSessions() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CSessionPtr &getSessionsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CSessionPtr &getSessionsById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CSessionParticipantPtr> &getSessionParticipants() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CSessionParticipantPtr &getSessionParticipantsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CSessionParticipantPtr &getSessionParticipantsById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CKnownUserPtr> &getKnownBy() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CKnownUserPtr &getKnownByByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CKnownUserPtr &getKnownByById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CPlayerRatingPtr> &getPlayerRatings() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CPlayerRatingPtr &getPlayerRatingsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CPlayerRatingPtr &getPlayerRatingsById(uint32 id) const;

        
                bool operator == (const CCharacter &other) const
                {
                        return _CharId == other._CharId
                                && _CharName == other._CharName
                                && _UserId == other._UserId
                                && _GuildId == other._GuildId
                                && _BestCombatLevel == other._BestCombatLevel
                                && _HomeMainlandSessionId == other._HomeMainlandSessionId
                                && _RingAccess == other._RingAccess
                                && _Race == other._Race
                                && _Civilisation == other._Civilisation
                                && _Cult == other._Cult
                                && _CurrentSession == other._CurrentSession
                                && _RRPAM == other._RRPAM
                                && _RRPMasterless == other._RRPMasterless
                                && _RRPAuthor == other._RRPAuthor
                                && _Newcomer == other._Newcomer
                                && _CreationDate == other._CreationDate
                                && _LastPlayedDate == other._LastPlayedDate;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CCharacter()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _CharId(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _GuildId = 0;
                        _BestCombatLevel = 0;
                        _HomeMainlandSessionId = 0;
                        _CurrentSession = 0;
                        _RRPAM = 0;
                        _RRPMasterless = 0;
                        _RRPAuthor = 0;
                        _Newcomer = 1;
                        _LastPlayedDate = 0;
                        _Sessions = NULL;
                        _SessionParticipants = NULL;
                        _KnownBy = NULL;
                        _PlayerRatings = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CCharacter();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CCharacterPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CCharacterPtr(new CCharacter(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CCharacterPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CRingUser and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCRingUser(MSW::CConnection &connection, uint32 parentId, std::map < uint32, CCharacterPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CGuild and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCGuild(MSW::CConnection &connection, uint32 parentId, std::vector < CCharacterPtr > &children, const char *filename, uint32 lineNum);

                /// Load Sessions child(ren) object(s).
                bool loadSessions(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load SessionParticipants child(ren) object(s).
                bool loadSessionParticipants(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load KnownBy child(ren) object(s).
                bool loadKnownBy(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load PlayerRatings child(ren) object(s).
                bool loadPlayerRatings(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CCharacterPtr;

                typedef std::map<uint32, CCharacter*>   TObjectCache;
                typedef std::set<CCharacter*>                   TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CCharacterPtr           *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CCharacter *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CCharacterPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CCharacterPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _CharId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_CharId == NOPE::INVALID_OBJECT_ID);
                        _CharId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


        

        struct TCurrentActivity
        {
                enum TValues
                {
                        ca_none = 1,
                        ca_play,
                        ca_edit,
                        ca_anim,
                        /// the highest valid value in the enum
                        last_enum_item = ca_anim,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 4
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(ca_none, 0));
                                indexTable.insert(std::make_pair(ca_play, 1));
                                indexTable.insert(std::make_pair(ca_edit, 2));
                                indexTable.insert(std::make_pair(ca_anim, 3));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ca_none)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ca_play)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ca_edit)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ca_anim)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TCurrentActivity()
                        : _Value(invalid_val)
                {
                }
                TCurrentActivity(TValues value)
                        : _Value(value)
                {
                }

                TCurrentActivity(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TCurrentActivity &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TCurrentActivity &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TCurrentActivity &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TCurrentActivity &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TCurrentActivity &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TCurrentActivity &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TCurrentStatus
        {
                enum TValues
                {
                        cs_offline = 1,
                        cs_logged,
                        cs_online,
                        /// the highest valid value in the enum
                        last_enum_item = cs_online,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 3
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(cs_offline, 0));
                                indexTable.insert(std::make_pair(cs_logged, 1));
                                indexTable.insert(std::make_pair(cs_online, 2));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(cs_offline)
                                NL_STRING_CONVERSION_TABLE_ENTRY(cs_logged)
                                NL_STRING_CONVERSION_TABLE_ENTRY(cs_online)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TCurrentStatus()
                        : _Value(invalid_val)
                {
                }
                TCurrentStatus(TValues value)
                        : _Value(value)
                {
                }

                TCurrentStatus(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TCurrentStatus &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TCurrentStatus &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TCurrentStatus &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TCurrentStatus &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TCurrentStatus &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TCurrentStatus &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TPublicLevel
        {
                enum TValues
                {
                        ul_none = 1,
                        ul_public,
                        /// the highest valid value in the enum
                        last_enum_item = ul_public,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 2
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(ul_none, 0));
                                indexTable.insert(std::make_pair(ul_public, 1));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ul_none)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ul_public)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TPublicLevel()
                        : _Value(invalid_val)
                {
                }
                TPublicLevel(TValues value)
                        : _Value(value)
                {
                }

                TPublicLevel(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TPublicLevel &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TPublicLevel &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TPublicLevel &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TPublicLevel &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TPublicLevel &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TPublicLevel &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TAccountType
        {
                enum TValues
                {
                        at_normal = 1,
                        at_gold,
                        /// the highest valid value in the enum
                        last_enum_item = at_gold,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 2
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(at_normal, 0));
                                indexTable.insert(std::make_pair(at_gold, 1));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(at_normal)
                                NL_STRING_CONVERSION_TABLE_ENTRY(at_gold)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TAccountType()
                        : _Value(invalid_val)
                {
                }
                TAccountType(TValues value)
                        : _Value(value)
                {
                }

                TAccountType(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TAccountType &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TAccountType &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TAccountType &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TAccountType &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TAccountType &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TAccountType &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TLanguage
        {
                enum TValues
                {
                        lang_en = 1,
                        lang_fr,
                        lang_de,
                        lang_other,
                        /// the highest valid value in the enum
                        last_enum_item = lang_other,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 4
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(lang_en, 0));
                                indexTable.insert(std::make_pair(lang_fr, 1));
                                indexTable.insert(std::make_pair(lang_de, 2));
                                indexTable.insert(std::make_pair(lang_other, 3));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(lang_en)
                                NL_STRING_CONVERSION_TABLE_ENTRY(lang_fr)
                                NL_STRING_CONVERSION_TABLE_ENTRY(lang_de)
                                NL_STRING_CONVERSION_TABLE_ENTRY(lang_other)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TLanguage()
                        : _Value(invalid_val)
                {
                }
                TLanguage(TValues value)
                        : _Value(value)
                {
                }

                TLanguage(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TLanguage &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TLanguage &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TLanguage &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TLanguage &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TLanguage &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TLanguage &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CRingUser
        {
        protected:
                // 
                uint32  _UserId;
                // 
                std::string     _UserName;
                // 
                uint32  _CurrentCharacter;
                // 
                uint32  _CurrentSession;
                // 
                TCurrentActivity        _CurrentActivity;
                // 
                TCurrentStatus  _CurrentStatus;
                // 
                TPublicLevel    _PublicLevel;
                // 
                TAccountType    _AccountType;
                // 
                std::string     _ContentAccessLevel;
                // 
                std::string     _Description;
                // 
                TLanguage       _Lang;
                // 
                std::string     _Cookie;
                // 
                sint32  _CurrentDomainId;
                // 
                std::string     _AddedPrivileges;

                friend class CKnownUser;

                std::vector < CKnownUserPtr >   *_KnownUsers;

                friend class CCharacter;

                std::map < uint32,  CCharacterPtr >     *_Characters;

                friend class CFolder;

                std::vector < CFolderPtr >      *_Folders;

                friend class CFolderAccess;

                std::vector < CFolderAccessPtr >        *_FolderAccess;
                friend class CGmStatus;
                bool                                                            _GMStatusLoaded;
                CGmStatusPtr    _GMStatus;
        public:
                // 
                const std::string &getUserName() const
                {
                        return _UserName;
                }



                void setUserName(const std::string &value)
                {

                        if (_UserName != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _UserName = value;

                                
                        }

                }
                        // 
                uint32 getCurrentCharacter() const
                {
                        return _CurrentCharacter;
                }

                void setCurrentCharacter(uint32 value)
                {

                        if (_CurrentCharacter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentCharacter = value;

                        }

                }
                        // 
                uint32 getCurrentSession() const
                {
                        return _CurrentSession;
                }

                void setCurrentSession(uint32 value)
                {

                        if (_CurrentSession != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentSession = value;

                        }

                }
                        // 
                TCurrentActivity getCurrentActivity() const
                {
                        return _CurrentActivity;
                }

                void setCurrentActivity(TCurrentActivity value)
                {

                        if (_CurrentActivity != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentActivity = value;

                        }

                }
                        // 
                TCurrentStatus getCurrentStatus() const
                {
                        return _CurrentStatus;
                }

                void setCurrentStatus(TCurrentStatus value)
                {

                        if (_CurrentStatus != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentStatus = value;

                        }

                }
                        // 
                TPublicLevel getPublicLevel() const
                {
                        return _PublicLevel;
                }

                void setPublicLevel(TPublicLevel value)
                {

                        if (_PublicLevel != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _PublicLevel = value;

                        }

                }
                        // 
                TAccountType getAccountType() const
                {
                        return _AccountType;
                }

                void setAccountType(TAccountType value)
                {

                        if (_AccountType != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _AccountType = value;

                        }

                }
                        // 
                const std::string &getContentAccessLevel() const
                {
                        return _ContentAccessLevel;
                }



                void setContentAccessLevel(const std::string &value)
                {

                        if (_ContentAccessLevel != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _ContentAccessLevel = value;

                                
                        }

                }
                        // 
                const std::string &getDescription() const
                {
                        return _Description;
                }



                void setDescription(const std::string &value)
                {

                        if (_Description != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Description = value;

                                
                        }

                }
                        // 
                TLanguage getLang() const
                {
                        return _Lang;
                }

                void setLang(TLanguage value)
                {

                        if (_Lang != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Lang = value;

                        }

                }
                        // 
                const std::string &getCookie() const
                {
                        return _Cookie;
                }



                void setCookie(const std::string &value)
                {

                        if (_Cookie != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Cookie = value;

                                
                        }

                }
                        // 
                sint32 getCurrentDomainId() const
                {
                        return _CurrentDomainId;
                }

                void setCurrentDomainId(sint32 value)
                {

                        if (_CurrentDomainId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _CurrentDomainId = value;

                        }

                }
                        // 
                const std::string &getAddedPrivileges() const
                {
                        return _AddedPrivileges;
                }



                void setAddedPrivileges(const std::string &value)
                {

                        if (_AddedPrivileges != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _AddedPrivileges = value;

                                
                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CKnownUserPtr> &getKnownUsers() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CKnownUserPtr &getKnownUsersByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CKnownUserPtr &getKnownUsersById(uint32 id) const;

        
                /** Return a const reference to the map of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following method who return non const pointer
                 *      on contained elements.
                 */
                const std::map<uint32, CCharacterPtr> &getCharacters() const;
                /** Return the identified element by looking in the map
                 *      If no element match the id, NULL pointer is returned
                 */
                CCharacterPtr &getCharactersById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CFolderPtr> &getFolders() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CFolderPtr &getFoldersByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CFolderPtr &getFoldersById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CFolderAccessPtr> &getFolderAccess() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CFolderAccessPtr &getFolderAccessByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CFolderAccessPtr &getFolderAccessById(uint32 id) const;

        
                /** Return the one child object (or null if not) */
                CGmStatusPtr getGMStatus();

                bool operator == (const CRingUser &other) const
                {
                        return _UserId == other._UserId
                                && _UserName == other._UserName
                                && _CurrentCharacter == other._CurrentCharacter
                                && _CurrentSession == other._CurrentSession
                                && _CurrentActivity == other._CurrentActivity
                                && _CurrentStatus == other._CurrentStatus
                                && _PublicLevel == other._PublicLevel
                                && _AccountType == other._AccountType
                                && _ContentAccessLevel == other._ContentAccessLevel
                                && _Description == other._Description
                                && _Lang == other._Lang
                                && _Cookie == other._Cookie
                                && _CurrentDomainId == other._CurrentDomainId
                                && _AddedPrivileges == other._AddedPrivileges;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CRingUser()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _UserId(NOPE::INVALID_OBJECT_ID)
                {
                        _KnownUsers = NULL;
                        _Characters = NULL;
                        _Folders = NULL;
                        _FolderAccess = NULL;
                        _GMStatusLoaded = false;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CRingUser();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CRingUserPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CRingUserPtr(new CRingUser(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CRingUserPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /// Load KnownUsers child(ren) object(s).
                bool loadKnownUsers(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load Characters child(ren) object(s).
                bool loadCharacters(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load Folders child(ren) object(s).
                bool loadFolders(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load FolderAccess child(ren) object(s).
                bool loadFolderAccess(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load GMStatus child(ren) object(s).
                bool loadGMStatus(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CRingUserPtr;

                typedef std::map<uint32, CRingUser*>    TObjectCache;
                typedef std::set<CRingUser*>                    TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CRingUserPtr            *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CRingUser *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CRingUserPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CRingUserPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _UserId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_UserId == NOPE::INVALID_OBJECT_ID);
                        _UserId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


        

        struct TRelationToParent
        {
                enum TValues
                {
                        rtp_same = 1,
                        rtp_variant,
                        rtp_different,
                        /// the highest valid value in the enum
                        last_enum_item = rtp_different,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 3
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(rtp_same, 0));
                                indexTable.insert(std::make_pair(rtp_variant, 1));
                                indexTable.insert(std::make_pair(rtp_different, 2));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rtp_same)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rtp_variant)
                                NL_STRING_CONVERSION_TABLE_ENTRY(rtp_different)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TRelationToParent()
                        : _Value(invalid_val)
                {
                }
                TRelationToParent(TValues value)
                        : _Value(value)
                {
                }

                TRelationToParent(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TRelationToParent &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TRelationToParent &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TRelationToParent &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TRelationToParent &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TRelationToParent &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TRelationToParent &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
        

        struct TPlayType
        {
                enum TValues
                {
                        pt_rp = 1,
                        pt_pvp,
                        /// the highest valid value in the enum
                        last_enum_item = pt_pvp,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 2
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(pt_rp, 0));
                                indexTable.insert(std::make_pair(pt_pvp, 1));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(pt_rp)
                                NL_STRING_CONVERSION_TABLE_ENTRY(pt_pvp)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TPlayType()
                        : _Value(invalid_val)
                {
                }
                TPlayType(TValues value)
                        : _Value(value)
                {
                }

                TPlayType(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TPlayType &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TPlayType &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TPlayType &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TPlayType &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TPlayType &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TPlayType &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CSession
        {
        protected:
                // 
                TSessionId      _SessionId;
                // 
                TSessionType    _SessionType;
                // 
                std::string     _Title;
                // 
                uint32  _OwnerId;
                // 
                uint32  _PlanDate;
                // 
                uint32  _StartDate;
                // 
                std::string     _Description;
                // 
                TSessionOrientation     _Orientation;
                // 
                R2::TSessionLevel       _Level;
                // 
                TRuleType       _RuleType;
                // 
                TAccessType     _AccessType;
                // 
                TSessionState   _State;
                // 
                uint32  _HostShardId;
                // 
                uint32  _SubscriptionSlots;
                // 
                uint32  _ReservedSlots;
                // 
                TEstimatedDuration      _EstimatedDuration;
                // 
                uint32  _FinalDuration;
                // 
                uint32  _FolderId;
                // 
                std::string     _Lang;
                // 
                std::string     _Icone;
                // 
                TAnimMode       _AnimMode;
                // 
                TRaceFilter     _RaceFilter;
                // 
                TReligionFilter _ReligionFilter;
                // 
                TGuildFilter    _GuildFilter;
                // 
                TShardFilter    _ShardFilter;
                // 
                TLevelFilter    _LevelFilter;
                // 
                bool    _SubscriptionClosed;
                // 
                bool    _Newcomer;

                friend class CSessionParticipant;

                std::vector < CSessionParticipantPtr >  *_SessionParticipants;

                friend class CGuildInvite;

                std::vector < CGuildInvitePtr > *_GuildInvites;

                friend class CJournalEntry;

                std::vector < CJournalEntryPtr >        *_JournalEntries;
        public:
                // 
                TSessionType getSessionType() const
                {
                        return _SessionType;
                }

                void setSessionType(TSessionType value)
                {

                        if (_SessionType != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SessionType = value;

                        }

                }
                        // 
                const std::string &getTitle() const
                {
                        return _Title;
                }



                void setTitle(const std::string &value)
                {

                        if (_Title != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Title = value;

                                
                        }

                }
                        // 
                uint32 getOwnerId() const
                {
                        return _OwnerId;
                }

                void setOwnerId(uint32 value)
                {

                        if (_OwnerId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _OwnerId = value;

                        }

                }
                        // 
                uint32 getPlanDate() const
                {
                        return _PlanDate;
                }

                void setPlanDate(uint32 value)
                {

                        if (_PlanDate != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _PlanDate = value;

                        }

                }
                        // 
                uint32 getStartDate() const
                {
                        return _StartDate;
                }

                void setStartDate(uint32 value)
                {

                        if (_StartDate != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _StartDate = value;

                        }

                }
                        // 
                const std::string &getDescription() const
                {
                        return _Description;
                }



                void setDescription(const std::string &value)
                {

                        if (_Description != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Description = value;

                                
                        }

                }
                        // 
                TSessionOrientation getOrientation() const
                {
                        return _Orientation;
                }

                void setOrientation(TSessionOrientation value)
                {

                        if (_Orientation != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Orientation = value;

                        }

                }
                        // 
                R2::TSessionLevel getLevel() const
                {
                        return _Level;
                }

                void setLevel(R2::TSessionLevel value)
                {

                        if (_Level != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Level = value;

                        }

                }
                        // 
                TRuleType getRuleType() const
                {
                        return _RuleType;
                }

                void setRuleType(TRuleType value)
                {

                        if (_RuleType != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RuleType = value;

                        }

                }
                        // 
                TAccessType getAccessType() const
                {
                        return _AccessType;
                }

                void setAccessType(TAccessType value)
                {

                        if (_AccessType != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _AccessType = value;

                        }

                }
                        // 
                TSessionState getState() const
                {
                        return _State;
                }

                void setState(TSessionState value)
                {

                        if (_State != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _State = value;

                        }

                }
                        // 
                uint32 getHostShardId() const
                {
                        return _HostShardId;
                }

                void setHostShardId(uint32 value)
                {

                        if (_HostShardId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _HostShardId = value;

                        }

                }
                        // 
                uint32 getSubscriptionSlots() const
                {
                        return _SubscriptionSlots;
                }

                void setSubscriptionSlots(uint32 value)
                {

                        if (_SubscriptionSlots != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SubscriptionSlots = value;

                        }

                }
                        // 
                uint32 getReservedSlots() const
                {
                        return _ReservedSlots;
                }

                void setReservedSlots(uint32 value)
                {

                        if (_ReservedSlots != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ReservedSlots = value;

                        }

                }
                        // 
                TEstimatedDuration getEstimatedDuration() const
                {
                        return _EstimatedDuration;
                }

                void setEstimatedDuration(TEstimatedDuration value)
                {

                        if (_EstimatedDuration != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _EstimatedDuration = value;

                        }

                }
                        // 
                uint32 getFinalDuration() const
                {
                        return _FinalDuration;
                }

                void setFinalDuration(uint32 value)
                {

                        if (_FinalDuration != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _FinalDuration = value;

                        }

                }
                        // 
                uint32 getFolderId() const
                {
                        return _FolderId;
                }

                void setFolderId(uint32 value)
                {

                        if (_FolderId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _FolderId = value;

                        }

                }
                        // 
                const std::string &getLang() const
                {
                        return _Lang;
                }



                void setLang(const std::string &value)
                {

                        if (_Lang != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Lang = value;

                                
                        }

                }
                        // 
                const std::string &getIcone() const
                {
                        return _Icone;
                }



                void setIcone(const std::string &value)
                {

                        if (_Icone != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Icone = value;

                                
                        }

                }
                        // 
                TAnimMode getAnimMode() const
                {
                        return _AnimMode;
                }

                void setAnimMode(TAnimMode value)
                {

                        if (_AnimMode != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _AnimMode = value;

                        }

                }
                        // 
                TRaceFilter getRaceFilter() const
                {
                        return _RaceFilter;
                }

                void setRaceFilter(TRaceFilter value)
                {

                        if (_RaceFilter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RaceFilter = value;

                        }

                }
                        // 
                TReligionFilter getReligionFilter() const
                {
                        return _ReligionFilter;
                }

                void setReligionFilter(TReligionFilter value)
                {

                        if (_ReligionFilter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ReligionFilter = value;

                        }

                }
                        // 
                TGuildFilter getGuildFilter() const
                {
                        return _GuildFilter;
                }

                void setGuildFilter(TGuildFilter value)
                {

                        if (_GuildFilter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _GuildFilter = value;

                        }

                }
                        // 
                TShardFilter getShardFilter() const
                {
                        return _ShardFilter;
                }

                void setShardFilter(TShardFilter value)
                {

                        if (_ShardFilter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ShardFilter = value;

                        }

                }
                        // 
                TLevelFilter getLevelFilter() const
                {
                        return _LevelFilter;
                }

                void setLevelFilter(TLevelFilter value)
                {

                        if (_LevelFilter != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _LevelFilter = value;

                        }

                }
                        // 
                bool getSubscriptionClosed() const
                {
                        return _SubscriptionClosed;
                }

                void setSubscriptionClosed(bool value)
                {

                        if (_SubscriptionClosed != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SubscriptionClosed = value;

                        }

                }
                        // 
                bool getNewcomer() const
                {
                        return _Newcomer;
                }

                void setNewcomer(bool value)
                {

                        if (_Newcomer != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Newcomer = value;

                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CSessionParticipantPtr> &getSessionParticipants() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CSessionParticipantPtr &getSessionParticipantsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CSessionParticipantPtr &getSessionParticipantsById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CGuildInvitePtr> &getGuildInvites() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CGuildInvitePtr &getGuildInvitesByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CGuildInvitePtr &getGuildInvitesById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CJournalEntryPtr> &getJournalEntries() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CJournalEntryPtr &getJournalEntriesByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CJournalEntryPtr &getJournalEntriesById(uint32 id) const;

        
                bool operator == (const CSession &other) const
                {
                        return _SessionId == other._SessionId
                                && _SessionType == other._SessionType
                                && _Title == other._Title
                                && _OwnerId == other._OwnerId
                                && _PlanDate == other._PlanDate
                                && _StartDate == other._StartDate
                                && _Description == other._Description
                                && _Orientation == other._Orientation
                                && _Level == other._Level
                                && _RuleType == other._RuleType
                                && _AccessType == other._AccessType
                                && _State == other._State
                                && _HostShardId == other._HostShardId
                                && _SubscriptionSlots == other._SubscriptionSlots
                                && _ReservedSlots == other._ReservedSlots
                                && _EstimatedDuration == other._EstimatedDuration
                                && _FinalDuration == other._FinalDuration
                                && _FolderId == other._FolderId
                                && _Lang == other._Lang
                                && _Icone == other._Icone
                                && _AnimMode == other._AnimMode
                                && _RaceFilter == other._RaceFilter
                                && _ReligionFilter == other._ReligionFilter
                                && _GuildFilter == other._GuildFilter
                                && _ShardFilter == other._ShardFilter
                                && _LevelFilter == other._LevelFilter
                                && _SubscriptionClosed == other._SubscriptionClosed
                                && _Newcomer == other._Newcomer;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CSession()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _SessionId(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _AccessType = TAccessType::at_private;
                        _Newcomer = 1;
                        _SessionParticipants = NULL;
                        _GuildInvites = NULL;
                        _JournalEntries = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CSession();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CSessionPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CSessionPtr(new CSession(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CSessionPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CCharacter and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCCharacter(MSW::CConnection &connection, uint32 parentId, std::vector < CSessionPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CFolder and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCFolder(MSW::CConnection &connection, uint32 parentId, std::vector < CSessionPtr > &children, const char *filename, uint32 lineNum);

                /// Load SessionParticipants child(ren) object(s).
                bool loadSessionParticipants(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load GuildInvites child(ren) object(s).
                bool loadGuildInvites(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load JournalEntries child(ren) object(s).
                bool loadJournalEntries(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CSessionPtr;

                typedef std::map<uint32, CSession*>     TObjectCache;
                typedef std::set<CSession*>                     TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CSessionPtr             *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CSession *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CSessionPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CSessionPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _SessionId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_SessionId == NOPE::INVALID_OBJECT_ID);
                        _SessionId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


        

        struct TAccessLevel
        {
                enum TValues
                {
                        ds_close,
                        ds_dev,
                        ds_restricted,
                        ds_open,
                        /// the highest valid value in the enum
                        last_enum_item = ds_open,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 4
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(ds_close, 0));
                                indexTable.insert(std::make_pair(ds_dev, 1));
                                indexTable.insert(std::make_pair(ds_restricted, 2));
                                indexTable.insert(std::make_pair(ds_open, 3));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ds_close)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ds_dev)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ds_restricted)
                                NL_STRING_CONVERSION_TABLE_ENTRY(ds_open)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TAccessLevel()
                        : _Value(invalid_val)
                {
                }
                TAccessLevel(TValues value)
                        : _Value(value)
                {
                }

                TAccessLevel(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TAccessLevel &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TAccessLevel &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TAccessLevel &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TAccessLevel &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TAccessLevel &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TAccessLevel &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CShard
        {
        protected:
                // 
                uint32  _ShardId;
                // 
                bool    _WSOnline;
                // 
                TAccessLevel    _RequiredState;
                // 
                std::string     _MOTD;

                friend class CGuild;

                std::map < uint32,  CGuildPtr > *_Guilds;
        public:
                // 
                bool getWSOnline() const
                {
                        return _WSOnline;
                }

                void setWSOnline(bool value)
                {

                        if (_WSOnline != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _WSOnline = value;

                        }

                }
                        // 
                const TAccessLevel &getRequiredState() const
                {
                        return _RequiredState;
                }



                void setRequiredState(const TAccessLevel &value)
                {

                        if (_RequiredState != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _RequiredState = value;

                                
                        }

                }
                        // 
                const std::string &getMOTD() const
                {
                        return _MOTD;
                }



                void setMOTD(const std::string &value)
                {

                        if (_MOTD != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _MOTD = value;

                                
                        }

                }
        
                /** Return a const reference to the map of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following method who return non const pointer
                 *      on contained elements.
                 */
                const std::map<uint32, CGuildPtr> &getGuilds() const;
                /** Return the identified element by looking in the map
                 *      If no element match the id, NULL pointer is returned
                 */
                CGuildPtr &getGuildsById(uint32 id) const;

        
                bool operator == (const CShard &other) const
                {
                        return _ShardId == other._ShardId
                                && _WSOnline == other._WSOnline
                                && _RequiredState == other._RequiredState
                                && _MOTD == other._MOTD;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CShard()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _ShardId(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _WSOnline = false;
                        _Guilds = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CShard();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CShardPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CShardPtr(new CShard(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CShardPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /// Load Guilds child(ren) object(s).
                bool loadGuilds(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CShardPtr;

                typedef std::map<uint32, CShard*>       TObjectCache;
                typedef std::set<CShard*>                       TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CShardPtr               *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CShard *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CShardPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CShardPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _ShardId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_ShardId == NOPE::INVALID_OBJECT_ID);
                        _ShardId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CGuild
        {
        protected:
                // 
                uint32  _GuildId;
                // 
                std::string     _GuildName;
                // 
                uint32  _ShardId;

                friend class CCharacter;

                std::vector < CCharacterPtr >   *_Characters;

                friend class CGuildInvite;

                std::vector < CGuildInvitePtr > *_Invites;
        public:
                // 
                const std::string &getGuildName() const
                {
                        return _GuildName;
                }



                void setGuildName(const std::string &value)
                {

                        if (_GuildName != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _GuildName = value;

                                
                        }

                }
                        // 
                uint32 getShardId() const
                {
                        return _ShardId;
                }

                void setShardId(uint32 value)
                {

                        if (_ShardId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ShardId = value;

                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CCharacterPtr> &getCharacters() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CCharacterPtr &getCharactersByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CCharacterPtr &getCharactersById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CGuildInvitePtr> &getInvites() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CGuildInvitePtr &getInvitesByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CGuildInvitePtr &getInvitesById(uint32 id) const;

        
                bool operator == (const CGuild &other) const
                {
                        return _GuildId == other._GuildId
                                && _GuildName == other._GuildName
                                && _ShardId == other._ShardId;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CGuild()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _GuildId(NOPE::INVALID_OBJECT_ID)
                {
                        _Characters = NULL;
                        _Invites = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CGuild();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CGuildPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CGuildPtr(new CGuild(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CGuildPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CShard and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCShard(MSW::CConnection &connection, uint32 parentId, std::map < uint32, CGuildPtr > &children, const char *filename, uint32 lineNum);

                /// Load Characters child(ren) object(s).
                bool loadCharacters(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load Invites child(ren) object(s).
                bool loadInvites(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CGuildPtr;

                typedef std::map<uint32, CGuild*>       TObjectCache;
                typedef std::set<CGuild*>                       TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CGuildPtr               *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CGuild *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CGuildPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CGuildPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _GuildId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_GuildId == NOPE::INVALID_OBJECT_ID);
                        _GuildId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CGuildInvite
        {
        protected:
                // 
                uint32  _Id;
                // 
                uint32  _GuildId;
                // 
                TSessionId      _SessionId;
        public:
                // 
                uint32 getGuildId() const
                {
                        return _GuildId;
                }

                void setGuildId(uint32 value)
                {

                        if (_GuildId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _GuildId = value;

                        }

                }
                        // 
                TSessionId getSessionId() const
                {
                        return _SessionId;
                }

                void setSessionId(TSessionId value)
                {

                        if (_SessionId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SessionId = value;

                        }

                }
        
                bool operator == (const CGuildInvite &other) const
                {
                        return _Id == other._Id
                                && _GuildId == other._GuildId
                                && _SessionId == other._SessionId;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CGuildInvite()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CGuildInvite();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CGuildInvitePtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CGuildInvitePtr(new CGuildInvite(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CGuildInvitePtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CGuild and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCGuild(MSW::CConnection &connection, uint32 parentId, std::vector < CGuildInvitePtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CSession and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCSession(MSW::CConnection &connection, uint32 parentId, std::vector < CGuildInvitePtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CGuildInvitePtr;

                typedef std::map<uint32, CGuildInvite*> TObjectCache;
                typedef std::set<CGuildInvite*>                 TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CGuildInvitePtr         *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CGuildInvite *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CGuildInvitePtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CGuildInvitePtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CPlayerRating
        {
        protected:
                // 
                uint32  _Id;
                // 
                uint32  _ScenarioId;
                // 
                uint32  _Author;
                // 
                uint32  _RateFun;
                // 
                uint32  _RateDifficulty;
                // 
                uint32  _RateAccessibility;
                // 
                uint32  _RateOriginality;
                // 
                uint32  _RateDirection;
        public:
                // 
                uint32 getScenarioId() const
                {
                        return _ScenarioId;
                }

                void setScenarioId(uint32 value)
                {

                        if (_ScenarioId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ScenarioId = value;

                        }

                }
                        // 
                uint32 getAuthor() const
                {
                        return _Author;
                }

                void setAuthor(uint32 value)
                {

                        if (_Author != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Author = value;

                        }

                }
                        // 
                uint32 getRateFun() const
                {
                        return _RateFun;
                }

                void setRateFun(uint32 value)
                {

                        if (_RateFun != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RateFun = value;

                        }

                }
                        // 
                uint32 getRateDifficulty() const
                {
                        return _RateDifficulty;
                }

                void setRateDifficulty(uint32 value)
                {

                        if (_RateDifficulty != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RateDifficulty = value;

                        }

                }
                        // 
                uint32 getRateAccessibility() const
                {
                        return _RateAccessibility;
                }

                void setRateAccessibility(uint32 value)
                {

                        if (_RateAccessibility != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RateAccessibility = value;

                        }

                }
                        // 
                uint32 getRateOriginality() const
                {
                        return _RateOriginality;
                }

                void setRateOriginality(uint32 value)
                {

                        if (_RateOriginality != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RateOriginality = value;

                        }

                }
                        // 
                uint32 getRateDirection() const
                {
                        return _RateDirection;
                }

                void setRateDirection(uint32 value)
                {

                        if (_RateDirection != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RateDirection = value;

                        }

                }
        
                bool operator == (const CPlayerRating &other) const
                {
                        return _Id == other._Id
                                && _ScenarioId == other._ScenarioId
                                && _Author == other._Author
                                && _RateFun == other._RateFun
                                && _RateDifficulty == other._RateDifficulty
                                && _RateAccessibility == other._RateAccessibility
                                && _RateOriginality == other._RateOriginality
                                && _RateDirection == other._RateDirection;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CPlayerRating()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CPlayerRating();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CPlayerRatingPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CPlayerRatingPtr(new CPlayerRating(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CPlayerRatingPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CScenario and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCScenario(MSW::CConnection &connection, uint32 parentId, std::vector < CPlayerRatingPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CCharacter and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCCharacter(MSW::CConnection &connection, uint32 parentId, std::vector < CPlayerRatingPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CPlayerRatingPtr;

                typedef std::map<uint32, CPlayerRating*>        TObjectCache;
                typedef std::set<CPlayerRating*>                        TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CPlayerRatingPtr                *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CPlayerRating *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CPlayerRatingPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CPlayerRatingPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


        

        struct TJournalEntryType
        {
                enum TValues
                {
                        jet_credits = 1,
                        jet_notes,
                        /// the highest valid value in the enum
                        last_enum_item = jet_notes,
                        /// a value equal to the last enum item +1
                        end_of_enum,

                        invalid_val,
                        
                        /// Number of enumerated values
                        nb_enum_items = 2
                };
                
                /// Index table to convert enum value to linear index table
                const std::map<TValues, uint32> &getIndexTable() const
                {
                        static std::map<TValues, uint32> indexTable;
                        static bool init = false;
                        if (!init)
                        {
                                // fill the index table
                                indexTable.insert(std::make_pair(jet_credits, 0));
                                indexTable.insert(std::make_pair(jet_notes, 1));
                        
                                init = true;
                        }

                        return indexTable;
                }
                

                static const NLMISC::CStringConversion<TValues> &getConversionTable()
                {
                        NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
                                NL_STRING_CONVERSION_TABLE_ENTRY(jet_credits)
                                NL_STRING_CONVERSION_TABLE_ENTRY(jet_notes)
                                NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
                        };
                        static NLMISC::CStringConversion<TValues>
                        conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
                        / sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

                        return conversionTable;
                }

                TValues _Value;

        public:
                TJournalEntryType()
                        : _Value(invalid_val)
                {
                }
                TJournalEntryType(TValues value)
                        : _Value(value)
                {
                }

                TJournalEntryType(const std::string &str)
                {
                        _Value = getConversionTable().fromString(str);
                }

                void serial(NLMISC::IStream &s)
                {
                        s.serialEnum(_Value);
                }

                bool operator == (const TJournalEntryType &other) const
                {
                        return _Value == other._Value;
                }
                bool operator != (const TJournalEntryType &other) const
                {
                        return ! (_Value == other._Value);
                }
                bool operator < (const TJournalEntryType &other) const
                {
                        return _Value < other._Value;
                }

                bool operator <= (const TJournalEntryType &other) const
                {
                        return _Value <= other._Value;
                }

                bool operator > (const TJournalEntryType &other) const
                {
                        return !(_Value <= other._Value);
                }
                bool operator >= (const TJournalEntryType &other) const
                {
                        return !(_Value < other._Value);
                }

                const std::string &toString() const
                {
                        return getConversionTable().toString(_Value);
                }
                static const std::string &toString(TValues value)
                {
                        return getConversionTable().toString(value);
                }

                TValues getValue() const
                {
                        return _Value;
                }

                // return true if the actual value of the enum is valid, otherwise false
                bool isValid()
                {
                        if (_Value == invalid_val)
                                return false;

                        // not invalid, check other enum value
                        return getConversionTable().isValid(_Value);
                }

                
                uint32 asIndex()
                {
                        std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
                        nlassert(it != getIndexTable().end());
                        return it->second;
                }
                
        };
                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CJournalEntry
        {
        protected:
                // 
                uint32  _Id;
                // 
                TSessionId      _SessionId;
                // 
                uint32  _Author;
                // 
                TJournalEntryType       _Type;
                // 
                std::string     _Text;
                // 
                uint32  _TimeStamp;
        public:
                // 
                TSessionId getSessionId() const
                {
                        return _SessionId;
                }

                void setSessionId(TSessionId value)
                {

                        if (_SessionId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _SessionId = value;

                        }

                }
                        // 
                uint32 getAuthor() const
                {
                        return _Author;
                }

                void setAuthor(uint32 value)
                {

                        if (_Author != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Author = value;

                        }

                }
                        // 
                TJournalEntryType getType() const
                {
                        return _Type;
                }

                void setType(TJournalEntryType value)
                {

                        if (_Type != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Type = value;

                        }

                }
                        // 
                const std::string &getText() const
                {
                        return _Text;
                }



                void setText(const std::string &value)
                {

                        if (_Text != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Text = value;

                                
                        }

                }
                        // 
                uint32 getTimeStamp() const
                {
                        return _TimeStamp;
                }

                void setTimeStamp(uint32 value)
                {

                        if (_TimeStamp != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _TimeStamp = value;

                        }

                }
        
                bool operator == (const CJournalEntry &other) const
                {
                        return _Id == other._Id
                                && _SessionId == other._SessionId
                                && _Author == other._Author
                                && _Type == other._Type
                                && _Text == other._Text
                                && _TimeStamp == other._TimeStamp;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CJournalEntry()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CJournalEntry();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CJournalEntryPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CJournalEntryPtr(new CJournalEntry(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CJournalEntryPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CSession and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCSession(MSW::CConnection &connection, uint32 parentId, std::vector < CJournalEntryPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CJournalEntryPtr;

                typedef std::map<uint32, CJournalEntry*>        TObjectCache;
                typedef std::set<CJournalEntry*>                        TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CJournalEntryPtr                *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CJournalEntry *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CJournalEntryPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CJournalEntryPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CFolder
        {
        protected:
                // 
                uint32  _Id;
                // 
                uint32  _Author;
                // 
                std::string     _Title;
                // 
                std::string     _Comments;

                friend class CFolderAccess;

                std::vector < CFolderAccessPtr >        *_FolderAccess;

                friend class CSession;

                std::vector < CSessionPtr >     *_Sessions;
        public:
                // 
                uint32 getAuthor() const
                {
                        return _Author;
                }

                void setAuthor(uint32 value)
                {

                        if (_Author != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Author = value;

                        }

                }
                        // 
                const std::string &getTitle() const
                {
                        return _Title;
                }



                void setTitle(const std::string &value)
                {

                        if (_Title != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Title = value;

                                
                        }

                }
                        // 
                const std::string &getComments() const
                {
                        return _Comments;
                }



                void setComments(const std::string &value)
                {

                        if (_Comments != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Comments = value;

                                
                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CFolderAccessPtr> &getFolderAccess() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CFolderAccessPtr &getFolderAccessByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CFolderAccessPtr &getFolderAccessById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CSessionPtr> &getSessions() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CSessionPtr &getSessionsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CSessionPtr &getSessionsById(uint32 id) const;

        
                bool operator == (const CFolder &other) const
                {
                        return _Id == other._Id
                                && _Author == other._Author
                                && _Title == other._Title
                                && _Comments == other._Comments;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CFolder()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {
                        _FolderAccess = NULL;
                        _Sessions = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CFolder();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CFolderPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CFolderPtr(new CFolder(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CFolderPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CRingUser and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCRingUser(MSW::CConnection &connection, uint32 parentId, std::vector < CFolderPtr > &children, const char *filename, uint32 lineNum);

                /// Load FolderAccess child(ren) object(s).
                bool loadFolderAccess(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load Sessions child(ren) object(s).
                bool loadSessions(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CFolderPtr;

                typedef std::map<uint32, CFolder*>      TObjectCache;
                typedef std::set<CFolder*>                      TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CFolderPtr              *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CFolder *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CFolderPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CFolderPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CFolderAccess
        {
        protected:
                // 
                uint32  _Id;
                // 
                uint32  _FolderId;
                // 
                uint32  _UserId;
        public:
                // 
                uint32 getFolderId() const
                {
                        return _FolderId;
                }

                void setFolderId(uint32 value)
                {

                        if (_FolderId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _FolderId = value;

                        }

                }
                        // 
                uint32 getUserId() const
                {
                        return _UserId;
                }

                void setUserId(uint32 value)
                {

                        if (_UserId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _UserId = value;

                        }

                }
        
                bool operator == (const CFolderAccess &other) const
                {
                        return _Id == other._Id
                                && _FolderId == other._FolderId
                                && _UserId == other._UserId;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CFolderAccess()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CFolderAccess();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CFolderAccessPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CFolderAccessPtr(new CFolderAccess(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CFolderAccessPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CRingUser and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCRingUser(MSW::CConnection &connection, uint32 parentId, std::vector < CFolderAccessPtr > &children, const char *filename, uint32 lineNum);

                /** Load all objects children of CFolder and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCFolder(MSW::CConnection &connection, uint32 parentId, std::vector < CFolderAccessPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CFolderAccessPtr;

                typedef std::map<uint32, CFolderAccess*>        TObjectCache;
                typedef std::set<CFolderAccess*>                        TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CFolderAccessPtr                *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CFolderAccess *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CFolderAccessPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CFolderAccessPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CScenario
        {
        protected:
                // 
                uint32  _Id;
                // 
                NLMISC::CHashKeyMD5     _MD5;
                // 
                std::string     _Title;
                // 
                std::string     _Description;
                // 
                std::string     _Author;
                // 
                uint32  _RRPTotal;
                // 
                TAnimMode       _AnimMode;
                // 
                std::string     _Language;
                // 
                TSessionOrientation     _Orientation;
                // 
                R2::TSessionLevel       _Level;
                // 
                bool    _AllowFreeTrial;

                friend class CSessionLog;

                std::vector < CSessionLogPtr >  *_SessionLogs;

                friend class CPlayerRating;

                std::vector < CPlayerRatingPtr >        *_PlayerRatings;
        public:
                // 
                const NLMISC::CHashKeyMD5 &getMD5() const
                {
                        return _MD5;
                }



                void setMD5(const NLMISC::CHashKeyMD5 &value)
                {

                        if (_MD5 != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _MD5 = value;

                                
                        }

                }
                        // 
                const std::string &getTitle() const
                {
                        return _Title;
                }



                void setTitle(const std::string &value)
                {

                        if (_Title != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Title = value;

                                
                        }

                }
                        // 
                const std::string &getDescription() const
                {
                        return _Description;
                }



                void setDescription(const std::string &value)
                {

                        if (_Description != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Description = value;

                                
                        }

                }
                        // 
                const std::string &getAuthor() const
                {
                        return _Author;
                }



                void setAuthor(const std::string &value)
                {

                        if (_Author != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Author = value;

                                
                        }

                }
                        // 
                uint32 getRRPTotal() const
                {
                        return _RRPTotal;
                }

                void setRRPTotal(uint32 value)
                {

                        if (_RRPTotal != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RRPTotal = value;

                        }

                }
                        // 
                TAnimMode getAnimMode() const
                {
                        return _AnimMode;
                }

                void setAnimMode(TAnimMode value)
                {

                        if (_AnimMode != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _AnimMode = value;

                        }

                }
                        // 
                const std::string &getLanguage() const
                {
                        return _Language;
                }



                void setLanguage(const std::string &value)
                {

                        if (_Language != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Language = value;

                                
                        }

                }
                        // 
                TSessionOrientation getOrientation() const
                {
                        return _Orientation;
                }

                void setOrientation(TSessionOrientation value)
                {

                        if (_Orientation != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Orientation = value;

                        }

                }
                        // 
                R2::TSessionLevel getLevel() const
                {
                        return _Level;
                }

                void setLevel(R2::TSessionLevel value)
                {

                        if (_Level != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Level = value;

                        }

                }
                        // 
                bool getAllowFreeTrial() const
                {
                        return _AllowFreeTrial;
                }

                void setAllowFreeTrial(bool value)
                {

                        if (_AllowFreeTrial != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _AllowFreeTrial = value;

                        }

                }
        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CSessionLogPtr> &getSessionLogs() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CSessionLogPtr &getSessionLogsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CSessionLogPtr &getSessionLogsById(uint32 id) const;

        
                /** Return a const reference to the vector of child.
                 *      If you want to modify the element inside, you need to
                 *      use on of the two following methods who return non const pointer
                 *      on contained elements.
                 */
                const std::vector<CPlayerRatingPtr> &getPlayerRatings() const;
                /** Return the ith element of the child vector
                 *      index must be valid (ie less than size of the vector)
                 */
                CPlayerRatingPtr &getPlayerRatingsByIndex(uint32 index) const;
                /** Return the identified element by looking in the vector
                 *      If no element match the id, NULL pointer is returned
                 */
                CPlayerRatingPtr &getPlayerRatingsById(uint32 id) const;

        
                bool operator == (const CScenario &other) const
                {
                        return _Id == other._Id
                                && _MD5 == other._MD5
                                && _Title == other._Title
                                && _Description == other._Description
                                && _Author == other._Author
                                && _RRPTotal == other._RRPTotal
                                && _AnimMode == other._AnimMode
                                && _Language == other._Language
                                && _Orientation == other._Orientation
                                && _Level == other._Level
                                && _AllowFreeTrial == other._AllowFreeTrial;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CScenario()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _RRPTotal = 0;
                        _AllowFreeTrial = false;
                        _SessionLogs = NULL;
                        _PlayerRatings = NULL;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CScenario();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CScenarioPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CScenarioPtr(new CScenario(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CScenarioPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /// Load SessionLogs child(ren) object(s).
                bool loadSessionLogs(MSW::CConnection &connection, const char *filename, uint32 lineNum);

                /// Load PlayerRatings child(ren) object(s).
                bool loadPlayerRatings(MSW::CConnection &connection, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CScenarioPtr;

                typedef std::map<uint32, CScenario*>    TObjectCache;
                typedef std::set<CScenario*>                    TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CScenarioPtr            *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CScenario *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CScenarioPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CScenarioPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        nlassert(getPersistentState() != NOPE::os_transient);
                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CSessionLog
        {
        protected:
                // 
                uint32  _Id;
                // 
                uint32  _ScenarioId;
                // 
                uint32  _RRPScored;
                // 
                uint32  _ScenarioPointScored;
                // 
                uint32  _TimeTaken;
                // 
                std::string     _Participants;
                // 
                uint32  _LaunchDate;
                // 
                std::string     _Owner;
                // 
                std::string     _GuildName;
        public:
                // 
                uint32 getScenarioId() const
                {
                        return _ScenarioId;
                }

                void setScenarioId(uint32 value)
                {

                        if (_ScenarioId != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ScenarioId = value;

                        }

                }
                        // 
                uint32 getRRPScored() const
                {
                        return _RRPScored;
                }

                void setRRPScored(uint32 value)
                {

                        if (_RRPScored != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _RRPScored = value;

                        }

                }
                        // 
                uint32 getScenarioPointScored() const
                {
                        return _ScenarioPointScored;
                }

                void setScenarioPointScored(uint32 value)
                {

                        if (_ScenarioPointScored != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _ScenarioPointScored = value;

                        }

                }
                        // 
                uint32 getTimeTaken() const
                {
                        return _TimeTaken;
                }

                void setTimeTaken(uint32 value)
                {

                        if (_TimeTaken != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _TimeTaken = value;

                        }

                }
                        // 
                const std::string &getParticipants() const
                {
                        return _Participants;
                }



                void setParticipants(const std::string &value)
                {

                        if (_Participants != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Participants = value;

                                
                        }

                }
                        // 
                uint32 getLaunchDate() const
                {
                        return _LaunchDate;
                }

                void setLaunchDate(uint32 value)
                {

                        if (_LaunchDate != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _LaunchDate = value;

                        }

                }
                        // 
                const std::string &getOwner() const
                {
                        return _Owner;
                }



                void setOwner(const std::string &value)
                {

                        if (_Owner != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _Owner = value;

                                
                        }

                }
                        // 
                const std::string &getGuildName() const
                {
                        return _GuildName;
                }



                void setGuildName(const std::string &value)
                {

                        if (_GuildName != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);


                                _GuildName = value;

                                
                        }

                }
        
                bool operator == (const CSessionLog &other) const
                {
                        return _Id == other._Id
                                && _ScenarioId == other._ScenarioId
                                && _RRPScored == other._RRPScored
                                && _ScenarioPointScored == other._ScenarioPointScored
                                && _TimeTaken == other._TimeTaken
                                && _Participants == other._Participants
                                && _LaunchDate == other._LaunchDate
                                && _Owner == other._Owner
                                && _GuildName == other._GuildName;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CSessionLog()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _Id(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _RRPScored = 0;
                        _ScenarioPointScored = 0;
                        _TimeTaken = 0;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CSessionLog();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CSessionLogPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CSessionLogPtr(new CSessionLog(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CSessionLogPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load all objects children of CScenario and
                 *      return them by using the specified output iterator.
                 */

                static bool loadChildrenOfCScenario(MSW::CConnection &connection, uint32 parentId, std::vector < CSessionLogPtr > &children, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CSessionLogPtr;

                typedef std::map<uint32, CSessionLog*>  TObjectCache;
                typedef std::set<CSessionLog*>                  TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CSessionLogPtr          *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CSessionLog *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CSessionLogPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CSessionLogPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _Id;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_Id == NOPE::INVALID_OBJECT_ID);
                        _Id = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


                /////////////////////////////////////////////////////////////////
        // WARNING : this is a generated file, don't change it !
        /////////////////////////////////////////////////////////////////
        class CGmStatus
        {
        protected:
                // 
                uint32  _UserId;
                // 
                bool    _Available;
        public:
                // 
                bool getAvailable() const
                {
                        return _Available;
                }

                void setAvailable(bool value)
                {

                        if (_Available != value)
                        {
                                if (getPersistentState() != NOPE::os_transient)
                                        setPersistentState(NOPE::os_dirty);

                                _Available = value;

                        }

                }
        
                bool operator == (const CGmStatus &other) const
                {
                        return _UserId == other._UserId
                                && _Available == other._Available;
                }


        private:
                // private constructor, you must use 'createTransient' to get an instance
                CGmStatus()
                        : _PtrList(NULL),
                        _ObjectState(NOPE::os_transient),
                        _UserId(NOPE::INVALID_OBJECT_ID)
                {
                        // Default initialisation
                        _Available = 1;

                        // register the cache for this class (if not already done)
                        registerUpdatable();
                }

                // Destructor, delete any children
                ~CGmStatus();

                /// utility func to remove this object from the released object container
                void removeFromReleased();


        public:
                /// Create a new instance in the transient space
                static CGmStatusPtr createTransient(const char *filename, uint32 lineNum)
                {
                        return CGmStatusPtr(new CGmStatus(), filename, lineNum);
                }

                /** Create a new object in the database from the current object data.
                 *      The object MUST be in transient state (i.e, it must be a new
                 *      object created by user and not comming from the databse).
                 *      If identifier is autogenerated, the generated id can be read after
                 *      this call.
                 */
                bool create(MSW::CConnection &connection);
                /** Update the database with the current object state.
                 *      The object MUST be either in clean or dirty state.
                 *      Return true if the object has been effectively stored
                 *      in the database.
                 *      After this call, the object is in 'clean' state.
                 */
                bool update(MSW::CConnection &connection);
                /** Remove the current object from the persistent storage.
                 *      The object must be in clean or dirty state.
                 *      Return true if the object has been correctly
                 *      updated in the database.
                 *      After the call, the object is in 'clean' state.
                 */
                bool remove(MSW::CConnection &connection);
                /** Remove an object from the persistent storage by specifying
                 *      the id to remove.
                 *      Return true if an entry as been effectively removed from
                 *      the database.
                 *      After the call, the object is in 'removed' state and should
                 *      no more be used. A good pratice should be to delete
                 *      the transient object just after the remove call.
                 */
                static bool removeById(MSW::CConnection &connection, uint32 id);

                /** Load an instance from the database.
                 *      This call allocate a new object and load the property value
                 *      from the database.
                 *      Return NULL if the object id is not found.
                 */
                static CGmStatusPtr load(MSW::CConnection &connection, uint32 id, const char *filename, uint32 lineNum);


                /** Load the object child of CRingUser and
                 *      return true if no error, false in case of error (in SQL maybe).
                 *      If no such object is found, fill the child pointer with NULL.
                 */
                static bool loadChildOfCRingUser(MSW::CConnection &connection, uint32 parentId, CGmStatusPtr &childPtr, const char *filename, uint32 lineNum);


        private:
        
        private:
                friend class CPersistentCache;
                friend class CGmStatusPtr;

                typedef std::map<uint32, CGmStatus*>    TObjectCache;
                typedef std::set<CGmStatus*>                    TObjectSet;
                typedef std::map<time_t, TObjectSet>    TReleasedObject;

                /// The complete set of object currently in memory (either active or released) excluding transient instance
                static TObjectCache             _ObjectCache;
                /// The set of object in memory ut released (no pointer on them) and waiting for decommit
                static TReleasedObject  _ReleasedObject;

                /// The current object state
                NOPE::TObjectState              _ObjectState;

                /// For object in released state, this is the release date (used to trigger deletion of the object from memory)
                time_t                                  _ReleaseDate;

                /// The linked list of pointer on this object
                CGmStatusPtr            *_PtrList;

                // Try to load the specified object from the memory cache, return NULL if the object is not in the cache
                static CGmStatus *loadFromCache(uint32 objectId, bool unrelease);

                // Receive and execute command from the cache manager.
                static uint32 cacheCmd(NOPE::TCacheCmd cmd);

                static void dump();

                static void updateCache();

        public:
                static void clearCache();
        private:
                void registerUpdatable();

                // set the pointer on the first pointer of the pointer list (set to null when there is no more pointer)
                void setFirstPtr(CGmStatusPtr *ptr);

                // return the first pointer of the pointer list (can be null)
                CGmStatusPtr *getFirstPtr()
                {
                        return _PtrList;
                }

        public:

                /** Return the object identifier (witch is unique)
                 *      You can only call this method on a persistent instance.
                 *      (because transient instance can have invalid id)
                 */
                uint32 getObjectId() const
                {

                        return _UserId;
                }

                /** Set the object unique ID.
                 *      You can only set the object id on a transient object
                 *      having a non autogenerated unique id.
                 *      Furthermore, you MUST set the id before calling create()
                 *      if the id is not autogenerated.
                 */
                void setObjectId(uint32 objectId)
                {
                        // can only be set when in transient state
                        nlassert(getPersistentState() == NOPE::os_transient);
                        // can only be set once
                        nlassert(_UserId == NOPE::INVALID_OBJECT_ID);
                        _UserId = objectId;
                }

                /** Return the current persistent state of the object.*/
                NOPE::TObjectState getPersistentState() const
                {
                        return _ObjectState;
                }

        private:
                // Set the persistent state of the object and do some house keeping
                void setPersistentState(NOPE::TObjectState state);



        };


        
}
        
#endif