address.h

// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include <cstdint>
 
namespace pw::i2c {
 
class Address {
 public:
  static constexpr uint8_t kMaxSevenBitAddress = (1 << 7) - 1;
  static constexpr uint16_t kMaxTenBitAddress = (1 << 10) - 1;
 
  template <uint16_t kAddress>
  static constexpr Address TenBit() {
    static_assert(kAddress <= kMaxTenBitAddress);
    return Address(kAddress, Mode::kTenBit, kAlreadyCheckedAddress);
  }
 
  static Address TenBit(uint16_t address) {
    return Address(address, Mode::kTenBit);
  }
 
  template <uint8_t kAddress>
  static constexpr Address SevenBit() {
    static_assert(kAddress <= kMaxSevenBitAddress);
    return Address(kAddress, Mode::kSevenBit, kAlreadyCheckedAddress);
  }
 
  static Address SevenBit(uint16_t address) {
    return Address(address, Mode::kSevenBit);
  }
 
  [[deprecated("Use one of the factory methods above to construct safely.")]]
  explicit Address(uint16_t address);
 
  uint8_t GetSevenBit() const;
 
  [[deprecated("Use GetAddress() and IsTenBit() as appropriate.")]]
  uint16_t GetTenBit() const {
    return address_;
  }
 
  uint16_t GetAddress() const { return address_; }
 
  friend bool operator==(const Address& a1, const Address& a2);
 
  constexpr bool IsTenBit() const { return mode_ == Mode::kTenBit; }
 
 private:
  enum class Mode : uint8_t {
    kSevenBit = 0,
    kTenBit = 1,
  };
 
  Address(uint16_t address, Mode mode);
 
  enum AlreadyCheckedAddress { kAlreadyCheckedAddress };
  constexpr Address(uint16_t address, Mode mode, AlreadyCheckedAddress)
      : address_(address), mode_(mode) {}
 
  uint16_t address_ : 10;
  Mode mode_ : 1;
};
 
// Compares two address objects.
inline bool operator==(const Address& a1, const Address& a2) {
  return a1.address_ == a2.address_ && a1.mode_ == a2.mode_;
}
 
}  // namespace pw::i2c