private bool matches_case_insensitive(line l) { Debug.Assert(part != part_type.font); string line_part = this.line_part(l).ToLower(); return(compare(line_part, lo_text, lo_words)); }
private line parse_relative_line(string l, ulong pos_in_log) { List <Tuple <int, int> > indexes = new List <Tuple <int, int> >(); for (int i = 0; i < (int)info_type.max; ++i) { indexes.Add(new Tuple <int, int>(-1, -1)); } int cur_idx = 0; int correct_count = 0; foreach (var rel in relative_idx_in_line_) { if (cur_idx < 0) { break; } var index = parse_relative_part(l, rel, ref cur_idx); if (index.Item1 >= 0 && index.Item2 >= 0) { indexes[(int)rel.type] = index; ++correct_count; } } // if we could parse time or date, we consider it an OK line bool normal_line = correct_count == relative_idx_in_line_.Count; line new_ = new line(pos_in_log, l, normal_line ? indexes.ToArray() : line_contains_msg_only_); return(new_); }
private string line_part(line l) { string sub = ""; switch (part) { case part_type.date: sub = l.part(info_type.date); break; case part_type.time: sub = l.part(info_type.time); break; case part_type.level: sub = l.part(info_type.level); break; case part_type.message: sub = l.part(info_type.msg); break; case part_type.file: sub = l.part(info_type.file); break; case part_type.func: sub = l.part(info_type.func); break; case part_type.class_: sub = l.part(info_type.class_); break; case part_type.ctx1: sub = l.part(info_type.ctx1); break; case part_type.ctx2: sub = l.part(info_type.ctx2); break; case part_type.ctx3: sub = l.part(info_type.ctx3); break; case part_type.thread: sub = l.part(info_type.thread); break; default: Debug.Assert(false); break; } return(sub); }
public override line line_at(int idx) { lock (this) { if (idx < entries_.Count) { var entry = entries_[idx]; var l = new line( new sub_string(string_, idx), entry.idx_in_line(aliases), entry.time ); return l; } else { // this can happen, when the log has been re-written, and everything is being refreshed throw new line.exception("invalid line request " + idx + " / " + entries_.Count); } } }
private line parse_line(string l, ulong pos_in_log) { if (relative_syntax_) { return(parse_relative_line(l, pos_in_log)); } try { bool normal_line = parse_time(l, idx_in_line_[(int)info_type.time]) && parse_date(l, idx_in_line_[(int)info_type.date]); if (idx_in_line_[(int)info_type.time].Item1 < 0 && idx_in_line_[(int)info_type.date].Item1 < 0) { // in this case, we don't have time & date - see that the level matches // note: we can't rely on level too much, since the user might have additional levels that our defaults - so we could get false negatives normal_line = parse_level(l, idx_in_line_[(int)info_type.level]); } line new_ = new line(pos_in_log, l, normal_line ? idx_in_line_ : line_contains_msg_only_); return(new_); } catch (Exception e) { logger.Error("invalid line: " + l); return(new line(pos_in_log, l, line_contains_msg_only_)); } }
public match_item(BitArray matches, font_info font, line line, int line_idx, log_view parent) : base(matches, font, line, line_idx) { }
public bool matches(line l) { return(case_sensitive ? matches_case_sensitive(l) : matches_case_insensitive(l)); }
private line parse_relative_line(string l, ulong pos_in_log) { List< Tuple<int,int> > indexes = new List<Tuple<int, int>>(); for ( int i = 0; i < (int)info_type.max; ++i) indexes.Add(new Tuple<int,int>(-1,-1)); int cur_idx = 0; int correct_count = 0; foreach (var rel in relative_idx_in_line_) { if (cur_idx < 0) break; var index = parse_relative_part(l, rel, ref cur_idx); if (index.Item1 >= 0 && index.Item2 >= 0) { indexes[(int) rel.type] = index; ++correct_count; } } // if we could parse time or date, we consider it an OK line bool normal_line = correct_count == relative_idx_in_line_.Count; line new_ = new line(pos_in_log, l, normal_line ? indexes.ToArray() : line_contains_msg_only_); return new_; }
private line parse_line(string l, ulong pos_in_log) { if (relative_syntax_) return parse_relative_line(l, pos_in_log); try { bool normal_line = parse_time(l, idx_in_line_[(int) info_type.time]) && parse_date(l, idx_in_line_[(int) info_type.date]); if (idx_in_line_[(int) info_type.time].Item1 < 0 && idx_in_line_[(int) info_type.date].Item1 < 0) // in this case, we don't have time & date - see that the level matches // note: we can't rely on level too much, since the user might have additional levels that our defaults - so we could get false negatives normal_line = parse_level(l, idx_in_line_[(int) info_type.level]); line new_ = new line(pos_in_log, l, normal_line ? idx_in_line_ : line_contains_msg_only_); return new_; } catch(Exception e) { logger.Error("invalid line: " + l); return new line(pos_in_log, l, line_contains_msg_only_); } }
private bool matches_case_sensitive(line l) { Debug.Assert( part != part_type.font ); string line_part = this.line_part(l); return compare(line_part, text, words); }
private bool matches_case_insensitive(line l) { Debug.Assert( part != part_type.font ); string line_part = this.line_part(l).ToLower(); return compare(line_part, lo_text, lo_words); }
private string line_part(line l) { string sub = ""; switch (part) { case part_type.date: sub = l.part(info_type.date); break; case part_type.time: sub = l.part(info_type.time); break; case part_type.level: sub = l.part(info_type.level); break; case part_type.message: sub = l.part(info_type.msg); break; case part_type.file: sub = l.part(info_type.file); break; case part_type.func: sub = l.part(info_type.func); break; case part_type.class_: sub = l.part(info_type.class_); break; case part_type.ctx1: sub = l.part(info_type.ctx1); break; case part_type.ctx2: sub = l.part(info_type.ctx2); break; case part_type.ctx3: sub = l.part(info_type.ctx3); break; case part_type.thread: sub = l.part(info_type.thread); break; default: Debug.Assert(false); break; } return sub; }
public bool matches(line l) { return case_sensitive ? matches_case_sensitive(l) : matches_case_insensitive(l); }