Struct codespan::Files

pub struct Files { /* fields omitted */ }

A database of source files.

Methods

impl Files

pub fn new() -> Files

Create a new, empty database of files.

pub fn add(
    &mut self,
    name: impl Into<String>,
    source: impl Into<String>
) -> FileId

Add a file to the database, returning the handle that can be used to refer to it again.

pub fn update(&mut self, file_id: FileId, source: impl Into<String>)

Update a source file in place.

This will mean that any outstanding byte indexes will now point to invalid locations.

pub fn name(&self, file_id: FileId) -> &str

Get the name of the source file.

use codespan::Files;

let name = "test";

let mut files = Files::new();
let file_id = files.add(name, "hello world!");

assert_eq!(files.name(file_id), name);

pub fn line_span(
    &self,
    file_id: FileId,
    line_index: impl Into<LineIndex>
) -> Result<Span, LineIndexOutOfBoundsError>

Get the span at the given line index.

use codespan::{Files, LineIndex, LineIndexOutOfBoundsError, Span};

let mut files = Files::new();
let file_id = files.add("test", "foo\nbar\r\n\nbaz");

let line_sources = (0..5)
    .map(|line| files.line_span(file_id, line))
    .collect::<Vec<_>>();

assert_eq!(
    line_sources,
    [
        Ok(Span::new(0, 4)),    // 0: "foo\n"
        Ok(Span::new(4, 9)),    // 1: "bar\r\n"
        Ok(Span::new(9, 10)),   // 2: ""
        Ok(Span::new(10, 13)),  // 3: "baz"
        Err(LineIndexOutOfBoundsError {
            given: LineIndex::from(5),
            max: LineIndex::from(4),
        }),
    ]
);

pub fn location(
    &self,
    file_id: FileId,
    byte_index: impl Into<ByteIndex>
) -> Result<Location, LocationError>

Get the location at the given byte index in the source file.

use codespan::{ByteIndex, Files, Location, LocationError, Span};

let mut files = Files::new();
let file_id = files.add("test", "foo\nbar\r\n\nbaz");

assert_eq!(files.location(file_id, 0), Ok(Location::new(0, 0)));
assert_eq!(files.location(file_id, 7), Ok(Location::new(1, 3)));
assert_eq!(files.location(file_id, 8), Ok(Location::new(1, 4)));
assert_eq!(files.location(file_id, 9), Ok(Location::new(2, 0)));
assert_eq!(
    files.location(file_id, 100),
    Err(LocationError::OutOfBounds {
        given: ByteIndex::from(100),
        span: Span::new(0, 13),
    }),
);

pub fn source(&self, file_id: FileId) -> &str

Get the source of the file.

use codespan::Files;

let source = "hello world!";

let mut files = Files::new();
let file_id = files.add("test", source);

assert_eq!(files.source(file_id), source);

pub fn source_span(&self, file_id: FileId) -> Span

Return the span of the full source.

use codespan::{Files, Span};

let source = "hello world!";

let mut files = Files::new();
let file_id = files.add("test", source);

assert_eq!(files.source_span(file_id), Span::from_str(source));

pub fn source_slice(
    &self,
    file_id: FileId,
    span: impl Into<Span>
) -> Result<&str, SpanOutOfBoundsError>

Return a slice of the source file, given a span.

use codespan::{Files, Span};

let mut files = Files::new();
let file_id = files.add("test",  "hello world!");

assert_eq!(files.source_slice(file_id, Span::new(0, 5)), Ok("hello"));
assert!(files.source_slice(file_id, Span::new(0, 100)).is_err());

Trait Implementations

impl Clone for Files

fn clone(&self) -> Files

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Files

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

Formats the value using the given formatter.