KnowledgeBase.cpp

Go to the documentation of this file.

 
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/knowledge/KnowledgeBaseImpl.h"
#include "madara/logger/Logger.h"
#include "madara/utility/Utility.h"
#include "ContextGuard.h"
#include "madara/utility/EpochEnforcer.h"
 
#include <sstream>
#include <iostream>
 
namespace utility = madara::utility;
 
typedef utility::EpochEnforcer<std::chrono::steady_clock> EpochEnforcer;
 
namespace madara
{
namespace knowledge
{
  
#ifndef _MADARA_NO_KARL_
        
KnowledgeRecord
KnowledgeBase::wait(
    CompiledExpression& expression, const WaitSettings& settings)
{
  KnowledgeRecord result;
 
  if (context_)
  {
    EpochEnforcer enforcer(settings.poll_frequency, settings.max_wait_time);
 
    KnowledgeRecord last_value;
 
    // print the post statement at highest log level (cannot be masked)
    if (settings.pre_print_statement != "")
      context_->print(settings.pre_print_statement, logger::LOG_ALWAYS);
 
    {
      ContextGuard context_guard(*context_);
 
      madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
          "KnowledgeBase::wait:"
          " waiting on %s\n",
          expression.logic.c_str());
 
      last_value = expression.expression.evaluate(settings);
 
      madara_logger_log(context_->get_logger(), logger::LOG_DETAILED,
          "KnowledgeBase::wait:"
          " completed first eval to get %s\n",
          last_value.to_string().c_str());
 
      send_modifieds("KnowledgeBase:wait", settings);
    }
 
    // wait for expression to be true
    while (!last_value.to_integer() &&
           (settings.max_wait_time < 0 || !enforcer.is_done()))
    {
      madara_logger_log(context_->get_logger(), logger::LOG_DETAILED,
          "KnowledgeBase::wait:"
          " last value didn't result in success\n");
 
      // Unlike the other wait statements, we allow for a time based wait.
      // To do this, we allow a user to specify a
      if (settings.poll_frequency > 0)
      {
        enforcer.sleep_until_next();
      }
      else
        context_->wait_for_change(true);
 
      // relock - basically we need to evaluate the tree again, and
      // we can't have a bunch of people changing the variables as
      // while we're evaluating the tree.
      {
        ContextGuard context_guard(*context_);
 
        madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
            "KnowledgeBase::wait:"
            " waiting on %s\n",
            expression.logic.c_str());
 
        last_value = expression.expression.evaluate(settings);
 
        madara_logger_log(context_->get_logger(), logger::LOG_DETAILED,
            "KnowledgeBase::wait:"
            " completed eval to get %s\n",
            last_value.to_string().c_str());
 
        send_modifieds("KnowledgeBase:wait", settings);
      }
 
      context_->signal();
    }  // end while (!last)
 
    if (enforcer.is_done())
    {
      madara_logger_log(context_->get_logger(), logger::LOG_MAJOR,
          "KnowledgeBase::wait:"
          " Evaluate did not succeed. Timeout occurred\n");
    }
 
    // print the post statement at highest log level (cannot be masked)
    if (settings.post_print_statement != "")
      context_->print(settings.post_print_statement, logger::LOG_ALWAYS);
 
    return last_value;
  }
  else if (impl_.get())
  {
    result = impl_->wait(expression, settings);
  }
 
  return result;
}
#endif  // _MADARA_NO_KARL_
}
}  // namespace madara