ip_address.hpp

Go to the documentation of this file.

 
#pragma once
#include "sockets/address_family.hpp"
#include "../array.hpp"
#include "../core_export.hpp"
#include "../iequatable.hpp"
#include "../object.hpp"
#include "../types.hpp"
#include "../string.hpp"
#include <vector>
 
namespace xtd {
  namespace net {
    namespace sockets {
      class socket;
    }
    
    class core_export_ ip_address : public xtd::object, public xtd::iequatable<xtd::net::ip_address> {
    public:
      
      static const ip_address any;
      static const ip_address broadcast;
      static const ip_address ip_v6_any;
      static const ip_address ip_v6_loopback;
      static const ip_address ip_v6_none;
      static const ip_address loopback;
      static const ip_address none;
      
      
      ip_address();
      explicit ip_address(xtd::uint32 address);
      explicit ip_address(const xtd::array<xtd::byte>& address);
      ip_address(const xtd::array<xtd::byte>& address, xtd::uint32 scope_id);
      ip_address(xtd::byte quad_part_address1, xtd::byte quad_part_address2, xtd::byte quad_part_address3, xtd::byte quad_part_address4);
      
      ip_address(ip_address&& ip_address) = default;
      ip_address(const ip_address& ip_address) = default;
      ip_address& operator =(const ip_address&) = default;
      
      
      xtd::net::sockets::address_family address_family() const noexcept;
      
      bool is_ip_v4_mapped_to_ip_v6() const noexcept;
      
      bool is_ip_v6_link_local() const noexcept;
      
      bool is_ip_v6_multicast() const noexcept;
      
      bool is_ip_v6_site_local() const noexcept;
      
      bool is_ip_v6_teredo() const noexcept;
      
      xtd::uint32 scope_id() const;
      ip_address& scope_id(xtd::uint32 value);
      
      
      bool equals(const object& obj) const noexcept override;
      bool equals(const ip_address& other) const noexcept override;
      
      xtd::array<xtd::byte> get_address_bytes() const;
      
      xtd::size get_hash_code() const noexcept override;
 
      ip_address map_to_ip_v4() const noexcept;
      
      ip_address map_to_ip_v6() const noexcept;
      
      xtd::string to_string() const noexcept override;
 
      
      static double host_to_network_order(double host);
      
      static xtd::int16 host_to_network_order(xtd::int16 host);
      
      static xtd::int32 host_to_network_order(xtd::int32 host);
      
      static xtd::int64 host_to_network_order(xtd::int64 host);
      
      static float host_to_network_order(float host);
      
      static xtd::uint16 host_to_network_order(xtd::uint16 host);
      
      static xtd::uint32 host_to_network_order(xtd::uint32 host);
      
      static xtd::uint64 host_to_network_order(xtd::uint64 host);
      
      static bool is_loopback(const ip_address& address);
      
      static double network_to_host_order(double network);
      
      static xtd::int16 network_to_host_order(xtd::int16 network);
      
      static xtd::int32 network_to_host_order(xtd::int32 host);
      
      static xtd::int64 network_to_host_order(xtd::int64 network);
      
      static float network_to_host_order(float network);
      
      static xtd::uint16 network_to_host_order(xtd::uint16 network);
      
      static xtd::uint32 network_to_host_order(xtd::uint32 network);
      
      static xtd::uint64 network_to_host_order(xtd::uint64 network);
      
      static ip_address parse(const xtd::string& str);
      
      static bool try_parse(const xtd::string& str, ip_address& address) noexcept;
 
    private:
      friend xtd::net::sockets::socket;
      static constexpr xtd::size number_of_numbers_ = 8;
      ip_address(const xtd::array<xtd::uint16>& numbers, xtd::uint32 scope_id);
      xtd::uint32 address_or_scope_id_ = 0;
      xtd::array<xtd::uint16> numbers_ = xtd::array<xtd::uint16>(number_of_numbers_);
      sockets::address_family address_family_ = sockets::address_family::inter_network;
    };
  }
}