AuxDataContainer.hpp

Go to the documentation of this file.

//===- AuxDataContainer.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_AUXDATACONTAINER_H
#define GTIRB_AUXDATACONTAINER_H
 
#include <gtirb/AuxData.hpp>
#include <gtirb/Node.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <type_traits>
 
 
namespace gtirb {
 
namespace proto {
class IR;
class Module;
} // namespace proto
 
template <typename MessageType> struct message_has_aux_data_container {
  static constexpr bool value = false;
};
template <> struct message_has_aux_data_container<proto::IR> {
  static constexpr bool value = true;
};
template <> struct message_has_aux_data_container<proto::Module> {
  static constexpr bool value = true;
};
 
template <typename MessageType>
inline constexpr bool message_has_aux_data_container_v =
    message_has_aux_data_container<MessageType>::value;
 
 
class GTIRB_EXPORT_API AuxDataContainer : public Node {
  using AuxDataSet = std::map<std::string, std::unique_ptr<gtirb::AuxData>>;
 
public:
 
  template <typename Schema> static void registerAuxDataType() {
    registerAuxDataTypeInternal(Schema::Name,
                                std::make_unique<AuxDataTypeImpl<Schema>>());
  }
 
  template <typename Schema> void addAuxData(typename Schema::Type&& X) {
    // Make sure this type matches a registered type.
    assert(checkAuxDataRegistration(
               Schema::Name, AuxDataImpl<Schema>::staticGetApiTypeId()) &&
           "Attempting to add AuxData with unregistered or incorrect type.");
    this->AuxDatas[Schema::Name] =
        std::make_unique<AuxDataImpl<Schema>>(std::move(X));
  }
 
  template <typename Schema> typename Schema::Type* getAuxData() {
    return const_cast<typename Schema::Type*>(
        const_cast<const AuxDataContainer*>(this)->getAuxData<Schema>());
  }
 
  template <typename Schema> const typename Schema::Type* getAuxData() const {
    auto Found = this->AuxDatas.find(Schema::Name);
 
    if (Found == this->AuxDatas.end())
      return nullptr;
 
    AuxData& AD = *(Found->second);
 
    // Is the type of the AuxData registered?
    if (AD.getApiTypeId() == AuxData::UNREGISTERED_API_TYPE_ID) {
      // We can get here for two reasons:
      //
      //  1) The type is not registered. We treat this as a developer
      //  error and assert. getAuxData should only ever be called for
      //  types that are registered.
      //
      //  2) The type is registered, but the attempt to unserialized
      //  the AuxData using the registered type failed. This is a
      //  legitimate runtime error situation. An example might be
      //  loading a GTIRB file that has a previous version of the
      //  AuxData with a different type. In this situation, we don't
      //  want to assert, just return nullptr.
      assert(checkAuxDataRegistration(
                 Schema::Name, AuxDataImpl<Schema>::staticGetApiTypeId()) &&
             "Attempting to retrieve AuxData with an unregistered type.");
      return nullptr;
    }
 
    // Does the type match the type being requested?
    if (AD.getApiTypeId() != AuxDataImpl<Schema>::staticGetApiTypeId()) {
      assert(false && "Attempting to retrieve AuxData with incorrect type.");
      return nullptr;
    }
 
    // If we get here, it should be safe to downcast to the typed AuxDataImpl.
    auto& ADI = static_cast<AuxDataImpl<Schema>&>(AD);
    return ADI.get();
  }
 
  template <typename Schema> bool removeAuxData() {
    assert(checkAuxDataRegistration(
               Schema::Name, AuxDataImpl<Schema>::staticGetApiTypeId()) &&
           "Attempting to remove AuxData with an unregistered type.");
    return this->AuxDatas.erase(Schema::Name) > 0;
  }
 
  bool removeAuxData(std::string Name) {
    return this->AuxDatas.erase(Name) > 0;
  }
 
