CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetCommon/plClientGuid.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 "plClientGuid.h"
#include "hsStream.h"
#include <sstream>
#include "plNetCommon.h"
#include "pnMessage/plMessage.h"
#include "plSockets/plNet.h"

plClientGuid::plClientGuid()
:fPlayerID(0)
,fCCRLevel(0)
,fFlags(0)
,fProtectedLogin(false)
,fBuildType(plNetCommon::BuildType::kUnknown)
,fSrcAddr(0)
,fSrcPort(0)
,fReserved(false)
{
    fAccountUUID.Clear();
}

void plClientGuid::SetAccountUUID(const plUUID * v )
{
    fAccountUUID.CopyFrom( v );
    if ( !fAccountUUID.IsNull() )
        fFlags|=kAccountUUID;
    else
        fFlags&=~kAccountUUID;
}

void plClientGuid::SetAccountUUID(const plUUID & v )
{
    SetAccountUUID( &v );
}

void plClientGuid::SetBuildType(UInt8 type)
{
    fBuildType=type;
    fFlags|=kBuildType;
}

void plClientGuid::SetPlayerID(UInt32 id)
{
    fPlayerID=id;
    if ( fPlayerID )
    {
        fFlags|=kPlayerID;
        fFlags&=~kTempPlayerID;
    }
    else
        fFlags&=~kPlayerID;
}

void plClientGuid::SetTempPlayerID(UInt32 id)
{
    fPlayerID=id;
    if ( fPlayerID )
    {
        fFlags&=~kPlayerID;
        fFlags|=kTempPlayerID;
    }
    else
    {
        fFlags&=~kTempPlayerID;
    }
}

void plClientGuid::SetPlayerName( const char * v )
{
    fPlayerName = v?v:"";
    if ( fPlayerName.size() )
        fFlags|=kPlayerName;
    else
        fFlags&=~kPlayerName;
}

void plClientGuid::SetCCRLevel(UInt8 v)
{
    fCCRLevel=v;
    fFlags|=kCCRLevel;
}

void plClientGuid::SetProtectedLogin(bool b)
{
    fProtectedLogin=b;
    fFlags |= kProtectedLogin;
}

void plClientGuid::SetSrcAddr( UInt32 v )
{
    fSrcAddr = v;
    if ( fSrcAddr )
        fFlags|=kSrcAddr;
    else
        fFlags&=~kSrcAddr;
}

void plClientGuid::SetSrcAddrFromStr( const char * s )
{
    hsAssert(false, "eric, port me");
}

void plClientGuid::SetSrcPort( UInt16 v )
{
    fSrcPort = v;
    if ( fSrcPort )
        fFlags|=kSrcPort;
    else
        fFlags&=~kSrcPort;
}

void plClientGuid::SetReserved(bool b)
{
    fReserved=b;
    fFlags |= kReserved;
}

void plClientGuid::SetClientKey(const std::string& key)
{
    fClientKey = key;
    if ( fClientKey.size() )
        fFlags|=kClientKey;
    else
        fFlags&=~kClientKey;
}

const char * plClientGuid::GetSrcAddrStr() const
{
    hsAssert(false, "eric, port me");
    static const char foo[] = "";
    return foo;
}

std::string plClientGuid::AsStdString() const
{
#define kComma  ","
#define kEmpty  ""
    const char * spacer = kEmpty;

    std::stringstream ss;

    ss << "[";

    if (IsFlagSet(kPlayerID))
    {
        ss << spacer << "Pid:" << fPlayerID;
        spacer = kComma;
    }
    else if (IsFlagSet(kTempPlayerID))
    {
        ss << spacer << "tPd:" << fPlayerID;
        spacer = kComma;
    }
    if (IsFlagSet(kPlayerName))
    {
        ss << spacer << "Plr:" << fPlayerName;
    }
    if (IsFlagSet(kCCRLevel))
    {
        ss << spacer << "CCR:" << (int)fCCRLevel;
        spacer = kComma;
    }
    if (IsFlagSet(kProtectedLogin))
    {
        ss << spacer << "Pro:" << (int)fProtectedLogin;
        spacer = kComma;
    }
    if (IsFlagSet(kBuildType))
    {
        ss << spacer << "Bld:" << plNetCommon::BuildType::BuildTypeStr(fBuildType);
        spacer = kComma;
    }
    if ( IsFlagSet(kSrcAddr) )
    {
        ss << spacer << "Addr:" << GetSrcAddrStr();
        spacer = kComma;
    }
    if ( IsFlagSet(kSrcPort) )
    {
        ss << spacer << "Port:" << (int)fSrcPort;
        spacer = kComma;
    }
    if (IsFlagSet(kAccountUUID))
    {
        ss << spacer << "plUUID:" << fAccountUUID.AsStdString();
        spacer = kComma;
    }
    if ( IsFlagSet(kReserved))
    {
        ss << spacer << "Res:" << (int)fReserved;
        spacer = kComma;
    }
    if (IsFlagSet(kClientKey))
    {
        ss << spacer << "ClientKey:" << fClientKey;
        spacer = kComma;
    }
    ss  << "]";

    return ss.str().c_str();
}

