.. _program_listing_file__tmp_ws_src_log_view_include_log_view_log_filter.h:

Program Listing for File log_filter.h
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_log_view_include_log_view_log_filter.h>` (``/tmp/ws/src/log_view/include/log_view/log_filter.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #ifndef LOG_VIEW_LOG_FILTER_H_
   #define LOG_VIEW_LOG_FILTER_H_
   
   #include <array>
   #include <cstdint>
   #include <deque>
   #include <map>
   
   #include <log_view/datatypes.h>
   #include <log_view/log_store.h>
   
   namespace log_view {
   
   class LogFilter {
   public:
     explicit LogFilter(LogStorePtr& logs);
   
     void setCursorOffset(int64_t offset) { cursor_offset_ = offset; }
   
     void setFilter(const std::string& filter);
     std::string getFilterString() const { return filter_string_; }
     void setExclude(const std::string& exclude);
     void setDebugLevel(bool enable);
     void setInfoLevel(bool enable);
     void setWarnLevel(bool enable);
     void setErrorLevel(bool enable);
     void setFatalLevel(bool enable);
     void setEnableNodeFilter(bool enable);
     void toggleNode(const std::string& node);
     void selectAllNodes();
     void invertNodes();
   
     bool getDebugLevel() const { return debug_level_; }
     bool getInfoLevel() const { return info_level_; }
     bool getWarnLevel() const { return warn_level_; }
     bool getErrorLevel() const { return error_level_; }
     bool getFatalLevel() const { return fatal_level_; }
     bool getEnableNodeFilter() const { return filter_nodes_; }
   
     void reset();
     void update();
     void idleProcess();
   
     void setCursor(int64_t index);
     size_t getCursor();
   
     void clearSelect();
   
     void setSelectStart(int64_t index);
     int64_t getSelectStart();
   
     void setSelectEnd(int64_t index);
     int64_t getSelectEnd();
   
     void search(const std::string& pattern);
     void nextMatch();
     void prevMatch();
     void clearSearch();
     std::string getSearch() const { return search_; }
   
     const std::deque<LogLine>& indices() const { return log_indices_; }
     const std::map<std::string, NodeData>& nodes() const { return nodes_; }
   
     int64_t search_cursor_ = -1;
     int64_t search_cursor_fwd_ = -1;
     int64_t search_cursor_rev_ = -1;
   
   private:
     bool accepted(const LogEntry& entry, bool new_entry = false);
   
     LogStorePtr logs_;
   
     std::deque<LogLine> log_indices_;
     size_t latest_log_index_ = 0;
     size_t earliest_log_index_ = 0;
   
     int64_t cursor_ = -1;
     int64_t select_start_ = -1;
     int64_t select_end_ = -1;
   
     int64_t cursor_offset_ = 0;
   
     enum SearchDirection { SEARCH_BOTH, SEARCH_FWD, SEARCH_REV };
     std::string search_;
     int search_direction_ = SEARCH_BOTH;
   
     bool debug_level_ = true;
     bool info_level_ = true;
     bool warn_level_ = true;
     bool error_level_ = true;
     bool fatal_level_ = true;
     bool filter_nodes_ = false;
   
     std::string filter_string_;
   
     std::vector<std::string> filter_list_;
     std::vector<std::string> exclude_list_;
   
     std::map<std::string, NodeData> nodes_;
   };
   typedef std::shared_ptr<LogFilter> LogFilterPtr;
   
   }  // namespace log_view
   
   #endif  // LOG_VIEW_LOG_FILTER_H_