CompositeArrayReference.cpp

Go to the documentation of this file.

 
#ifndef _MADARA_NO_KARL_
 
#include "madara/expression/Visitor.h"
#include "madara/expression/CompositeArrayReference.h"
#include "madara/utility/Utility.h"
#include "VariableExpander.h"
 
#include <string>
#include <sstream>
 
madara::expression::CompositeArrayReference::CompositeArrayReference(
    const std::string& key, ComponentNode* index,
    madara::knowledge::ThreadSafeContext& context)
  : CompositeUnaryNode(context.get_logger(), index),
    context_(context),
    key_(key),
    key_expansion_necessary_(false)
{
  VariableExpander expander;
  ref_ = expander.expand(key, "CompositeArrayReference", context, logger_,
      key_expansion_necessary_, splitters_, tokens_, pivot_list_);
}
 
std::string madara::expression::CompositeArrayReference::expand_key(void) const
{
  if (key_expansion_necessary_)
  {
    madara_logger_ptr_log(logger_, logger::LOG_DETAILED,
        "Variable %s requires variable expansion\n", key_.c_str());
 
    unsigned int count = 0;
 
    // add the first token into a string builder
    std::stringstream builder;
    std::vector<std::string>::const_iterator token = tokens_.begin();
    builder << *token;
 
    // move the token to the next in the list.
    for (++token, ++count; token != tokens_.end(); ++token, ++count)
    {
      if (*token != "")
      {
        // is the current token a variable to lookup?
        if (count < pivot_list_.size() && pivot_list_[count] == "}")
        {
          builder << context_.get_record(*token)->to_string();
        }
        else
        {
          builder << *token;
        }
      }
    }
 
    return builder.str();
  }
  // if there was no need to expand the key, just return
  // the key
  else
    return key_;
}
 
void madara::expression::CompositeArrayReference::accept(Visitor& visitor) const
{
  visitor.visit(*this);
}
 
madara::knowledge::KnowledgeRecord
madara::expression::CompositeArrayReference::item() const
{
  size_t index = right_->item().to_integer();
 
  if (ref_.is_valid())
  {
    return ref_.get_record_unsafe()->retrieve_index(index);
  }
  else
  {
    return context_.get(expand_key()).retrieve_index(index);
  }
}
 
madara::knowledge::KnowledgeRecord
madara::expression::CompositeArrayReference::prune(bool& can_change)
{
  // a variable is one of very few nodes that can change over time and
  // cannot be pruned
  can_change = true;
 
  std::string key = expand_key();
 
  if (key == "nan")
  {
    madara_logger_ptr_log(logger_, logger::LOG_DETAILED,
        "CompositeArrayReference::prune: "
        "KARL COMPILE ERROR:"
        "Reserved word 'nan' used as an array reference.\n",
        key_.c_str());
 
    // return new LeafNode (context_.get_logger (), NAN);
    throw exceptions::KarlException(
        "madara::expression::ComponentNode: "
        "KARL COMPILE ERROR: "
        "Reserved word 'nan' used as an array reference.");
  }
  else if (key == "inf")
  {
    madara_logger_ptr_log(logger_, logger::LOG_DETAILED,
        "CompositeArrayReference::prune: "
        "KARL COMPILE ERROR:"
        "Reserved word 'inf' used as an array reference.\n",
        key_.c_str());
 
    // return new LeafNode (context_.get_logger (), NAN);
    throw exceptions::KarlException(
        "madara::expression::ComponentNode: "
        "KARL COMPILE ERROR: "
        "Reserved word 'inf' used as an array reference.");
  }
 
  // we could call item(), but since it is virtual, it incurs unnecessary
  // overhead.
  if (ref_.is_valid())
    return *ref_.get_record_unsafe();
  else
    return context_.get(expand_key());
}
 
madara::knowledge::KnowledgeRecord
madara::expression::CompositeArrayReference::evaluate(
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  size_t index = right_->evaluate(settings).to_integer();
 
  if (ref_.is_valid())
  {
    auto ret = ref_.get_record_unsafe();
 
    if (settings.exception_on_unitialized && !ret->exists ())
    {
      std::stringstream buffer;
      buffer << "madara::expression::CompositeArrayReference::evaluate: ";
      buffer << "ERROR: settings do not allow reads of unset vars and ";
      buffer << ref_.get_name() << " is uninitialized";
      throw exceptions::UninitializedException (buffer.str ());
    }
 
    return ret->retrieve_index(index);
  }
  else
  {
    auto ret = context_.get(expand_key()).retrieve_index(index);
 
    if (settings.exception_on_unitialized && !ret.exists ())
    {
      std::stringstream buffer;
      buffer << "madara::expression::CompositeArrayReference::evaluate: ";
      buffer << "ERROR: settings do not allow reads of unset vars and ";
      buffer << ref_.get_name() << " is uninitialized";
      throw exceptions::UninitializedException (buffer.str ());
    }
 
    return ret;
  }
}
 
