Double.cpp

Go to the documentation of this file.

#include "Double.h"
#include "madara/knowledge/ContextGuard.h"
 
madara::knowledge::containers::Double::Double(
    const KnowledgeUpdateSettings& settings)
  : BaseContainer("", settings), context_(0)
{
}
 
madara::knowledge::containers::Double::Double(const std::string& name,
    KnowledgeBase& knowledge, const KnowledgeUpdateSettings& settings)
  : BaseContainer(name, settings), context_(&(knowledge.get_context()))
{
  variable_ = knowledge.get_ref(name, settings_);
}
 
madara::knowledge::containers::Double::Double(const std::string& name,
    Variables& knowledge, const KnowledgeUpdateSettings& settings)
  : BaseContainer(name, settings), context_(knowledge.get_context())
{
  variable_ = knowledge.get_ref(name, settings_);
}
 
madara::knowledge::containers::Double::Double(const std::string& name,
    KnowledgeBase& knowledge, type value,
    const KnowledgeUpdateSettings& settings)
  : BaseContainer(name, settings), context_(&(knowledge.get_context()))
{
  variable_ = knowledge.get_ref(name);
  context_->set(variable_, value, settings);
}
 
madara::knowledge::containers::Double::Double(const std::string& name,
    Variables& knowledge, type value, const KnowledgeUpdateSettings& settings)
  : BaseContainer(name, settings), context_(knowledge.get_context())
{
  variable_ = knowledge.get_ref(name);
  context_->set(variable_, value, settings);
}
 
madara::knowledge::containers::Double::Double(const Double& rhs)
  : BaseContainer(rhs), context_(rhs.context_), variable_(rhs.variable_)
{
}
 
madara::knowledge::containers::Double::~Double() {}
 
void madara::knowledge::containers::Double::modify(void)
{
  ContextGuard context_guard(*context_);
  if (context_ && name_ != "")
  {
    context_->mark_modified(variable_);
  }
}
 
std::string madara::knowledge::containers::Double::get_debug_info(void)
{
  std::stringstream result;
 
  result << "Double: ";
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    result << this->name_;
    result << " = " << context_->get(variable_).to_string();
  }
 
  return result.str();
}
 
void madara::knowledge::containers::Double::modify_(void)
{
  modify();
}
 
std::string madara::knowledge::containers::Double::get_debug_info_(void)
{
  return get_debug_info();
}
 
madara::knowledge::containers::BaseContainer*
madara::knowledge::containers::Double::clone(void) const
{
  return new Double(*this);
}
 
void madara::knowledge::containers::Double::operator=(const Double& rhs)
{
  if (this != &rhs)
  {
    MADARA_GUARD_TYPE guard(mutex_), guard2(rhs.mutex_);
 
    this->context_ = rhs.context_;
    this->name_ = rhs.name_;
    this->settings_ = rhs.settings_;
    this->variable_ = rhs.variable_;
  }
}
 
void madara::knowledge::containers::Double::exchange(containers::Double& 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);
 
    type temp = *other;
    other = **this;
    *this = temp;
  }
}
 
void madara::knowledge::containers::Double::set_name(
    const std::string& var_name, KnowledgeBase& knowledge)
{
  KnowledgeUpdateSettings keep_local(true);
  context_ = &(knowledge.get_context());
 
  ContextGuard context_guard(*context_);
  MADARA_GUARD_TYPE guard(mutex_);
 
  name_ = var_name;
  variable_ = context_->get_ref(name_, keep_local);
}
 
void madara::knowledge::containers::Double::set_name(
    const std::string& var_name, Variables& knowledge)
{
  KnowledgeUpdateSettings keep_local(true);
  context_ = knowledge.get_context();
 
  ContextGuard context_guard(*context_);
  MADARA_GUARD_TYPE guard(mutex_);
 
  name_ = var_name;
  variable_ = context_->get_ref(name_, keep_local);
}
 
void madara::knowledge::containers::Double::set_name(
    const std::string& var_name, ThreadSafeContext& knowledge)
{
  KnowledgeUpdateSettings keep_local(true);
  context_ = &knowledge;
 
  ContextGuard context_guard(*context_);
  MADARA_GUARD_TYPE guard(mutex_);
 
  name_ = var_name;
  variable_ = context_->get_ref(name_, keep_local);
}
 
