text: //
  // ip/address_v4.hpp
  // ~~~~~~~~~~~~~~~~~
  //
  // Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
  //
  // Distributed under the Boost Software License, Version 1.0. (See accompanying
  // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  //
  
  #ifndef BOOST_ASIO_IP_ADDRESS_V4_HPP
  #define BOOST_ASIO_IP_ADDRESS_V4_HPP
  
  #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  # pragma once
  #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  
  #include <boost/asio/detail/config.hpp>
  #include <string>
  #include <boost/asio/detail/array.hpp>
  #include <boost/asio/detail/socket_types.hpp>
  #include <boost/asio/detail/winsock_init.hpp>
  #include <boost/system/error_code.hpp>
  
  #if !defined(BOOST_NO_IOSTREAM)
  # include <iosfwd>
  #endif // !defined(BOOST_NO_IOSTREAM)
  
  #include <boost/asio/detail/push_options.hpp>
  
  namespace boost {
  namespace asio {
  namespace ip {
  
  /// Implements IP version 4 style addresses.
  /**
   * The boost::asio::ip::address_v4 class provides the ability to use and
   * manipulate IP version 4 addresses.
   *
   * @par Thread Safety
   * @e Distinct @e objects: Safe.@n
   * @e Shared @e objects: Unsafe.
   */
  class address_v4
  {
  public:
    /// The type used to represent an address as an array of bytes.
    /**
     * @note This type is defined in terms of the C++0x template @c std::array
     * when it is available. Otherwise, it uses @c boost:array.
     */
  #if defined(GENERATING_DOCUMENTATION)
    typedef array<unsigned char, 4> bytes_type;
  #else
    typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
  #endif
  
    /// Default constructor.
    address_v4()
    {
      addr_.s_addr = 0;
    }
  
    /// Construct an address from raw bytes.
    BOOST_ASIO_DECL explicit address_v4(const bytes_type& bytes);
  
    /// Construct an address from a unsigned long in host byte order.
    BOOST_ASIO_DECL explicit address_v4(unsigned long addr);
  
    /// Copy constructor.
    address_v4(const address_v4& other)
      : addr_(other.addr_)
    {
    }
  
  #if defined(BOOST_ASIO_HAS_MOVE)
    /// Move constructor.
    address_v4(address_v4&& other)
      : addr_(other.addr_)
    {
    }
  #endif // defined(BOOST_ASIO_HAS_MOVE)
  
    /// Assign from another address.
    address_v4& operator=(const address_v4& other)
    {
      addr_ = other.addr_;
      return *this;
    }
  
  #if defined(BOOST_ASIO_HAS_MOVE)
    /// Move-assign from another address.
    address_v4& operator=(address_v4&& other)
    {
      addr_ = other.addr_;
      return *this;
    }
  #endif // defined(BOOST_ASIO_HAS_MOVE)
  
    /// Get the address in bytes, in network byte order.
    BOOST_ASIO_DECL bytes_type to_bytes() const;
  
    /// Get the address as an unsigned long in host byte order
    BOOST_ASIO_DECL unsigned long to_ulong() const;
  
    /// Get the address as a string in dotted decimal format.
    BOOST_ASIO_DECL std::string to_string() const;
  
    /// Get the address as a string in dotted decimal format.
    BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
  
    /// Create an address from an IP address string in dotted decimal form.
    BOOST_ASIO_DECL static address_v4 from_string(const char* str);
  
    /// Create an address from an IP address string in dotted decimal form.
    BOOST_ASIO_DECL static address_v4 from_string(
        const char* str, boost::system::error_code& ec);
  
    /// Create an address from an IP address string in dotted decimal form.
    BOOST_ASIO_DECL static address_v4 from_string(const std::string& str);
  
    /// Create an address from an IP address string in dotted decimal form.
    BOOST_ASIO_DECL static address_v4 from_string(
        const std::string& str, boost::system::error_code& ec);
  
    /// Determine whether the address is a loopback address.
    BOOST_ASIO_DECL bool is_loopback() const;
  
    /// Determine whether the address is unspecified.
    BOOST_ASIO_DECL bool is_unspecified() const;
  
    /// Determine whether the address is a class A address.
    BOOST_ASIO_DECL bool is_class_a() const;
  
    /// Determine whether the address is a class B address.
    BOOST_ASIO_DECL bool is_class_b() const;
  
    /// Determine whether the address is a class C address.
    BOOST_ASIO_DECL bool is_class_c() const;
  
    /// Determine whether the address is a multicast address.
    BOOST_ASIO_DECL bool is_multicast() const;
  
    /// Compare two addresses for equality.
    friend bool operator==(const address_v4& a1, const address_v4& a2)
    {
      return a1.addr_.s_addr == a2.addr_.s_addr;
    }
  
    /// Compare two addresses for inequality.
    friend bool operator!=(const address_v4& a1, const address_v4& a2)
    {
      return a1.addr_.s_addr != a2.addr_.s_addr;
    }
  
    /// Compare addresses for ordering.
    friend bool operator<(const address_v4& a1, const address_v4& a2)
    {
      return a1.to_ulong() < a2.to_ulong();
    }
  
    /// Compare addresses for ordering.
    friend bool operator>(const address_v4& a1, const address_v4& a2)
    {
      return a1.to_ulong() > a2.to_ulong();
    }
  
    /// Compare addresses for ordering.
    friend bool operator<=(const address_v4& a1, const address_v4& a2)
    {
      return a1.to_ulong() <= a2.to_ulong();
    }
  
    /// Compare addresses for ordering.
    friend bool operator>=(const address_v4& a1, const address_v4& a2)
    {
      return a1.to_ulong() >= a2.to_ulong();
    }
  
    /// Obtain an address object that represents any address.
    static address_v4 any()
    {
      return address_v4();
    }
  
    /// Obtain an address object that represents the loopback address.
    static address_v4 loopback()
    {
      return address_v4(0x7F000001);
    }
  
    /// Obtain an address object that represents the broadcast address.
    static address_v4 broadcast()
    {
      return address_v4(0xFFFFFFFF);
    }
  
    /// Obtain an address object that represents the broadcast address that
    /// corresponds to the specified address and netmask.
    BOOST_ASIO_DECL static address_v4 broadcast(
        const address_v4& addr, const address_v4& mask);
  
    /// Obtain the netmask that corresponds to the address, based on its address
    /// class.
    BOOST_ASIO_DECL static address_v4 netmask(const address_v4& addr);
  
  private:
    // The underlying IPv4 address.
    boost::asio::detail::in4_addr_type addr_;
  };
  
  #if !defined(BOOST_NO_IOSTREAM)
  
  /// Output an address as a string.
  /**
   * Used to output a human-readable string for a specified address.
   *
   * @param os The output stream to which the string will be written.
   *
   * @param addr The address to be written.
   *
   * @return The output stream.
   *
   * @relates boost::asio::ip::address_v4
   */
  template <typename Elem, typename Traits>
  std::basic_ostream<Elem, Traits>& operator<<(
      std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
  
  #endif // !defined(BOOST_NO_IOSTREAM)
  
  } // namespace ip
  } // namespace asio
  } // namespace boost
  
  #include <boost/asio/detail/pop_options.hpp>
  
  #include <boost/asio/ip/impl/address_v4.hpp>
  #if defined(BOOST_ASIO_HEADER_ONLY)
  # include <boost/asio/ip/impl/address_v4.ipp>
  #endif // defined(BOOST_ASIO_HEADER_ONLY)
  
  #endif // BOOST_ASIO_IP_ADDRESS_V4_HPP
  