lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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
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