Struct tokei::Language

pub struct Language {
    pub blanks: usize,
    pub code: usize,
    pub comments: usize,
    pub reports: Vec<Report>,
    pub children: BTreeMap<LanguageType, Vec<Report>>,
    pub inaccurate: bool,
}

A struct representing statistics about a single Language.

Fields

blanks: usize

The total number of blank lines.

code: usize

The total number of lines of code.

comments: usize

The total number of comments(both single, and multi-line)

reports: Vec<Report>

A collection of statistics of individual files.

children: BTreeMap<LanguageType, Vec<Report>>

A map of any languages found in the reports.

inaccurate: bool

Whether this language had problems with file parsing

Implementations

impl Language

pub fn new() -> Self

Constructs a new empty Language with the comments provided.

let mut rust = Language::new();

pub fn lines(&self) -> usize

Returns the total number of lines.

pub fn add_report(&mut self, report: Report)

Add a Report to the Language. This will not update the totals in the Language struct.

pub fn mark_inaccurate(&mut self)

Marks this language as possibly not reflecting correct stats.

pub fn summarise(&self) -> Language

Creates a new Language from self, which is a summarised version of the language that doesn’t contain any children. It will count non-blank lines in child languages as code unless the child language is considered “literate” then it will be counted as comments.

pub fn total(&mut self)

Totals up the statistics of the Stat structs currently contained in the language.

use std::{collections::BTreeMap, path::PathBuf};
use tokei::Language;

let mut language = Language::new();

// Add stats...

assert_eq!(0, language.lines());

language.total();

assert_eq!(10, language.lines());

pub fn is_empty(&self) -> bool

Checks if the language is empty. Empty meaning it doesn’t have any statistics.

let rust = Language::new();

assert!(rust.is_empty());

pub fn sort_by(&mut self, category: Sort)

Sorts each of the Reports contained in the language based on what category is provided.

use std::{collections::BTreeMap, path::PathBuf};
use tokei::{Language, Sort};

let mut language = Language::new();

// Add stats...

language.sort_by(Sort::Lines);
assert_eq!(20, language.reports[0].stats.lines());

language.sort_by(Sort::Code);
assert_eq!(8, language.reports[0].stats.code);

Trait Implementations

impl AddAssign<Language> for Language

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Language

fn clone(&self) -> Language

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Language

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Language

fn default() -> Language

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Language

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Language> for Language

fn eq(&self, other: &Language) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Language

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Language