Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Improved the API documentation of sf::IpAddress

Browse Source 
git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1452 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
LaurentGom 2010-03-12 09:35:17 +00:00
parent b7eb09cb79
commit e924c9cf39
34 changed files with 336 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CSFML/build/VC2005/csfml-network.vcproj
View File

@ -223,11 +223,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\IPAddress.cpp"
RelativePath="..\..\src\SFML\Network\IpAddress.cpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Network\IPAddress.h"
RelativePath="..\..\include\SFML\Network\IpAddress.h"
>
</File>
<File

4
CSFML/build/VC2008/csfml-network.vcproj
View File

@ -222,11 +222,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\IPAddress.cpp"
RelativePath="..\..\src\SFML\Network\IpAddress.cpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Network\IPAddress.h"
RelativePath="..\..\include\SFML\Network\IpAddress.h"
>
</File>
<File

4
CSFML/build/codeblocks/csfml-network.cbp
View File

@ -56,7 +56,7 @@
</Linker>
<Unit filename="..\..\include\SFML\Network\Ftp.h" />
<Unit filename="..\..\include\SFML\Network\Http.h" />
<Unit filename="..\..\include\SFML\Network\IPAddress.h" />
<Unit filename="..\..\include\SFML\Network\IpAddress.h" />
<Unit filename="..\..\include\SFML\Network\Packet.h" />
<Unit filename="..\..\include\SFML\Network\Selector.h" />
<Unit filename="..\..\include\SFML\Network\SocketStatus.h" />
@ -67,7 +67,7 @@
<Unit filename="..\..\src\SFML\Network\FtpStruct.h" />
<Unit filename="..\..\src\SFML\Network\Http.cpp" />
<Unit filename="..\..\src\SFML\Network\HttpStruct.h" />
<Unit filename="..\..\src\SFML\Network\IPAddress.cpp" />
<Unit filename="..\..\src\SFML\Network\IpAddress.cpp" />
<Unit filename="..\..\src\SFML\Network\Packet.cpp" />
<Unit filename="..\..\src\SFML\Network\PacketStruct.h" />
<Unit filename="..\..\src\SFML\Network\Selector.cpp" />

2
CSFML/include/SFML/Network.h
View File

@ -30,7 +30,7 @@
////////////////////////////////////////////////////////////
#include <SFML/System.h>
#include <SFML/Network/IPAddress.h>
#include <SFML/Network/IpAddress.h>
#include <SFML/Network/Packet.h>
#include <SFML/Network/Selector.h>
#include <SFML/Network/SocketTCP.h>

4
CSFML/include/SFML/Network/Ftp.h
View File

@ -29,7 +29,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
#include <SFML/Network/IPAddress.h>
#include <SFML/Network/IpAddress.h>
#include <SFML/Network/Types.h>
@ -287,7 +287,7 @@ CSFML_API void sfFtp_Destroy(sfFtp* ftp);
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
CSFML_API sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIPAddress server, unsigned short port, float timeout);
CSFML_API sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIpAddress server, unsigned short port, float timeout);
////////////////////////////////////////////////////////////
/// Log in using anonymous account

22
CSFML/include/SFML/Network/IpAddress.h
View File

@ -32,12 +32,12 @@
////////////////////////////////////////////////////////////
/// sfIPAddress provides easy manipulation of IP v4 addresses
/// sfIpAddress provides easy manipulation of IP v4 addresses
////////////////////////////////////////////////////////////
typedef struct
{
char Address[16];
} sfIPAddress;
} sfIpAddress;
////////////////////////////////////////////////////////////
@ -48,7 +48,7 @@ typedef struct
/// \return Resulting address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromString(const char* string);
CSFML_API sfIpAddress sfIpAddress_FromString(const char* string);
////////////////////////////////////////////////////////////
/// Construct an address from 4 bytes
@ -61,7 +61,7 @@ CSFML_API sfIPAddress sfIPAddress_FromString(const char* string);
/// \return Resulting address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
CSFML_API sfIpAddress sfIpAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3);
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
@ -69,7 +69,7 @@ CSFML_API sfIPAddress sfIPAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint
/// \param address : 4 bytes of the address packed into a 32-bits integer
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_FromInteger(sfUint32 address);
CSFML_API sfIpAddress sfIpAddress_FromInteger(sfUint32 address);
////////////////////////////////////////////////////////////
/// Tell if an address is a valid one
@ -79,7 +79,7 @@ CSFML_API sfIPAddress sfIPAddress_FromInteger(sfUint32 address);
/// \return sfTrue if address has a valid syntax
///
////////////////////////////////////////////////////////////
CSFML_API sfBool sfIPAddress_IsValid(sfIPAddress address);
CSFML_API sfBool sfIpAddress_IsValid(sfIpAddress address);
////////////////////////////////////////////////////////////
/// Get a string representation of an address
@ -88,7 +88,7 @@ CSFML_API sfBool sfIPAddress_IsValid(sfIPAddress address);
/// \param string : Char array to fill (size must be >= 16)
///
////////////////////////////////////////////////////////////
CSFML_API void sfIPAddress_ToString(sfIPAddress address, char* string);
CSFML_API void sfIpAddress_ToString(sfIpAddress address, char* string);
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
@ -98,7 +98,7 @@ CSFML_API void sfIPAddress_ToString(sfIPAddress address, char* string);
/// \return 32-bits integer containing the 4 bytes of the address, in system endianness
///
////////////////////////////////////////////////////////////
CSFML_API sfUint32 sfIPAddress_ToInteger(sfIPAddress address);
CSFML_API sfUint32 sfIpAddress_ToInteger(sfIpAddress address);
////////////////////////////////////////////////////////////
/// Get the computer's local IP address (from the LAN point of view)
@ -106,7 +106,7 @@ CSFML_API sfUint32 sfIPAddress_ToInteger(sfIPAddress address);
/// \return Local IP address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_GetLocalAddress();
CSFML_API sfIpAddress sfIpAddress_GetLocalAddress();
////////////////////////////////////////////////////////////
/// Get the computer's public IP address (from the web point of view).
@ -119,7 +119,7 @@ CSFML_API sfIPAddress sfIPAddress_GetLocalAddress();
/// \return Public IP address
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_GetPublicAddress(float timeout);
CSFML_API sfIpAddress sfIpAddress_GetPublicAddress(float timeout);
////////////////////////////////////////////////////////////
/// Get the computer's loopback address
@ -127,7 +127,7 @@ CSFML_API sfIPAddress sfIPAddress_GetPublicAddress(float timeout);
/// \return Local host IP address (127.0.0.1, or "localhost")
///
////////////////////////////////////////////////////////////
CSFML_API sfIPAddress sfIPAddress_LocalHost();
CSFML_API sfIpAddress sfIpAddress_LocalHost();
#endif // SFML_IPADDRESS_H