std::string plClientGuid::AsLogString() const
{
#define kSemicolon  ";"
    const char* spacer = kSemicolon;

    std::stringstream ss;

    if (IsFlagSet(kAccountUUID))
    {
        ss << "AcctUUID=" << fAccountUUID.AsStdString();
        ss << spacer;
    }
    if (IsFlagSet(kPlayerID))
    {
        ss << "PlayerID=" << fPlayerID;
        ss << spacer;
    }
//  else if (IsFlagSet(kTempPlayerID))
//  {
//      ss << "tempPlayerID:" << fPlayerID;
//      ss << spacer;
//  }
    if ( IsFlagSet(kSrcAddr) )
    {
        ss << "SrcAddr=" << GetSrcAddrStr();
        ss << spacer;
    }
    if ( IsFlagSet(kSrcPort) )
    {
        ss << "SrcPort=" << (int)fSrcPort;
        ss << spacer;
    }
    if (IsFlagSet(kCCRLevel))
    {
        ss << "CCRLevel=" << (int)fCCRLevel;
        ss << spacer;
    }
    if (IsFlagSet(kProtectedLogin))
    {
        ss << "Protected=" << (int)fProtectedLogin;
        ss << spacer;
    }
    if (IsFlagSet(kBuildType))
    {
        ss << "Build=" << plNetCommon::BuildType::BuildTypeStr(fBuildType);
        ss << spacer;
    }
    if (IsFlagSet(kReserved))
    {
        ss << "Reserved=" << (int)fReserved;
        ss << spacer;
    }
    if (IsFlagSet(kClientKey))
    {
        ss << "ClientKey=" << fClientKey;
        ss << spacer;
    }

    return ss.str().c_str();
}

void plClientGuid::Read(hsStream * s, hsResMgr* mgr)
{
    s->LogSubStreamStart("push me");
    s->LogReadSwap(&fFlags,"Flags");
    if (IsFlagSet(kAccountUUID))
    {
        s->LogSubStreamPushDesc("AcctUUID");
        fAccountUUID.Read( s );
    }
    if (IsFlagSet(kPlayerID))
        s->LogReadSwap(&fPlayerID,"PlayerID");
    else if (IsFlagSet(kTempPlayerID))
        s->LogReadSwap(&fPlayerID,"TempPlayerID");
    if (IsFlagSet(kPlayerName))
    {
        s->LogSubStreamPushDesc("PlayerName");
        plMsgStdStringHelper::Peek( fPlayerName, s );
    }
    if (IsFlagSet(kCCRLevel))
        s->LogReadSwap(&fCCRLevel,"CCRLevel");
    if (IsFlagSet(kProtectedLogin))
        s->LogReadSwap(&fProtectedLogin,"ProtectedLogin");
    if (IsFlagSet(kBuildType))
        s->LogReadSwap(&fBuildType,"BuildType");
    if (IsFlagSet(kSrcAddr))
        s->LogReadSwap(&fSrcAddr,"SrcAddr");
    if (IsFlagSet(kSrcPort))
        s->LogReadSwap(&fSrcPort,"SrcPort");
    if (IsFlagSet(kReserved))
        s->LogReadSwap(&fReserved,"Reserved");
    if (IsFlagSet(kClientKey))
    {
        s->LogSubStreamPushDesc("ClientKey");
        plMsgStdStringHelper::Peek( fClientKey, s );
    }
    s->LogSubStreamEnd();
}

