ip_address.h

Go to the documentation of this file.

#pragma once
#include "sockets/address_family.h"
#include "../core_export.h"
#include "../iequatable.h"
#include "../object.h"
#include "../types.h"
#include "../ustring.h"
#include <vector>

namespace xtd {
  namespace net {
    namespace sockets {
      class socket;
    }
    
    class core_export_ ip_address : public xtd::object, public xtd::iequatable<ip_address> {
    public:
      
      static ip_address any;
      static ip_address broadcast;
      static ip_address ip_v6_any;
      static ip_address ip_v6_loopback;
      static ip_address ip_v6_none;
      static ip_address loopback;
      static ip_address none;
      
      
      ip_address() = default;
      explicit ip_address(uint32 address);
      explicit ip_address(const std::vector<xtd::byte>& address);
      ip_address(const std::vector<xtd::byte>& address, 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;
      
      
      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;
      
      uint32 scope_id() const;
      ip_address& scope_id(uint32 value);
      
      
      bool equals(const ip_address& other) const noexcept override;
      
      std::vector<xtd::byte> get_address_bytes() const;
      
      static double host_to_network_order(double host);
      
      static int16 host_to_network_order(int16 host);
      
      static int32 host_to_network_order(int32 host);
      
      static int64 host_to_network_order(int64 host);
      
      static float host_to_network_order(float host);
      
      static uint16 host_to_network_order(uint16 host);
      
      static uint32 host_to_network_order(uint32 host);
      
      static uint64 host_to_network_order(uint64 host);
      
      static bool is_loopback(const ip_address& address);
      
      ip_address map_to_ip_v4() const noexcept;
      
      ip_address map_to_ip_v6() const noexcept;
      
      static double network_to_host_order(double network);
      
      static int16 network_to_host_order(int16 network);
      
      static int32 network_to_host_order(int32 host);
      
      static int64 network_to_host_order(int64 network);
      
      static float network_to_host_order(float network);
      
      static uint16 network_to_host_order(uint16 network);
      
      static uint32 network_to_host_order(uint32 network);
      
      static uint64 network_to_host_order(uint64 network);
      
      static ip_address parse(const ustring& str);
      
      ustring to_string() const noexcept override;
      
      static bool try_parse(const ustring& str, ip_address& address) noexcept;
      
    private:
      friend xtd::net::sockets::socket;
      static constexpr size_t number_of_numbers_ = 8;
      ip_address(const std::vector<uint16>& numbers, uint32 scope_id);
      uint32 address_ = 0xFFFFFFFF;
      std::vector<uint16> numbers_ = std::vector<uint16>(number_of_numbers_);
      uint32 scope_id_ = 0;
      sockets::address_family address_family_ = sockets::address_family::inter_network;
    };
  }
}