6
CSFML/include/SFML/Network/SocketTCP.h
View File

@ -29,7 +29,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
#include <SFML/Network/IPAddress.h>
#include <SFML/Network/IpAddress.h>
#include <SFML/Network/SocketStatus.h>
#include <SFML/Network/Types.h>
@ -81,7 +81,7 @@ CSFML_API void sfSocketTCP_SetBlocking(sfSocketTCP* socket, sfBool blocking);
/// \return sfTrue if operation has been successful
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIPAddress host, float timeout);
CSFML_API sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIpAddress host, float timeout);
////////////////////////////////////////////////////////////
/// Listen to a specified port for incoming data or connections
@ -106,7 +106,7 @@ CSFML_API sfBool sfSocketTCP_Listen(sfSocketTCP* socket, unsigned short port);
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIPAddress* address);
CSFML_API sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIpAddress* address);
////////////////////////////////////////////////////////////
/// Send an array of bytes to the host (must be connected first)

10
CSFML/include/SFML/Network/SocketUDP.h
View File

@ -29,7 +29,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.h>
#include <SFML/Network/IPAddress.h>
#include <SFML/Network/IpAddress.h>
#include <SFML/Network/SocketStatus.h>
#include <SFML/Network/Types.h>
@ -103,7 +103,7 @@ CSFML_API sfBool sfSocketUDP_Unbind(sfSocketUDP* socket);
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIPAddress address, unsigned short port);
CSFML_API sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIpAddress address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive an array of bytes.
@ -120,7 +120,7 @@ CSFML_API sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data,
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIPAddress* address, unsigned short* port);
CSFML_API sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIpAddress* address, unsigned short* port);
////////////////////////////////////////////////////////////
/// Send a packet of data
@ -133,7 +133,7 @@ CSFML_API sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, si
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress address, unsigned short port);
CSFML_API sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIpAddress address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive a packet.
@ -148,7 +148,7 @@ CSFML_API sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* p
/// \return Socket status
///
////////////////////////////////////////////////////////////
CSFML_API sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress* address, unsigned short* port);
CSFML_API sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIpAddress* address, unsigned short* port);
////////////////////////////////////////////////////////////
/// Close the socket

6
CSFML/src/SFML/Network/Ftp.cpp
View File

@ -27,7 +27,7 @@
////////////////////////////////////////////////////////////
#include <SFML/Network/Ftp.h>
#include <SFML/Network/FtpStruct.h>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Internal.h>
@ -197,11 +197,11 @@ void sfFtp_Destroy(sfFtp* ftp)
////////////////////////////////////////////////////////////
/// Connect to the specified FTP server
////////////////////////////////////////////////////////////
sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIPAddress server, unsigned short port, float timeout)
sfFtpResponse* sfFtp_Connect(sfFtp* ftp, sfIpAddress server, unsigned short port, float timeout)
{
CSFML_CHECK_RETURN(ftp, NULL);
sf::IPAddress SFMLServer(server.Address);
sf::IpAddress SFMLServer(server.Address);
return new sfFtpResponse(ftp->This.Connect(SFMLServer, port, timeout));
}

42
CSFML/src/SFML/Network/IpAddress.cpp
View File

