IPAddress.h

Go to the documentation of this file.

#pragma once
#include "stdint.h"
#include <cstdint>
#include <cstring>
#include <cstdio>
#include <string>
 
namespace audio_tools {
 
class IPAddress {
 public:
  // -------------------------------------------------------------------------
  // Constructors
  // -------------------------------------------------------------------------
 
  IPAddress() { _addr.dword = 0; }
 
  IPAddress(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
    _addr.bytes[0] = a;
    _addr.bytes[1] = b;
    _addr.bytes[2] = c;
    _addr.bytes[3] = d;
  }
 
  explicit IPAddress(uint32_t dword) { _addr.dword = dword; }
 
  explicit IPAddress(const uint8_t octets[4]) {
    std::memcpy(_addr.bytes, octets, 4);
  }
 
  explicit IPAddress(const char* str) {
    _addr.dword = 0;
    fromString(str);
  }
 
  // -------------------------------------------------------------------------
  // Assignment
  // -------------------------------------------------------------------------
 
  IPAddress& operator=(uint32_t dword) {
    _addr.dword = dword;
    return *this;
  }
 
  IPAddress& operator=(const uint8_t octets[4]) {
    std::memcpy(_addr.bytes, octets, 4);
    return *this;
  }
 
  IPAddress& operator=(const char* str) {
    fromString(str);
    return *this;
  }
 
  // -------------------------------------------------------------------------
  // Accessors
  // -------------------------------------------------------------------------
 
  uint8_t& operator[](int i) { return _addr.bytes[i]; }
  uint8_t  operator[](int i) const { return _addr.bytes[i]; }
 
  operator uint32_t() const { return _addr.dword; }
 
  explicit operator bool() const { return _addr.dword != 0; }
 
  // -------------------------------------------------------------------------
  // Comparison
  // -------------------------------------------------------------------------
 
  bool operator==(const IPAddress& other) const {
    return _addr.dword == other._addr.dword;
  }
 
  bool operator!=(const IPAddress& other) const {
    return !(*this == other);
  }
 
  bool operator==(uint32_t dword) const { return _addr.dword == dword; }
  bool operator!=(uint32_t dword) const { return _addr.dword != dword; }
 
  bool operator==(const uint8_t octets[4]) const {
    return std::memcmp(_addr.bytes, octets, 4) == 0;
  }
 
  std::string toString() const {
    char buf[16];
    std::snprintf(buf, sizeof(buf), "%u.%u.%u.%u",
                  _addr.bytes[0], _addr.bytes[1],
                  _addr.bytes[2], _addr.bytes[3]);
    return buf;
  }
 
  bool fromString(const char* str) {
    if (!str) return false;
    unsigned a, b, c, d;
    if (std::sscanf(str, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) return false;
    if (a > 255 || b > 255 || c > 255 || d > 255) return false;
    _addr.bytes[0] = (uint8_t)a;
    _addr.bytes[1] = (uint8_t)b;
    _addr.bytes[2] = (uint8_t)c;
    _addr.bytes[3] = (uint8_t)d;
    return true;
  }
 
  const uint8_t* raw() const { return _addr.bytes; }
  uint8_t*       raw()       { return _addr.bytes; }
 
  // -------------------------------------------------------------------------
  // Well-known addresses
  // -------------------------------------------------------------------------
 
  static IPAddress any()       { return IPAddress(0u); }
  static IPAddress broadcast() { return IPAddress(255, 255, 255, 255); }
  static IPAddress loopback()  { return IPAddress(127, 0, 0, 1); }
 
 private:
  union {
    uint8_t  bytes[4];
    uint32_t dword;
  } _addr;
};
 
const IPAddress INADDR_NONE(0,0,0,0);
 
} // namespace audio_tools