CompositeForLoop.cpp

Go to the documentation of this file.

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

#ifndef _MADARA_NO_KARL_

#include <iostream>

#include "madara/expression/ComponentNode.h"
#include "madara/expression/CompositeUnaryNode.h"
#include "madara/expression/Visitor.h"
#include "madara/expression/CompositeForLoop.h"
#include "madara/expression/LeafNode.h"
#include "madara/expression/CompositeAssignmentNode.h"



// Ctor

madara::expression::CompositeForLoop::CompositeForLoop (
       ComponentNode * precondition,
        ComponentNode * condition, 
        ComponentNode * postcondition,
        ComponentNode * body,
        madara::knowledge::ThreadSafeContext & context)
: ComponentNode (context.get_logger ()), context_(context),
    precondition_ (precondition), condition_ (condition), 
    postcondition_ (postcondition), body_ (body)
{
  
}

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

madara::knowledge::KnowledgeRecord
madara::expression::CompositeForLoop::item (void) const
{
  madara::knowledge::KnowledgeRecord record;
  record.set_value ("for (;;)");
  return record;
}

madara::knowledge::KnowledgeRecord
madara::expression::CompositeForLoop::prune (bool & can_change)
{
  // user can always change a function, and we have no control over
  // what it does. Consequently, a function node cannot be pruned out
  // under any situation
  can_change = true;
  
  madara::knowledge::KnowledgeRecord zero;
  return zero;
}

madara::knowledge::KnowledgeRecord 
madara::expression::CompositeForLoop::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
  madara_logger_ptr_log (logger_, logger::LOG_MAJOR,
    "CompositeForLoop::evaluate: Executing precondition\n");

  precondition_->evaluate (settings);

  madara::knowledge::KnowledgeRecord::Integer count = 0;
  while (condition_->evaluate (settings).is_true ())
  {
    madara_logger_ptr_log (logger_, logger::LOG_MINOR,
      "CompositeForLoop::evaluate: Executing loop body\n");

    body_->evaluate (settings);

    madara_logger_ptr_log (logger_, logger::LOG_MINOR,
      "CompositeForLoop::evaluate: Executing postcondition\n");

    postcondition_->evaluate (settings);
    ++count;
  }

  // return is the number of successful body executions
  
  madara::knowledge::KnowledgeRecord evaluations;
  evaluations.set_value (count);
  return evaluations;
}

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

#endif // _MADARA_NO_KARL_

#endif /* _FOR_LOOP_CPP_ */