VariableReference.h

Go to the documentation of this file.

#ifndef _MADARA_VARIABLE_REFERENCE_H_
#define _MADARA_VARIABLE_REFERENCE_H_
 
#include <string>
#include <cstring>
#include "madara/MadaraExport.h"
#include "madara/expression/ExpressionTree.h"
#include "madara/utility/ScopedArray.h"
#include "madara/utility/Comparators.h"
#include "madara/utility/StlHelper.h"
 
namespace madara
{
namespace knowledge
{
class ThreadSafeContext;
class KnolwedgeBaseImpl;
class Variables;
 
class MADARA_EXPORT VariableReference
{
public:
  friend class ThreadSafeContext;
  friend class KnowledgeBaseImpl;
  friend class Variables;
 
  using pair_ptr = KnowledgeMap::value_type*;
 
  VariableReference() = default;
 
  VariableReference(pair_ptr entry);
 
  bool is_valid(void) const;
 
  bool operator==(const VariableReference& rhs) const;
 
  bool operator!=(const VariableReference& rhs) const;
 
  const char* get_name(void) const;
 
  KnowledgeRecord* get_record_unsafe(void) const;
 
  void assign(pair_ptr entry);
 
private:
  pair_ptr entry_ = nullptr;
};
 
typedef std::vector<VariableReference> VariableReferences;
 
typedef std::map<const char*, VariableReference, utility::ComparisonLessThan>
    VariableReferenceMap;
 
class VariableReferenceMapReader
{
public:
  VariableReferenceMapReader(const VariableReferenceMap& map,
      bool history = false, uint64_t min_toi = 0)
    : map_(map), history_(history), min_toi_(min_toi)
  {
  }
 
  class const_iterator
  {
  public:
    using value_type = std::pair<const char*, const KnowledgeRecord*>;
    using difference_type = size_t;
    using reference = value_type;
    using pointer = value_type*;
    using iterator_category = std::input_iterator_tag;
 
    value_type operator*() const
    {
      if (biter_)
      {
        return {miter_->first, &**biter_};
      }
      return {miter_->first, miter_->second.get_record_unsafe()};
    }
 
    const_iterator& operator++()
    {
      if (biter_)
      {
        ++*biter_;
        auto rec = miter_->second.get_record_unsafe();
        auto cbuf = rec->share_circular_buffer();
        if (cbuf && *biter_ != cbuf->cend())
        {
          return *this;
        }
      }
 
      ++miter_;
      biter_ = begin_biter();
      return *this;
    }
 
    const_iterator operator++(int)
    {
      const_iterator ret(*this);
      ++*this;
      return ret;
    }
 
    bool operator==(const const_iterator& o) const
    {
      return reader_ == o.reader_ && miter_ == o.miter_ &&
             ((biter_ == nullptr && o.biter_ == nullptr) ||
                 (biter_ && o.biter_ && *biter_ == *o.biter_));
    }
 
    bool operator!=(const const_iterator& o) const
    {
      return !(*this == o);
    }
 
  private:
    using miter_type = VariableReferenceMap::const_iterator;
    using biter_type = utility::CircularBuffer<KnowledgeRecord>::const_iterator;
    using biter_uptr = std::unique_ptr<biter_type>;
 
    biter_uptr begin_biter()
    {
      for (;;)
      {
        if (!reader_->history_ || miter_ == reader_->map_.end())
        {
          return nullptr;
        }
 
        const KnowledgeRecord* rec = miter_->second.get_record_unsafe();
 
        if (!rec->has_history())
        {
          return nullptr;
        }
 
        auto cbuf = rec->share_circular_buffer();
        auto ret = cbuf->cbegin();
 
        if (reader_->min_toi_ > 0)
        {
          ret = std::upper_bound(ret, cbuf->cend(), reader_->min_toi_,
              [](const uint64_t& lhs, const KnowledgeRecord& rhs) {
                return lhs < rhs.toi();
              });
        }
 
        if (ret == cbuf->cend())
        {
          ++miter_;
          continue;
        }
 
        return into_unique(std::move(ret));
      }
    }
 
    const_iterator(const VariableReferenceMapReader& f)
      : reader_(&f), miter_(reader_->map_.begin()), biter_(begin_biter())
    {
    }
 
    const_iterator(const VariableReferenceMapReader& f, miter_type miter)
      : reader_(&f), miter_(miter), biter_(begin_biter())
    {
    }
 
  public:
    const_iterator(const const_iterator& o)
      : reader_(o.reader_),
        miter_(o.miter_),
        biter_(o.biter_ ? into_unique(*o.biter_) : nullptr)
    {
    }
 
    const_iterator& operator=(const const_iterator& o)
    {
      biter_ = o.biter_ ? into_unique(*o.biter_) : nullptr;
      reader_ = o.reader_;
      miter_ = o.miter_;
      return *this;
    }
 
    const_iterator(const_iterator&& o) = default;
    const_iterator& operator=(const_iterator&& o) = default;
 
  private:
    const VariableReferenceMapReader* reader_;
 
    miter_type miter_;
 
    biter_uptr biter_{nullptr};
 
    friend class VariableReferenceMapReader;
  };
 
  const_iterator begin() const
  {
    return {*this};
  }
 
  const_iterator end() const
  {
    return {*this, map_.end()};
  }
 
private:
  const VariableReferenceMap& map_;
 
  bool history_ = false;
 
  uint64_t min_toi_ = 0;
};
}
}
 
#include "VariableReference.inl"
 
#endif  // _MADARA_VARIABLE_REFERENCE_H_