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 (unsigned char * source, int size, int max_size) const;

      void filter_decode (unsigned 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_