timelinesearch.h

Go to the documentation of this file.

#ifndef ION_PROFILE_TIMELINESEARCH_H_
#define ION_PROFILE_TIMELINESEARCH_H_

#include <string>

#include "ion/port/threadutils.h"
#include "ion/profile/timeline.h"
#include "ion/profile/timelineevent.h"
#include "ion/profile/timelinenode.h"
#include "ion/profile/timelinethread.h"

typedef std::function<bool(const TimelineNode*)> Predicate;

class TimelineSearch {
 public:
  TimelineSearch(const Timeline& timeline, TimelineNode::Type node_type);
  TimelineSearch(const Timeline& timeline, TimelineNode::Type node_type,
                 const std::string& node_name);
  TimelineSearch(const Timeline& timeline, TimelineNode::Type node_type,
                 uint32 begin, uint32 end);
  TimelineSearch(const Timeline& timeline, TimelineNode::Type node_type,
                 const std::string& node_name, uint32 begin, uint32 end);
  TimelineSearch(const Timeline& timeline,
                 const ion::port::ThreadId& thread_id);
  TimelineSearch(const Timeline& timeline, const Predicate& predicate);

  class const_iterator {
   public:
    const_iterator(Timeline::const_iterator iter, const TimelineSearch* search);
    const TimelineNode* operator*() const { return *iter_; }
    const_iterator operator++();
    bool operator==(const const_iterator& other) const;
    bool operator!=(const const_iterator& other) const;

   private:
    Timeline::const_iterator iter_;
    const TimelineSearch* search_results_;
  };

  const Predicate& predicate() const { return predicate_; }
  const Timeline& timeline() const { return timeline_; }
  bool empty() const { return begin() == end(); }
  const_iterator begin() const;
  const_iterator end() const;

 private:
  const Timeline& timeline_;
  Predicate predicate_;
};

inline TimelineSearch::const_iterator TimelineSearch::const_iterator::
operator++() {
  do {
    ++iter_;
  } while (iter_ != search_results_->timeline().end() &&
           !search_results_->predicate()(*iter_));
  return *this;
}

inline TimelineSearch::const_iterator::const_iterator(
    Timeline::const_iterator iter, const TimelineSearch* search_results)
    : iter_(iter), search_results_(search_results) {}

inline bool TimelineSearch::const_iterator::operator==(
    const const_iterator& other) const {
  return (iter_ == other.iter_) && (search_results_ == other.search_results_);
}

inline bool TimelineSearch::const_iterator::operator!=(
    const const_iterator& other) const {
  return !(*this == other);
}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      TimelineNode::Type node_type)
    : timeline_(timeline),
      predicate_([node_type](const TimelineNode* node) {
        return node->GetType() == node_type;
      }) {}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      TimelineNode::Type node_type,
                                      const std::string& node_name)
    : timeline_(timeline),
      predicate_([node_type, node_name](const TimelineNode* node) {
        return node->GetType() == node_type && node->GetName() == node_name;
      }) {}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      TimelineNode::Type node_type,
                                      uint32 begin, uint32 end)
    : timeline_(timeline),
      predicate_([node_type, begin, end](const TimelineNode* node) {
        return node->GetType() == node_type && node->GetBegin() >= begin &&
               node->GetEnd() <= end;
      }) {}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      TimelineNode::Type node_type,
                                      const std::string& node_name,
                                      uint32 begin, uint32 end)
    : timeline_(timeline),
      predicate_([node_type, node_name, begin, end](const TimelineNode* node) {
        return node->GetType() == node_type && node->GetName() == node_name &&
               node->GetBegin() >= begin && node->GetEnd() <= end;
      }) {}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      const ion::port::ThreadId& thread_id)
    : timeline_(timeline),
      predicate_([thread_id](const TimelineNode* node) {
        if (node->GetType() != TimelineNode::Type::kThread) return false;
        const TimelineThread* thread = static_cast<const TimelineThread*>(node);
        return thread->GetThreadId() == thread_id;
      }) {}

inline TimelineSearch::TimelineSearch(const Timeline& timeline,
                                      const Predicate& predicate)
    : timeline_(timeline), predicate_(predicate) {}

inline TimelineSearch::const_iterator TimelineSearch::begin() const {
  auto iter = timeline_.begin();
  while (iter != timeline_.end() && !predicate_(*iter)) {
    ++iter;
  }
  return const_iterator(iter, this);
}

inline TimelineSearch::const_iterator TimelineSearch::end() const {
  return const_iterator(timeline_.end(), this);
}

#endif  // ION_PROFILE_TIMELINESEARCH_H_