ip_address.h

Go to the documentation of this file.

#pragma once

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

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_t address);
      explicit ip_address(const std::vector<byte_t>& address);
      ip_address(const std::vector<byte_t>& address, uint32_t scope_id);
      ip_address(byte_t quad_part_address1, byte_t quad_part_address2, byte_t quad_part_address3, byte_t 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;
      friend std::ostream& operator <<(std::ostream& os, const ip_address& address) noexcept {return os << address.to_string();}
      
      
      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_t scope_id() const;
      ip_address& scope_id(uint32_t value);
      
      
      bool equals(const object& other) const noexcept override;
      bool equals(const ip_address& other) const noexcept override;
      
      std::vector<byte_t> get_address_bytes() const;
      
      static double host_to_network_order(double host);
      
      static int16_t host_to_network_order(int16_t host);
      
      static int32_t host_to_network_order(int32_t host);
      
      static int64_t host_to_network_order(int64_t host);
      
      static float host_to_network_order(float host);
      
      static uint16_t host_to_network_order(uint16_t host);
      
      static uint32_t host_to_network_order(uint32_t host);
      
      static uint64_t host_to_network_order(uint64_t 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_t network_to_host_order(int16_t network);
      
      static int32_t network_to_host_order(int32_t host);
      
      static int64_t network_to_host_order(int64_t network);
      
      static float network_to_host_order(float network);
      
      static uint16_t network_to_host_order(uint16_t network);
      
      static uint32_t network_to_host_order(uint32_t 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);
      
    private:
      friend xtd::net::sockets::socket;
      static constexpr const size_t number_of_numbers_ = 8;
      ip_address(const std::vector<uint16_t>& numbers, uint32_t scope_id);
      uint32_t address_ = 0xFFFFFFFF;
      std::vector<uint16_t> numbers_ = std::vector<uint16_t>(number_of_numbers_);
      uint32_t scope_id_ = 0;
      sockets::address_family address_family_ = sockets::address_family::inter_network;
    };
  }
}