metadata.h

/***
 * © 2020 Duality Technologies, Inc. All rights reserved.
 * This is a proprietary software product of Duality Technologies, Inc.
 *protected under copyright laws and international copyright treaties, patent
 *law, trade secret law and other intellectual property rights of general
 *applicability. Any use of this software is strictly prohibited absent a
 *written agreement executed by Duality Technologies, Inc., which provides
 *certain limited rights to use this software. You may not copy, distribute,
 *make publicly available, publicly perform, disassemble, de-compile or reverse
 *engineer any part of this software, breach its security, or circumvent,
 *manipulate, impair or disrupt its operation.
 ***/

#ifndef LBCRYPTO_CRYPTO_METADATA_H
#define LBCRYPTO_CRYPTO_METADATA_H

namespace lbcrypto {

class Metadata {
 public:
  Metadata() {}

  Metadata(const Metadata& mdata) { Metadata(); }

  virtual ~Metadata() {}

  virtual std::shared_ptr<Metadata> Clone() const {
    return std::make_shared<Metadata>();
  }

  virtual bool operator==(const Metadata& mdata) const { return true; }

  virtual bool operator!=(const Metadata& mdata) const {
    return !(*this == mdata);
  }

  virtual std::ostream& print(std::ostream& out) const {
    out << "[ ]" << std::endl;
    return out;
  }

  friend std::ostream& operator<<(std::ostream& out, const Metadata& m) {
    m.print(out);
    return out;
  }

  template <class Archive>
  void save(Archive& ar, std::uint32_t const version) const {}

  template <class Archive>
  void load(Archive& ar, std::uint32_t const version) {
    if (version > SerializedVersion()) {
      PALISADE_THROW(deserialize_error,
                     "serialized object version " + std::to_string(version) +
                         " is from a later version of the library");
    }
  }

  virtual std::string SerializedObjectName() const { return "Metadata"; }

  static uint32_t SerializedVersion() { return 1; }
};

class MetadataTest : public Metadata {
 public:
  MetadataTest() : Metadata(), m_s("") {}
  virtual ~MetadataTest() {}

  MetadataTest(const MetadataTest& mdata) : Metadata() { m_s = mdata.m_s; }

  std::shared_ptr<Metadata> Clone() const {
    auto mdata = std::make_shared<MetadataTest>();
    mdata->m_s = this->m_s;
    return mdata;
  }

  void SetMetadata(string str) { m_s = string(str); }

  string GetMetadata() const { return m_s; }

  bool operator==(const Metadata& mdata) const {
    try {
      const MetadataTest& mdataTest = dynamic_cast<const MetadataTest&>(mdata);
      return m_s == mdataTest.GetMetadata();  // All Metadata objects without
                                              // any members are equal
    } catch (const std::bad_cast& e) {
      PALISADE_THROW(
          palisade_error,
          "Tried to downcast an object of different class to MetadataTest");
    }
  }

  std::ostream& print(std::ostream& out) const {
    out << "[ " << m_s << " ]";
    return out;
  }

  template <class Archive>
  void save(Archive& ar, std::uint32_t const version) const {
    ar(cereal::base_class<Metadata>(this));
    ar(cereal::make_nvp("str", m_s));
  }

  template <class Archive>
  void load(Archive& ar, std::uint32_t const version) {
    if (version > SerializedVersion()) {
      PALISADE_THROW(deserialize_error,
                     "serialized object version " + std::to_string(version) +
                         " is from a later version of the library");
    }
    ar(cereal::base_class<Metadata>(this));
    ar(cereal::make_nvp("str", m_s));
  }

  template <class Element>
  static const shared_ptr<MetadataTest> CloneMetadata(
      ConstCiphertext<Element> ciphertext) {
    auto it = ciphertext->FindMetadataByKey("test");

    if (ciphertext->MetadataFound(it)) {
      return std::dynamic_pointer_cast<MetadataTest>(
          ciphertext->GetMetadata(it)->Clone());
    } else {
      PALISADE_THROW(
          palisade_error,
          "Attempt to access metadata (MetadataTest) that has not been set.");
    }
  }

  template <class Element>
  static const shared_ptr<MetadataTest> GetMetadata(
      ConstCiphertext<Element> ciphertext) {
    auto it = ciphertext->FindMetadataByKey("test");

    if (ciphertext->MetadataFound(it)) {
      return std::dynamic_pointer_cast<MetadataTest>(
          ciphertext->GetMetadata(it));
    } else {
      PALISADE_THROW(
          palisade_error,
          "Attempt to access metadata (MetadataTest) that has not been set.");
    }
  }

  template <class Element>
  static void StoreMetadata(Ciphertext<Element> ciphertext,
                            shared_ptr<MetadataTest> mdata) {
    ciphertext->SetMetadataByKey("test", mdata);
  }

 protected:
  string m_s;
};

}  // end namespace lbcrypto

#endif