Struct tokei::Language

pub struct Language {
    pub blanks: usize,
    pub code: usize,
    pub comments: usize,
    pub lines: usize,
    pub stats: Vec<Stats>,
    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)

lines: usize

The total number of total lines.

stats: Vec<Stats>

A collection of statistics of individual files.

inaccurate: bool

Whether this language had problems with file parsing

Methods

impl Language

pub fn new() -> Self

Constructs a new empty Language with the comments provided.

let mut rust = Language::new();

pub fn add_stat(&mut self, stat: Stats)

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

use std::path::PathBuf;
use tokei::{Language, Stats};

let mut language = Language::new();

language.add_stat(Stats {
    lines: 10,
    code: 4,
    comments: 3,
    blanks: 3,
    name: PathBuf::from("test.rs"),
});

pub fn mark_inaccurate(&mut self)

Marks this language as possibly not reflecting correct stats.

pub fn total(&mut self)

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

use std::path::PathBuf;
use tokei::{Language, Stats};

let mut language = Language::new();

language.add_stat(Stats {
    lines: 10,
    code: 4,
    comments: 3,
    blanks: 3,
    name: PathBuf::from("test.rs"),
});

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 Stats structs contained in the language based on what category is provided.

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

let mut language = Language::new();

language.add_stat(Stats {
    lines: 10,
    code: 8,
    comments: 0,
    blanks: 2,
    name: PathBuf::from("test.rs"),
});

language.add_stat(Stats {
    lines: 20,
    code: 4,
    comments: 13,
    blanks: 3,
    name: PathBuf::from("testsuite.rs"),
});

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

language.sort_by(Sort::Code);
assert_eq!(8, language.stats[0].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: &Language) -> bool

This method tests for !=.

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