- Main Page
- Namespaces
- Classes
- Files

- File List

# Packet.cpp

    00001
    00002 //
    00003 // SFML - Simple and Fast Multimedia Library
    00004 // Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
    00005 //
    00006 // This software is provided 'as-is', without any express or implied warranty.
    00007 // In no event will the authors be held liable for any damages arising from the use of this software.
    00008 //
    00009 // Permission is granted to anyone to use this software for any purpose,
    00010 // including commercial applications, and to alter it and redistribute it freely,
    00011 // subject to the following restrictions:
    00012 //
    00013 // 1. The origin of this software must not be misrepresented;
    00014 //    you must not claim that you wrote the original software.
    00015 //    If you use this software in a product, an acknowledgment
    00016 //    in the product documentation would be appreciated but is not required.
    00017 //
    00018 // 2. Altered source versions must be plainly marked as such,
    00019 //    and must not be misrepresented as being the original software.
    00020 //
    00021 // 3. This notice may not be removed or altered from any source distribution.
    00022 //
    00024
    00026 // Headers
    00028 #include <SFML/Network/Packet.hpp>
    00029 #include <SFML/Network/SocketHelper.hpp>
    00030 #include <string.h>
    00031
    00032
    00033 namespace sf
    00034 {
    00038 Packet::Packet() :
    00039 myReadPos(0),
    00040 myIsValid(true)
    00041 {
    00042
    00043 }
    00044
    00045
    00049 Packet::~Packet()
    00050 {
    00051
    00052 }
    00053
    00054
    00058 void Packet::Append(const void* Data, std::size_t SizeInBytes)
    00059 {
    00060     if (Data && (SizeInBytes > 0))
    00061     {
    00062         std::size_t Start = myData.size();
    00063         myData.resize(Start + SizeInBytes);
    00064         memcpy(&myData[Start], Data, SizeInBytes);
    00065     }
    00066 }
    00067
    00068
    00072 void Packet::Clear()
    00073 {
    00074     myData.clear();
    00075     myReadPos = 0;
    00076     myIsValid = true;
    00077 }
    00078
    00079
    00085 const char* Packet::GetData() const
    00086 {
    00087     return !myData.empty() ? &myData[0] : NULL;
    00088 }
    00089
    00090
    00094 std::size_t Packet::GetDataSize() const
    00095 {
    00096     return myData.size();
    00097 }
    00098
    00099
    00103 bool Packet::EndOfPacket() const
    00104 {
    00105     return myReadPos >= myData.size();
    00106 }
    00107
    00108
    00112 Packet::operator bool() const
    00113 {
    00114     return myIsValid;
    00115 }
    00116
    00117
    00121 Packet& Packet::operator >>(bool& Data)
    00122 {
    00123     Uint8 Value;
    00124     if (*this >> Value)
    00125         Data = (Value != 0);
    00126
    00127     return *this;
    00128 }
    00129 Packet& Packet::operator >>(Int8& Data)
    00130 {
    00131     if (CheckSize(sizeof(Data)))
    00132     {
    00133         Data = *reinterpret_cast<const Int8*>(GetData() + myReadPos);
    00134         myReadPos += sizeof(Data);
    00135     }
    00136
    00137     return *this;
    00138 }
    00139 Packet& Packet::operator >>(Uint8& Data)
    00140 {
    00141     if (CheckSize(sizeof(Data)))
    00142     {
    00143         Data = *reinterpret_cast<const Uint8*>(GetData() + myReadPos);
    00144         myReadPos += sizeof(Data);
    00145     }
    00146
    00147     return *this;
    00148 }
    00149 Packet& Packet::operator >>(Int16& Data)
    00150 {
    00151     if (CheckSize(sizeof(Data)))
    00152     {
    00153         Data = ntohs(*reinterpret_cast<const Int16*>(GetData() + myReadPos));
    00154         myReadPos += sizeof(Data);
    00155     }
    00156
    00157     return *this;
    00158 }
    00159 Packet& Packet::operator >>(Uint16& Data)
    00160 {
    00161     if (CheckSize(sizeof(Data)))
    00162     {
    00163         Data = ntohs(*reinterpret_cast<const Uint16*>(GetData() + myReadPos));
    00164         myReadPos += sizeof(Data);
    00165     }
    00166
    00167     return *this;
    00168 }
    00169 Packet& Packet::operator >>(Int32& Data)
    00170 {
    00171     if (CheckSize(sizeof(Data)))
    00172     {
    00173         Data = ntohl(*reinterpret_cast<const Int32*>(GetData() + myReadPos));
    00174         myReadPos += sizeof(Data);
    00175     }
    00176
    00177     return *this;
    00178 }
    00179 Packet& Packet::operator >>(Uint32& Data)
    00180 {
    00181     if (CheckSize(sizeof(Data)))
    00182     {
    00183         Data = ntohl(*reinterpret_cast<const Uint32*>(GetData() + myReadPos));
    00184         myReadPos += sizeof(Data);
    00185     }
    00186
    00187     return *this;
    00188 }
    00189 Packet& Packet::operator >>(float& Data)
    00190 {
    00191     if (CheckSize(sizeof(Data)))
    00192     {
    00193         Data = *reinterpret_cast<const float*>(GetData() + myReadPos);
    00194         myReadPos += sizeof(Data);
    00195     }
    00196
    00197     return *this;
    00198 }
    00199 Packet& Packet::operator >>(double& Data)
    00200 {
    00201     if (CheckSize(sizeof(Data)))
    00202     {
    00203         Data = *reinterpret_cast<const double*>(GetData() + myReadPos);
    00204         myReadPos += sizeof(Data);
    00205     }
    00206
    00207     return *this;
    00208 }
    00209 Packet& Packet::operator >>(char* Data)
    00210 {
    00211     // First extract string length
    00212     Uint32 Length;
    00213     *this >> Length;
    00214
    00215     if ((Length > 0) && CheckSize(Length))
    00216     {
    00217         // Then extract characters
    00218         memcpy(Data, GetData() + myReadPos, Length);
    00219         Data[Length] = '\0';
    00220
    00221         // Update reading position
    00222         myReadPos += Length;
    00223     }
    00224
    00225     return *this;
    00226 }
    00227 Packet& Packet::operator >>(std::string& Data)
    00228 {
    00229     // First extract string length
    00230     Uint32 Length;
    00231     *this >> Length;
    00232
    00233     Data.clear();
    00234     if ((Length > 0) && CheckSize(Length))
    00235     {
    00236         // Then extract characters
    00237         Data.assign(GetData() + myReadPos, Length);
    00238
    00239         // Update reading position
    00240         myReadPos += Length;
    00241     }
    00242
    00243     return *this;
    00244 }
    00245 Packet& Packet::operator >>(wchar_t* Data)
    00246 {
    00247     // First extract string length
    00248     Uint32 Length;
    00249     *this >> Length;
    00250
    00251     if ((Length > 0) && CheckSize(Length * sizeof(Int32)))
    00252     {
    00253         // Then extract characters
    00254         for (Uint32 i = 0; i < Length; ++i)
    00255         {
    00256             Uint32 c;
    00257             *this >> c;
    00258             Data[i] = static_cast<wchar_t>(c);
    00259         }
    00260         Data[Length] = L'\0';
    00261     }
    00262
    00263     return *this;
    00264 }
    00265 Packet& Packet::operator >>(std::wstring& Data)
    00266 {
    00267     // First extract string length
    00268     Uint32 Length;
    00269     *this >> Length;
    00270
    00271     Data.clear();
    00272     if ((Length > 0) && CheckSize(Length * sizeof(Int32)))
    00273     {
    00274         // Then extract characters
    00275         for (Uint32 i = 0; i < Length; ++i)
    00276         {
    00277             Uint32 c;
    00278             *this >> c;
    00279             Data += static_cast<wchar_t>(c);
    00280         }
    00281     }
    00282
    00283     return *this;
    00284 }
    00285
    00286
    00290 Packet& Packet::operator <<(bool Data)
    00291 {
    00292     *this << static_cast<Uint8>(Data);
    00293     return *this;
    00294 }
    00295 Packet& Packet::operator <<(Int8 Data)
    00296 {
    00297     Append(&Data, sizeof(Data));
    00298     return *this;
    00299 }
    00300 Packet& Packet::operator <<(Uint8 Data)
    00301 {
    00302     Append(&Data, sizeof(Data));
    00303     return *this;
    00304 }
    00305 Packet& Packet::operator <<(Int16 Data)
    00306 {
    00307     Int16 ToWrite = htons(Data);
    00308     Append(&ToWrite, sizeof(ToWrite));
    00309     return *this;
    00310 }
    00311 Packet& Packet::operator <<(Uint16 Data)
    00312 {
    00313     Uint16 ToWrite = htons(Data);
    00314     Append(&ToWrite, sizeof(ToWrite));
    00315     return *this;
    00316 }
    00317 Packet& Packet::operator <<(Int32 Data)
    00318 {
    00319     Int32 ToWrite = htonl(Data);
    00320     Append(&ToWrite, sizeof(ToWrite));
    00321     return *this;
    00322 }
    00323 Packet& Packet::operator <<(Uint32 Data)
    00324 {
    00325     Uint32 ToWrite = htonl(Data);
    00326     Append(&ToWrite, sizeof(ToWrite));
    00327     return *this;
    00328 }
    00329 Packet& Packet::operator <<(float Data)
    00330 {
    00331     Append(&Data, sizeof(Data));
    00332     return *this;
    00333 }
    00334 Packet& Packet::operator <<(double Data)
    00335 {
    00336     Append(&Data, sizeof(Data));
    00337     return *this;
    00338 }
    00339 Packet& Packet::operator <<(const char* Data)
    00340 {
    00341     // First insert string length
    00342     Uint32 Length = 0;
    00343     for (const char* c = Data; *c != '\0'; ++c)
    00344         ++Length;
    00345     *this << Length;
    00346
    00347     // Then insert characters
    00348     Append(Data, Length * sizeof(char));
    00349
    00350     return *this;
    00351 }
    00352 Packet& Packet::operator <<(const std::string& Data)
    00353 {
    00354     // First insert string length
    00355     Uint32 Length = static_cast<Uint32>(Data.size());
    00356     *this << Length;
    00357
    00358     // Then insert characters
    00359     if (Length > 0)
    00360     {
    00361         Append(Data.c_str(), Length * sizeof(std::string::value_type));
    00362     }
    00363
    00364     return *this;
    00365 }
    00366 Packet& Packet::operator <<(const wchar_t* Data)
    00367 {
    00368     // First insert string length
    00369     Uint32 Length = 0;
    00370     for (const wchar_t* c = Data; *c != L'\0'; ++c)
    00371         ++Length;
    00372     *this << Length;
    00373
    00374     // Then insert characters
    00375     for (const wchar_t* c = Data; *c != L'\0'; ++c)
    00376         *this << static_cast<Int32>(*c);
    00377
    00378     return *this;
    00379 }
    00380 Packet& Packet::operator <<(const std::wstring& Data)
    00381 {
    00382     // First insert string length
    00383     Uint32 Length = static_cast<Uint32>(Data.size());
    00384     *this << Length;
    00385
    00386     // Then insert characters
    00387     if (Length > 0)
    00388     {
    00389         for (std::wstring::const_iterator c = Data.begin(); c != Data.end(); ++c)
    00390             *this << static_cast<Int32>(*c);
    00391     }
    00392
    00393     return *this;
    00394 }
    00395
    00396
    00400 bool Packet::CheckSize(std::size_t Size)
    00401 {
    00402     myIsValid = myIsValid && (myReadPos + Size <= myData.size());
    00403
    00404     return myIsValid;
    00405 }
    00406
    00407
    00411 const char* Packet::OnSend(std::size_t& DataSize)
    00412 {
    00413     DataSize = GetDataSize();
    00414     return GetData();
    00415 }
    00416
    00417
    00421 void Packet::OnReceive(const char* Data, std::size_t DataSize)
    00422 {
    00423     Append(Data, DataSize);
    00424 }
    00425
    00426 } // namespace sf

:: Copyright © 2007-2008 Laurent Gomila, all rights reserved :: Documentation generated by doxygen 1.5.2 ::