SYMBOL INDEX (473 symbols across 21 files)

FILE: imdb-eval/src/eval.rs
  constant TRUTH_DATA (line 18) | const TRUTH_DATA: &str = include_str!("../../data/eval/truth.toml");
  type Truth (line 29) | struct Truth {
    method from_path (line 45) | fn from_path<P: AsRef<Path>>(path: P) -> anyhow::Result<Truth> {
  type Task (line 38) | struct Task {
  type Spec (line 72) | pub struct Spec {
    method new (line 82) | pub fn new() -> Spec {
    method with_result_size (line 95) | pub fn with_result_size(
    method with_ngram_size (line 112) | pub fn with_ngram_size(
    method with_ngram_type (line 127) | pub fn with_ngram_type(mut self, ngram_type: NgramType) -> Spec {
    method with_similarity (line 133) | pub fn with_similarity(mut self, sim: Similarity) -> Spec {
    method with_scorer (line 143) | pub fn with_scorer(mut self, scorer: Option<NameScorer>) -> Spec {
    method evaluate (line 149) | pub fn evaluate<P1: AsRef<Path>, P2: AsRef<Path>>(
    method evaluate_with (line 163) | pub fn evaluate_with<P1: AsRef<Path>, P2: AsRef<Path>, P3: AsRef<Path>>(
    method query (line 178) | fn query(&self, task: &Task) -> Query {
    method index (line 190) | fn index<P1: AsRef<Path>, P2: AsRef<Path>>(
    method index_dir (line 208) | fn index_dir<P: AsRef<Path>>(&self, eval_dir: P) -> PathBuf {
    method index_name (line 217) | fn index_name(&self) -> String {
    method fmt (line 229) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 223) | fn default() -> Spec {
  type Summary (line 270) | pub struct Summary {
    method from_task_results (line 284) | pub fn from_task_results(results: &[TaskResult]) -> Vec<Summary> {
    method from_same_task_results (line 300) | fn from_same_task_results(results: &[&TaskResult]) -> Summary {
  type TaskResult (line 322) | pub struct TaskResult {
  type Evaluation (line 352) | pub struct Evaluation<'s> {
  type Item (line 360) | type Item = anyhow::Result<TaskResult>;
  method next (line 362) | fn next(&mut self) -> Option<anyhow::Result<TaskResult>> {
  type Evaluator (line 371) | struct Evaluator<'s> {
  function run (line 381) | fn run(&mut self, task: &Task) -> anyhow::Result<TaskResult> {
  function rank (line 440) | fn rank(&mut self, task: &Task) -> anyhow::Result<Option<u64>> {
  function approx_eq (line 467) | fn approx_eq(x1: f64, x2: f64) -> bool {
  function fractional_seconds (line 475) | fn fractional_seconds(d: &Duration) -> f64 {
  function spec_printer (line 487) | fn spec_printer() {

FILE: imdb-eval/src/logger.rs
  function init (line 11) | pub fn init() -> Result<()> {
  type Logger (line 20) | struct Logger(());
    method init (line 28) | fn init() -> std::result::Result<(), log::SetLoggerError> {
  constant LOGGER (line 22) | const LOGGER: &'static Logger = &Logger(());
  method enabled (line 34) | fn enabled(&self, _: &log::Metadata) -> bool {
  method log (line 40) | fn log(&self, record: &log::Record) {
  method flush (line 47) | fn flush(&self) {
  function should_log (line 52) | fn should_log(record: &log::Record) -> bool {

FILE: imdb-eval/src/main.rs
  function main (line 16) | fn main() {
  function try_main (line 28) | fn try_main() -> anyhow::Result<()> {
  function run_eval (line 61) | fn run_eval(
  function run_summarize (line 90) | fn run_summarize(summarize: &Path) -> anyhow::Result<()> {
  type Args (line 106) | struct Args {
    method from_matches (line 122) | fn from_matches(matches: &clap::ArgMatches) -> anyhow::Result<Args> {
    method specs (line 169) | fn specs(&self) -> anyhow::Result<Vec<Spec>> {
  function app (line 202) | fn app() -> clap::App<'static, 'static> {
  type OptionalNameScorer (line 309) | struct OptionalNameScorer(Option<NameScorer>);
    method from (line 323) | fn from(scorer: NameScorer) -> OptionalNameScorer {
  type Err (line 312) | type Err = imdb_index::Error;
  method from_str (line 314) | fn from_str(
  function parse_many_lossy (line 329) | fn parse_many_lossy<
  function is_pipe_error (line 350) | fn is_pipe_error(err: &anyhow::Error) -> bool {

FILE: imdb-index/src/error.rs
  type Result (line 5) | pub type Result<T> = std::result::Result<T, Error>;
  type Error (line 9) | pub struct Error {
    method kind (line 15) | pub fn kind(&self) -> &ErrorKind {
    method into_kind (line 20) | pub fn into_kind(self) -> ErrorKind {
    method new (line 24) | pub(crate) fn new(kind: ErrorKind) -> Error {
    method unknown_title (line 28) | pub(crate) fn unknown_title<T: AsRef<str>>(unk: T) -> Error {
    method unknown_scorer (line 32) | pub(crate) fn unknown_scorer<T: AsRef<str>>(unk: T) -> Error {
    method unknown_ngram_type (line 36) | pub(crate) fn unknown_ngram_type<T: AsRef<str>>(unk: T) -> Error {
    method unknown_sim (line 40) | pub(crate) fn unknown_sim<T: AsRef<str>>(unk: T) -> Error {
    method unknown_directive (line 44) | pub(crate) fn unknown_directive<T: AsRef<str>>(unk: T) -> Error {
    method bug (line 48) | pub(crate) fn bug<T: AsRef<str>>(msg: T) -> Error {
    method config (line 52) | pub(crate) fn config<T: AsRef<str>>(msg: T) -> Error {
    method version (line 56) | pub(crate) fn version(expected: u64, got: u64) -> Error {
    method csv (line 60) | pub(crate) fn csv(err: csv::Error) -> Error {
    method fst (line 64) | pub(crate) fn fst(err: fst::Error) -> Error {
    method io (line 68) | pub(crate) fn io(err: std::io::Error) -> Error {
    method io_path (line 72) | pub(crate) fn io_path<P: AsRef<Path>>(
    method number (line 84) | pub(crate) fn number<E: std::error::Error + Send + Sync + 'static>(
    method source (line 92) | fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
    method fmt (line 102) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ErrorKind (line 109) | pub enum ErrorKind {
    method fmt (line 172) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

FILE: imdb-index/src/index/aka.rs
  constant AKAS (line 18) | const AKAS: &str = "akas.fst";
  type Index (line 26) | pub struct Index {
    method open (line 35) | pub fn open<P1: AsRef<Path>, P2: AsRef<Path>>(
    method create (line 49) | pub fn create<P1: AsRef<Path>, P2: AsRef<Path>>(
    method find (line 72) | pub fn find(&mut self, id: &[u8]) -> Result<AKARecordIter> {
  type AKARecordIter (line 97) | pub struct AKARecordIter<'r>(
  type Item (line 102) | type Item = Result<AKA>;
  method next (line 104) | fn next(&mut self) -> Option<Result<AKA>> {
  type AKAIndexRecord (line 121) | struct AKAIndexRecord {
  type AKAIndexRecords (line 136) | struct AKAIndexRecords<R> {
  function new (line 147) | fn new(rdr: csv::Reader<R>) -> AKAIndexRecords<R> {
  type Item (line 153) | type Item = Result<AKAIndexRecord>;
  method next (line 160) | fn next(&mut self) -> Option<Result<AKAIndexRecord>> {
  function aka_index_records1 (line 205) | fn aka_index_records1() {
  function aka_index_records2 (line 245) | fn aka_index_records2() {
  function aka_index_records3 (line 277) | fn aka_index_records3() {
  function aka_index_records4 (line 297) | fn aka_index_records4() {

FILE: imdb-index/src/index/episode.rs
  constant SEASONS (line 23) | const SEASONS: &str = "episode.seasons.fst";
  constant TVSHOWS (line 34) | const TVSHOWS: &str = "episode.tvshows.fst";
  type Index (line 39) | pub struct Index {
    method open (line 46) | pub fn open<P: AsRef<Path>>(index_dir: P) -> Result<Index> {
    method create (line 58) | pub fn create<P1: AsRef<Path>, P2: AsRef<Path>>(
    method seasons (line 97) | pub fn seasons(&self, tvshow_id: &[u8]) -> Result<Vec<Episode>> {
    method episodes (line 115) | pub fn episodes(
    method episode (line 143) | pub fn episode(&self, episode_id: &[u8]) -> Result<Option<Episode>> {
  function read_sorted_episodes (line 156) | fn read_sorted_episodes(data_dir: &Path) -> Result<Vec<Episode>> {
  function cmp_episode (line 169) | fn cmp_episode(ep1: &Episode, ep2: &Episode) -> cmp::Ordering {
  function read_episode (line 185) | fn read_episode(bytes: &[u8]) -> Result<Episode> {
  function write_episode (line 209) | fn write_episode(ep: &Episode, buf: &mut Vec<u8>) -> Result<()> {
  function read_tvshow (line 221) | fn read_tvshow(bytes: &[u8]) -> Result<Episode> {
  function write_tvshow (line 245) | fn write_tvshow(ep: &Episode, buf: &mut Vec<u8>) -> Result<()> {
  function from_optional_u32 (line 258) | fn from_optional_u32(
  function to_optional_season (line 271) | fn to_optional_season(ep: &Episode) -> Result<u32> {
  function to_optional_epnum (line 283) | fn to_optional_epnum(ep: &Episode) -> Result<u32> {
  function basics (line 302) | fn basics() {
  function by_season (line 318) | fn by_season() {
  function tvshow (line 333) | fn tvshow() {

FILE: imdb-index/src/index/id.rs
  type IndexReader (line 15) | pub struct IndexReader {
    method from_path (line 21) | pub fn from_path<P: AsRef<Path>>(path: P) -> Result<IndexReader> {
    method get (line 28) | pub fn get(&self, key: &[u8]) -> Option<u64> {
  type IndexSortedWriter (line 35) | pub struct IndexSortedWriter<W> {
  function from_path (line 41) | pub fn from_path<P: AsRef<Path>>(
  function insert (line 53) | pub fn insert(&mut self, key: &[u8], value: u64) -> Result<()> {
  function finish (line 61) | pub fn finish(self) -> Result<()> {

FILE: imdb-index/src/index/mod.rs
  constant VERSION (line 36) | const VERSION: u64 = 1;
  constant TITLE (line 42) | const TITLE: &str = "title.fst";
  constant CONFIG (line 48) | const CONFIG: &str = "config.json";
  type MediaEntity (line 58) | pub struct MediaEntity {
    method title (line 66) | pub fn title(&self) -> &Title {
    method episode (line 71) | pub fn episode(&self) -> Option<&Episode> {
    method rating (line 76) | pub fn rating(&self) -> Option<&Rating> {
  type Index (line 104) | pub struct Index {
    method open (line 143) | pub fn open<P1: AsRef<Path>, P2: AsRef<Path>>(
    method create (line 163) | pub fn create<P1: AsRef<Path>, P2: AsRef<Path>>(
    method try_clone (line 177) | pub fn try_clone(&self) -> Result<Index> {
    method search (line 196) | pub fn search(
    method entity (line 222) | pub fn entity(&mut self, id: &str) -> Result<Option<MediaEntity>> {
    method entity_from_title (line 233) | pub fn entity_from_title(&mut self, title: Title) -> Result<MediaEntit...
    method title (line 247) | pub fn title(&mut self, id: &str) -> Result<Option<Title>> {
    method aka_records (line 260) | pub fn aka_records(&mut self, id: &str) -> Result<AKARecordIter> {
    method rating (line 269) | pub fn rating(&mut self, id: &str) -> Result<Option<Rating>> {
    method seasons (line 284) | pub fn seasons(&mut self, tvshow_id: &str) -> Result<Vec<Episode>> {
    method episodes (line 300) | pub fn episodes(
    method episode (line 313) | pub fn episode(&mut self, episode_id: &str) -> Result<Option<Episode>> {
    method data_dir (line 318) | pub fn data_dir(&self) -> &Path {
    method index_dir (line 323) | pub fn index_dir(&self) -> &Path {
    method read_record (line 336) | fn read_record(&mut self, offset: u64) -> Result<Option<Title>> {
  type Config (line 126) | struct Config {
  type IndexBuilder (line 353) | pub struct IndexBuilder {
    method new (line 360) | pub fn new() -> IndexBuilder {
    method open (line 378) | pub fn open<P1: AsRef<Path>, P2: AsRef<Path>>(
    method create (line 421) | pub fn create<P1: AsRef<Path>, P2: AsRef<Path>>(
    method ngram_type (line 491) | pub fn ngram_type(&mut self, ngram_type: NgramType) -> &mut IndexBuild...
    method ngram_size (line 499) | pub fn ngram_size(&mut self, ngram_size: usize) -> &mut IndexBuilder {
  method default (line 506) | fn default() -> IndexBuilder {
  function create_name_index (line 518) | fn create_name_index(

FILE: imdb-index/src/index/names.rs
  constant CONFIG (line 26) | const CONFIG: &str = "names.config.json";
  constant NGRAM (line 33) | const NGRAM: &str = "names.ngram.fst";
  constant POSTINGS (line 51) | const POSTINGS: &str = "names.postings.idx";
  constant IDMAP (line 66) | const IDMAP: &str = "names.idmap.idx";
  constant NORMS (line 77) | const NORMS: &str = "names.norms.idx";
  type NameID (line 91) | pub type NameID = u64;
  type DocID (line 109) | type DocID = u32;
  constant MAX_DOC_ID (line 117) | const MAX_DOC_ID: DocID = (1 << 28) - 1;
  type NameQuery (line 124) | pub struct NameQuery {
    method new (line 133) | pub fn new(name: &str) -> NameQuery {
    method with_size (line 144) | pub fn with_size(self, size: usize) -> NameQuery {
    method with_scorer (line 149) | pub fn with_scorer(self, scorer: NameScorer) -> NameQuery {
    method with_stop_word_ratio (line 169) | pub fn with_stop_word_ratio(self, ratio: f64) -> NameQuery {
  type IndexReader (line 176) | pub struct IndexReader {
    method open (line 225) | pub fn open<P: AsRef<Path>>(dir: P) -> Result<IndexReader> {
    method search (line 242) | pub fn search(&self, query: &NameQuery) -> SearchResults<NameID> {
    method docid_to_nameid (line 258) | fn docid_to_nameid(&self, docid: DocID) -> NameID {
    method document_length (line 268) | fn document_length(&self, docid: DocID) -> u64 {
  type Config (line 216) | struct Config {
  type CollectTopK (line 281) | struct CollectTopK {
    method new (line 297) | fn new(k: usize) -> CollectTopK {
    method collect (line 308) | fn collect(mut self, searcher: &mut Searcher) -> SearchResults<NameID> {
  type Searcher (line 391) | struct Searcher<'i> {
  function new (line 405) | fn new(idx: &'i IndexReader, query: &NameQuery) -> Searcher<'i> {
  function index (line 448) | fn index(&self) -> &'i IndexReader {
  type Item (line 454) | type Item = Scored<DocID>;
  method next (line 456) | fn next(&mut self) -> Option<Scored<DocID>> {
  type Disjunction (line 479) | struct Disjunction<'i> {
  function new (line 507) | fn new(
  function empty (line 523) | fn empty(index: &'i IndexReader, scorer: NameScorer) -> Disjunction<'i> {
  function skip_to (line 539) | fn skip_to(&mut self, target_docid: DocID) -> Option<Scored<DocID>> {
  type Item (line 581) | type Item = Scored<DocID>;
  method next (line 583) | fn next(&mut self) -> Option<Scored<DocID>> {
  type PostingIter (line 670) | struct PostingIter<'i> {
  type Posting (line 704) | struct Posting {
    method read (line 715) | fn read(slice: &[u8]) -> Option<Posting> {
  function new (line 731) | fn new(
  function posting (line 779) | fn posting(&self) -> Option<Posting> {
  function len (line 785) | fn len(&self) -> usize {
  function docid (line 791) | fn docid(&self) -> Option<DocID> {
  function score (line 797) | fn score(&self) -> Option<Scored<DocID>> {
  function score_okapibm25 (line 809) | fn score_okapibm25(&self) -> Option<Scored<DocID>> {
  function score_tfidf (line 829) | fn score_tfidf(&self) -> Option<Scored<DocID>> {
  function score_jaccard (line 848) | fn score_jaccard(&self) -> Option<Scored<DocID>> {
  function score_query_ratio (line 857) | fn score_query_ratio(&self) -> Option<Scored<DocID>> {
  type Item (line 863) | type Item = Posting;
  method next (line 865) | fn next(&mut self) -> Option<Posting> {
  method eq (line 884) | fn eq(&self, other: &PostingIter<'i>) -> bool {
  method cmp (line 890) | fn cmp(&self, other: &PostingIter<'i>) -> cmp::Ordering {
  method partial_cmp (line 900) | fn partial_cmp(&self, other: &PostingIter<'i>) -> Option<cmp::Ordering> {
  type IndexWriter (line 914) | pub struct IndexWriter {
    method open (line 986) | pub fn open<P: AsRef<Path>>(
    method finish (line 1013) | pub fn finish(mut self) -> Result<()> {
    method insert (line 1056) | pub fn insert(&mut self, name_id: NameID, name: &str) -> Result<()> {
    method insert_term (line 1078) | fn insert_term(&mut self, docid: DocID, term: &str) {
    method next_docid (line 1089) | fn next_docid(&mut self, name_id: NameID) -> Result<DocID> {
    method num_docs (line 1104) | fn num_docs(&self) -> u32 {
  type Postings (line 975) | struct Postings {
    method posting (line 1112) | fn posting(&mut self, docid: DocID) -> &mut Posting {
  type NameScorer (line 1127) | pub enum NameScorer {
    method possible_names (line 1147) | pub fn possible_names() -> &'static [&'static str] {
    method as_str (line 1154) | pub fn as_str(&self) -> &'static str {
    method fmt (line 1171) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 1165) | fn default() -> NameScorer {
  type Err (line 1177) | type Err = Error;
  method from_str (line 1179) | fn from_str(s: &str) -> Result<NameScorer> {
  type NgramType (line 1201) | pub enum NgramType {
    method possible_names (line 1231) | pub fn possible_names() -> &'static [&'static str] {
    method as_str (line 1236) | pub fn as_str(&self) -> &'static str {
    method iter (line 1248) | fn iter<'t, F: FnMut(&'t str)>(&self, size: usize, text: &'t str, f: F) {
    method iter_window (line 1255) | fn iter_window<'t, F: FnMut(&'t str)>(
    method iter_edge (line 1271) | fn iter_edge<'t, F: FnMut(&'t str)>(
    method fmt (line 1304) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  constant MIN_EDGE_NGRAM_SIZE (line 1227) | const MIN_EDGE_NGRAM_SIZE: usize = 3;
  method default (line 1298) | fn default() -> NgramType {
  type Err (line 1310) | type Err = Error;
  method from_str (line 1312) | fn from_str(s: &str) -> Result<NgramType> {
  function normalize_query (line 1321) | fn normalize_query(s: &str) -> String {
  function read_le_u32 (line 1327) | fn read_le_u32(slice: &[u8]) -> u32 {
  function create_index (line 1340) | fn create_index(index_dir: &Path, names: &[&str]) -> IndexReader {
  function name_query (line 1355) | fn name_query(name: &str) -> NameQuery {
  function ids (line 1359) | fn ids(results: &[Scored<NameID>]) -> Vec<NameID> {
  constant BRUCES (line 1366) | const BRUCES: &'static [&'static str] = &[
  function names_bruces_1 (line 1377) | fn names_bruces_1() {
  function names_bruces_2 (line 1393) | fn names_bruces_2() {
  function names_bruces_3 (line 1408) | fn names_bruces_3() {
  function names_bruces_4 (line 1419) | fn names_bruces_4() {
  function ngrams_window (line 1432) | fn ngrams_window(n: usize, text: &str) -> Vec<&str> {
  function ngrams_edge (line 1438) | fn ngrams_edge(n: usize, text: &str) -> Vec<&str> {
  function ngrams_window_zero_banned (line 1446) | fn ngrams_window_zero_banned() {
  function ngrams_window_weird_sizes (line 1451) | fn ngrams_window_weird_sizes() {
  function ngrams_window_ascii (line 1467) | fn ngrams_window_ascii() {
  function ngrams_window_non_ascii (line 1481) | fn ngrams_window_non_ascii() {
  function ngrams_edge_ascii (line 1494) | fn ngrams_edge_ascii() {
  function ngrams_edge_non_ascii (line 1506) | fn ngrams_edge_non_ascii() {

FILE: imdb-index/src/index/rating.rs
  constant RATINGS (line 19) | const RATINGS: &str = "ratings.fst";
  type Index (line 24) | pub struct Index {
    method open (line 30) | pub fn open<P: AsRef<Path>>(index_dir: P) -> Result<Index> {
    method create (line 41) | pub fn create<P1: AsRef<Path>, P2: AsRef<Path>>(
    method rating (line 70) | pub fn rating(&self, id: &[u8]) -> Result<Option<Rating>> {
  function read_rating (line 82) | fn read_rating(bytes: &[u8]) -> Result<Rating> {
  function write_rating (line 100) | fn write_rating(rat: &Rating, buf: &mut Vec<u8>) -> Result<()> {
  function read_votes_value (line 112) | fn read_votes_value(slice: &[u8]) -> Result<u32> {
  function write_votes_value (line 119) | fn write_votes_value(votes: u32, buf: &mut Vec<u8>) {
  function read_rating_value (line 123) | fn read_rating_value(slice: &[u8]) -> Result<f32> {
  function write_rating_value (line 130) | fn write_rating_value(rating: f32, buf: &mut Vec<u8>) {
  function basics (line 140) | fn basics() {

FILE: imdb-index/src/index/tests.rs
  type Result (line 12) | pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
  type TestContext (line 20) | pub struct TestContext {
    method new (line 32) | pub fn new(name: &str) -> TestContext {
    method data_dir (line 40) | pub fn data_dir(&self) -> &Path {
    method index_dir (line 45) | pub fn index_dir(&self) -> &Path {
  type TempDir (line 56) | pub struct TempDir(PathBuf);
    method new (line 67) | pub fn new(prefix: &str) -> Result<TempDir> {
    method path (line 89) | pub fn path(&self) -> &Path {
  method drop (line 59) | fn drop(&mut self) {

FILE: imdb-index/src/index/writer.rs
  type CursorWriter (line 13) | pub struct CursorWriter<W> {
  function from_path (line 21) | pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self> {
  function new (line 29) | pub fn new(wtr: W) -> CursorWriter<W> {
  function position (line 34) | pub fn position(&self) -> usize {
  function write_u16 (line 39) | pub fn write_u16(&mut self, n: u16) -> io::Result<()> {
  function write_u32 (line 44) | pub fn write_u32(&mut self, n: u32) -> io::Result<()> {
  function write_u64 (line 49) | pub fn write_u64(&mut self, n: u64) -> io::Result<()> {
  function write (line 55) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  function flush (line 61) | fn flush(&mut self) -> io::Result<()> {

FILE: imdb-index/src/record.rs
  type Title (line 15) | pub struct Title {
  type TitleKind (line 72) | pub enum TitleKind {
    method as_str (line 100) | pub fn as_str(&self) -> &'static str {
    method is_tv_series (line 117) | pub fn is_tv_series(&self) -> bool {
    method fmt (line 128) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method cmp (line 134) | fn cmp(&self, other: &TitleKind) -> cmp::Ordering {
  method partial_cmp (line 140) | fn partial_cmp(&self, other: &TitleKind) -> Option<cmp::Ordering> {
  type Err (line 146) | type Err = Error;
  method from_str (line 148) | fn from_str(ty: &str) -> Result<TitleKind, Error> {
  type AKA (line 173) | pub struct AKA {
  type Episode (line 211) | pub struct Episode {
  type Rating (line 235) | pub struct Rating {
  function number_as_bool (line 247) | fn number_as_bool<'de, D>(de: D) -> Result<bool, D::Error>
  function optional_number_as_bool (line 254) | fn optional_number_as_bool<'de, D>(de: D) -> Result<Option<bool>, D::Error>

FILE: imdb-index/src/scored.rs
  type SearchResults (line 8) | pub struct SearchResults<T>(Vec<Scored<T>>);
  function new (line 12) | pub fn new() -> SearchResults<T> {
  function from_min_heap (line 17) | pub fn from_min_heap(
  function push (line 32) | pub fn push(&mut self, scored: Scored<T>) {
  function normalize (line 42) | pub fn normalize(&mut self) {
  function rescore (line 60) | pub fn rescore<F: FnMut(&T) -> f64>(&mut self, mut rescore: F) {
  function trim (line 70) | pub fn trim(&mut self, size: usize) {
  function len (line 77) | pub fn len(&self) -> usize {
  function is_empty (line 82) | pub fn is_empty(&self) -> bool {
  function as_slice (line 87) | pub fn as_slice(&self) -> &[Scored<T>] {
  function into_vec (line 93) | pub fn into_vec(self) -> Vec<Scored<T>> {
  type IntoIter (line 99) | type IntoIter = vec::IntoIter<Scored<T>>;
  type Item (line 100) | type Item = Scored<T>;
  method into_iter (line 102) | fn into_iter(self) -> vec::IntoIter<Scored<T>> {
  type Scored (line 113) | pub struct Scored<T> {
  function new (line 120) | pub fn new(value: T) -> Scored<T> {
  function score (line 130) | pub fn score(&self) -> f64 {
  function set_score (line 137) | pub fn set_score(&mut self, score: f64) {
  function with_score (line 146) | pub fn with_score(mut self, score: f64) -> Scored<T> {
  function map (line 154) | pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Scored<U> {
  function map_score (line 162) | pub fn map_score<F: FnOnce(f64) -> f64>(self, f: F) -> Scored<T> {
  function value (line 168) | pub fn value(&self) -> &T {
  function into_value (line 174) | pub fn into_value(self) -> T {
  function into_pair (line 180) | pub fn into_pair(self) -> (f64, T) {
  method default (line 186) | fn default() -> Scored<T> {
  method eq (line 194) | fn eq(&self, other: &Scored<T>) -> bool {
  method cmp (line 201) | fn cmp(&self, other: &Scored<T>) -> cmp::Ordering {
  method partial_cmp (line 207) | fn partial_cmp(&self, other: &Scored<T>) -> Option<cmp::Ordering> {
  function never_nan_1 (line 219) | fn never_nan_1() {
  function never_nan_2 (line 225) | fn never_nan_2() {
  function never_nan_3 (line 231) | fn never_nan_3() {

FILE: imdb-index/src/search.rs
  type Searcher (line 28) | pub struct Searcher {
    method new (line 39) | pub fn new(idx: Index) -> Searcher {
    method search (line 67) | pub fn search(
    method index (line 84) | pub fn index(&mut self) -> &mut Index {
    method search_with_name (line 88) | fn search_with_name(
    method search_exhaustive (line 110) | fn search_exhaustive(
    method search_with_tvshow (line 169) | fn search_with_tvshow(
    method similarity (line 190) | fn similarity(&self, query: &Query, name: &str) -> f64 {
  type Query (line 213) | pub struct Query {
    method new (line 234) | pub fn new() -> Query {
    method is_empty (line 252) | pub fn is_empty(&self) -> bool {
    method name (line 270) | pub fn name(mut self, name: &str) -> Query {
    method name_scorer (line 288) | pub fn name_scorer(mut self, scorer: Option<NameScorer>) -> Query {
    method similarity (line 304) | pub fn similarity(mut self, sim: Similarity) -> Query {
    method size (line 315) | pub fn size(mut self, size: usize) -> Query {
    method kind (line 327) | pub fn kind(mut self, kind: TitleKind) -> Query {
    method year_ge (line 337) | pub fn year_ge(mut self, year: u32) -> Query {
    method year_le (line 345) | pub fn year_le(mut self, year: u32) -> Query {
    method votes_ge (line 351) | pub fn votes_ge(mut self, votes: u32) -> Query {
    method votes_le (line 357) | pub fn votes_le(mut self, votes: u32) -> Query {
    method season_ge (line 365) | pub fn season_ge(mut self, season: u32) -> Query {
    method season_le (line 373) | pub fn season_le(mut self, season: u32) -> Query {
    method episode_ge (line 381) | pub fn episode_ge(mut self, episode: u32) -> Query {
    method episode_le (line 389) | pub fn episode_le(mut self, episode: u32) -> Query {
    method tvshow_id (line 398) | pub fn tvshow_id(mut self, tvshow_id: &str) -> Query {
    method matches (line 407) | fn matches(&self, ent: &MediaEntity) -> bool {
    method matches_title (line 416) | fn matches_title(&self, title: &Title) -> bool {
    method matches_rating (line 434) | fn matches_rating(&self, rating: Option<&Rating>) -> bool {
    method matches_episode (line 447) | fn matches_episode(&self, ep: Option<&Episode>) -> bool {
    method name_query (line 466) | fn name_query(&self) -> Option<NameQuery> {
    method has_filters (line 490) | fn has_filters(&self) -> bool {
    method needs_only_title (line 501) | fn needs_only_title(&self) -> bool {
    method needs_rating (line 506) | fn needs_rating(&self) -> bool {
    method needs_episode (line 511) | fn needs_episode(&self) -> bool {
    method deserialize (line 528) | fn deserialize<D>(d: D) -> result::Result<Query, D::Error>
    method fmt (line 616) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 227) | fn default() -> Query {
  method serialize (line 519) | fn serialize<S>(&self, s: S) -> result::Result<S::Ok, S::Error>
  type Err (line 542) | type Err = Error;
  method from_str (line 544) | fn from_str(qstr: &str) -> Result<Query> {
  type Similarity (line 665) | pub enum Similarity {
    method possible_names (line 682) | pub fn possible_names() -> &'static [&'static str] {
    method is_none (line 687) | pub fn is_none(&self) -> bool {
    method similarity (line 696) | pub fn similarity(&self, q1: &str, q2: &str) -> f64 {
    method fmt (line 730) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 724) | fn default() -> Similarity {
  type Err (line 741) | type Err = Error;
  method from_str (line 743) | fn from_str(s: &str) -> Result<Similarity> {
  type Range (line 758) | struct Range<T> {
  function none (line 764) | pub fn none() -> Range<T> {
  function is_none (line 768) | pub fn is_none(&self) -> bool {
  function contains (line 774) | pub fn contains(&self, t: Option<&T>) -> bool {
  function fmt (line 789) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Err (line 803) | type Err = Error;
  method from_str (line 805) | fn from_str(range: &str) -> Result<Range<T>> {
  function ranges (line 845) | fn ranges() {
  function query_parser (line 863) | fn query_parser() {
  function query_parser_error (line 911) | fn query_parser_error() {
  function query_parser_weird (line 918) | fn query_parser_weird() {
  function query_display (line 927) | fn query_display() {
  function query_serialize (line 942) | fn query_serialize() {
  function query_deserialize (line 960) | fn query_deserialize() {

FILE: imdb-index/src/util.rs
  constant IMDB_BASICS (line 15) | pub const IMDB_BASICS: &str = "title.basics.tsv";
  constant IMDB_AKAS (line 21) | pub const IMDB_AKAS: &str = "title.akas.tsv";
  constant IMDB_EPISODE (line 29) | pub const IMDB_EPISODE: &str = "title.episode.tsv";
  constant IMDB_RATINGS (line 35) | pub const IMDB_RATINGS: &str = "title.ratings.tsv";
  type NiceDuration (line 39) | pub struct NiceDuration(pub time::Duration);
    method fmt (line 42) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method since (line 50) | pub fn since(t: time::Instant) -> NiceDuration {
    method fractional_seconds (line 57) | pub fn fractional_seconds(&self) -> f64 {
  function csv_reader_builder (line 65) | pub fn csv_reader_builder() -> csv::ReaderBuilder {
  function csv_mmap (line 77) | pub unsafe fn csv_mmap<P: AsRef<Path>>(
  function csv_file (line 88) | pub fn csv_file<P: AsRef<Path>>(path: P) -> Result<csv::Reader<File>> {
  function mmap_file (line 97) | pub unsafe fn mmap_file<P: AsRef<Path>>(path: P) -> Result<Mmap> {
  function create_file (line 105) | pub fn create_file<P: AsRef<Path>>(path: P) -> Result<File> {
  function open_file (line 112) | pub fn open_file<P: AsRef<Path>>(path: P) -> Result<File> {
  function fst_set_builder_file (line 119) | pub fn fst_set_builder_file<P: AsRef<Path>>(
  function fst_set_file (line 131) | pub unsafe fn fst_set_file<P: AsRef<Path>>(path: P) -> Result<fst::Set<M...
  function fst_map_builder_file (line 142) | pub fn fst_map_builder_file<P: AsRef<Path>>(
  function fst_map_file (line 154) | pub unsafe fn fst_map_file<P: AsRef<Path>>(path: P) -> Result<fst::Map<M...

FILE: src/download.rs
  constant IMDB_BASE_URL (line 11) | const IMDB_BASE_URL: &'static str = "https://datasets.imdbws.com";
  constant DATA_SETS (line 16) | const DATA_SETS: &'static [&'static str] = &[
  function download_all (line 28) | pub fn download_all<P: AsRef<Path>>(dir: P) -> anyhow::Result<bool> {
  function update_all (line 41) | pub fn update_all<P: AsRef<Path>>(dir: P) -> anyhow::Result<()> {
  function download_one (line 53) | fn download_one(outdir: &Path, dataset: &'static str) -> anyhow::Result<...
  function non_existent_data_sets (line 70) | fn non_existent_data_sets(dir: &Path) -> anyhow::Result<Vec<&'static str...
  function dataset_path (line 83) | fn dataset_path(dir: &Path, name: &'static str) -> PathBuf {
  function write_sorted_csv_records (line 96) | fn write_sorted_csv_records<R: io::Read, W: io::Write>(

FILE: src/logger.rs
  function init (line 9) | pub fn init() -> anyhow::Result<()> {
  type Logger (line 18) | struct Logger(());
    method init (line 26) | fn init() -> std::result::Result<(), log::SetLoggerError> {
  constant LOGGER (line 20) | const LOGGER: &'static Logger = &Logger(());
  method enabled (line 32) | fn enabled(&self, _: &log::Metadata) -> bool {
  method log (line 38) | fn log(&self, record: &log::Record) {
  method flush (line 45) | fn flush(&self) {
  function should_log (line 50) | fn should_log(record: &log::Record) -> bool {

FILE: src/main.rs
  function main (line 20) | fn main() {
  function try_main (line 32) | fn try_main() -> anyhow::Result<()> {
  type Args (line 113) | struct Args {
    method from_matches (line 132) | fn from_matches(matches: &clap::ArgMatches) -> anyhow::Result<Args> {
    method create_index (line 195) | fn create_index(&self) -> anyhow::Result<Index> {
    method open_index (line 202) | fn open_index(&self) -> anyhow::Result<Index> {
    method searcher (line 206) | fn searcher(&self) -> anyhow::Result<Searcher> {
    method download_all (line 210) | fn download_all(&self) -> anyhow::Result<bool> {
    method download_all_update (line 214) | fn download_all_update(&self) -> anyhow::Result<()> {
  function app (line 219) | fn app() -> clap::App<'static, 'static> {
  function collect_paths (line 341) | fn collect_paths(paths: Vec<&OsStr>, follow: bool) -> Vec<PathBuf> {
  function is_pipe_error (line 361) | fn is_pipe_error(err: &anyhow::Error) -> bool {

FILE: src/rename.rs
  type RenameProposal (line 15) | pub struct RenameProposal {
    method new (line 59) | fn new(
    method rename (line 75) | pub fn rename(&self) -> anyhow::Result<()> {
    method src (line 119) | pub fn src(&self) -> &Path {
    method dst (line 128) | pub fn dst(&self) -> &Path {
  type RenameAction (line 23) | pub enum RenameAction {
    method fmt (line 33) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method is_link (line 44) | fn is_link(&self) -> bool {
  type Renamer (line 143) | pub struct Renamer {
    method propose (line 175) | pub fn propose(
    method propose_one (line 237) | fn propose_one(
    method find_any (line 322) | fn find_any(
    method find_episode (line 361) | fn find_episode(
    method find_tvshow_for_episode (line 396) | fn find_tvshow_for_episode(
    method find_unknown (line 434) | fn find_unknown(&self) -> anyhow::Result<MediaEntity> {
    method candidate (line 453) | fn candidate(&self, path: &Path) -> anyhow::Result<Candidate> {
    method episode_parts (line 490) | fn episode_parts(
    method name_query (line 526) | fn name_query(&self, name: &str) -> Query {
    method choose_one (line 539) | fn choose_one(
    method search (line 558) | fn search(
  type Candidate (line 577) | struct Candidate {
  type CandidatePath (line 598) | struct CandidatePath {
    method from_path (line 656) | fn from_path(path: &Path) -> anyhow::Result<CandidatePath> {
    method imdb_name (line 691) | fn imdb_name(&self, ent: &MediaEntity) -> String {
  type CandidateKind (line 611) | enum CandidateKind {
  type CandidateAny (line 632) | struct CandidateAny {
  type CandidateEpisode (line 644) | struct CandidateEpisode {
  type RenamerBuilder (line 713) | pub struct RenamerBuilder {
    method new (line 724) | pub fn new() -> RenamerBuilder {
    method build (line 736) | pub fn build(&self) -> anyhow::Result<Renamer> {
    method force (line 758) | pub fn force(&mut self, entity: MediaEntity) -> &mut RenamerBuilder {
    method min_votes (line 769) | pub fn min_votes(&mut self, min_votes: u32) -> &mut RenamerBuilder {
    method good_threshold (line 782) | pub fn good_threshold(&mut self, threshold: f64) -> &mut RenamerBuilder {
    method regex_episode (line 791) | pub fn regex_episode(&mut self, pattern: &str) -> &mut RenamerBuilder {
    method regex_season (line 800) | pub fn regex_season(&mut self, pattern: &str) -> &mut RenamerBuilder {
    method regex_year (line 809) | pub fn regex_year(&mut self, pattern: &str) -> &mut RenamerBuilder {
  method default (line 816) | fn default() -> RenamerBuilder {

FILE: src/util.rs
  function choose (line 16) | pub fn choose(
  function read_number (line 35) | pub fn read_number(start: usize, end: usize) -> anyhow::Result<usize> {
  function read_yesno (line 57) | pub fn read_yesno(msg: &str) -> anyhow::Result<bool> {
  function write_tsv (line 73) | pub fn write_tsv<W: io::Write>(
  function write_tsv_title (line 104) | fn write_tsv_title<W: io::Write>(
  function write_tsv_episode (line 127) | fn write_tsv_episode<W: io::Write>(