AggregateFilter.h

Go to the documentation of this file.

 
#ifndef _MADARA_AGGREGATE_FILTERS_H_
#define _MADARA_AGGREGATE_FILTERS_H_
 
#include <list>
#include <string>
#include "madara/MadaraExport.h"
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/Variables.h"
#include "madara/transport/TransportContext.h"
#include "madara/filters/AggregateFilter.h"
 
#ifdef _MADARA_JAVA_
#include <jni.h>
#include "madara_jni.h"
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
#include <boost/python.hpp>
#endif
 
namespace madara
{
namespace knowledge
{
class MADARA_EXPORT AggregateFilter
{
public:
  enum Types
  {
    UNINITIALIZED = 0,
    EXTERN_UNNAMED = 1,
    EXTERN_NAMED = 2,
    PYTHON_CALLABLE = 3,
    JAVA_CALLABLE = 4,
    FUNCTOR = 5
  };
 
  AggregateFilter() : unnamed_filter(0), functor(0), type(UNINITIALIZED) {}
 
  AggregateFilter(void (*extern_func)(
      KnowledgeMap&, const transport::TransportContext&, Variables&))
    : unnamed_filter(extern_func), functor(0), type(EXTERN_UNNAMED)
  {
  }
 
  AggregateFilter(filters::AggregateFilter* filter)
    : unnamed_filter(0), functor(filter), type(FUNCTOR)
  {
  }
 
#ifdef _MADARA_JAVA_
  jobject java_object;
 
  AggregateFilter(jobject& object) : type(JAVA_CALLABLE)
  {
    // We have to create a globla ref to the object or we cant call it
    JNIEnv* env = madara_jni_get_env();
    java_object = (jobject)env->NewGlobalRef(object);
  }
 
  bool is_java_callable(void) const
  {
    return type == JAVA_CALLABLE;
  }
 
    // KnowledgeRecord call_java(KnowledgeMap & recordsMap, const
    // transport::TransportContext & context, Variables & vars) const
    //{
    //  return knowledge::KnowledgeRecord ();
    //}
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
  AggregateFilter(boost::python::object& func)
    : python_function(func), type(PYTHON_CALLABLE)
  {
    // Check to make sure its a callable object
    if (0 == PyObject_HasAttrString(func.ptr(), "__call__"))
    {
      // If not, lets throw an exception to warn the user
      PyErr_SetString(PyExc_TypeError, "Handler must be a callable object");
 
      boost::python::throw_error_already_set();
    }
  }
 
  bool is_python_callable(void) const
  {
    return type == PYTHON_CALLABLE && !python_function.is_none();
  }
 
  boost::python::object python_function;
#endif
 
  inline bool is_extern_unnamed(void) const
  {
    return type == EXTERN_UNNAMED && unnamed_filter;
  }
 
  inline bool is_extern_named(void) const
  {
    return type == EXTERN_NAMED && named_filter;
  }
 
  inline bool is_functor(void) const
  {
    return type == FUNCTOR;
  }
 
  bool is_uninitialized(void) const
  {
    return type == UNINITIALIZED;
  }
 
  void (*unnamed_filter)(
      KnowledgeMap&, const transport::TransportContext&, Variables&);
 
  void (*named_filter)(const char*, KnowledgeMap&,
      const transport::TransportContext&, Variables&);
 
  filters::AggregateFilter* functor;
 
  // type of function definition
  int type;
};
 
typedef std::list<AggregateFilter> AggregateFilters;
}
}
 
#endif  // _MADARA_AGGREGATE_FILTERS_H_