data.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_DATA_HPP
#define NDN_DATA_HPP

#include "name.hpp"
#include "signature.hpp"
#include "meta-info.hpp"
#include "util/signed-blob.hpp"
#include "encoding/wire-format.hpp"
#include "util/change-counter.hpp"
#include "lite/data-lite.hpp"

namespace ndn {

class LpPacket;

class Data {
public:
  Data();

  Data(const Name& name);

  Data(const Data& data);

  virtual ~Data();

  Data& operator=(const Data& data);

  SignedBlob
  wireEncode(WireFormat& wireFormat = *WireFormat::getDefaultWireFormat()) const;

  virtual void
  wireDecode(const Blob& input, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  wireDecode
    (const uint8_t* input, size_t inputLength,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(Blob(input, inputLength), wireFormat);
  }

  void
  wireDecode(const std::vector<uint8_t>& input, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    wireDecode(&input[0], input.size(), wireFormat);
  }

  void
  get(DataLite& dataLite) const;

  void
  set(const DataLite& dataLite);

  const Signature*
  getSignature() const { return signature_.get(); }

  Signature*
  getSignature() { return signature_.get(); }

  const Name&
  getName() const { return name_.get(); }

  Name&
  getName() { return name_.get(); }

  const MetaInfo&
  getMetaInfo() const { return metaInfo_.get(); }

  MetaInfo& getMetaInfo() { return metaInfo_.get(); }

  const Blob&
  getContent() const { return content_; }

  uint64_t
  getIncomingFaceId() const;

  const SignedBlob&
  getDefaultWireEncoding() const
  {
    if (getDefaultWireEncodingChangeCount_ != getChangeCount()) {
      // The values have changed, so the default wire encoding is invalidated.
      // This method can be called on a const object, but we want to be able to update the default cached value.
      const_cast<Data*>(this)->defaultWireEncoding_ = SignedBlob();
      const_cast<Data*>(this)->defaultWireEncodingFormat_ = 0;
      const_cast<Data*>(this)->getDefaultWireEncodingChangeCount_ = getChangeCount();
    }

    return defaultWireEncoding_;
  }

  WireFormat*
  getDefaultWireEncodingFormat() const { return defaultWireEncodingFormat_; }

  Data&
  setSignature(const Signature& signature)
  {
    signature_.set(signature.clone());
    ++changeCount_;
    return *this;
  }

  virtual Data&
  setName(const Name& name);

  Data&
  setMetaInfo(const MetaInfo& metaInfo)
  {
    metaInfo_.set(metaInfo);
    ++changeCount_;
    return *this;
  }

  Data&
  setContent(const std::vector<uint8_t>& content)
  {
    return setContent(Blob(content));
  }

  Data&
  setContent(const uint8_t* content, size_t contentLength)
  {
    return setContent(Blob(content, contentLength));
  }

  Data&
  setContent(const Blob& content)
  {
    content_ = content;
    ++changeCount_;
    return *this;
  }

  Data&
  setLpPacket(const ptr_lib::shared_ptr<LpPacket>& lpPacket)
  {
    lpPacket_ = lpPacket;
    // Don't update changeCount_ since this doesn't affect the wire encoding.
    return *this;
  }

  uint64_t
  getChangeCount() const
  {
    // Make sure each of the checkChanged is called.
    bool changed = signature_.checkChanged();
    changed = name_.checkChanged() || changed;
    changed = metaInfo_.checkChanged() || changed;
    if (changed)
      // A child object has changed, so update the change count.
      // This method can be called on a const object, but we want to be able to update the changeCount_.
      ++const_cast<Data*>(this)->changeCount_;

    return changeCount_;
  }

private:
  void
  setDefaultWireEncoding
    (const SignedBlob& defaultWireEncoding,
     WireFormat *defaultWireEncodingFormat)
  {
    defaultWireEncoding_ = defaultWireEncoding;
    defaultWireEncodingFormat_ = defaultWireEncodingFormat;
    // Set getDefaultWireEncodingChangeCount_ so that the next call to
    //   getDefaultWireEncoding() won't clear defaultWireEncoding_.
    getDefaultWireEncodingChangeCount_ = getChangeCount();
  }

  SharedPointerChangeCounter<Signature> signature_;
  ChangeCounter<Name> name_;
  ChangeCounter<MetaInfo> metaInfo_;
  Blob content_;
  SignedBlob defaultWireEncoding_;
  WireFormat *defaultWireEncodingFormat_;
  uint64_t getDefaultWireEncodingChangeCount_;
  ptr_lib::shared_ptr<LpPacket> lpPacket_;
  uint64_t changeCount_;
};

}

#endif