MunRoomPlayerInfo.hpp

Go to the documentation of this file.

#ifndef __MUN_ROOM_PLAYER_INFO_HPP__
#define __MUN_ROOM_PLAYER_INFO_HPP__

#include <mrs.hpp>
#include <stream/MunStream.hpp>
#include <log/MunLogger.hpp>

class MunRoomPlayerInfo
{
protected:
    MrsConnection   m_Connection;
    
    int32   m_Id;
    
    std::string m_Name;
    
    STREAM::KeyValue m_Parameters[STREAM::PLAYER_PARAMETERS_MAX];
    
    uint16           m_ParametersLen;
    
    uint32  m_clientUidForMasterServer;
    
    uint64  m_clientUidForProxyServer;

    uint64  m_RoomId;
    
    uint16 m_GroupWriteRecordOptions;
    
    uint16 m_GroupWriteRecordPayloadType;
    
    uint32 m_GroupWriteRecordCount;
    
    MunBuffer m_GroupWriteRecordBuffer;
    
public:
    MrsConnection   GetConnection() { return m_Connection; }
    
    int32   GetId() { return m_Id; }
    
    std::string   GetName() { return m_Name; }
    
    void    SetName(std::string name) { m_Name = name; }
    
    STREAM::KeyValue*   GetParameters() { return m_Parameters; }
    
    uint16  GetParametersLen() { return m_ParametersLen; }
    
    void SetParameters( STREAM::KeyValue* pParameters, uint16 parametersLen ){
        m_ParametersLen = parametersLen;
        for ( uint16 i = 0; i < m_ParametersLen; ++i ){
            m_Parameters[ i ] = pParameters[ i ];
        }
    }
    
    void UpdateParameters( STREAM::KeyValue* pParameters, uint16 parametersLen ){
        std::map<std::string, STREAM::Union> parameters;
        for ( uint16 i = 0; i < m_ParametersLen; ++i ){
            parameters.insert( std::pair<std::string, STREAM::Union>( m_Parameters[ i ].key.text, m_Parameters[ i ].value ) );
        }
        for ( uint16 i = 0; i < parametersLen; ++i ){
            std::map<std::string, STREAM::Union>::iterator itr = parameters.find( pParameters[ i ].key.text );
            if ( parameters.end() == itr ){
                parameters.insert( std::pair<std::string, STREAM::Union>( pParameters[ i ].key.text, pParameters[ i ].value ) );
            }else{
                itr->second = pParameters[ i ].value;
            }
        }
        if ( STREAM::PLAYER_PARAMETERS_MAX < parameters.size() ) return;
        
        m_ParametersLen = (uint16)parameters.size();
        uint16 i = 0;
        for ( std::map<std::string, STREAM::Union>::iterator itr = parameters.begin(); parameters.end() != itr; ++itr ){
            STREAM::Text key = STREAM::Text( itr->first );
            m_Parameters[ i++ ] = STREAM::KeyValue( key, itr->second );
        }
    }
    
    uint32  GetClientIdForMasterServer() { return m_clientUidForMasterServer; }
    
    uint64  GetClientIdForProxyServer() { return m_clientUidForProxyServer; }
    
    uint64  GetRoomId() { return m_RoomId; }
    
public:
    MunRoomPlayerInfo( MrsConnection connection = NULL, int32 id = 0, std::string name = "", uint32 clientUidForMasterServer = 0, uint64 clientUidForProxyServer = 0, uint64 roomId = 0, STREAM::KeyValue* pParameters = NULL, uint16 parametersLen = 0 ) {
        m_Connection = connection;
        m_Id = id;
        m_Name = name;
        m_clientUidForMasterServer = clientUidForMasterServer;
        m_clientUidForProxyServer = clientUidForProxyServer;
        m_RoomId = roomId;
        SetParameters( pParameters, parametersLen );
        
        m_GroupWriteRecordOptions = 0;
        m_GroupWriteRecordPayloadType = 0;
        m_GroupWriteRecordCount = 0;
    }
    
    virtual ~MunRoomPlayerInfo() {}
    
    void FlushGroupWriteRecord(){
        if ( 0 == m_GroupWriteRecordPayloadType ) return;
        
//        MRSEXT_LOG_INFO( "FlushGroupWriteRecord id=%d options=%u payload_type=%u payload_len=%u count=%u", m_Id, m_GroupWriteRecordOptions, m_GroupWriteRecordPayloadType, m_GroupWriteRecordBuffer.GetDataLen(), m_GroupWriteRecordCount );
        mrs_write_record( m_Connection, m_GroupWriteRecordOptions, m_GroupWriteRecordPayloadType, m_GroupWriteRecordBuffer.GetData(), m_GroupWriteRecordBuffer.GetDataLen() );
        
        m_GroupWriteRecordOptions = 0;
        m_GroupWriteRecordPayloadType = 0;
        m_GroupWriteRecordCount = 0;
        m_GroupWriteRecordBuffer.Unread( 0xFFFFFFFF );
        m_GroupWriteRecordBuffer.Unwrite( 0xFFFFFFFF );
    }
    
    void GroupWriteRecord( uint16 options, uint16 payload_type, const void* payload, uint32 payload_len, bool is_group ){
        if ( is_group ){
            if ( ( m_GroupWriteRecordOptions != options ) || ( m_GroupWriteRecordPayloadType != payload_type ) ){
                FlushGroupWriteRecord();
                m_GroupWriteRecordOptions = options;
                m_GroupWriteRecordPayloadType = payload_type;
            }
            
            m_GroupWriteRecordBuffer.Write( payload, payload_len );
            ++m_GroupWriteRecordCount;
        }else{
            FlushGroupWriteRecord();
            mrs_write_record( m_Connection, options, payload_type, payload, payload_len );
        }
    }
    
    void Update(){
        FlushGroupWriteRecord();
    }
};

#endif  /* __MUN_ROOM_PLAYER_INFO_HPP__ */