@ -25,8 +25,8 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Network/IPAddress.h>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.h>
#include <SFML/Network/IpAddress.hpp>
#include <string.h>
@ -35,9 +35,9 @@ namespace
////////////////////////////////////////////////////////////
/// Helper function for converting a SFML address to a CSFML one
////////////////////////////////////////////////////////////
sfIPAddress FromSFMLAddress(sf::IPAddress address)
sfIpAddress FromSFMLAddress(sf::IpAddress address)
{
sfIPAddress result;
sfIpAddress result;
strncpy(result.Address, address.ToString().c_str(), 16);
return result;
@ -46,9 +46,9 @@ namespace
////////////////////////////////////////////////////////////
/// Helper function for converting a CSFML address to a SFML one
////////////////////////////////////////////////////////////
sf::IPAddress ToSFMLAddress(sfIPAddress address)
sf::IpAddress ToSFMLAddress(sfIpAddress address)
{
return sf::IPAddress(address.Address);
return sf::IpAddress(address.Address);
}
}
@ -56,34 +56,34 @@ namespace
////////////////////////////////////////////////////////////
/// Construct an address from a string
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromString(const char* string)
sfIpAddress sfIpAddress_FromString(const char* string)
{
return FromSFMLAddress(sf::IPAddress(string));
return FromSFMLAddress(sf::IpAddress(string));
}
////////////////////////////////////////////////////////////
/// Construct an address from 4 bytes
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3)
sfIpAddress sfIpAddress_FromBytes(sfUint8 byte0, sfUint8 byte1, sfUint8 byte2, sfUint8 byte3)
{
return FromSFMLAddress(sf::IPAddress(byte0, byte1, byte2, byte3));
return FromSFMLAddress(sf::IpAddress(byte0, byte1, byte2, byte3));
}
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_FromInteger(sfUint32 address)
sfIpAddress sfIpAddress_FromInteger(sfUint32 address)
{
return FromSFMLAddress(sf::IPAddress(address));
return FromSFMLAddress(sf::IpAddress(address));
}
////////////////////////////////////////////////////////////
/// Tell if an address is a valid one
////////////////////////////////////////////////////////////
sfBool sfIPAddress_IsValid(sfIPAddress address)
sfBool sfIpAddress_IsValid(sfIpAddress address)
{
return ToSFMLAddress(address).IsValid() ? sfTrue : sfFalse;
}
@ -92,7 +92,7 @@ sfBool sfIPAddress_IsValid(sfIPAddress address)
////////////////////////////////////////////////////////////
/// Get a string representation of an address
////////////////////////////////////////////////////////////
void sfIPAddress_ToString(sfIPAddress address, char* string)
void sfIpAddress_ToString(sfIpAddress address, char* string)
{
if (string)
strcpy(string, address.Address);
@ -102,7 +102,7 @@ void sfIPAddress_ToString(sfIPAddress address, char* string)
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
////////////////////////////////////////////////////////////
sfUint32 sfIPAddress_ToInteger(sfIPAddress address)
sfUint32 sfIpAddress_ToInteger(sfIpAddress address)
{
return ToSFMLAddress(address).ToInteger();
}
@ -111,9 +111,9 @@ sfUint32 sfIPAddress_ToInteger(sfIPAddress address)
////////////////////////////////////////////////////////////
/// Get the computer's local IP address (from the LAN point of view)
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_GetLocalAddress()
sfIpAddress sfIpAddress_GetLocalAddress()
{
return FromSFMLAddress(sf::IPAddress::GetLocalAddress());
return FromSFMLAddress(sf::IpAddress::GetLocalAddress());
}
@ -123,16 +123,16 @@ sfIPAddress sfIPAddress_GetLocalAddress()
/// distant website ; as a consequence, this function may be
/// very slow -- use it as few as possible !
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_GetPublicAddress(float timeout)
sfIpAddress sfIpAddress_GetPublicAddress(float timeout)
{
return FromSFMLAddress(sf::IPAddress::GetPublicAddress(timeout));
return FromSFMLAddress(sf::IpAddress::GetPublicAddress(timeout));
}
////////////////////////////////////////////////////////////
/// Get the computer's loopback address
////////////////////////////////////////////////////////////
sfIPAddress sfIPAddress_LocalHost()
sfIpAddress sfIpAddress_LocalHost()
{
return FromSFMLAddress(sf::IPAddress::LocalHost);
return FromSFMLAddress(sf::IpAddress::LocalHost);
}

10
CSFML/src/SFML/Network/SocketTCP.cpp
View File

@ -28,7 +28,7 @@
#include <SFML/Network/SocketTCP.h>
#include <SFML/Network/SocketTCPStruct.h>
#include <SFML/Network/PacketStruct.h>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Internal.h>
#include <string.h>
@ -79,9 +79,9 @@ void sfSocketTCP_SetBlocking(sfSocketTCP* socket, sfBool blocking)
////////////////////////////////////////////////////////////
/// Connect a TCP socket to another computer on a specified port
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIPAddress host, float timeout)
sfSocketStatus sfSocketTCP_Connect(sfSocketTCP* socket, unsigned short port, sfIpAddress host, float timeout)
{
sf::IPAddress address(host.Address);
sf::IpAddress address(host.Address);
CSFML_CHECK_RETURN(socket, sfSocketError);
@ -103,13 +103,13 @@ sfBool sfSocketTCP_Listen(sfSocketTCP* socket, unsigned short port)
/// This function is blocking, ie. it won't return before
/// a connection has been accepted
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIPAddress* address)
sfSocketStatus sfSocketTCP_Accept(sfSocketTCP* socket, sfSocketTCP** connected, sfIpAddress* address)
{
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(connected, sfSocketError);
// Call SFML internal function
sf::IPAddress clientAddress;
sf::IpAddress clientAddress;
sf::SocketTCP client;
sf::Socket::Status status = socket->This.Accept(client, &clientAddress);
if (status != sf::Socket::Done)

18
CSFML/src/SFML/Network/SocketUDP.cpp
View File

@ -28,7 +28,7 @@
#include <SFML/Network/SocketUDP.h>
#include <SFML/Network/SocketUDPStruct.h>
#include <SFML/Network/PacketStruct.h>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Internal.h>
#include <string.h>
@ -97,12 +97,12 @@ sfBool sfSocketUDP_Unbind(sfSocketUDP* socket)
////////////////////////////////////////////////////////////
/// Send an array of bytes
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIPAddress address, unsigned short port)
sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t size, sfIpAddress address, unsigned short port)
{
CSFML_CHECK_RETURN(socket, sfSocketError)
// Convert the address
sf::IPAddress receiver(address.Address);
sf::IpAddress receiver(address.Address);
return static_cast<sfSocketStatus>(socket->This.Send(data, size, receiver, port));
}
@ -113,12 +113,12 @@ sfSocketStatus sfSocketUDP_Send(sfSocketUDP* socket, const char* data, size_t si
/// This function is blocking, ie. it won't return before some
/// bytes have been received
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIPAddress* address, unsigned short* port)
sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSize, size_t* sizeReceived, sfIpAddress* address, unsigned short* port)
{
CSFML_CHECK_RETURN(socket, sfSocketError);
// Call SFML internal function
sf::IPAddress sender;
sf::IpAddress sender;
unsigned short senderPort;
std::size_t received;
@ -142,13 +142,13 @@ sfSocketStatus sfSocketUDP_Receive(sfSocketUDP* socket, char* data, size_t maxSi
////////////////////////////////////////////////////////////
/// Send a packet of data
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress address, unsigned short port)
sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfIpAddress address, unsigned short port)
{
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
// Convert the address
sf::IPAddress receiver(address.Address);
sf::IpAddress receiver(address.Address);
return static_cast<sfSocketStatus>(socket->This.Send(packet->This, receiver, port));
}
@ -159,12 +159,12 @@ sfSocketStatus sfSocketUDP_SendPacket(sfSocketUDP* socket, sfPacket* packet, sfI
/// This function is blocking, ie. it won't return before a
/// packet is received
////////////////////////////////////////////////////////////
sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIPAddress* address, unsigned short* port)
sfSocketStatus sfSocketUDP_ReceivePacket(sfSocketUDP* socket, sfPacket* packet, sfIpAddress* address, unsigned short* port)
{
CSFML_CHECK_RETURN(socket, sfSocketError);
CSFML_CHECK_RETURN(packet, sfSocketError);
sf::IPAddress sender;
sf::IpAddress sender;
unsigned short senderPort;
sf::Socket::Status status = socket->This.Receive(packet->This, sender, senderPort);
if (status != sf::Socket::Done)

18
CSFML/src/SFML/Network/csfml-network-d.def
View File

@ -49,15 +49,15 @@ EXPORTS
sfHttp_Destroy
sfHttp_SetHost
sfHttp_SendRequest
sfIPAddress_FromString
sfIPAddress_FromBytes
sfIPAddress_FromInteger
sfIPAddress_IsValid
sfIPAddress_ToString
sfIPAddress_ToInteger
sfIPAddress_GetLocalAddress
sfIPAddress_GetPublicAddress
sfIPAddress_LocalHost
sfIpAddress_FromString
sfIpAddress_FromBytes
sfIpAddress_FromInteger
sfIpAddress_IsValid
sfIpAddress_ToString
sfIpAddress_ToInteger
sfIpAddress_GetLocalAddress
sfIpAddress_GetPublicAddress
sfIpAddress_LocalHost
sfSocketTCP_Create
sfSocketTCP_Destroy
sfSocketTCP_SetBlocking

18
CSFML/src/SFML/Network/csfml-network.def
View File

@ -49,15 +49,15 @@ EXPORTS
sfHttp_Destroy
sfHttp_SetHost
sfHttp_SendRequest
sfIPAddress_FromString
sfIPAddress_FromBytes
sfIPAddress_FromInteger
sfIPAddress_IsValid
sfIPAddress_ToString
sfIPAddress_ToInteger
sfIPAddress_GetLocalAddress
sfIPAddress_GetPublicAddress
sfIPAddress_LocalHost
sfIpAddress_FromString
sfIpAddress_FromBytes
sfIpAddress_FromInteger
sfIpAddress_IsValid
sfIpAddress_ToString
sfIpAddress_ToInteger
sfIpAddress_GetLocalAddress
sfIpAddress_GetPublicAddress
sfIpAddress_LocalHost
sfSocketTCP_Create
sfSocketTCP_Copy
sfSocketTCP_Destroy

4
build/codeblocks/sfml-network.cbp
View File

@ -114,7 +114,7 @@
</Linker>
<Unit filename="..\..\include\SFML\Network\Ftp.hpp" />
<Unit filename="..\..\include\SFML\Network\Http.hpp" />
<Unit filename="..\..\include\SFML\Network\IPAddress.hpp" />
<Unit filename="..\..\include\SFML\Network\IpAddress.hpp" />
<Unit filename="..\..\include\SFML\Network\Packet.hpp" />
<Unit filename="..\..\include\SFML\Network\Selector.hpp" />
<Unit filename="..\..\include\SFML\Network\Selector.inl" />
@ -125,7 +125,7 @@
<Unit filename="..\..\include\SFML\Network\Win32\SocketHelper.hpp" />
<Unit filename="..\..\src\SFML\Network\Ftp.cpp" />
<Unit filename="..\..\src\SFML\Network\Http.cpp" />
<Unit filename="..\..\src\SFML\Network\IPAddress.cpp" />
<Unit filename="..\..\src\SFML\Network\IpAddress.cpp" />
<Unit filename="..\..\src\SFML\Network\Packet.cpp" />
<Unit filename="..\..\src\SFML\Network\SelectorBase.cpp" />
<Unit filename="..\..\src\SFML\Network\SocketTCP.cpp" />

4
build/vc2005/sfml-network.vcproj
View File

@ -369,11 +369,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\IPAddress.cpp"
RelativePath="..\..\src\SFML\Network\IpAddress.cpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Network\IPAddress.hpp"
RelativePath="..\..\include\SFML\Network\IpAddress.hpp"
>
</File>
<File

4
build/vc2008/sfml-network.vcproj
View File

@ -368,11 +368,11 @@
>
</File>
<File
RelativePath="..\..\src\SFML\Network\IPAddress.cpp"
RelativePath="..\..\src\SFML\Network\IpAddress.cpp"
>
</File>
<File
RelativePath="..\..\include\SFML\Network\IPAddress.hpp"
RelativePath="..\..\include\SFML\Network\IpAddress.hpp"
>
</File>
<File

2
include/SFML/Network.hpp
View File

@ -32,7 +32,7 @@
#include <SFML/System.hpp>
#include <SFML/Network/Ftp.hpp>
#include <SFML/Network/Http.hpp>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/Packet.hpp>
#include <SFML/Network/Selector.hpp>
#include <SFML/Network/SocketTCP.hpp>

4
include/SFML/Network/Ftp.hpp
View File

@ -36,7 +36,7 @@
namespace sf
{
class IPAddress;
class IpAddress;
////////////////////////////////////////////////////////////
/// This class provides methods for manipulating the FTP
@ -267,7 +267,7 @@ public :
/// \return Server response to the request
///
////////////////////////////////////////////////////////////
Response Connect(const IPAddress& server, unsigned short port = 21, float timeout = 0.f);
Response Connect(const IpAddress& server, unsigned short port = 21, float timeout = 0.f);
////////////////////////////////////////////////////////////
/// Log in using anonymous account

4
include/SFML/Network/Http.hpp
View File

@ -29,7 +29,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/NonCopyable.hpp>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/SocketTCP.hpp>
#include <map>
#include <string>
@ -334,7 +334,7 @@ private :
// Member data
////////////////////////////////////////////////////////////
SocketTCP myConnection; ///< Connection to the host
IPAddress myHost; ///< Web host address
IpAddress myHost; ///< Web host address
std::string myHostName; ///< Web host name
unsigned short myPort; ///< Port used for connection with host
};

235
include/SFML/Network/IpAddress.hpp
View File

@ -37,56 +37,93 @@
namespace sf
{
////////////////////////////////////////////////////////////
/// IPAddress provides easy manipulation of IP v4 addresses
/// \brief Encapsulate an IPv4 network address
///
////////////////////////////////////////////////////////////
class SFML_API IPAddress
class SFML_API IpAddress
{
public :
////////////////////////////////////////////////////////////
/// Default constructor -- constructs an invalid address
/// \brief Default constructor
///
/// This constructor creates an empty (invalid) address
///
////////////////////////////////////////////////////////////
IPAddress();
IpAddress();
////////////////////////////////////////////////////////////
/// Construct the address from a string
/// \brief Construct the address from a string
///
/// \param address : IP address ("xxx.xxx.xxx.xxx") or network name
/// Here \a address can be either a decimal address
/// (ex: "192.168.1.56") or a network name (ex: "localhost").
///
/// \param address IP address or network name
///
////////////////////////////////////////////////////////////
IPAddress(const std::string& address);
IpAddress(const std::string& address);
////////////////////////////////////////////////////////////
/// Construct the address from a C-style string ;
/// Needed for implicit conversions from literal strings to IPAddress to work
/// \brief Construct the address from a string
///
/// \param address : IP address ("xxx.xxx.xxx.xxx") or network name
/// Here \a address can be either a decimal address
/// (ex: "192.168.1.56") or a network name (ex: "localhost").
/// This is equivalent to the constructor taking a std::string
/// parameter, it is defined for convenience so that the
/// implicit conversions from literal strings to IpAddress work.
///
/// \param address IP address or network name
///
////////////////////////////////////////////////////////////
IPAddress(const char* address);
IpAddress(const char* address);
////////////////////////////////////////////////////////////
/// Construct the address from 4 bytes
/// \brief Construct the address from 4 bytes
///
/// \param byte0 : First byte of the address
/// \param byte1 : Second byte of the address
/// \param byte2 : Third byte of the address
/// \param byte3 : Fourth byte of the address
/// Calling IpAddress(a, b, c, d) is equivalent to calling
/// IpAddress("a.b.c.d"), but safer as it doesn't have to
/// parse a string to get the address components.
///
/// \param byte0 First byte of the address
/// \param byte1 Second byte of the address
/// \param byte2 Third byte of the address
/// \param byte3 Fourth byte of the address
///
////////////////////////////////////////////////////////////
IPAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3);
IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3);
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
/// \brief Construct the address from a 32-bits integer
///
/// \param address : 4 bytes of the address packed into a 32-bits integer
/// This constructor uses the internal representation of
/// the address directly. It should be used for optimization
/// purposes, and only if you got that representation from
/// IpAddress::ToInteger().
///
/// \param address 4 bytes of the address packed into a 32-bits integer
///
/// \see ToInteger
///
////////////////////////////////////////////////////////////
IPAddress(Uint32 address);
IpAddress(Uint32 address);
////////////////////////////////////////////////////////////
/// Tell if the address is a valid one
/// \brief Check if the address is a valid one
///
/// If the address was constructed from a decimal representation
/// (like "192.168.1.56") this function will always return true
/// unless the address is the special one 255.255.255.255.
/// If the address was constructed from a host name, it is
/// reported as beeing valid only if the host exists and could
/// be converted to a decimal IP address.
///
/// Examples:
/// \begincode
/// bool b1 = sf::IpAddress("127.0.0.1").IsValid(); // true
/// bool b2 = sf::IpAddress("1.2.3.4").IsValid(); // true
/// bool b3 = sf::IpAddress("www.google.com").IsValid(); // true
/// bool b4 = sf::IpAddress("www.dfgfghqsd.com").IsValid(); // false
/// \endcode
///
/// \return True if address has a valid syntax
///
@ -94,46 +131,79 @@ public :
bool IsValid() const;
////////////////////////////////////////////////////////////
/// Get a string representation of the address
/// \brief Get a string representation of the address
///
/// \return String representation of the IP address ("xxx.xxx.xxx.xxx")
/// The returned string is the decimal representation of the
/// IP address (like "192.168.1.56"), even if it was constructed
/// from a host name.
///
/// \return String representation of the address
///
/// \see ToInteger
///
////////////////////////////////////////////////////////////
std::string ToString() const;
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
/// \brief Get an integer representation of the address
///
/// \return 32-bits integer containing the 4 bytes of the address, in system endianness
/// The returned number is the internal representation of the
/// address, and should be used for optimization purposes only
/// (like sending the address through a socket).
/// The integer produced by this function can then be converted
/// back to a sf::IpAddress with the proper constructor.
///
/// \return 32-bits unsigned integer representation of the address
///
/// \see ToString
///
////////////////////////////////////////////////////////////
Uint32 ToInteger() const;
////////////////////////////////////////////////////////////
/// Get the computer's local IP address (from the LAN point of view)
/// \brief Get the computer's local address
///
/// \return Local IP address
/// The local address is the address of the computer from the
/// LAN point of view, i.e. something like 192.168.1.56. It is
/// meaningful only for communications over the local network.
/// Unlike GetPublicAddress, this function is fast and may be
/// used safely anywhere.
///
/// \return Local IP address of the computer
///
/// \see GetPublicAddress
///
////////////////////////////////////////////////////////////
static IPAddress GetLocalAddress();
static IpAddress GetLocalAddress();
////////////////////////////////////////////////////////////
/// Get the computer's public IP address (from the web point of view).
/// \brief Get the computer's public address
///
/// The public address is the address of the computer from the
/// internet point of view, i.e. something like 89.54.1.169.
/// It is necessary for communications over the world wide web.
/// The only way to get a public address is to ask it to a
/// distant website ; as a consequence, this function may be
/// very slow -- use it as few as possible !
/// distant website; as a consequence, this function depends on
/// both your network connection and the server, and may be
/// very slow. You should use it as few as possible. Because
/// this function depends on the network connection and on a distant
/// server, you may use a time limit if you don't want your program
/// to be possibly stuck waiting in case there is a problem; this
/// limit is deactivated by default.
///
/// \param timeout : Maximum time to wait, in seconds (0 by default : no timeout)
/// \param timeout Maximum time to wait, in seconds
///
/// \return Public IP address
/// \return Public IP address of the computer
///
/// \see GetLocalAddress
///
////////////////////////////////////////////////////////////
static IPAddress GetPublicAddress(float timeout = 0.f);
static IpAddress GetPublicAddress(float timeout = 0.f);
////////////////////////////////////////////////////////////
// Static member data
////////////////////////////////////////////////////////////
static const IPAddress LocalHost; ///< Local host address (to connect to the same computer)
static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally)
private :
@ -144,94 +214,121 @@ private :
};
////////////////////////////////////////////////////////////
/// \brief Overload of == operator to compare two host addresses
/// \brief Overload of == operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if both hosts are equal
/// \return True if both addresses are equal
///
////////////////////////////////////////////////////////////
SFML_API bool operator ==(const IPAddress& left, const IPAddress& right);
SFML_API bool operator ==(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// \brief Overload of != operator to compare two host addresses
/// \brief Overload of != operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if both hosts are different
/// \return True if both addresses are different
///
////////////////////////////////////////////////////////////
SFML_API bool operator !=(const IPAddress& left, const IPAddress& right);
SFML_API bool operator !=(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// \brief Overload of < operator to compare two host addresses
/// \brief Overload of < operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if \a left is lesser than \a right
///
////////////////////////////////////////////////////////////
SFML_API bool operator <(const IPAddress& left, const IPAddress& right);
SFML_API bool operator <(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// \brief Overload of > operator to compare two host addresses
/// \brief Overload of > operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if \a left is greater than \a right
///
////////////////////////////////////////////////////////////
SFML_API bool operator >(const IPAddress& left, const IPAddress& right);
SFML_API bool operator >(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// \brief Overload of <= operator to compare two host addresses
/// \brief Overload of <= operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if \a left is lesser or equal than \a right
///
////////////////////////////////////////////////////////////
SFML_API bool operator <=(const IPAddress& left, const IPAddress& right);
SFML_API bool operator <=(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// \brief Overload of >= operator to compare two host addresses
/// \brief Overload of >= operator to compare two IP addresses
///
/// \param left Left operand (a host address)
/// \param right Right operand (a host address)
/// \param left Left operand (a IP address)
/// \param right Right operand (a IP address)
///
/// \return True if \a left is greater or equal than \a right
///
////////////////////////////////////////////////////////////
SFML_API bool operator >=(const IPAddress& left, const IPAddress& right);
SFML_API bool operator >=(const IpAddress& left, const IpAddress& right);
////////////////////////////////////////////////////////////
/// Operator >> overload to extract an host address from an input stream
/// \brief Overload of >> operator to extract an IP address from an input stream
///
/// \param Stream : Input stream
/// \param Address : Host address to extract
/// \param stream Input stream
/// \param address IP address to extract
///
/// \return Reference to the input stream
///
////////////////////////////////////////////////////////////
SFML_API std::istream& operator >>(std::istream& stream, IPAddress& address);
SFML_API std::istream& operator >>(std::istream& stream, IpAddress& address);
////////////////////////////////////////////////////////////
/// Operator << overload to print an host address to an output stream
/// \brief Overload of << operator to print an IP address to an output stream
///
/// \param Stream : Output stream
/// \param Address : Host address to print
/// \param stream Output stream
/// \param address IP address to print
///
/// \return Reference to the output stream
///
////////////////////////////////////////////////////////////
SFML_API std::ostream& operator <<(std::ostream& stream, const IPAddress& address);
SFML_API std::ostream& operator <<(std::ostream& stream, const IpAddress& address);
} // namespace sf
#endif // SFML_IPADDRESS_HPP
////////////////////////////////////////////////////////////
/// \class sf::IpAddress
///
/// sf::IpAddress is a utility class for manipulating network
/// addresses. It provides a set a implicit constructors and
/// conversion functions to easily build or transform an IP
/// address from/to various representations.
///
/// Usage example:
/// \code
/// sf::IpAddress a1; // an invalid address
/// sf::IpAddress a2("127.0.0.1"); // the local host address
/// sf::IpAddress a3 = sf::IpAddress::LocalHost; // the local host address (same as a2)
/// sf::IpAddress a4(192, 168, 1, 56); // a local address
/// sf::IpAddress a5("my_computer"); // a local address created from a network name
/// sf::IpAddress a6("89.54.1.169"); // a distant address
/// sf::IpAddress a7("www.google.com"); // a distant address created from a network name
/// sf::IpAddress a8 = sf::IpAddress::GetLocalAddress(); // my address on the local network
/// sf::IpAddress a9 = sf::IpAddress::GetPublicAddress(); // my address on the internet
/// \endcode
///
/// Note that sf::IpAddress currently doesn't support IPv6
/// nor other types of network addresses.
///
////////////////////////////////////////////////////////////

6
include/SFML/Network/SocketTCP.hpp
View File

@ -35,7 +35,7 @@
namespace sf
{
class Packet;
class IPAddress;
class IpAddress;
template <typename> class Selector;
////////////////////////////////////////////////////////////
@ -71,7 +71,7 @@ public :
/// \return True if operation has been successful
///
////////////////////////////////////////////////////////////
Socket::Status Connect(unsigned short port, const IPAddress& host, float timeout = 0.f);
Socket::Status Connect(unsigned short port, const IpAddress& host, float timeout = 0.f);
////////////////////////////////////////////////////////////
/// Listen to a specified port for incoming data or connections
@ -93,7 +93,7 @@ public :
/// \return Status code
///
////////////////////////////////////////////////////////////
Socket::Status Accept(SocketTCP& connected, IPAddress* address = NULL);
Socket::Status Accept(SocketTCP& connected, IpAddress* address = NULL);
////////////////////////////////////////////////////////////
/// Send an array of bytes to the host (must be connected first)

10
include/SFML/Network/SocketUDP.hpp
View File

@ -35,7 +35,7 @@
namespace sf
{
class Packet;
class IPAddress;
class IpAddress;
template <typename> class Selector;
////////////////////////////////////////////////////////////
@ -90,7 +90,7 @@ public :
/// \return Status code
///
////////////////////////////////////////////////////////////
Socket::Status Send(const char* data, std::size_t sizeInBytes, const IPAddress& address, unsigned short port);
Socket::Status Send(const char* data, std::size_t sizeInBytes, const IpAddress& address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive an array of bytes.
@ -105,7 +105,7 @@ public :
/// \return Status code
///
////////////////////////////////////////////////////////////
Socket::Status Receive(char* data, std::size_t maxSize, std::size_t& sizeReceived, IPAddress& address, unsigned short& port);
Socket::Status Receive(char* data, std::size_t maxSize, std::size_t& sizeReceived, IpAddress& address, unsigned short& port);
////////////////////////////////////////////////////////////
/// Send a packet of data
@ -117,7 +117,7 @@ public :
/// \return Status code
///
////////////////////////////////////////////////////////////
Socket::Status Send(Packet& packet, const IPAddress& address, unsigned short port);
Socket::Status Send(Packet& packet, const IpAddress& address, unsigned short port);
////////////////////////////////////////////////////////////
/// Receive a packet.
@ -130,7 +130,7 @@ public :
/// \return Status code
///
////////////////////////////////////////////////////////////
Socket::Status Receive(Packet& packet, IPAddress& address, unsigned short& port);
Socket::Status Receive(Packet& packet, IpAddress& address, unsigned short& port);
////////////////////////////////////////////////////////////
/// Close the socket

2
samples/ftp/Ftp.cpp
View File

@ -26,7 +26,7 @@ std::ostream& operator <<(std::ostream& stream, const sf::Ftp::Response& respons
int main()
{
// Choose the server address
sf::IPAddress address;
sf::IpAddress address;
do
{
std::cout << "Enter the FTP server address : ";

4
samples/sockets/TCP.cpp
View File

@ -13,7 +13,7 @@
void DoClientTCP(unsigned short port)
{
// Ask for server address
sf::IPAddress serverAddress;
sf::IpAddress serverAddress;
do
{
std::cout << "Type address or name of the server to connect to : ";
@ -66,7 +66,7 @@ void DoServerTCP(unsigned short port)
std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl;
// Wait for a connection
sf::IPAddress clientAddress;
sf::IpAddress clientAddress;
sf::SocketTCP client;
if (server.Accept(client, &clientAddress) != sf::Socket::Done)
return;

40
samples/sockets/UDP.cpp
View File

@ -10,28 +10,28 @@
/// Create a client and send a message to a running server
///
////////////////////////////////////////////////////////////
void DoClientUDP(unsigned short Port)
void DoClientUDP(unsigned short port)
{
// Ask for server address
sf::IPAddress ServerAddress;
sf::IpAddress serverAddress;
do
{
std::cout << "Type address or name of the server to send the message to : ";
std::cin >> ServerAddress;
std::cin >> serverAddress;
}
while (!ServerAddress.IsValid());
while (!serverAddress.IsValid());
// Create a UDP socket for communicating with server
sf::SocketUDP Client;
sf::SocketUDP client;
// Send a message to the server
char Message[] = "Hi, I'm a client !";
if (Client.Send(Message, sizeof(Message), ServerAddress, Port) != sf::Socket::Done)
char message[] = "Hi, I'm a client !";
if (client.Send(message, sizeof(message), serverAddress, port) != sf::Socket::Done)
return;
std::cout << "Message sent to server : \"" << Message << "\"" << std::endl;
std::cout << "Message sent to server : \"" << message << "\"" << std::endl;
// Close the socket when we're done
Client.Close();
client.Close();
}
@ -39,27 +39,27 @@ void DoClientUDP(unsigned short Port)
/// Launch a server and wait for incoming messages
///
////////////////////////////////////////////////////////////
void DoServerUDP(unsigned short Port)
void DoServerUDP(unsigned short port)
{
// Create a UDP socket for communicating with clients
sf::SocketUDP Server;
sf::SocketUDP server;
// Bind it to the specified port
if (!Server.Bind(Port))
if (!server.Bind(port))
return;
// Receive a message from anyone
sf::IPAddress ClientAddress;
unsigned short ClientPort;
char Message[128];
std::size_t Received;
if (Server.Receive(Message, sizeof(Message), Received, ClientAddress, ClientPort) != sf::Socket::Done)
sf::IpAddress clientAddress;
unsigned short clientPort;
char message[128];
std::size_t received;
if (server.Receive(message, sizeof(message), received, clientAddress, clientPort) != sf::Socket::Done)
return;
// Display it
std::cout << "Message received from " << ClientAddress << " on port " << ClientPort
<< ": \"" << Message << "\"" << std::endl;
std::cout << "Message received from " << clientAddress << " on port " << clientPort
<< ": \"" << message << "\"" << std::endl;
// Close the socket when we're done
Server.Close();
server.Close();
}

2
samples/voip/Client.cpp
View File

@ -70,7 +70,7 @@ void DoClient(unsigned short port)
}
// Ask for server address
sf::IPAddress serverAddress;
sf::IpAddress serverAddress;
do
{
std::cout << "Type address or name of the server to connect to : ";

2
samples/voip/Server.cpp
View File

@ -57,7 +57,7 @@ public :
std::cout << "Server is listening to port " << port << ", waiting for connections... " << std::endl;
// Wait for a connection
sf::IPAddress clientAddress;
sf::IpAddress clientAddress;
myListener.Accept(myClient, &clientAddress);
std::cout << "Client connected : " << clientAddress << std::endl;

6
src/SFML/Network/Ftp.cpp
View File

@ -26,7 +26,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Network/Ftp.hpp>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <algorithm>
#include <fstream>
#include <iterator>
@ -192,7 +192,7 @@ Ftp::~Ftp()
////////////////////////////////////////////////////////////
/// Connect to the specified FTP server
////////////////////////////////////////////////////////////
Ftp::Response Ftp::Connect(const IPAddress& server, unsigned short port, float timeout)
Ftp::Response Ftp::Connect(const IpAddress& server, unsigned short port, float timeout)
{
// Connect to the server
if (myCommandSocket.Connect(port, server, timeout) != Socket::Done)
@ -647,7 +647,7 @@ Ftp::Response Ftp::DataChannel::Open(Ftp::TransferMode mode)
// Reconstruct connection port and address
unsigned short port = data[4] * 256 + data[5];
IPAddress address(static_cast<Uint8>(data[0]),
IpAddress address(static_cast<Uint8>(data[0]),
static_cast<Uint8>(data[1]),
static_cast<Uint8>(data[2]),
static_cast<Uint8>(data[3]));

2
src/SFML/Network/Http.cpp
View File

@ -350,7 +350,7 @@ void Http::SetHost(const std::string& host, unsigned short port)
if (!myHostName.empty() && (*myHostName.rbegin() == '/'))
myHostName.erase(myHostName.size() - 1);
myHost = IPAddress(myHostName);
myHost = IpAddress(myHostName);
}

73
src/SFML/Network/IpAddress.cpp
View File

@ -25,7 +25,7 @@
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/Http.hpp>
#include <SFML/Network/SocketHelper.hpp>
#include <string.h>
@ -34,15 +34,11 @@
namespace sf
{
////////////////////////////////////////////////////////////
/// Static member data
////////////////////////////////////////////////////////////
const IPAddress IPAddress::LocalHost(127, 0, 0, 1);
const IpAddress IpAddress::LocalHost(127, 0, 0, 1);
////////////////////////////////////////////////////////////
/// Default constructor
////////////////////////////////////////////////////////////
IPAddress::IPAddress() :
IpAddress::IpAddress() :
myAddress(INADDR_NONE)
{
@ -50,9 +46,7 @@ myAddress(INADDR_NONE)
////////////////////////////////////////////////////////////
/// Construct the address from a string
////////////////////////////////////////////////////////////
IPAddress::IPAddress(const std::string& address)
IpAddress::IpAddress(const std::string& address)
{
// First try to convert it as a byte representation ("xxx.xxx.xxx.xxx")
myAddress = inet_addr(address.c_str());
@ -76,10 +70,7 @@ IPAddress::IPAddress(const std::string& address)
////////////////////////////////////////////////////////////
/// Construct the address from a C-style string ;
/// Needed for implicit conversions from literal strings to IPAddress to work
////////////////////////////////////////////////////////////
IPAddress::IPAddress(const char* address)
IpAddress::IpAddress(const char* address)
{
// First try to convert it as a byte representation ("xxx.xxx.xxx.xxx")
myAddress = inet_addr(address);
@ -103,36 +94,28 @@ IPAddress::IPAddress(const char* address)
////////////////////////////////////////////////////////////
/// Construct the address from 4 bytes
////////////////////////////////////////////////////////////
IPAddress::IPAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)
IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3)
{
myAddress = htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
}
////////////////////////////////////////////////////////////
/// Construct the address from a 32-bits integer
////////////////////////////////////////////////////////////
IPAddress::IPAddress(Uint32 address)
IpAddress::IpAddress(Uint32 address)
{
myAddress = htonl(address);
}
////////////////////////////////////////////////////////////
/// Tell if the address is a valid one
////////////////////////////////////////////////////////////
bool IPAddress::IsValid() const
bool IpAddress::IsValid() const
{
return myAddress != INADDR_NONE;
}
////////////////////////////////////////////////////////////
/// Get a string representation of the address
////////////////////////////////////////////////////////////
std::string IPAddress::ToString() const
std::string IpAddress::ToString() const
{
in_addr address;
address.s_addr = myAddress;
@ -142,24 +125,20 @@ std::string IPAddress::ToString() const
////////////////////////////////////////////////////////////
/// Get an integer representation of the address
////////////////////////////////////////////////////////////
Uint32 IPAddress::ToInteger() const
Uint32 IpAddress::ToInteger() const
{
return ntohl(myAddress);
}
////////////////////////////////////////////////////////////
/// Get the computer's local IP address (from the LAN point of view)
////////////////////////////////////////////////////////////
IPAddress IPAddress::GetLocalAddress()
IpAddress IpAddress::GetLocalAddress()
{
// The method here is to connect a UDP socket to anyone (here to localhost),
// and get the local socket address with the getsockname function.
// UDP connection will not send anything to the network, so this function won't cause any overhead.
IPAddress localAddress;
IpAddress localAddress;
// Create the socket
SocketHelper::SocketType sock = socket(PF_INET, SOCK_DGRAM, 0);
@ -199,82 +178,80 @@ IPAddress IPAddress::GetLocalAddress()
////////////////////////////////////////////////////////////
/// Get the computer's public IP address (from the web point of view)
////////////////////////////////////////////////////////////
IPAddress IPAddress::GetPublicAddress(float timeout)
IpAddress IpAddress::GetPublicAddress(float timeout)
{
// The trick here is more complicated, because the only way
// to get our public IP address is to get it from a distant computer.
// Here we get the web page from http://www.sfml-dev.org/ip-provider.php
// and parse the result to extract our IP address
// (not very hard : the web page contains only our IP address).
// (not very hard: the web page contains only our IP address).
Http server("www.sfml-dev.org");
Http::Request request(Http::Request::Get, "/ip-provider.php");
Http::Response page = server.SendRequest(request, timeout);
if (page.GetStatus() == Http::Response::Ok)
return IPAddress(page.GetBody());
return IpAddress(page.GetBody());
// Something failed: return an invalid address
return IPAddress();
return IpAddress();
}
////////////////////////////////////////////////////////////
bool operator ==(const IPAddress& left, const IPAddress& right)
bool operator ==(const IpAddress& left, const IpAddress& right)
{
return left.ToInteger() == right.ToInteger();
}
////////////////////////////////////////////////////////////
bool operator !=(const IPAddress& left, const IPAddress& right)
bool operator !=(const IpAddress& left, const IpAddress& right)
{
return !(left == right);
}
////////////////////////////////////////////////////////////
bool operator <(const IPAddress& left, const IPAddress& right)
bool operator <(const IpAddress& left, const IpAddress& right)
{
return left.ToInteger() < right.ToInteger();
}
////////////////////////////////////////////////////////////
bool operator >(const IPAddress& left, const IPAddress& right)
bool operator >(const IpAddress& left, const IpAddress& right)
{
return right < left;
}
////////////////////////////////////////////////////////////
bool operator <=(const IPAddress& left, const IPAddress& right)
bool operator <=(const IpAddress& left, const IpAddress& right)
{
return !(right < left);
}
////////////////////////////////////////////////////////////
bool operator >=(const IPAddress& left, const IPAddress& right)
bool operator >=(const IpAddress& left, const IpAddress& right)
{
return !(left < right);
}
////////////////////////////////////////////////////////////
std::istream& operator >>(std::istream& stream, IPAddress& address)
std::istream& operator >>(std::istream& stream, IpAddress& address)
{
std::string str;
stream >> str;
address = IPAddress(str);
address = IpAddress(str);
return stream;
}
////////////////////////////////////////////////////////////
std::ostream& operator <<(std::ostream& stream, const IPAddress& address)
std::ostream& operator <<(std::ostream& stream, const IpAddress& address)
{
return stream << address.ToString();
}

10
src/SFML/Network/SocketTCP.cpp
View File

@ -26,7 +26,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Network/SocketTCP.hpp>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/Packet.hpp>
#include <SFML/Network/SocketHelper.hpp>
#include <SFML/System/Err.hpp>
@ -67,7 +67,7 @@ void SocketTCP::SetBlocking(bool blocking)
////////////////////////////////////////////////////////////
/// Connect to another computer on a specified port
////////////////////////////////////////////////////////////
Socket::Status SocketTCP::Connect(unsigned short port, const IPAddress& host, float timeout)
Socket::Status SocketTCP::Connect(unsigned short port, const IpAddress& host, float timeout)
{
// Make sure our socket is valid
if (!IsValid())
@ -203,7 +203,7 @@ bool SocketTCP::Listen(unsigned short port)
/// Wait for a connection (must be listening to a port).
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketTCP::Accept(SocketTCP& connected, IPAddress* address)
Socket::Status SocketTCP::Accept(SocketTCP& connected, IpAddress* address)
{
// Address that will be filled with client informations
sockaddr_in clientAddress;
@ -216,14 +216,14 @@ Socket::Status SocketTCP::Accept(SocketTCP& connected, IPAddress* address)
if (!connected.IsValid())
{
if (address)
*address = IPAddress();
*address = IpAddress();
return SocketHelper::GetErrorStatus();
}
// Fill address if requested
if (address)
*address = IPAddress(inet_ntoa(clientAddress.sin_addr));
*address = IpAddress(inet_ntoa(clientAddress.sin_addr));
return Socket::Done;
}

16
src/SFML/Network/SocketUDP.cpp
View File

@ -26,7 +26,7 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Network/SocketUDP.hpp>
#include <SFML/Network/IPAddress.hpp>
#include <SFML/Network/IpAddress.hpp>
#include <SFML/Network/Packet.hpp>
#include <SFML/System/Err.hpp>
#include <algorithm>
@ -115,7 +115,7 @@ bool SocketUDP::Unbind()
////////////////////////////////////////////////////////////
/// Send an array of bytes
////////////////////////////////////////////////////////////
Socket::Status SocketUDP::Send(const char* data, std::size_t sizeInBytes, const IPAddress& address, unsigned short port)
Socket::Status SocketUDP::Send(const char* data, std::size_t sizeInBytes, const IpAddress& address, unsigned short port)
{
// Make sure the socket is valid
if (!IsValid())
@ -159,7 +159,7 @@ Socket::Status SocketUDP::Send(const char* data, std::size_t sizeInBytes, const
/// Receive an array of bytes.
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketUDP::Receive(char* data, std::size_t maxSize, std::size_t& sizeReceived, IPAddress& address, unsigned short& port)
Socket::Status SocketUDP::Receive(char* data, std::size_t maxSize, std::size_t& sizeReceived, IpAddress& address, unsigned short& port)
{
// First clear the size received
sizeReceived = 0;
@ -192,14 +192,14 @@ Socket::Status SocketUDP::Receive(char* data, std::size_t maxSize, std::size_t&
// Check the number of bytes received
if (received > 0)
{
address = IPAddress(inet_ntoa(sockAddr.sin_addr));
address = IpAddress(inet_ntoa(sockAddr.sin_addr));
port = ntohs(sockAddr.sin_port);
sizeReceived = static_cast<std::size_t>(received);
return Socket::Done;
}
else
{
address = IPAddress();
address = IpAddress();
port = 0;
return received == 0 ? Socket::Disconnected : SocketHelper::GetErrorStatus();
}
@ -216,7 +216,7 @@ Socket::Status SocketUDP::Receive(char* data, std::size_t maxSize, std::size_t&
////////////////////////////////////////////////////////////
/// Send a packet of data
////////////////////////////////////////////////////////////
Socket::Status SocketUDP::Send(Packet& packet, const IPAddress& address, unsigned short port)
Socket::Status SocketUDP::Send(Packet& packet, const IpAddress& address, unsigned short port)
{
// Get the data to send from the packet
std::size_t dataSize = 0;
@ -242,7 +242,7 @@ Socket::Status SocketUDP::Send(Packet& packet, const IPAddress& address, unsigne
/// Receive a packet.
/// This function will block if the socket is blocking
////////////////////////////////////////////////////////////
Socket::Status SocketUDP::Receive(Packet& packet, IPAddress& address, unsigned short& port)
Socket::Status SocketUDP::Receive(Packet& packet, IpAddress& address, unsigned short& port)
{
// We start by getting the size of the incoming packet
Uint32 packetSize = 0;
@ -272,7 +272,7 @@ Socket::Status SocketUDP::Receive(Packet& packet, IPAddress& address, unsigned s
// Use another address instance for receiving the packet data ;
// chunks of data coming from a different sender will be discarded (and lost...)
IPAddress sender;
IpAddress sender;
unsigned short senderPort;
// Then loop until we receive all the packet data

2
src/SFML/System/String.cpp
View File

@ -34,8 +34,6 @@
namespace sf
{
////////////////////////////////////////////////////////////
// Static member data
////////////////////////////////////////////////////////////
const std::size_t String::InvalidPos = std::basic_string<Uint32>::npos;