NativeDoubleVector.cpp

Go to the documentation of this file.

#include "NativeDoubleVector.h"
#include "madara/knowledge/ContextGuard.h"
#include "madara/logger/GlobalLogger.h"
 
madara::knowledge::containers::NativeDoubleVector::NativeDoubleVector(
    const KnowledgeUpdateSettings& settings)
  : BaseContainer("", settings), context_(0)
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::constructor: new object\n");
}
 
madara::knowledge::containers::NativeDoubleVector::NativeDoubleVector(
    const std::string& name, KnowledgeBase& knowledge, int size,
    const KnowledgeUpdateSettings& settings)
  : BaseContainer(name, settings), context_(&(knowledge.get_context()))
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::constructor called for %s[%d]\n", name.c_str(),
      size);
 
  vector_ = knowledge.get_ref(name, settings_);
  if (size >= 0)
  {
    resize(size);
  }
}
 
madara::knowledge::containers::NativeDoubleVector::NativeDoubleVector(
    const std::string& name, Variables& knowledge, int size,
    const KnowledgeUpdateSettings& settings)
  : context_(knowledge.get_context())
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::constructor called for %s[%d]\n", name.c_str(),
      size);
 
  vector_ = knowledge.get_ref(name, settings);
  if (size >= 0)
  {
    resize(size);
  }
}
 
madara::knowledge::containers::NativeDoubleVector::NativeDoubleVector(
    const NativeDoubleVector& rhs)
  : BaseContainer(rhs), context_(rhs.context_), vector_(rhs.vector_)
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::copy constructor called on %s\n", rhs.name_.c_str());
}
 
madara::knowledge::containers::NativeDoubleVector::~NativeDoubleVector()
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::destructor called on %s\n", this->name_.c_str());
}
 
void madara::knowledge::containers::NativeDoubleVector::modify(void)
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::modify called\n");
 
  ContextGuard context_guard(*context_);
  if (context_ && name_ != "")
  {
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::modify: context is valid. Marking %s.\n",
        this->name_.c_str());
 
    context_->mark_modified(vector_);
  }
}
 
std::string madara::knowledge::containers::NativeDoubleVector::get_debug_info(
    void)
{
  std::stringstream result;
 
  result << "Native Double Vector: ";
 
  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();
}
 
void madara::knowledge::containers::NativeDoubleVector::modify_(void)
{
  modify();
}
 
std::string madara::knowledge::containers::NativeDoubleVector::get_debug_info_(
    void)
{
  return get_debug_info();
}
 
madara::knowledge::containers::BaseContainer*
madara::knowledge::containers::NativeDoubleVector::clone(void) const
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::clone: cloning %s\n", this->name_.c_str());
 
  return new NativeDoubleVector(*this);
}
 
void madara::knowledge::containers::NativeDoubleVector::operator=(
    const NativeDoubleVector& rhs)
{
  if (this != &rhs)
  {
    MADARA_GUARD_TYPE guard(mutex_), guard2(rhs.mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::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_;
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::push_back(type value)
{
  if (context_ && name_ != "")
  {
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::push_back: %s: valid context, pushing.\n",
        this->name_.c_str());
 
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    size_t i = size();
    resize((int)i + 1);
    set(i, value);
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::resize(size_t size)
{
  if (context_ && name_ != "")
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::resize: %s: resizing to %d\n", this->name_.c_str(),
        (int)size);
 
    knowledge::KnowledgeRecord value = context_->get(vector_, settings_);
 
    value.resize(size);
 
    context_->set(vector_, value, settings_);
  }
}
 
size_t madara::knowledge::containers::NativeDoubleVector::size(void) const
{
  ContextGuard context_guard(*context_);
  MADARA_GUARD_TYPE guard(mutex_);
 
  return context_->get(vector_, settings_).size();
}
 
void madara::knowledge::containers::NativeDoubleVector::set_name(
    const std::string& var_name, KnowledgeBase& knowledge, int size)
{
  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,
        "NativeDoubleVector::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));
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::set_name(
    const std::string& var_name, Variables& knowledge, int size)
{
  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,
        "NativeDoubleVector::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));
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::set_name(
    const std::string& var_name, ThreadSafeContext& knowledge, int size)
{
  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,
        "NativeDoubleVector::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));
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::exchange(
    NativeDoubleVector& other)
{
  if (context_ && other.context_)
  {
    std::lock(*context_, *other.context_, mutex_, other.mutex_);
 
    ContextGuard context_guard(*context_, std::adopt_lock);
    ContextGuard other_context_guard(*other.context_, std::adopt_lock);
    MADARA_GUARD_TYPE guard(mutex_, std::adopt_lock),
        guard2(other.mutex_, std::adopt_lock);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::exchange: %s exchanging with %s\n",
        this->name_.c_str(), other.name_.c_str());
 
    knowledge::KnowledgeRecord temp(context_->get(other.vector_));
 
    context_->set(other.vector_, context_->get(vector_), other.settings_);
    context_->set(vector_, temp, settings_);
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::transfer_to(
    NativeDoubleVector& other)
{
  if (context_ && other.context_)
  {
    std::lock(*context_, *other.context_, mutex_, other.mutex_);
 
    ContextGuard context_guard(*context_, std::adopt_lock);
    ContextGuard other_context_guard(*other.context_, std::adopt_lock);
    MADARA_GUARD_TYPE guard(mutex_, std::adopt_lock),
        guard2(other.mutex_, std::adopt_lock);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::transfer_to: %s transfering to %s\n",
        this->name_.c_str(), other.name_.c_str());
 
    size_t other_size = other.size();
    size_t this_size = this->size();
 
    if (this_size > 0)
    {
      madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MINOR,
          "NativeDoubleVector::transfer_to: %s has elements\n",
          this->name_.c_str());
 
      size_t size = other_size + this_size;
      other.resize((int)size);
 
      knowledge::KnowledgeRecord rhs(other.context_->get(other.vector_));
      knowledge::KnowledgeRecord lhs(context_->get(vector_));
 
      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(other_size, lhs.retrieve_index(i).to_double());
      }
 
      other.context_->set(other.vector_, rhs, other.settings_);
 
      this->resize(0);
    }
  }
}
 
void madara::knowledge::containers::NativeDoubleVector::copy_to(
    KnowledgeVector& target) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::copy_to: %s: copying elements to vector\n",
        this->name_.c_str());
 
    target.resize(size());
 
    for (size_t i = 0; i < target.size(); ++i)
    {
      target[i] = knowledge::KnowledgeRecord((*this)[i]);
    }
  }
}
 
