Struct tokei::Languages

pub struct Languages {
    // some fields omitted
}

A collection of existing languages(List of Languages)

Methods

impl Languages

fn from_cbor<'a, I: Into<&'a [u8]>>(cbor: I) -> Result<Self>

Creates a Languages struct from cbor.

let cbor = "a16452757374a666626c616e6b730564636f64650c68636f6d6d656e7473\
    0065737461747381a566626c616e6b730564636f64650c68636f6d6d656e74730065\
    6c696e657311646e616d65722e5c7372635c6c69625c6275696c642e7273656c696e\
    6573116b746f74616c5f66696c657301";

let mut languages = Languages::from_cbor(&*cbor.from_hex().unwrap()).unwrap();
assert_eq!(12, languages.get_mut(&LanguageType::Rust).unwrap().code);

fn from_json<'a, I: Into<&'a [u8]>>(json: I) -> Result<Self>

Creates a Languages struct from json.

let json = r#"{
    "Rust": {
        "blanks": 5,
        "code": 12,
        "comments": 0,
        "stats": [
            {
                "blanks": 5,
                "code": 12,
                "comments": 0,
                "lines": 17,
                "name": ".\\src\\lib\\build.rs"
            }
        ],
        "lines": 17
    }
}"#;
let mut languages = Languages::from_json(json.as_bytes()).unwrap();
assert_eq!(12, languages.get_mut(&LanguageType::Rust).unwrap().code);

fn from_yaml<'a, I: Into<&'a [u8]>>(yaml: I) -> Result<Self>

Creates a Languages struct from json.

let yaml = r#"\
---
Rust:
  blanks: 5
  code: 12
  comments: 0
  lines: 17
  stats:
    -
      blanks: 5
      code: 12
      comments: 0
      lines: 17
      name: .\src\lib\build.rs
"#;

let mut languages = Languages::from_yaml(yaml.as_bytes()).unwrap();

assert_eq!(12, languages.get_mut(&LanguageType::Rust).unwrap().code);

fn get_statistics<'a, I>(&mut self, paths: I, ignored: I) where I: Into<Cow<'a, [&'a str]>>

Get statistics from the list of paths provided, and a list ignored keywords to ignore paths containing them.

let mut languages = Languages::new();
languages.get_statistics(&*vec!["."], &*vec![".git", "target"]);

println!("{:?}", languages);

fn new() -> Self

Constructs a new, blank Languages.

let languages = Languages::new();

fn remove_empty(&self) -> BTreeMap<LanguageType, Language>

Creates a new map that only contains non empty languages.

use tokei::*;
use std::collections::BTreeMap;

let mut languages = Languages::new();
languages.get_statistics(vec!["doesnt/exist"], vec![".git"]);

let empty_map = languages.remove_empty();
let new_map: BTreeMap<LanguageType, Language> = BTreeMap::new();

assert_eq!(empty_map, new_map);

fn to_cbor(&self) -> Result<Vec<u8>, Error>

Converts Languages to CBOR.

extern crate tokei;
extern crate rustc_serialize;
use rustc_serialize::hex::ToHex;

let cbor = "a16452757374a666626c616e6b730564636f64650c68636f6d6d656e74730\
    065737461747381a566626c616e6b730564636f64650c68636f6d6d656e747300656c\
    696e657311646e616d65722e5c7372635c6c69625c6275696c642e7273656c696e657\
    3116b746f74616c5f66696c657301";

let mut languages = Languages::new();
languages.get_statistics(&*vec!["src/lib/build.rs"], &*vec![".git"]);

assert_eq!(cbor, languages.to_cbor().unwrap().to_hex());

fn to_json(&self) -> Result<String, Error>

Converts Languages to JSON.

let json = r#"{
    "Rust": {
        "blanks": 5,
        "code": 12,
        "comments": 0,
        "stats": [
            {
                "blanks": 5,
                "code": 12,
                "comments": 0,
                "lines": 17,
                "name": ".\\src\\lib\\build.rs"
            }
        ],
        "lines": 17
    }
}"#;
let mut languages = Languages::new();
languages.get_statistics(&*vec!["src/lib/build.rs"], &*vec![".git"]);

