Struct codespan::Files

pub struct Files<Source> { /* private fields */ }

A database of source files.

The Source generic parameter determines how source text is stored. Using String will have Files take ownership of all source text. Smart pointer types such as Cow<'_, str>, Rc<str> or Arc<str> can be used to share the source text with the rest of the program.

Implementations

impl<Source> Files<Source> where
    Source: AsRef<str>, 

pub fn new() -> Self

Create a new, empty database of files.

pub fn add(&mut self, name: impl Into<OsString>, source: Source) -> 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: Source)

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) -> &OsStr

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, Error>

Get the span at the given line index.

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

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

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

assert_eq!(line_sources,
    [
        Span::new(0, 4),    // 0: "foo\n"
        Span::new(4, 9),    // 1: "bar\r\n"
        Span::new(9, 10),   // 2: ""
        Span::new(10, 13),  // 3: "baz"
    ]
);
assert!(files.line_span(file_id, 4).is_err());

pub fn line_index(
    &self,
    file_id: FileId,
    byte_index: impl Into<ByteIndex>
) -> LineIndex

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

use codespan::{Files, LineIndex};

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

assert_eq!(files.line_index(file_id, 0), LineIndex::from(0));
assert_eq!(files.line_index(file_id, 7), LineIndex::from(1));
assert_eq!(files.line_index(file_id, 8), LineIndex::from(1));
assert_eq!(files.line_index(file_id, 9), LineIndex::from(2));
assert_eq!(files.line_index(file_id, 100), LineIndex::from(3));

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

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

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

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

assert_eq!(files.location(file_id, 0).unwrap(), Location::new(0, 0));
assert_eq!(files.location(file_id, 7).unwrap(), Location::new(1, 3));
assert_eq!(files.location(file_id, 8).unwrap(), Location::new(1, 4));
assert_eq!(files.location(file_id, 9).unwrap(), Location::new(2, 0));
assert!(files.location(file_id, 100).is_err());

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

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, Error>

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)).unwrap(), "hello");
assert!(files.source_slice(file_id, Span::new(0, 100)).is_err());

Trait Implementations

impl<Source: Clone> Clone for Files<Source>

fn clone(&self) -> Files<Source>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Source: Debug> Debug for Files<Source>

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

Formats the value using the given formatter.

impl<Source> Default for Files<Source> where
    Source: AsRef<str>, 

fn default() -> Self

Returns the “default value” for a type.

impl<'a, Source> Files<'a> for Files<Source> where
    Source: AsRef<str>, 

type FileId = FileId

A unique identifier for files in the file provider. This will be used for rendering diagnostic::Labels in the corresponding source files.

type Name = String

The user-facing name of a file, to be displayed in diagnostics.

type Source = &'a str

The source code of a file.

fn name(&self, id: FileId) -> Result<String, Error>

The user-facing name of a file.

fn source(&'a self, id: FileId) -> Result<&str, Error>

The source code of a file.

fn line_index(&self, id: FileId, byte_index: usize) -> Result<usize, Error>

The index of the line at the given byte index. If the byte index is past the end of the file, returns the maximum line index in the file. This means that this function only fails if the file is not present.

fn line_range(
    &'a self,
    id: FileId,
    line_index: usize
) -> Result<Range<usize>, Error>

The byte range of line in the source of the file.

fn line_number(
    &'a self,
    id: Self::FileId,
    line_index: usize
) -> Result<usize, Error>

The user-facing line number at the given line index. It is not necessarily checked that the specified line index is actually in the file.

fn column_number(
    &'a self,
    id: Self::FileId,
    line_index: usize,
    byte_index: usize
) -> Result<usize, Error>

The user-facing column number at the given line index and byte index.

fn location(
    &'a self,
    id: Self::FileId,
    byte_index: usize
) -> Result<Location, Error>

Convenience method for returning line and column number at the given byte index in the file.