CWE-ou-minkata/Sources/Plasma/NucleusLib/pnMessage/plMessage.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#define PLMESSAGE_PRIVATE
#include "plMessage.h"
#include "hsStream.h"
#include "pnKeyedObject/plKey.h"
#include "hsResMgr.h"
#include "hsTimer.h"
#include "hsTemplates.h"
#include "plgDispatch.h"
#include "hsBitVector.h"
#include <algorithm>
#include <iterator>

plMessage::plMessage()
:   fSender(nil),
    fBCastFlags(kLocalPropagate),
    fTimeStamp(0),
    fNetRcvrPlayerIDs(nil),
    dispatchBreak(false)
{
}

plMessage::plMessage(const plKey &s, 
            const plKey &r, 
            const double* t)
:   fSender(s),
    fBCastFlags(kLocalPropagate),
    fNetRcvrPlayerIDs(nil),
    dispatchBreak(false)
{
    if( r )
    {
        fReceivers.SetCount(1);
        fReceivers[0] = r;
    }
    fTimeStamp = t ? *t : hsTimer::GetSysSeconds();
}

plMessage::~plMessage()
{
    delete fNetRcvrPlayerIDs;
}

plMessage&      plMessage::SetNumReceivers(int n) { fReceivers.SetCount(n); return *this; }
UInt32          plMessage::GetNumReceivers() const { return fReceivers.GetCount(); }
const plKey&    plMessage::GetReceiver(int i) const { return fReceivers[i]; }
plMessage&      plMessage::RemoveReceiver(int i) { fReceivers.Remove(i); return *this; }

plMessage&      plMessage::ClearReceivers() { fReceivers.SetCount(0); return *this; }
plMessage&      plMessage::AddReceiver(const plKey &r) { fReceivers.Append(r); return *this; }

plMessage& plMessage::AddReceivers(const hsTArray<plKey>& rList)
{
    int i;
    for( i = 0; i < rList.GetCount(); i++ )
        AddReceiver(rList[i]);

    return *this;
}

hsBool plMessage::Send(const plKey r, hsBool async)
{
    if( r )
        AddReceiver(r);
    return plgDispatch::MsgSend(this,async);
}

hsBool plMessage::SendAndKeep(const plKey r, hsBool async)
{
    Ref();
    return Send(r, async);
}

void plMessage::IMsgRead(hsStream* s, hsResMgr* mgr)
{
    plCreatable::Read(s, mgr);

    fSender = mgr->ReadKey(s);
    int n;
    s->LogReadSwap(&n,"NumberOfReceivers"); 
    fReceivers.SetCount(n);
    int i;
    for( i = 0; i < fReceivers.GetCount(); i++ )
        fReceivers[i] = mgr->ReadKey(s);

    s->LogReadSwap(&fTimeStamp,"TimeStamp");    // read as double
    s->LogReadSwap(&fBCastFlags, "BCastFlags");
}

void plMessage::IMsgWrite(hsStream* s, hsResMgr* mgr)
{
    plCreatable::Write(s, mgr);
    
    mgr->WriteKey(s,fSender);
    s->WriteSwap32(fReceivers.GetCount());
    int i;
    for( i = 0; i < fReceivers.GetCount(); i++ )
        mgr->WriteKey(s,fReceivers[i]);

    s->WriteSwap(fTimeStamp);   // write as double
    s->WriteSwap32(fBCastFlags);
}

enum MsgFlags
{
    kMsgSender,
    kMsgReceivers,
    kMsgTimeStamp,
    kMsgBCastFlags,
};

void plMessage::IMsgReadVersion(hsStream* s, hsResMgr* mgr)
{
    hsBitVector contentFlags;
    contentFlags.Read(s);

    if (contentFlags.IsBitSet(kMsgSender))
        fSender = mgr->ReadKey(s);

    if (contentFlags.IsBitSet(kMsgReceivers))
    {
        int n = s->ReadSwap32();
        fReceivers.SetCount(n);
        int i;
        for( i = 0; i < fReceivers.GetCount(); i++ )
            fReceivers[i] = mgr->ReadKey(s);
    }

    if (contentFlags.IsBitSet(kMsgTimeStamp))
        s->ReadSwap(&fTimeStamp);   // read as double

    if (contentFlags.IsBitSet(kMsgBCastFlags))
        fBCastFlags = s->ReadSwap32();
}

void plMessage::IMsgWriteVersion(hsStream* s, hsResMgr* mgr)
{
    hsBitVector contentFlags;
    contentFlags.SetBit(kMsgSender);
    contentFlags.SetBit(kMsgReceivers);
    contentFlags.SetBit(kMsgTimeStamp);
    contentFlags.SetBit(kMsgBCastFlags);
    contentFlags.Write(s);

    // kMsgSender
    mgr->WriteKey(s,fSender);

    // kMsgReceivers
    s->WriteSwap32(fReceivers.GetCount());
    int i;
    for( i = 0; i < fReceivers.GetCount(); i++ )
        mgr->WriteKey(s,fReceivers[i]);

    // kMsgTimeStamp
    s->WriteSwap(fTimeStamp);   // write as double

    // kMsgBCastFlags
    s->WriteSwap32(fBCastFlags);
}

void plMessage::AddNetReceiver( UInt32 plrID )
{
    if ( !fNetRcvrPlayerIDs )
        fNetRcvrPlayerIDs = TRACKED_NEW std::vector<UInt32>;
    fNetRcvrPlayerIDs->push_back( plrID );
}

