folly::detail::Bytes Struct Reference

#include <IPAddressSource.h>

Static Public Member Functions
template<std::size_t N>
static std::array< uint8_t, N >	mask (const std::array< uint8_t, N > &a, const std::array< uint8_t, N > &b)
template<std::size_t N>
static std::pair< std::array< uint8_t, N >, uint8_t >	longestCommonPrefix (const std::array< uint8_t, N > &one, uint8_t oneMask, const std::array< uint8_t, N > &two, uint8_t twoMask)
static in_addr	mkAddress4 (const uint8_t *src)
static in6_addr	mkAddress6 (const uint8_t *src)
static std::string	toHex (const uint8_t *src, std::size_t len)

Private Member Functions
	Bytes ()=delete
	~Bytes ()=delete

Detailed Description

Helper for working with unsigned char* or uint8_t* ByteArray values

Definition at line 44 of file IPAddressSource.h.

Constructor & Destructor Documentation

folly::detail::Bytes::Bytes ( )

privatedelete

Referenced by toHex().

folly::detail::Bytes::~Bytes ( )

privatedelete

Referenced by toHex().

Member Function Documentation

template<std::size_t N>

static std::pair<std::array<uint8_t, N>, uint8_t> folly::detail::Bytes::longestCommonPrefix ( const std::array< uint8_t, N > &  one, uint8_t  oneMask, const std::array< uint8_t, N > &  two, uint8_t  twoMask  )

inlinestatic

Definition at line 60 of file IPAddressSource.h.

References mask(), max, min, folly::sformat(), and uint8_t.

Referenced by folly::IPAddressV4::longestCommonPrefix(), and folly::IPAddressV6::longestCommonPrefix().

                       {
    static constexpr auto kBitCount = N * 8;
    static constexpr std::array<uint8_t, 8> kMasks{{
        0x80, // /1
        0xc0, // /2
        0xe0, // /3
        0xf0, // /4
        0xf8, // /5
        0xfc, // /6
        0xfe, // /7
        0xff // /8
    }};
    if (oneMask > kBitCount || twoMask > kBitCount) {
      throw std::invalid_argument(sformat(
          "Invalid mask length: {}. Mask length must be <= {}",
          std::max(oneMask, twoMask),
          kBitCount));
    }

    auto mask = std::min(oneMask, twoMask);
    uint8_t byteIndex = 0;
    std::array<uint8_t, N> ba{{0}};
    // Compare a byte at a time. Note - I measured compared this with
    // going multiple bytes at a time (8, 4, 2 and 1). It turns out
    // to be 20 - 25% slower for 4 and 16 byte arrays.
    while (byteIndex * 8 < mask && one[byteIndex] == two[byteIndex]) {
      ba[byteIndex] = one[byteIndex];
      ++byteIndex;
    }
    auto bitIndex = std::min(mask, uint8_t(byteIndex * 8));
    uint8_t bI = uint8_t(bitIndex / 8);
    uint8_t bM = uint8_t(bitIndex % 8);
    // Compute the bit up to which the two byte arrays match in the
    // unmatched byte.
    // Here the check is bitIndex < mask since the 0th mask entry in
    // kMasks array holds the mask for masking the MSb in this byte.
    // We could instead make it hold so that no 0th entry masks no
    // bits but thats a useless iteration.
    while (bitIndex < mask &&
           ((one[bI] & kMasks[bM]) == (two[bI] & kMasks[bM]))) {
      ba[bI] = uint8_t(one[bI] & kMasks[bM]);
      ++bitIndex;
      bI = uint8_t(bitIndex / 8);
      bM = uint8_t(bitIndex % 8);
    }
    return {ba, bitIndex};
  }

template<std::size_t N>

static std::array<uint8_t, N> folly::detail::Bytes::mask ( const std::array< uint8_t, N > &  a, const std::array< uint8_t, N > &  b  )

inlinestatic

Definition at line 47 of file IPAddressSource.h.

References i, and uint8_t.

Referenced by folly::IPAddressV4::inSubnetWithMask(), folly::IPAddressV6::inSubnetWithMask(), longestCommonPrefix(), folly::IPAddressV4::mask(), and folly::IPAddressV6::mask().

                                     {
    static_assert(N > 0, "Can't mask an empty ByteArray");
    std::size_t asize = a.size();
    std::array<uint8_t, N> ba{{0}};
    for (std::size_t i = 0; i < asize; i++) {
      ba[i] = uint8_t(a[i] & b[i]);
    }
    return ba;
  }

static in_addr folly::detail::Bytes::mkAddress4 ( const uint8_t *  src )

inlinestatic

Definition at line 113 of file IPAddressSource.h.

References addr, and uint8_t.

Referenced by folly::IPAddressV6::createIPv4(), and TEST_P().

                                                       {
    union {
      in_addr addr;
      uint8_t bytes[4];
    } addr;
    std::memset(&addr, 0, 4);
    std::memcpy(addr.bytes, src, 4);
    return addr.addr;
  }

static in6_addr folly::detail::Bytes::mkAddress6 ( const uint8_t *  src )

inlinestatic

Definition at line 124 of file IPAddressSource.h.

References addr.

Referenced by TEST_P().

                                                        {
    in6_addr addr;
    std::memset(&addr, 0, 16);
    std::memcpy(addr.s6_addr, src, 16);
    return addr;
  }

static std::string folly::detail::Bytes::toHex ( const uint8_t *  src, std::size_t  len  )

inlinestatic

Definition at line 132 of file IPAddressSource.h.

References Bytes(), c, i, string, type, value, and ~Bytes().

Referenced by folly::IPAddressV6::str(), TEST(), and folly::toAppend().

                                                            {
    static const char* const lut = "0123456789abcdef";
    std::string out(len * 2, 0);
    for (std::size_t i = 0; i < len; i++) {
      const unsigned char c = src[i];
      out[i * 2 + 0] = lut[c >> 4];
      out[i * 2 + 1] = lut[c & 15];
    }
    return out;
  }

---

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

• proxygen/folly/folly/detail/IPAddressSource.h