Offset.hpp

Go to the documentation of this file.

//===- Offset.hpp ------------------------------------------------*- C++-*-===//
//
//  Copyright (C) 2020 GrammaTech, Inc.
//
//  This code is licensed under the MIT license. See the LICENSE file in the
//  project root for license terms.
//
//  This project is sponsored by the Office of Naval Research, One Liberty
//  Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
//  N68335-17-C-0700.  The content of the information does not necessarily
//  reflect the position or policy of the Government and no official
//  endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_OFFSET_H
#define GTIRB_OFFSET_H
 
#include <gtirb/Context.hpp>
#include <gtirb/Export.hpp>
#include <boost/functional/hash.hpp>
#include <cstdint>
#include <functional>
 
namespace gtirb {
namespace proto {
class Offset;
}
 
struct GTIRB_EXPORT_API Offset {
  UUID ElementId;
 
  uint64_t Displacement{0};
 
  Offset(const UUID& ElemId, uint64_t Disp)
      : ElementId(ElemId), Displacement(Disp) {}
 
  Offset() = default;
 
  // Note: boost::uuid is not constexpr.
  friend bool operator==(const Offset& LHS, const Offset& RHS) noexcept {
    return LHS.ElementId == RHS.ElementId &&
           LHS.Displacement == RHS.Displacement;
  }
 
  friend bool operator!=(const Offset& LHS, const Offset& RHS) noexcept {
    return !operator==(LHS, RHS);
  }
 
  friend constexpr bool operator<(const Offset& LHS,
                                  const Offset& RHS) noexcept {
    return std::tie(LHS.ElementId, LHS.Displacement) <
           std::tie(RHS.ElementId, RHS.Displacement);
  }
 
  friend constexpr bool operator>(const Offset& LHS,
                                  const Offset& RHS) noexcept {
    return operator<(RHS, LHS);
  }
 
  friend constexpr bool operator<=(const Offset& LHS,
                                   const Offset& RHS) noexcept {
    return !operator<(RHS, LHS);
  }
 
  friend constexpr bool operator>=(const Offset& LHS,
                                   const Offset& RHS) noexcept {
    return !operator<(LHS, RHS);
  }
 
private:
  using MessageType = proto::Offset;
 
  void toProtobuf(MessageType* Message) const;
 
  bool fromProtobuf(Context& C, const MessageType& Message);
 
  // Enables serialization.
  friend bool fromProtobuf(Context&, Offset&, const MessageType&);
};
 
} // namespace gtirb
 
namespace std {
 
template <> struct hash<gtirb::Offset> {
  size_t operator()(const gtirb::Offset& X) const {
    std::size_t Seed = 0;
    boost::hash_combine(Seed, X.ElementId);
    boost::hash_combine(Seed, X.Displacement);
    return Seed;
  }
};
 
} // namespace std
 
#endif // GTIRB_OFFSET_H