void plClientGuid::Write(hsStream * s, hsResMgr* mgr)
{
    s->WriteSwap(fFlags);
    if (IsFlagSet(kAccountUUID))
        fAccountUUID.Write( s );
    if (IsFlagSet(kPlayerID))
        s->WriteSwap(fPlayerID);
    else if (IsFlagSet(kTempPlayerID))
        s->WriteSwap(fPlayerID);
    if (IsFlagSet(kPlayerName))
        plMsgStdStringHelper::Poke( fPlayerName, s );
    if (IsFlagSet(kCCRLevel))
        s->WriteSwap(fCCRLevel);
    if (IsFlagSet(kProtectedLogin))
        s->WriteSwap(fProtectedLogin);
    if (IsFlagSet(kBuildType))
        s->WriteSwap(fBuildType);
    if (IsFlagSet(kSrcAddr))
        s->WriteSwap(fSrcAddr);
    if (IsFlagSet(kSrcPort))
        s->WriteSwap(fSrcPort);
    if (IsFlagSet(kReserved))
        s->WriteSwap(fReserved);
    if (IsFlagSet(kClientKey))
        plMsgStdStringHelper::Poke( fClientKey, s );
}

void plClientGuid::CopyFrom(const plClientGuid * other)
{
    fFlags = other->fFlags;
    fAccountUUID.CopyFrom( &other->fAccountUUID );
    fPlayerID = other->fPlayerID;
    fPlayerName = other->fPlayerName;
    fCCRLevel = other->fCCRLevel;
    fProtectedLogin = other->fProtectedLogin;
    fBuildType = other->fBuildType;
    fSrcAddr = other->fSrcAddr;
    fSrcPort = other->fSrcPort;
    fReserved = other->fReserved;
    fClientKey = other->fClientKey;
}

void plClientGuid::UpdateFrom(const plClientGuid * other)
{
    if ( !HasAccountUUID() && other->HasAccountUUID() )
        SetAccountUUID( other->GetAccountUUID() );
    if ( !HasPlayerID() && other->HasPlayerID() )
        SetPlayerID( other->GetPlayerID() );
    if ( !HasPlayerName() && other->HasPlayerName() )
        SetPlayerName( other->GetPlayerName() );
    if ( !HasProtectedLogin() && other->HasProtectedLogin() )
        SetProtectedLogin( other->GetProtectedLogin() );
    if ( !HasCCRLevel() && other->HasCCRLevel() )
        SetCCRLevel( other->GetCCRLevel() );
    if ( !HasBuildType() && other->HasBuildType() )
        SetBuildType( other->GetBuildType() );
    if ( !HasSrcAddr() && other->HasSrcAddr() )
        SetSrcAddr( other->GetSrcAddr() );
    if ( !HasSrcPort() && other->HasSrcPort() )
        SetSrcPort( other->GetSrcPort() );
    if ( !HasReservedBit() && other->HasReservedBit() )
        SetReserved( other->IsReserved() );
    if ( !HasClientKey() && other->HasClientKey() )
        SetClientKey( other->GetClientKey() );
}

void plClientGuid::Clear()
{
    plClientGuid tmp;
    CopyFrom( &tmp );
}

bool plClientGuid::IsEqualTo(const plClientGuid * other) const
{
    return
        fFlags == other->fFlags &&
        fAccountUUID.IsEqualTo( &other->fAccountUUID ) &&
        fPlayerID == other->fPlayerID &&
        fPlayerName == other->fPlayerName &&
        fCCRLevel == other->fCCRLevel &&
        fProtectedLogin == other->fProtectedLogin &&
        fBuildType == other->fBuildType &&
        fReserved == other->fReserved &&
        fClientKey == other->fClientKey;
}

bool operator==(const plClientGuid & X, const plClientGuid & Y)
{
    return ( X.fAccountUUID.IsEqualTo( &Y.fAccountUUID )&&X.fPlayerID==Y.fPlayerID&&X.fFlags==Y.fFlags);
}
bool operator!=(const plClientGuid & X, const plClientGuid & Y)
{
    return ( !X.fAccountUUID.IsEqualTo( &Y.fAccountUUID )||X.fPlayerID!=Y.fPlayerID||X.fFlags!=Y.fFlags);
}
bool operator<(const plClientGuid & X, const plClientGuid & Y)
{
    return ( X.fAccountUUID.CompareTo( &Y.fAccountUUID )<0||X.fPlayerID<Y.fPlayerID);
}