madara::knowledge::containers::Double::type
madara::knowledge::containers::Double::operator=(type value)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    context_->set(variable_, value, settings_);
  }
 
  return value;
}
 
madara::knowledge::containers::Double::type
madara::knowledge::containers::Double::operator+=(type value)
{
  madara::knowledge::containers::Double::type result(0);
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    result = context_->get(variable_, settings_).to_double();
    result += value;
    context_->set(variable_, result, settings_);
  }
 
  return result;
}
 
madara::knowledge::containers::Double::type
madara::knowledge::containers::Double::operator-=(type value)
{
  madara::knowledge::containers::Double::type result(0);
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
 
    result = context_->get(variable_, settings_).to_double();
    result -= value;
    context_->set(variable_, result, settings_);
  }
 
  return result;
}
madara::knowledge::containers::Double::type
    madara::knowledge::containers::Double::operator++(void)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->inc(variable_, settings_).to_double();
  }
  else
    return 0;
}
 
madara::knowledge::containers::Double::type
    madara::knowledge::containers::Double::operator--(void)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->dec(variable_, settings_).to_double();
  }
  else
    return 0;
}
 
bool madara::knowledge::containers::Double::operator==(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() == value;
  }
 
  return false;
}
 
bool madara::knowledge::containers::Double::operator!=(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() != value;
  }
 
  return true;
}
 
bool madara::knowledge::containers::Double::operator==(
    const Double& value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_) ==
           value.context_->get(value.variable_, value.settings_);
  }
 
  return false;
}
 
bool madara::knowledge::containers::Double::operator!=(
    const Double& value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_) !=
           value.context_->get(value.variable_, value.settings_);
  }
 
  return true;
}
 
bool madara::knowledge::containers::Double::operator<(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() < value;
  }
 
  return false;
}
 
bool madara::knowledge::containers::Double::operator<=(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() <= value;
  }
 
  return false;
}
 
bool madara::knowledge::containers::Double::operator>(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() > value;
  }
 
  return false;
}
 
bool madara::knowledge::containers::Double::operator>=(type value) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double() >= value;
  }
 
  return false;
}
 
madara::knowledge::containers::Double::type
    madara::knowledge::containers::Double::operator*(void)const
{
  return to_double();
}
 
bool madara::knowledge::containers::Double::exists(void) const
{
  bool result(false);
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    result = context_->exists(variable_);
  }
 
  return result;
}
 
madara::knowledge::KnowledgeRecord
madara::knowledge::containers::Double::to_record(void) const
{
  madara::knowledge::KnowledgeRecord result;
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    result = context_->get(variable_, settings_);
  }
 
  return result;
}
 
double madara::knowledge::containers::Double::to_double(void) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_double();
  }
  else
    return 0.0;
}
 
madara::knowledge::KnowledgeRecord::Integer
madara::knowledge::containers::Double::to_integer(void) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_integer();
  }
  else
    return 0;
}
 
std::string madara::knowledge::containers::Double::to_string(void) const
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    return context_->get(variable_, settings_).to_string();
  }
  else
    return "";
}
 
void madara::knowledge::containers::Double::set_quality(
    uint32_t quality, const KnowledgeReferenceSettings& settings)
{
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    context_->set_quality(name_, quality, true, settings);
  }
}
 
bool madara::knowledge::containers::Double::is_true(void) const
{
  bool result(false);
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "Double::is_true: checking for non-zero value\n", (int)result);
 
  if (context_)
  {
    ContextGuard context_guard(*context_);
    MADARA_GUARD_TYPE guard(mutex_);
    result = context_->get(variable_, settings_).is_true();
  }
 
  madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
      "Double::is_true: final result is %d\n", (int)result);
 
  return result;
}
 
bool madara::knowledge::containers::Double::is_false(void) const
{
  return !is_true();
}
 
bool madara::knowledge::containers::Double::is_true_(void) const
{
  return is_true();
}
 
bool madara::knowledge::containers::Double::is_false_(void) const
{
  return is_false();
}