assert_eq!(json, languages.to_json().unwrap());

fn to_toml(&self) -> String

fn to_yaml(&self) -> Result<String, Error>

Converts Languages to YAML.

let yaml = r#"
    ---
    "Rust":
    "blanks": 5
    "code": 12
    "comments": 0
    "lines": 17
    "stats":
        -
        "blanks": 5
        "code": 12
        "comments": 0
        "lines": 17
        "name": ".\\src\\lib\\build.rs"#;
let mut languages = Languages::new();
languages.get_statistics(&*vec!["src/lib/build.rs"], &*vec![".git"]);

assert_eq!(yaml, languages.to_yaml().unwrap());

Methods from Deref<Target=BTreeMap<LanguageType, Language>>

fn clear(&mut self)

Clears the map, removing all values.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

fn get<Q>(&self, key: &Q) -> Option<&V> where K: Borrow<Q>, Q: Ord + ?Sized

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

fn contains_key<Q>(&self, key: &Q) -> bool where K: Borrow<Q>, Q: Ord + ?Sized

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Ord + ?Sized

Returns a mutable reference to the value corresponding to the key.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut(&1) {
    *x = "b";
}
assert_eq!(map[&1], "b");

fn insert(&mut self, key: K, value: V) -> Option<V>

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See the module-level documentation for more.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.insert(37, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(37, "b");
assert_eq!(map.insert(37, "c"), Some("b"));
assert_eq!(map[&37], "c");

fn remove<Q>(&mut self, key: &Q) -> Option<V> where K: Borrow<Q>, Q: Ord + ?Sized

Removes a key from the map, returning the value at the key if the key was previously in the map.

The key may be any borrowed form of the map's key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.remove(&1), Some("a"));
assert_eq!(map.remove(&1), None);

fn append(&mut self, other: &mut BTreeMap<K, V>)

Moves all elements from other into Self, leaving other empty.

Examples

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");

let mut b = BTreeMap::new();
b.insert(3, "d");
b.insert(4, "e");
b.insert(5, "f");

a.append(&mut b);

assert_eq!(a.len(), 5);
assert_eq!(b.len(), 0);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");
assert_eq!(a[&3], "d");
assert_eq!(a[&4], "e");
assert_eq!(a[&5], "f");

fn range<Min, Max>(&self, min: Bound<&Min>, max: Bound<&Max>) -> Range<K, V> where K: Borrow<Min> + Borrow<Max>, Max: Ord + ?Sized, Min: Ord + ?Sized

Unstable (btree_range)

: matches collection reform specification, waiting for dust to settle

Constructs a double-ended iterator over a sub-range of elements in the map, starting at min, and ending at max. If min is Unbounded, then it will be treated as "negative infinity", and if max is Unbounded, then it will be treated as "positive infinity". Thus range(Unbounded, Unbounded) will yield the whole collection.

Examples

Basic usage:

#![feature(btree_range, collections_bound)]

use std::collections::BTreeMap;
use std::collections::Bound::{Included, Unbounded};

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range(Included(&4), Included(&8)) {
    println!("{}: {}", key, value);
}
assert_eq!(Some((&5, &"b")), map.range(Included(&4), Unbounded).next());

fn range_mut<Min, Max>(&mut self, min: Bound<&Min>, max: Bound<&Max>) -> RangeMut<K, V> where K: Borrow<Min> + Borrow<Max>, Max: Ord + ?Sized, Min: Ord + ?Sized

Unstable (btree_range)

: matches collection reform specification, waiting for dust to settle

Constructs a mutable double-ended iterator over a sub-range of elements in the map, starting at min, and ending at max. If min is Unbounded, then it will be treated as "negative infinity", and if max is Unbounded, then it will be treated as "positive infinity". Thus range(Unbounded, Unbounded) will yield the whole collection.

Examples

Basic usage:

#![feature(btree_range, collections_bound)]

use std::collections::BTreeMap;
use std::collections::Bound::{Included, Excluded};

let mut map: BTreeMap<&str, i32> = ["Alice", "Bob", "Carol", "Cheryl"].iter()
                                                                      .map(|&s| (s, 0))
                                                                      .collect();
for (_, balance) in map.range_mut(Included("B"), Excluded("Cheryl")) {
    *balance += 100;
}
for (name, balance) in &map {
    println!("{} => {}", name, balance);
}

fn entry(&mut self, key: K) -> Entry<K, V>

Gets the given key's corresponding entry in the map for in-place manipulation.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut count: BTreeMap<&str, usize> = BTreeMap::new();

// count the number of occurrences of letters in the vec
for x in vec!["a","b","a","c","a","b"] {
    *count.entry(x).or_insert(0) += 1;
}

assert_eq!(count["a"], 3);

fn split_off<Q>(&mut self, key: &Q) -> BTreeMap<K, V> where K: Borrow<Q>, Q: Ord + ?Sized

Splits the collection into two at the given key. Returns everything after the given key, including the key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "a");
a.insert(2, "b");
a.insert(3, "c");
a.insert(17, "d");
a.insert(41, "e");

