////////////////////////////////////////////////////////////

//

// SFML - Simple and Fast Multimedia Library

// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)

//

// This software is provided 'as-is', without any express or implied warranty.

// In no event will the authors be held liable for any damages arising from the use of this software.

//

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it freely,

// subject to the following restrictions:

//

// 1. The origin of this software must not be misrepresented;

//    you must not claim that you wrote the original software.

//    If you use this software in a product, an acknowledgment

//    in the product documentation would be appreciated but is not required.

//

// 2. Altered source versions must be plainly marked as such,

//    and must not be misrepresented as being the original software.

//

// 3. This notice may not be removed or altered from any source distribution.

//

////////////////////////////////////////////////////////////



#ifndef SFML_IPADDRESS_HPP

#define SFML_IPADDRESS_HPP



////////////////////////////////////////////////////////////

// Headers

////////////////////////////////////////////////////////////

#include <SFML/Config.hpp>

#include <istream>

#include <ostream>

#include <string>





namespace sf

{

////////////////////////////////////////////////////////////

/// \brief Encapsulate an IPv4 network address

///

////////////////////////////////////////////////////////////

class SFML_API IpAddress

{

public :



    ////////////////////////////////////////////////////////////

    /// \brief Default constructor

    ///

    /// This constructor creates an empty (invalid) address

    ///

    ////////////////////////////////////////////////////////////

    IpAddress();



    ////////////////////////////////////////////////////////////

    /// \brief Construct the address from a string

    ///

    /// 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);



    ////////////////////////////////////////////////////////////

    /// \brief Construct the address from a string

    ///

    /// 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);



    ////////////////////////////////////////////////////////////

    /// \brief Construct the address from 4 bytes

    ///

    /// 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);



    ////////////////////////////////////////////////////////////

    /// \brief Construct the address from 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

    ///

    ////////////////////////////////////////////////////////////

    explicit IpAddress(Uint32 address);



    ////////////////////////////////////////////////////////////

    /// \brief Get a string representation of the address

    ///

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



    ////////////////////////////////////////////////////////////

    /// \brief Get an integer representation of the address

    ///

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



    ////////////////////////////////////////////////////////////

    /// \brief Get the computer's local 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();



    ////////////////////////////////////////////////////////////

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

    ///

    /// \return Public IP address of the computer

    ///

    /// \see GetLocalAddress

    ///

    ////////////////////////////////////////////////////////////

    static IpAddress GetPublicAddress(float timeout = 0.f);



    ////////////////////////////////////////////////////////////

    // Static member data

    ////////////////////////////////////////////////////////////

    static const IpAddress None;      ///< Value representing an empty/invalid address

    static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally)



private :



    ////////////////////////////////////////////////////////////

    // Member data

    ////////////////////////////////////////////////////////////

    Uint32 myAddress; ///< Address stored as an unsigned 32 bits integer

};



////////////////////////////////////////////////////////////

/// \brief Overload of == operator to compare two IP addresses

///

/// \param left  Left operand (a IP address)

/// \param right Right operand (a IP address)

///

/// \return True if both addresses are equal

///

////////////////////////////////////////////////////////////

SFML_API bool operator ==(const IpAddress& left, const IpAddress& right);



////////////////////////////////////////////////////////////

/// \brief Overload of != operator to compare two IP addresses

///

/// \param left  Left operand (a IP address)

/// \param right Right operand (a IP address)

///

/// \return True if both addresses are different

///

////////////////////////////////////////////////////////////

SFML_API bool operator !=(const IpAddress& left, const IpAddress& right);



////////////////////////////////////////////////////////////

/// \brief Overload of < operator to compare two IP addresses

///

/// \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);



////////////////////////////////////////////////////////////

/// \brief Overload of > operator to compare two IP addresses

///

/// \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);



////////////////////////////////////////////////////////////

/// \brief Overload of <= operator to compare two IP addresses

///

/// \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);



////////////////////////////////////////////////////////////

/// \brief Overload of >= operator to compare two IP addresses

///

/// \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);



////////////////////////////////////////////////////////////

/// \brief Overload of >> operator to extract an IP address from an input stream

///

/// \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);



////////////////////////////////////////////////////////////

/// \brief Overload of << operator to print an IP address to an output stream

///

/// \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);



} // namespace sf





#endif // SFML_IPADDRESS_HPP





////////////////////////////////////////////////////////////

/// \class sf::IpAddress

/// \ingroup network

///

/// 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 a0;                                     // an invalid address

/// sf::IpAddress a1 = sf::IpAddress::None;               // an invalid address (same as a0)

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

///

////////////////////////////////////////////////////////////