  struct AuxDataRaw {
 
    const std::string& Key;
 
    const std::string& RawBytes;
 
    const std::string& ProtobufType;
 
    AuxDataRaw(const std::string& K, const std::string& RB,
               const std::string& PT)
        : Key(K), RawBytes(RB), ProtobufType(PT) {}
  };
 
private:
  struct AccessRawData {
    auto operator()(const AuxDataSet::value_type& P) const {
      return AuxDataRaw(P.first, P.second->rawData().RawBytes,
                        P.second->rawData().ProtobufType);
    }
  };
 
public:
  using const_aux_data_iterator =
      boost::transform_iterator<AccessRawData, AuxDataSet::const_iterator>;
  using const_aux_data_range = boost::iterator_range<const_aux_data_iterator>;
 
  const_aux_data_iterator aux_data_begin() const {
    return const_aux_data_iterator(AuxDatas.begin(), AccessRawData());
  }
 
  const_aux_data_iterator aux_data_end() const {
    return const_aux_data_iterator(AuxDatas.end(), AccessRawData());
  }
 
  const_aux_data_range aux_data() const {
    return boost::make_iterator_range(aux_data_begin(), aux_data_end());
  }
 
  size_t getAuxDataSize() const { return AuxDatas.size(); }
 
  bool getAuxDataEmpty() const { return AuxDatas.empty(); }
 
  void clearAuxData() { AuxDatas.clear(); }
 
 
  template <
      class MessageType,
      class = std::enable_if_t<message_has_aux_data_container_v<MessageType>>>
  void toProtobuf(MessageType* Message) const {
    containerToProtobuf(this->AuxDatas, Message->mutable_aux_data());
  }
 
  template <
      class MessageType,
      class = std::enable_if_t<message_has_aux_data_container_v<MessageType>>>
  void fromProtobuf(const MessageType& Message) {
    this->AuxDatas.clear();
    for (const auto& M : Message.aux_data()) {
      std::unique_ptr<AuxData> Val;
      std::string Key = M.first;
 
      // See if the name for this AuxData is registered.
      if (const auto* ADT = lookupAuxDataType(Key)) {
        Val = ADT->fromProtobuf(M.second);
      }
 
      // If it wasn't registered or was registered with an incompatible
      // type wrt the serialized object, unserialized as just the
      // un-typed raw data.
      if (!Val) {
        Val = std::make_unique<AuxData>();
        AuxData::fromProtobuf(*Val, M.second);
      }
      this->AuxDatas.insert(std::make_pair(Key, std::move(Val)));
    }
  }
 
protected:
  AuxDataContainer(Context& C, Kind knd);
  AuxDataContainer(Context& C, Kind knd, const UUID& U);
 
private:
  AuxDataSet AuxDatas;
 
  struct AuxDataType {
    virtual ~AuxDataType() = default;
    virtual std::unique_ptr<AuxData>
    fromProtobuf(const proto::AuxData& Message) const = 0;
    virtual std::size_t getApiTypeId() const = 0;
  };
 
  template <typename Schema> struct AuxDataTypeImpl : public AuxDataType {
    std::unique_ptr<AuxData>
    fromProtobuf(const proto::AuxData& Message) const override {
      return AuxDataImpl<Schema>::fromProtobuf(Message);
    }
 
    std::size_t getApiTypeId() const override {
      return AuxDataImpl<Schema>::staticGetApiTypeId();
    }
  };
 
  static void registerAuxDataTypeInternal(const char* Name,
                                          std::unique_ptr<AuxDataType> ADT);
  static bool checkAuxDataRegistration(const char* Name, std::size_t Id);
  static const AuxDataType* lookupAuxDataType(const std::string& Name);
  friend struct AuxDataTypeMap; // Allows AuxDataTypeMap to use AuxDataType
};
} // namespace gtirb
#endif // GTIRB_AUXDATACONTAINER_H