BaseClient

Base Client Usage

• Idea of the "Base Client" is communicating the packets with the server whatever the way you prefer.

Packet Declaration

// SomePacketInfo.h
...
typedef enum _receivePacketType{
RECEIVE_PACKET_TYPE_DIDSOMETHING=0,
RECEIVE_PACKET_TYPE_DIDSOMETHING2,
RECEIVE_PACKET_TYPE_DIDSOMETHING3,
RECEIVE_PACKET_TYPE_ENDOFPROCESS,
}ReceivePacketType;

typedef enum _sendPacketType{
SEND_PACKET_TYPE_DOSOMETHING=0,
SEND_PACKET_TYPE_DOSOMETHING2,
SEND_PACKET_TYPE_DOSOMETHING3,
}SendPacketType;

struct SendPacket{
   SendPacketType packetType;
   unsigned int magicNum;
};

struct ReceivePacket{
   ReceivePacketType packetType;
};

Linking

// SomeClient.h
#include "epl.h"
#include "SomePacketInfo.h"
using namespace epl;

Client Declaration Example

// SomeClient.h
class SomeClient:public BaseClient
{
public:
   SomeClient();
   SomeClient(const SomeClient& b);
   virtual ~SomeClient();
   SomeClient & operator=(const SomeClient&b)
   {
      return *this;
   }
   virtual void parsePacket(const Packet &packet );
};

Client Implementation Example

// SomeClient.cpp
SomeClient::SomeClient():BaseClient()
{
}

SomeClient::SomeClient(const SomeClient& b):BaseClient(b)
{
}

SomeClient::~SomeClient()
{
}

void SomeClient::parsePacket(const Packet &packet )
{
   Packet sendPacket;
   PacketContainer<SendPacket> packetContainer;
   PacketContainer<ReceivePacket> container=PacketContainer<ReceivePacket>(reinterpret_cast<const void*>(packet.GetPacket()),packet.GetPacketByteSize(),false);

   switch(container.GetPacketPtr()->packetType)
   {
   case RECEIVE_PACKET_TYPE_DIDSOMETHING:
      _tprintf(_T("%s"), (TCHAR*)container.GetArray());
      packetContainer=PacketContainer<SendPacket>();
      packetContainer.GetPacketPtr()->packetType=SEND_PACKET_TYPE_DOSOMETHING2;
      packetContainer.GetPacketPtr()->magicNum = 2;
      CString someString=_T("Hello back");
      packetContainer.SetArray(reinterpret_cast<const char*>(someString.GetString()),(someString.GetLength()+1)*sizeof(TCHAR));
      sendPacket=Packet(reinterpret_cast<const void*>(packetContainer.GetPacketPtr()),packetContainer.GetPacketByteSize(),false);
      Send(sendPacket);
      break;
   case RECEIVE_PACKET_TYPE_DIDSOMETHING2:
      _tprintf(_T("%s"), (TCHAR*)container.GetArray());
      packetContainer=PacketContainer<SendPacket>();
      packetContainer.GetPacketPtr()->packetType=SEND_PACKET_TYPE_DOSOMETHING3;
      packetContainer.GetPacketPtr()->magicNum = 3;
      CString someString=_T("Hello back");
      packetContainer.SetArray(reinterpret_cast<const char*>(someString.GetString()),(someString.GetLength()+1)*sizeof(TCHAR));
      sendPacket=Packet(reinterpret_cast<const void*>(packetContainer.GetPacketPtr()),packetContainer.GetPacketByteSize(),false);
      Send(sendPacket);
      break;
   case RECEIVE_PACKET_TYPE_DIDSOMETHING3:
      ...
      break;
   case RECEIVE_PACKET_TYPE_ENDOFPROCESS:
      // Transmission from the server is done
      ...
      break;
   default:
      //TODO: Message Output for Error
      break;
   }
}

• • Note that each "parsePacket" function runs in different thread.

Client Connect/Disconnect Example

#include "SomeClient.h"
SomeClient m_client;
...
m_client.SetHostName(_T("11.222.33.44"));
m_client.SetPort(_T("1020")); // Must be same as server side port setting, but this must be done before connecting to server
if(m_client.Connect())
{
   // connected to server
   PacketContainer<SendPacket> packetContainer=PacketContainer<SendPacket>();
   packetContainer.GetPacketPtr()->packetType=SEND_PACKET_TYPE_DOSOMETHING;
   Packet sendPacket=Packet(reinterpret_cast<const void*>(packetContainer.GetPacketPtr()),packetContainer.GetPacketByteSize(),false);
    if(!m_client.Send(sendPacket))
    {
       // send failed
    }
}
else
{
   // connection failed
}

...
if(m_client.IsConnected()) // check if connected to server
{
   m_client.Disconnect();  // Disconnect from the server
}