madara::knowledge::containers::NativeDoubleVector::type
    madara::knowledge::containers::NativeDoubleVector::operator[](
        size_t index) const
{
  knowledge::KnowledgeRecord result;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector[]: %s: retrieving element from container\n",
        this->name_.c_str());
 
    result = context_->get(vector_, settings_);
 
    if (index < result.size())
      result = result.retrieve_index(index);
  }
 
  return result.to_double();
}
 
int madara::knowledge::containers::NativeDoubleVector::set(
    size_t index, type value)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting element [%d] to %f\n",
        this->name_.c_str(), (int)index, value);
 
    result = context_->set_index(vector_, index, value, settings_);
  }
 
  return result;
}
 
int madara::knowledge::containers::NativeDoubleVector::set(
    size_t index, type value, const KnowledgeUpdateSettings& settings)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting element [%d] "
        "to %f with custom settings\n",
        this->name_.c_str(), (int)index, value);
 
    result = context_->set_index(vector_, index, value, settings);
  }
 
  return result;
}
 
int madara::knowledge::containers::NativeDoubleVector::set(
    const std::vector<type>& value)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting all elements\n",
        this->name_.c_str());
 
    context_->set(vector_, value, settings_);
  }
 
  return result;
}
 
int madara::knowledge::containers::NativeDoubleVector::set(
    const std::vector<type>& value, const KnowledgeUpdateSettings& settings)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting all elements "
        "with custom settings\n",
        this->name_.c_str());
 
    context_->set(vector_, value, settings);
  }
 
  return result;
}
 
int madara::knowledge::containers::NativeDoubleVector::set(
    const double* values, uint32_t size)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting all elements\n",
        this->name_.c_str());
 
    context_->set(vector_, values, size, settings_);
  }
 
  return result;
}
 
int madara::knowledge::containers::NativeDoubleVector::set(const double* values,
    uint32_t size, const KnowledgeUpdateSettings& settings)
{
  int result = -1;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
        "NativeDoubleVector::set: %s: setting all elements "
        "with custom settings\n",
        this->name_.c_str());
 
    context_->set(vector_, values, size, settings);
  }
 
  return result;
}
 
void madara::knowledge::containers::NativeDoubleVector::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,
        "NativeDoubleVector::set: %s: setting quality of knowledge\n",
        this->name_.c_str());
 
    context_->set_quality(name_, quality, true, settings);
  }
}
 
bool madara::knowledge::containers::NativeDoubleVector::exists(void) const
{
  bool result(false);
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    result = context_->exists(vector_);
  }
 
  return result;
}
 
std::vector<double>
madara::knowledge::containers::NativeDoubleVector::to_doubles(void) const
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::to)doubles: %s: retrieving double vector\n",
      this->name_.c_str());
 
  return context_->get(this->vector_, settings_).to_doubles();
}
 
madara::knowledge::KnowledgeRecord
madara::knowledge::containers::NativeDoubleVector::to_record(size_t index) const
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::to_record: %s: retrieving record\n",
      this->name_.c_str());
 
  madara::knowledge::KnowledgeRecord result =
      context_->get(this->vector_, settings_);
 
  result = result.retrieve_index(index);
  return result;
}
 
madara::knowledge::KnowledgeRecord
madara::knowledge::containers::NativeDoubleVector::to_record(void) const
{
  madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
      "NativeDoubleVector::to_record: %s: retrieving record\n",
      this->name_.c_str());
 
  return context_->get(this->vector_, settings_);
}
 
bool madara::knowledge::containers::NativeDoubleVector::is_true(void) const
{
  bool result(false);
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "NativeDoubleVector::is_true: %s: Checking for non-zero value\n",
      this->name_.c_str());
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    result = context_->get(vector_, settings_).is_true();
  }
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "NativeDoubleVector::is_true: %s: final result is %d\n",
      this->name_.c_str(), (int)result);
 
  return result;
}
 
bool madara::knowledge::containers::NativeDoubleVector::is_false(void) const
{
  return !is_true();
}
 
bool madara::knowledge::containers::NativeDoubleVector::is_true_(void) const
{
  return is_true();
}
 
bool madara::knowledge::containers::NativeDoubleVector::is_false_(void) const
{
  return is_false();
}