CompositeConstArray.cpp

Go to the documentation of this file.

/* -*- C++ -*- */
#ifndef _FUNCTION_NODE_CPP_
#define _FUNCTION_NODE_CPP_

#ifndef _MADARA_NO_KARL_

#include <iostream>
#include <sstream>

#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/expression/ComponentNode.h"
#include "madara/expression/CompositeUnaryNode.h"
#include "madara/expression/Visitor.h"
#include "madara/expression/CompositeConstArray.h"
#include "madara/expression/LeafNode.h"


#include "madara/knowledge/Functions.h"
#include "madara/knowledge/ExternFunctionVariables.h"

#ifdef _MADARA_PYTHON_CALLBACKS_

  #include <boost/python/call.hpp> 

#endif

#ifdef _MADARA_JAVA_

#include "madara_jni.h"

#endif

// Ctor

madara::expression::CompositeConstArray::CompositeConstArray (
  logger::Logger & logger, 
  const ComponentNodes & nodes)
: madara::expression::CompositeTernaryNode (logger, nodes)
{
  
}

// Dtor
madara::expression::CompositeConstArray::~CompositeConstArray (void)
{
}

madara::knowledge::KnowledgeRecord
madara::expression::CompositeConstArray::item (void) const
{
  madara::knowledge::KnowledgeRecord record;
  return record;
}

madara::knowledge::KnowledgeRecord
madara::expression::CompositeConstArray::prune (bool & can_change)
{
  can_change = false;
  
  knowledge::KnowledgeRecord result;
  madara::knowledge::FunctionArguments args;
  args.resize (nodes_.size ());

  bool is_double (false);
  ComponentNodes::size_type i = 0;

  for (; i < nodes_.size (); ++i)
  {
    bool arg_can_change = false;
    args[i] = nodes_[i]->prune (arg_can_change);

    // we cannot initialize the array until we know if there are any doubles
    if (args[i].type () == knowledge::KnowledgeRecord::DOUBLE)
    {
      is_double = true;
    }

    if (!arg_can_change && dynamic_cast <LeafNode *> (nodes_[i]) == 0)
    {
      delete nodes_[i];
      nodes_[i] = new LeafNode (*(this->logger_), result);
    }
    else if (arg_can_change)
    {
      can_change = true;
    }
  }
  
  // if we are looking at a static const array, then leafize it
  if (i > 0)
  {
    result.clear_value ();

    if (is_double)
      result.set_index (i - 1, args[i - 1].to_double ());
    else
      result.set_index (i - 1, args[i - 1].to_integer ());

    for (i = 0; i < args.size () - 1; ++i)
    {
      if (is_double)
        result.set_index (i, args[i].to_double ());
      else
        result.set_index (i, args[i].to_integer ());
    }
  }
  else
  {
    madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
      "KARL COMPILE ERROR: Array initialized with no elements\n");
  }

  return result;
}

madara::knowledge::KnowledgeRecord 
madara::expression::CompositeConstArray::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
  madara::knowledge::FunctionArguments args;
  madara::knowledge::KnowledgeRecord result;

  args.resize (nodes_.size ());

  bool is_double (false);

  int j = 0;

  for (ComponentNodes::iterator i = nodes_.begin (); i != nodes_.end ();
       ++i, ++j)
  {
    args[j] = (*i)->evaluate (settings);

    // we cannot initialize the array until we know if there are any doubles
    if (args[j].type () == knowledge::KnowledgeRecord::DOUBLE)
    {
      is_double = true;
    }
    else if (args[j].type () != knowledge::KnowledgeRecord::INTEGER)
    {
      args[j] = knowledge::KnowledgeRecord ((*i)->evaluate (settings).to_integer ());
    }
  }

  // check if we have any args or if this was a poorly done array
  if (args.size () > 0)
  {
    // set last element first so there is only one resize
    if (is_double)
      result.set_index (j - 1, args[j - 1].to_double ());
    else
      result.set_index (j - 1, args[j - 1].to_integer ());

    for (size_t i = 0; i < args.size () - 1; ++i)
    {
      if (is_double)
        result.set_index (i, args[i].to_double ());
      else
        result.set_index (i, args[i].to_integer ());
    }
  }

  return result;
}

// accept a visitor
void 
madara::expression::CompositeConstArray::accept (Visitor &visitor) const
{
  visitor.visit (*this);
}

#endif // _MADARA_NO_KARL_

#endif /* _FUNCTION_NODE_CPP_ */