const std::string& madara::expression::CompositeArrayReference::key() const
{
  return key_;
}
 
madara::knowledge::KnowledgeRecord
madara::expression::CompositeArrayReference::dec(
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  size_t index = size_t(right_->evaluate(settings).to_integer());
 
  if (ref_.is_valid())
  {
    auto record = ref_.get_record_unsafe();
 
    // notice that we assume the context is locked
    // check if we have the appropriate write quality
    if (!settings.always_overwrite && record->write_quality < record->quality)
      return context_.retrieve_index(expand_key(), index, settings);
 
    // cheaper to read than write, so check to see if
    // we actually need to update quality and status
    if (record->write_quality != record->quality)
      record->quality = record->write_quality;
 
    knowledge::KnowledgeRecord result(record->dec_index(index));
 
    context_.mark_and_signal(ref_);
 
    return result;
  }
  else
  {
    knowledge::KnowledgeRecord result(
        context_.retrieve_index(expand_key(), index, settings) -
        knowledge::KnowledgeRecord(1));
 
    if (result.type() == knowledge::KnowledgeRecord::INTEGER)
      context_.set_index(expand_key(), index, result.to_integer(), settings);
    else if (result.type() == knowledge::KnowledgeRecord::DOUBLE)
      context_.set_index(expand_key(), index, result.to_double(), settings);
 
    return result;
  }
}
 
madara::knowledge::KnowledgeRecord
madara::expression::CompositeArrayReference::inc(
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  size_t index = size_t(right_->evaluate(settings).to_integer());
 
  if (ref_.is_valid())
  {
    auto record = ref_.get_record_unsafe();
 
    // notice that we assume the context is locked
    // check if we have the appropriate write quality
    if (!settings.always_overwrite && record->write_quality < record->quality)
      return context_.retrieve_index(expand_key(), index, settings);
 
    // cheaper to read than write, so check to see if
    // we actually need to update quality and status
    if (record->write_quality != record->quality)
      record->quality = record->write_quality;
 
    knowledge::KnowledgeRecord result(record->inc_index(index));
 
    context_.mark_and_signal(ref_);
 
    return result;
  }
  else
  {
    knowledge::KnowledgeRecord result =
        context_.retrieve_index(expand_key(), index, settings) +
        knowledge::KnowledgeRecord(1);
 
    if (result.type() == knowledge::KnowledgeRecord::INTEGER)
      context_.set_index(expand_key(), index, result.to_integer(), settings);
    else if (result.type() == knowledge::KnowledgeRecord::DOUBLE)
      context_.set_index(expand_key(), index, result.to_double(), settings);
 
    return result;
  }
}
 
int madara::expression::CompositeArrayReference::set(
    const madara::knowledge::KnowledgeRecord& value,
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  int return_value = 0;
 
  if (value.type() == knowledge::KnowledgeRecord::INTEGER)
    return_value = set(value.to_integer(), settings);
  else if (value.type() == knowledge::KnowledgeRecord::DOUBLE)
    return_value = set(value.to_double(), settings);
 
  return return_value;
}
 
int madara::expression::CompositeArrayReference::set(
    const madara::knowledge::KnowledgeRecord::Integer& value,
    const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  size_t index = size_t(right_->evaluate(settings).to_integer());
 
  if (ref_.is_valid())
  {
    auto record = ref_.get_record_unsafe();
 
    // notice that we assume the context is locked
    // check if we have the appropriate write quality
    if (!settings.always_overwrite && record->write_quality < record->quality)
      return -2;
 
    // cheaper to read than write, so check to see if
    // we actually need to update quality and status
    if (record->write_quality != record->quality)
      record->quality = record->write_quality;
 
    record->set_index(index, value);
 
    context_.mark_and_signal(ref_);
 
    return 0;
  }
  else
    return context_.set_index(expand_key(), index, value, settings);
}
 
int madara::expression::CompositeArrayReference::set(
    double value, const madara::knowledge::KnowledgeUpdateSettings& settings)
{
  size_t index = size_t(right_->evaluate(settings).to_integer());
 
  if (ref_.is_valid())
  {
    auto record = ref_.get_record_unsafe();
 
    // notice that we assume the context is locked
    // check if we have the appropriate write quality
    if (!settings.always_overwrite && record->write_quality < record->quality)
      return -2;
 
    // cheaper to read than write, so check to see if
    // we actually need to update quality and status
    if (record->write_quality != record->quality)
      record->quality = record->write_quality;
 
    record->set_index(index, value);
 
    context_.mark_and_signal(ref_);
 
    return 0;
  }
  else
    return context_.set_index(expand_key(), index, value, settings);
}
 
#endif  // _MADARA_NO_KARL_