DataBlock.hpp

Go to the documentation of this file.

//===- DataBlock.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_DataBlock_H
#define GTIRB_DataBlock_H
 
#include <gtirb/Addr.hpp>
#include <gtirb/ByteInterval.hpp>
#include <gtirb/Node.hpp>
#include <cstdint>
#include <functional>
#include <optional>
#include <vector>
 
 
namespace gtirb {
namespace proto {
class DataBlock;
}
 
template <class T> class ErrorOr;
 
class GTIRB_EXPORT_API DataBlock : public Node {
  DataBlock(Context& C) : Node(C, Kind::DataBlock) {}
  DataBlock(Context& C, uint64_t S, const UUID& U)
      : Node(C, Kind::DataBlock, U), Size(S) {}
  DataBlock(Context& C, uint64_t S) : Node(C, Kind::DataBlock), Size(S) {}
 
  static DataBlock* Create(Context& C, uint64_t S, const UUID& U) {
    return C.Create<DataBlock>(C, S, U);
  }
 
public:
  static DataBlock* Create(Context& C) { return C.Create<DataBlock>(C); }
 
  static DataBlock* Create(Context& C, uint64_t Size) {
    return C.Create<DataBlock>(C, Size);
  }
 
  ByteInterval* getByteInterval() { return Parent; }
  const ByteInterval* getByteInterval() const { return Parent; }
 
  uint64_t getSize() const { return Size; }
 
  uint64_t getOffset() const;
 
  std::optional<Addr> getAddress() const;
 
  void setSize(uint64_t S) {
    if (Observer) {
      std::swap(S, Size);
      [[maybe_unused]] ChangeStatus Status =
          Observer->sizeChange(this, S, Size);
      assert(Status != ChangeStatus::Rejected &&
             "recovering from rejected size change is not implemented yet");
    } else {
      Size = S;
    }
  }
 
  template <typename T> using bytes_iterator = ByteInterval::bytes_iterator<T>;
  template <typename T> using bytes_range = ByteInterval::bytes_range<T>;
  template <typename T>
  using const_bytes_iterator = ByteInterval::const_bytes_iterator<T>;
  template <typename T>
  using const_bytes_range = ByteInterval::const_bytes_range<T>;
 
  template <typename T> bytes_iterator<T> bytes_begin() {
    assert(Parent && "Block has no byte interval!");
    return bytes_begin<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_begin(boost::endian::order InputOrder,
              boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset();
  }
 
  template <typename T> bytes_iterator<T> bytes_end() {
    assert(Parent && "Block has no byte interval!");
    return bytes_end<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_iterator<T>
  bytes_end(boost::endian::order InputOrder,
            boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset() + Size;
  }
 
  template <typename T> bytes_range<T> bytes() {
    assert(Parent && "Block has no byte interval!");
    return bytes<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) {
    assert(Parent && "Block has no byte interval!");
    return bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                          bytes_end<T>(InputOrder, OutputOrder));
  }
 
  template <typename T> const_bytes_iterator<T> bytes_begin() const {
    assert(Parent && "Block has no byte interval!");
    return bytes_begin<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_begin(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset();
  }
 
  template <typename T> const_bytes_iterator<T> bytes_end() const {
    assert(Parent && "Block has no byte interval!");
    return bytes_end<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_iterator<T> bytes_end(
      boost::endian::order InputOrder,
      boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return Parent->bytes_begin<T>(InputOrder, OutputOrder) + getOffset() + Size;
  }
 
  template <typename T> const_bytes_range<T> bytes() const {
    assert(Parent && "Block has no byte interval!");
    return bytes<T>(Parent->getBoostEndianOrder());
  }
 
  template <typename T>
  const_bytes_range<T>
  bytes(boost::endian::order InputOrder,
        boost::endian::order OutputOrder = boost::endian::order::native) const {
    assert(Parent && "Block has no byte interval!");
    return const_bytes_range<T>(bytes_begin<T>(InputOrder, OutputOrder),
                                bytes_end<T>(InputOrder, OutputOrder));
  }
 
  template <typename T> T* rawBytes() {
    assert(Parent && "Block has no byte interval!");
    return reinterpret_cast<T*>(Parent->rawBytes<uint8_t>() + getOffset());
  }
 
  template <typename T> const T* rawBytes() const {
    assert(Parent && "Block has no byte interval!");
    return reinterpret_cast<const T*>(Parent->rawBytes<uint8_t>() +
                                      getOffset());
  }
 
  static bool classof(const Node* N) { return N->getKind() == Kind::DataBlock; }
 
private:
  ByteInterval* Parent{nullptr};
  DataBlockObserver* Observer{nullptr};
  uint64_t Size{0};
 
  void setParent(ByteInterval* BI, DataBlockObserver* O) {
    Parent = BI;
    Observer = O;
  }
 
  using MessageType = proto::DataBlock;
 
  void toProtobuf(MessageType* Message) const;
 
  static ErrorOr<DataBlock*> fromProtobuf(Context& C,
                                          const MessageType& Message);
 
  // Present for testing purposes only.
  void save(std::ostream& Out) const;
 
  // Present for testing purposes only.
  static DataBlock* load(Context& C, std::istream& In);
 
  friend class Context;      // Enables Context::Create
  friend class ByteInterval; // Enables to/fromProtobuf, setByteInterval
  friend class SerializationTestHarness; // Testing support.
};
} // namespace gtirb
 
#endif // GTIRB_DataBlock_H