let b = a.split_off(&3);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 3);

assert_eq!(a[&1], "a");
assert_eq!(a[&2], "b");

assert_eq!(b[&3], "c");
assert_eq!(b[&17], "d");
assert_eq!(b[&41], "e");

fn iter(&self) -> Iter<K, V>

Gets an iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{}: {}", key, value);
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));

fn iter_mut(&mut self) -> IterMut<K, V>

Gets a mutable iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

// add 10 to the value if the key isn't "a"
for (key, value) in map.iter_mut() {
    if key != &"a" {
        *value += 10;
    }
}

fn keys(&'a self) -> Keys<'a, K, V>

Gets an iterator over the keys of the map, in sorted order.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);

fn values(&'a self) -> Values<'a, K, V>

Gets an iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);

fn values_mut(&mut self) -> ValuesMut<K, V>

Gets a mutable iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, String::from("hello"));
a.insert(2, String::from("goodbye"));

for value in a.values_mut() {
    value.push_str("!");
}

let values: Vec<String> = a.values().cloned().collect();
assert_eq!(values, [String::from("hello!"),
                    String::from("goodbye!")]);

fn len(&self) -> usize

Returns the number of elements in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

Trait Implementations

impl Debug for Languages

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Languages

fn clone(&self) -> Languages

Returns a copy of the value.

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

Performs copy-assignment from source.

impl IntoIterator for Languages

type Item = BTreeMap<LanguageType, Language>::Item

The type of the elements being iterated over.

type IntoIter = BTreeMap<LanguageType, Language>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a Languages

type Item = (&'a LanguageType, &'a Language)

The type of the elements being iterated over.

type IntoIter = Iter<'a, LanguageType, Language>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Languages

type Item = (&'a LanguageType, &'a mut Language)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, LanguageType, Language>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl AddAssign<BTreeMap<LanguageType, Language>> for Languages

fn add_assign(&mut self, rhs: BTreeMap<LanguageType, Language>)

The method for the += operator

impl<'a> AddAssign<&'a BTreeMap<LanguageType, Language>> for Languages

fn add_assign(&mut self, rhs: &'a BTreeMap<LanguageType, Language>)

The method for the += operator

impl<'a> AddAssign<&'a mut BTreeMap<LanguageType, Language>> for Languages

fn add_assign(&mut self, rhs: &'a mut BTreeMap<LanguageType, Language>)

The method for the += operator

impl Deref for Languages

type Target = BTreeMap<LanguageType, Language>

The resulting type after dereferencing

fn deref(&self) -> &Self::Target

The method called to dereference a value

impl DerefMut for Languages

fn deref_mut(&mut self) -> &mut BTreeMap<LanguageType, Language>

The method called to mutably dereference a value