void plMessage::AddNetReceivers( const std::vector<UInt32> & plrIDs )
{
    if ( !fNetRcvrPlayerIDs )
        fNetRcvrPlayerIDs = TRACKED_NEW std::vector<UInt32>;
    std::copy( plrIDs.begin(), plrIDs.end(), std::back_inserter( *fNetRcvrPlayerIDs ) );
}

/////////////////////////////////////////////////////////////////

// STATIC
int plMsgStdStringHelper::Poke(const std::string & stringref, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    hsAssert( stringref.length()<0xFFFF, "buf too big for plMsgStdStringHelper" );
    strlen = stringref.length();
    stream->WriteSwap(strlen);
    if (strlen)
        stream->Write(strlen,stringref.data());
    return stream->GetPosition();
}

int plMsgStdStringHelper::PokeBig(const std::string & stringref, hsStream* stream, const UInt32 peekOptions)
{
    UInt32 strlen = stringref.length();
    stream->WriteSwap(strlen);
    if (strlen)
        stream->Write(strlen,stringref.data());
    return stream->GetPosition();
}

int plMsgStdStringHelper::Poke(const char * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    hsAssert( bufsz<0xFFFF, "buf too big for plMsgStdStringHelper" );
    strlen = (plMessage::plStrLen)bufsz;
    stream->WriteSwap(strlen);
    if (strlen)
        stream->Write(strlen,buf);
    return stream->GetPosition();
}

int plMsgStdStringHelper::PokeBig(const char * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions)
{
    stream->WriteSwap(bufsz);
    if (bufsz)
        stream->Write(bufsz,buf);
    return stream->GetPosition();
}

// STATIC
int plMsgStdStringHelper::Peek(std::string  & stringref, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    stream->LogSubStreamStart("push this");
    stream->LogReadSwap(&strlen,"StrLen");
    stringref.erase();
    if (strlen <= stream->GetSizeLeft())
    {
        stringref.resize(strlen);
        if (strlen){
            stream->LogRead(strlen,(void*)stringref.data(),"StdString");
            stream->LogStringString(xtl::format("Value: %s", stringref.data()).c_str());
        }
    }
    else
    {
        hsAssert( false, "plMsgStdStringHelper::Peek: overflow peeking string." );
    }
    stream->LogSubStreamEnd();
    return stream->GetPosition();
}

int plMsgStdStringHelper::PeekBig(std::string  & stringref, hsStream* stream, const UInt32 peekOptions)
{
    UInt32 bufsz;
    stream->LogSubStreamStart("push this");
    stream->LogReadSwap(&bufsz,"Bufsz");
    stringref.erase();
    if (bufsz <= stream->GetSizeLeft())
    {
        stringref.resize(bufsz);
        if (bufsz){
            stream->LogRead(bufsz,(void*)stringref.data(),"StdString");
            stream->LogStringString(xtl::format("Value: %s", stringref.data()).c_str());
        }
    }
    else
    {
        hsAssert( false, "plMsgStdStringHelper::PeekBig: overflow peeking string." );
    }
    stream->LogSubStreamEnd();
    return stream->GetPosition();
}

/////////////////////////////////////////////////////////////////

// STATIC
int plMsgXtlStringHelper::Poke(const xtl::istring & stringref, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    strlen = stringref.length();
    stream->WriteSwap(strlen);
    if (strlen)
        stream->Write(strlen,stringref.data());
    return stream->GetPosition();
}

// STATIC
int plMsgXtlStringHelper::Peek(xtl::istring & stringref, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    stream->LogSubStreamStart("push me");
    stream->LogReadSwap(&strlen,"StrLen");
    stringref.erase();
    if (strlen <= stream->GetSizeLeft())
    {
        stringref.resize(strlen);
        if (strlen){
            stream->LogRead(strlen,(void*)stringref.data(),"XtlString");
            stream->LogStringString(xtl::format("Value: %s", stringref.data()).c_str());
        }
    }
    stream->LogSubStreamEnd();
    return stream->GetPosition();
}


/////////////////////////////////////////////////////////////////

// STATIC
int plMsgCStringHelper::Poke(const char * str, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    strlen = (str)?hsStrlen(str):0;
    stream->WriteSwap(strlen);
    if (strlen)
        stream->Write(strlen,str);
    return stream->GetPosition();
}

// STATIC
int plMsgCStringHelper::Peek(char *& str, hsStream* stream, const UInt32 peekOptions)
{
    plMessage::plStrLen strlen;
    stream->LogSubStreamStart("push me");
    stream->LogReadSwap(&strlen,"StrLen");
    delete [] str;
    str = nil;
    if (strlen <= stream->GetSizeLeft())
    {
        if (strlen)
        {
            str = TRACKED_NEW char[strlen+1];
            str[strlen] = '\0';
            if (strlen) {
                stream->LogRead(strlen,str,"CString");
                stream->LogStringString(xtl::format("Value: %s",str).c_str());
            }
        }
    }
    stream->LogSubStreamEnd();
    return stream->GetPosition();
}


/////////////////////////////////////////////////////////////////

// STATIC
int plMsgCArrayHelper::Poke(const void * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions)
{
    stream->Write(bufsz,buf);
    return stream->GetPosition();
}

// STATIC
int plMsgCArrayHelper::Peek(void * buf, UInt32 bufsz, hsStream* stream, const UInt32 peekOptions)
{
    stream->LogSubStreamStart("push me");
    stream->LogRead(bufsz,buf,"CArray");
    stream->LogSubStreamEnd();
    return stream->GetPosition();
}