KnowledgeRecordFilters.h

Go to the documentation of this file.

 
 
#ifndef _MADARA_KNOWLEDGE_RECORD_FILTERS_H_
#define _MADARA_KNOWLEDGE_RECORD_FILTERS_H_
 
#include <string>
#include <vector>
#include <map>
#include <list>
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/Functions.h"
#include "madara/knowledge/ThreadSafeContext.h"
#include "madara/knowledge/AggregateFilter.h"
#include "madara/transport/TransportContext.h"
#include "madara/utility/StdInt.h"
#include "madara/MadaraExport.h"
#include "madara/filters/RecordFilter.h"
#include "madara/filters/AggregateFilter.h"
#include "madara/filters/BufferFilter.h"
 
#ifdef _MADARA_JAVA_
#include <jni.h>
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
#include <boost/python.hpp>
#endif
 
namespace madara
{
namespace knowledge
{
typedef std::list<Function> FilterChain;
 
typedef std::map<uint32_t, FilterChain> FilterMap;
 
class MADARA_EXPORT KnowledgeRecordFilters
{
public:
  KnowledgeRecordFilters();
 
  KnowledgeRecordFilters(const KnowledgeRecordFilters& filters);
 
  virtual ~KnowledgeRecordFilters();
 
  void operator=(const KnowledgeRecordFilters& rhs);
 
  void add(uint32_t types,
      knowledge::KnowledgeRecord (*function)(FunctionArguments&, Variables&));
 
  void add(void (*function)(
      KnowledgeMap&, const transport::TransportContext&, Variables&));
 
  void add(filters::AggregateFilter* filter);
 
  void add(filters::BufferFilter* filter);
 
  void add(uint32_t types, filters::RecordFilter* filter);
 
#ifdef _MADARA_JAVA_
 
  void add(uint32_t types, jobject& callable);
 
  void add(jobject& callable);
 
#endif
 
#ifdef _MADARA_PYTHON_CALLBACKS_
 
  void add(uint32_t types, boost::python::object& callable);
 
  void add(boost::python::object& callable);
 
#endif
 
  void attach(ThreadSafeContext* context);
 
  void clear(uint32_t types);
 
  void clear_aggregate_filters(void);
 
  void clear_buffer_filters(void);
 
  knowledge::KnowledgeRecord filter(const knowledge::KnowledgeRecord& input,
      const std::string& name, transport::TransportContext& context) const;
 
  void filter(KnowledgeMap& records,
      const transport::TransportContext& transport_context) const;
 
  void filter_encode(char* source, int size, int max_size) const;
 
  void filter_decode(char* source, int size, int max_size) const;
 
  void print_num_filters(void) const;
 
  size_t get_number_of_filtered_types(void) const;
 
  size_t get_number_of_aggregate_filters(void) const;
 
  size_t get_number_of_buffer_filters(void) const;
 
protected:
  FilterMap filters_;
 
  AggregateFilters aggregate_filters_;
 
  filters::BufferFilters buffer_filters_;
 
  ThreadSafeContext* context_;
};
}
}
 
#endif  // _MADARA_KNOWLEDGE_RECORD_FILTERS_H_