NetworkHelper.h

Go to the documentation of this file.

/*
 * NetworkHelper - A couple of helper methods.
 *
* @Author Michael <Tharbas> Matzen
 *
 * 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 2 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, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110, USA
 * 
 */
#pragma once

#include "StringCompressor.h"
#include "SraNetworkShared.h"
#include <locale>
#include <iostream>
#include <string>
#include <sstream>
#include <RakString.h>

using namespace std;

namespace SraNetwork
{
    class Helpers
    {
    public:

        static void GetWStringFromBuffer( const char* buffer, const size_t strlen, wchar_t* target)
        {
            wostringstream wstream;

            // Create the facet
            const ctype<wchar_t>& facet =
                use_facet< ctype<wchar_t> >( wstream.getloc() );

            // Now copy the characters
            for (size_t idx = 0; idx < strlen; ++idx)
            {
                wstream << facet.widen( buffer[idx] );
            }

            // And copy to the output
            wcscpy( target, wstream.str().c_str());
        }

        static RakNet::RakString GetStringFromBuffer(RakNet::BitStream* stream)
        {
            RakNet::RakString str = "";
            RakNet::StringCompressor::Instance()->DecodeString(&str, MAX_STRLEN, stream);           
        }

        static int GetIntFromBuffer( const char* buffer, int* offset )
        {
            int result = 0;
            memcpy( &result, buffer+ *offset, sizeof(result));
            *offset += sizeof(result);
            return result;
        }

        static void StoreWStringInBuffer( const wchar_t* source, char* target)
        {
            ostringstream ststream;
            
            // Create the facet
            const ctype<char>& facet =
                use_facet< ctype<char> >( ststream.getloc() );

            // Now copy the characters
            for (size_t idx = 0; idx < wcslen(source); ++idx)
            {
                ststream << facet.narrow( source[idx], 0 );
            }

            // And copy to the output
            strcpy( target, ststream.str().c_str());
        }

        static int StoreStringInBuffer( const std::string source, RakNet::BitStream* stream)
        {
             RakNet::StringCompressor::Instance()->EncodeString(
                 source.c_str(), MAX_STRLEN, stream);
        }

        static int StoreIntInBuffer( const int source, char* target)
        {
            memcpy(target, &source, sizeof(source));
            return sizeof(source);
        }
    };
}