schedule.hpp

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

#include <vector>
#include <ndn-cpp/c/errors.h>
#include <ndn-cpp/util/blob.hpp>
#include "repetitive-interval.hpp"

struct ndn_TlvEncoder;
struct ndn_TlvDecoder;

namespace ndn {

class Schedule {
public:
  class Result {
  public:
    Result(bool isPositive, const Interval& interval)
    {
      this->isPositive = isPositive;
      this->interval = interval;
    }

    bool isPositive;
    Interval interval;
  };

  Schedule()
  {
  }

  // Note: RepetitiveInterval is immutable, so we can use the default shallow
  //   copy constructor.

  Schedule&
  addWhiteInterval(const ptr_lib::shared_ptr<RepetitiveInterval>& repetitiveInterval)
  {
    // RepetitiveInterval is immutable, so we don't need to make a copy.
    sortedSetAdd(whiteIntervalList_, repetitiveInterval);
    return *this;
  }

  Schedule&
  addBlackInterval(const ptr_lib::shared_ptr<RepetitiveInterval>& repetitiveInterval)
  {
    // RepetitiveInterval is immutable, so we don't need to make a copy.
    sortedSetAdd(blackIntervalList_, repetitiveInterval);
    return *this;
  }

  Result
  getCoveringInterval(MillisecondsSince1970 timeStamp) const;

  Blob
  wireEncode() const;

  void
  wireDecode(const uint8_t *input, size_t inputLength);

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

  void
  wireDecode(const Blob& input)
  {
    wireDecode(input.buf(), input.size());
  }

  static MillisecondsSince1970
  fromIsoString(const std::string& dateString);

  static std::string
  toIsoString(MillisecondsSince1970 msSince1970);

private:
  static void
  sortedSetAdd
    (std::vector<ptr_lib::shared_ptr<RepetitiveInterval> >& list,
     const ptr_lib::shared_ptr<RepetitiveInterval>& element);

  static ndn_Error
  encodeRepetitiveIntervalValue(const void *context, ndn_TlvEncoder *encoder);

  static ndn_Error
  encodeRepetitiveIntervalListValue(const void *context, ndn_TlvEncoder *encoder);

  static ndn_Error
  encodeScheduleValue(const void *context, ndn_TlvEncoder *encoder);

  static ptr_lib::shared_ptr<RepetitiveInterval>
  decodeRepetitiveInterval(ndn_TlvDecoder *decoder);

  static void
  calculateIntervalResult
    (const std::vector<ptr_lib::shared_ptr<RepetitiveInterval> >& list,
     MillisecondsSince1970 timeStamp, Interval& positiveResult,
     Interval& negativeResult);

  std::vector<ptr_lib::shared_ptr<RepetitiveInterval> > whiteIntervalList_;
  std::vector<ptr_lib::shared_ptr<RepetitiveInterval> > blackIntervalList_;
  static const uint64_t MILLISECONDS_IN_DAY = 24 * 3600 * 1000;
};

}

#endif