mtcore::io::Formatter< IPv6 > Struct Reference

Formats IPv6 addresses Formatting options: More...

#include <ip.hpp>

Inheritance diagram for mtcore::io::Formatter< IPv6 >:

Collaboration diagram for mtcore::io::Formatter< IPv6 >:

Static Public Member Functions
template<WriterImpl WI>
static Result< size_t, typename Writer< WI >::ErrType >	fmt (Writer< WI > &writer, FormatOptions opts, const IPv6 &val)

Detailed Description

Formats IPv6 addresses Formatting options:

• z (flag) shortens leading zeros (0abc -> abc, 0000 -> 0)
• t (flag) truncates first section of all zeros (abcd:0000:ef12 -> abcd::ef12)
• 4 (flag) Will show IPv4 addresses in IPv4 syntax (::ffff:7400:0001 -> ::ffff:127.0.0.1)

If none are provided, will print in standard padded format. I.E. 0000:0000:0000:0000:0000:0000:0000:0000

Definition at line 310 of file ip.hpp.

Member Function Documentation

fmt()

template<WriterImpl WI>

static Result< size_t, typename Writer< WI >::ErrType > mtcore::io::Formatter< IPv6 >::fmt ( Writer< WI > & writer, FormatOptions opts, const IPv6 & val )

inlinestatic

Definition at line 312 of file ip.hpp.

                                                                                                                   {
      auto chunks = std::array{
        (val.high >> 48) & 0xffff, (val.high >> 32) & 0xffff, (val.high >> 16) & 0xffff, (val.high >> 0) & 0xffff,
        (val.low >> 48) & 0xffff,  (val.low >> 32) & 0xffff,  (val.low >> 16) & 0xffff,  (val.low >> 0) & 0xffff,
      };
      auto data = slice_from(chunks);
 
      auto fmtStr = "{\\::0<4;x}";
 
      if (slices::contains('z', opts.formatStr)) {
        fmtStr = "{\\::x}";
      }
 
      if (slices::contains('4', opts.formatStr) && val.is_ip4()) {
        auto prefix = slice_from("0000:0000:0000:0000:0000:ffff:");
        if (slices::contains('t', opts.formatStr)) {
          prefix = slice_from("::ffff:");
        }
        else if (slices::contains('z', opts.formatStr)) {
          prefix = slice_from("0:0:0:0:0:ffff:");
        }
        size_t written = 0;
        auto preRes    = writer.write_all(prefix);
        if (preRes.is_error()) {
          return preRes.error();
        }
        written += prefix.size();
        auto ip4    = val.to_ip4().value();
        auto ip4Res = format(writer, {}, ip4);
        if (ip4Res.is_error()) {
          return ip4Res.error();
        }
        written += ip4Res.value();
        return written;
      }
 
      // If there are zeros to truncate
      if (slices::contains('t', opts.formatStr) && slices::contains(0, data)) {
        size_t i = 0;
        for (; i < data.size() && data[i] != 0; ++i) {}
 
        auto skipStart = slices::first_index(0, data);
        ensure(skipStart.has_value());
        auto skipEndOpt = slices::first_index_not(0, data.sub(skipStart.value()));
        auto skipEnd    = skipEndOpt.has_value() ? skipEndOpt.value() + skipStart.value() : data.size();
 
        auto printPart1 = data.sub(0, skipStart.value());
        auto printPart2 = data.sub(skipEnd);
 
        size_t written = 0;
 
        if (!printPart1.empty()) {
          auto p1Res = print(writer, fmtStr, printPart1);
          if (p1Res.is_error()) {
            return p1Res.error();
          }
          written += p1Res.value();
        }
 
        auto sepRes = writer.write_all(slice_from("::"));
        if (sepRes.is_error()) {
          return sepRes.error();
        }
        written += 2;
 
        if (!printPart2.empty()) {
          auto p2Res = print(writer, fmtStr, printPart2);
          if (p2Res.is_error()) {
            return p2Res.error();
          }
          written += p2Res.value();
        }
 
        return written;
      }
 
      return print(writer, fmtStr, data);
    }

Here is the call graph for this function:

---

The documentation for this struct was generated from the following file:

• ip.hpp