NativeDoubleVectorStaged.inl

Go to the documentation of this file.

 
#ifndef _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_INL_
#define _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_INL_
 
#include "NativeDoubleVectorStaged.h"
#include "madara/knowledge/ContextGuard.h"
#include "madara/logger/GlobalLogger.h"
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::modify(
    void)
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVectorStaged::modify called\n");
 
  ContextGuard context_guard(*context_);
  if (context_ && name_ != "")
  {
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::modify: context is valid. Marking %s.\n",
        this->name_.c_str());
 
    context_->mark_modified(vector_);
  }
}
 
inline std::string
madara::knowledge::containers::NativeDoubleVectorStaged::get_debug_info(void)
{
  std::stringstream result;
 
  result << "Native Double Vector Staged: ";
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    result << this->name_;
    result << " [" << size() << "]";
    result << " = " << context_->get(vector_).to_string();
  }
 
  return result.str();
}
 
inline std::string
madara::knowledge::containers::NativeDoubleVectorStaged::get_debug_info_(void)
{
  return get_debug_info();
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::operator=(
    const NativeDoubleVectorStaged& rhs)
{
  if (this != &rhs)
  {
    MADARA_GUARD_TYPE guard(mutex_), guard2(rhs.mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::assignment: %s: copying from %s.\n",
        this->name_.c_str(), rhs.name_.c_str());
 
    this->context_ = rhs.context_;
    this->name_ = rhs.name_;
    this->settings_ = rhs.settings_;
    this->vector_ = rhs.vector_;
    this->value_ = rhs.value_;
    this->has_changed_ = true;
  }
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::operator=(
    const std::vector<type>& rhs)
{
  if (!has_changed_)
    has_changed_ = true;
 
  value_ = knowledge::KnowledgeRecord(rhs);
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::push_back(
    type value)
{
  if (!has_changed_)
    has_changed_ = true;
 
  size_t i = size();
  resize((int)i + 1);
  set(i, value);
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::resize(
    size_t size)
{
  if (!has_changed_)
    has_changed_ = true;
 
  value_.resize(size);
}
 
inline size_t madara::knowledge::containers::NativeDoubleVectorStaged::size(
    void) const
{
  return value_.size();
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::set_name(
    const std::string& var_name, KnowledgeBase& knowledge, int size, bool sync)
{
  if (context_ != &(knowledge.get_context()) || name_ != var_name)
  {
    context_ = &(knowledge.get_context());
 
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::set_name: setting name to %s\n",
        var_name.c_str());
 
    name_ = var_name;
 
    vector_ = knowledge.get_ref(var_name, settings_);
 
    if (size > 0)
    {
      resize(size_t(size));
    }
    else if (sync)
    {
      std::vector<type> values = knowledge.get(vector_).to_doubles();
      value_.set_value(values);
    }
  }
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::set_name(
    const std::string& var_name, Variables& knowledge, int size, bool sync)
{
  if (context_ != knowledge.get_context() || name_ != var_name)
  {
    context_ = knowledge.get_context();
 
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::set_name: setting name to %s\n",
        var_name.c_str());
 
    name_ = var_name;
 
    vector_ = knowledge.get_ref(var_name, settings_);
 
    if (size > 0)
    {
      resize(size_t(size));
    }
    else if (sync)
    {
      std::vector<type> values = knowledge.get(vector_).to_doubles();
      value_.set_value(values);
    }
  }
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::set_name(
    const std::string& var_name, ThreadSafeContext& knowledge, int size,
    bool sync)
{
  if (context_ != &knowledge || name_ != var_name)
  {
    context_ = &knowledge;
 
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::set_name: setting name to %s\n",
        var_name.c_str());
 
    name_ = var_name;
 
    vector_ = knowledge.get_ref(var_name, settings_);
 
    if (size > 0)
    {
      resize(size_t(size));
    }
    else if (sync)
    {
      std::vector<type> values = knowledge.get(vector_).to_doubles();
      value_.set_value(values);
    }
  }
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::exchange(
    NativeDoubleVectorStaged& other)
{
  knowledge::KnowledgeRecord temp(other.value_);
 
  other.value_ = value_;
  value_ = temp;
 
  if (!has_changed_)
    has_changed_ = true;
 
  if (!other.has_changed_)
    other.has_changed_ = true;
}
 
inline void
madara::knowledge::containers::NativeDoubleVectorStaged::transfer_to(
    NativeDoubleVectorStaged& other)
{
  size_t other_size = other.size();
  size_t this_size = this->size();
 
  if (this_size > 0)
  {
    size_t size = other_size + this_size;
    other.resize((int)size);
 
    knowledge::KnowledgeRecord& rhs(other.value_);
    knowledge::KnowledgeRecord& lhs(value_);
 
    rhs.set_index(size - 1, lhs.retrieve_index(this_size - 1).to_double());
 
    for (size_t i = 0, j = other_size; i < this_size - 1; ++i, ++j)
    {
      rhs.set_index(j, lhs.retrieve_index(i).to_double());
    }
 
    lhs.reset_value();
 
    if (!has_changed_)
      has_changed_ = true;
 
    if (!other.has_changed_)
      other.has_changed_ = true;
  }
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::copy_to(
    KnowledgeVector& target) const
{
  target.resize(size());
 
  for (size_t i = 0; i < target.size(); ++i)
  {
    target[i] = value_.retrieve_index(i);
  }
}
 
inline madara::knowledge::containers::NativeDoubleVectorStaged::type
    madara::knowledge::containers::NativeDoubleVectorStaged::operator[](
        size_t index) const
{
  knowledge::KnowledgeRecord result;
 
  result = result.retrieve_index(index);
 
  return result.to_double();
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::set(
    size_t index, type value)
{
  if (!has_changed_)
    has_changed_ = true;
 
  value_.set_index(index, value);
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::set(
    const std::vector<type>& value)
{
  if (!has_changed_)
    has_changed_ = true;
 
  value_ = knowledge::KnowledgeRecord(value);
}
 
inline void
madara::knowledge::containers::NativeDoubleVectorStaged::set_quality(
    size_t /*index*/, uint32_t quality,
    const KnowledgeReferenceSettings& settings)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVectorStaged::set: %s: setting quality of knowledge\n",
        this->name_.c_str());
 
    context_->set_quality(name_, quality, true, settings);
  }
}
 
inline madara::knowledge::KnowledgeRecord
madara::knowledge::containers::NativeDoubleVectorStaged::to_record(
    size_t index) const
{
  madara::knowledge::KnowledgeRecord result;
  result = value_.retrieve_index(index);
  return result;
}
 
inline madara::knowledge::KnowledgeRecord
madara::knowledge::containers::NativeDoubleVectorStaged::to_record(void) const
{
  return value_;
}
 
inline bool madara::knowledge::containers::NativeDoubleVectorStaged::is_true(
    void) const
{
  bool result(false);
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "NativeIntegerVectorStaged::is_true: checking for non-zero value\n");
 
  result = value_.is_true();
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "NativeIntegerVectorStaged::is_true: final result is %d\n", (int)result);
 
  return result;
}
 
inline bool madara::knowledge::containers::NativeDoubleVectorStaged::is_false(
    void) const
{
  return !is_true();
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::read(void)
{
  has_changed_ = false;
  value_ = context_->get(vector_);
}
 
inline void madara::knowledge::containers::NativeDoubleVectorStaged::write(void)
{
  if (has_changed_)
    context_->set(vector_, value_);
}
 
#endif  // _MADARA_NATIVE_DOUBLE_VECTOR_STAGED_INL_