SeqRepo

https://docs.rs/seqrepo/0.10.3/seqrepo/
Admin
SeqRepo is a Rust library providing read-only access to biological sequence repositories, enabling...
Tokens:31,660
Snippets:235
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### String Method Examples

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Examples demonstrating common string operations available on the Namespace struct via Deref.

```rust
let s = String::from("foo");

assert_eq!("foo", s.as_str());
```

```rust
let s = String::with_capacity(10);

assert!(s.capacity() >= 10);
```

```rust
let s = String::from("hello");

assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
```

```rust
let a = String::from("foo");
assert_eq!(a.len(), 3);

let fancy_f = String::from("ƒoo");
assert_eq!(fancy_f.len(), 4);
assert_eq!(fancy_f.chars().count(), 3);
```

```rust
let mut v = String::new();
assert!(v.is_empty());

v.push('a');
assert!(!v.is_empty());
```

--------------------------------

### String Slice Method Examples

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Examples demonstrating string slice operations available on the Namespace struct via Deref.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

```rust
let s = "";
assert!(s.is_empty());

let s = "not empty";
assert!(!s.is_empty());
```

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.floor_char_boundary(13);
assert_eq!(closest, 10);
assert_eq!(&s[..closest], "❤️🧡");
```

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.ceil_char_boundary(13);
assert_eq!(closest, 14);
assert_eq!(&s[..closest], "❤️🧡💛");
```

```rust
let bytes = "bors".as_bytes();
assert_eq!(b"bors", bytes);
```

```rust
let mut s = String::from("hello");
unsafe {
    let bytes = s.as_bytes_mut();
    bytes[0] = b'H';
}
```

--------------------------------

### Trim Start Matches

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Removes all prefixes that match a given pattern repeatedly.

```APIDOC
## trim_start_matches

### Description
Returns a string slice with all prefixes that match a pattern repeatedly removed. The pattern can be a `&str`, `char`, a slice of `char`s, or a function or closure that determines if a character matches.

### Text directionality
A string is a sequence of bytes. `start` in this context means the first position of that byte string; for a left-to-right language like English or Russian, this will be left side, and for right-to-left languages like Arabic or Hebrew, this will be the right side.

### Method
`&self` (implicit)

### Endpoint
N/A (Method on string slice)

### Parameters
- **pat** (Pattern) - Required - The pattern to match for trimming from the start.

### Request Body
None

### Response
#### Success Response (200)
- **&str** - The string slice with matching prefixes removed.

### Response Example
```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```
```

--------------------------------

### Trim start patterns with trim_start_matches

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Repeatedly removes prefixes that match a provided pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Strip prefix with strip_prefix

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Removes a prefix exactly once if the string starts with the specified pattern.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

--------------------------------

### Check if String Starts With a Pattern

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns true if the string slice starts with the given pattern. The pattern can be a &str, char, slice of chars, or a closure. For char or slice of chars, only the first character is checked.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Get String Slice as &str

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Dereferences string-like types to a string slice.

```APIDOC
## as_str

### Description
Returns the same string as a string slice `&str`. This method is useful for dereferencing other string-like types (e.g., `Box<str>`, `Arc<str>`) to string slices.

### Method
`pub fn as_str(&self) -> &str`

### Endpoint
N/A (local string method)

### Parameters
None

### Request Example
```rust
let boxed_str: Box<str> = "hello".into();
let slice: &str = boxed_str.as_str();
assert_eq!(slice, "hello");
```

### Response
#### Success Response (200)
- **&str**: The string slice representation.

#### Response Example
```rust
"hello"
```
```

--------------------------------

### Iterating Over Characters in a String Slice

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Provides an example of using the `chars` method to get an iterator over the Unicode scalar values (chars) of a string slice. Note that this may differ from grapheme clusters.

```rust
let s = "Per Martin-Löf";

let mut chars = s.chars();

assert_eq!(Some('P'), chars.next());
assert_eq!(Some('e'), chars.next());
assert_eq!(Some('r'), chars.next());
assert_eq!(Some(' '), chars.next());
assert_eq!(Some('M'), chars.next());
assert_eq!(Some('a'), chars.next());
assert_eq!(Some('r'), chars.next());
assert_eq!(Some('t'), chars.next());
assert_eq!(Some('i'), chars.next());
assert_eq!(Some('n'), chars.next());
assert_eq!(Some('-'), chars.next());
assert_eq!(Some('L'), chars.next());
assert_eq!(Some('ö'), chars.next());
assert_eq!(Some('f'), chars.next());
assert_eq!(None, chars.next());
```

--------------------------------

### GET fetch_sequence

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/trait.Interface.html

Retrieves the full sequence associated with a given alias or sequence identifier.

```APIDOC
## GET /fetch_sequence

### Description
Fetch the full sequence given an alias or sequence identifier.

### Method
GET

### Parameters
#### Query Parameters
- **alias_or_seq_id** (AliasOrSeqId) - Required - The alias or sequence identifier to look up.

### Response
#### Success Response (200)
- **String** - The full sequence.
```

--------------------------------

### Split String into N Parts (Back)

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Use `rsplitn` to split a string slice into at most `n` substrings starting from the end, using a pattern. The last substring will contain the remainder of the string. Requires a pattern that supports reverse searching.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);
```

```rust
let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);
```

```rust
let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

--------------------------------

### Find a character or substring in a string

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Use `find` to get the byte index of the first match. It supports characters, substrings, and closures for pattern matching. Returns `None` if the pattern is not found.

```rust
let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("pard"), Some(17));
```

```rust
let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(char::is_whitespace), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));
assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
```

```rust
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.find(x), None);
```

--------------------------------

### Get subslice safely

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Provides non-panicking alternatives to standard indexing for both immutable and mutable string slices.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

```rust
let mut v = String::from("hello");
// correct length
assert!(v.get_mut(0..5).is_some());
// out of bounds
assert!(v.get_mut(..42).is_none());
assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));

assert_eq!("hello", v);
{
    let s = v.get_mut(0..2);
    let s = s.map(|s| {
        s.make_ascii_uppercase();
        &*s
    });
    assert_eq!(Some("HE"), s);
}
assert_eq!("HEllo", v);
```

--------------------------------

### SeqRepo::fetch_sequence_part Implementation

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Fetches a specific part of a sequence using an alias or sequence ID. Allows specifying start and end boundaries. Returns the sequence part as a String or an Error.

```rust
fn fetch_sequence_part( &self, alias_or_seq_id: &AliasOrSeqId, begin: Option<usize>, end: Option<usize>, ) -> Result<String, Error>
```

--------------------------------

### AliasDb - Constructor

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDb.html

Initializes a new AliasDb instance. It requires the root directory of the SeqRepo and an instance name.

```APIDOC
## pub fn new<P>(sr_root_dir: &P, sr_instance: &str) -> Result<Self, Error>

### Description
Initializes a new `AliasDb` instance.

### Parameters
#### Path Parameters
- **sr_root_dir** (P: AsRef<Path>) - Required - The root directory of the SeqRepo.
- **sr_instance** (string) - Required - The name of the SeqRepo instance.

### Returns
- Result<Self, Error> - A new `AliasDb` instance or an error if initialization fails.
```

--------------------------------

### SeqRepo Initialization and Accessors

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Details on how to create a SeqRepo instance and access its underlying components.

```APIDOC
## SeqRepo

### Struct SeqRepo

```rust
pub struct SeqRepo { /* private fields */ }
```

#### Constructor

##### `new<P>(path: P, instance: &str) -> Result<Self, Error>`

*   **Description**: Creates a new `SeqRepo` instance at the specified path.
*   **Parameters**:
    *   `path` (P: AsRef<Path>) - The path to the SeqRepo directory.
    *   `instance` (&str) - The instance name of the SeqRepo.
*   **Returns**: `Result<Self, Error>` - A new `SeqRepo` instance or an error.

#### Accessors

##### `root_dir(&self) -> &Path`

*   **Description**: Provides read-only access to the root directory of the SeqRepo.

##### `instance(&self) -> &str`

*   **Description**: Provides read-only access to the instance name of the SeqRepo.

##### `alias_db(&self) -> &AliasDb`

*   **Description**: Provides read-only access to the `AliasDb` component.

##### `fasta_dir(&self) -> &FastaDir`

*   **Description**: Provides read-only access to the `FastaDir` component.
```

--------------------------------

### SeqRepo::new Constructor

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Creates a new SeqRepo instance at the specified path. Requires a path to the repository and an instance name. Returns a Result containing the SeqRepo or an Error.

```rust
pub fn new<P>(path: P, instance: &str) -> Result<Self, Error> 
where P: AsRef<Path>,
```

--------------------------------

### FastaDir Initialization and Schema

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.FastaDir.html

Provides methods for initializing a FastaDir and retrieving its schema version.

```APIDOC
## POST /api/fasta_dir/new

### Description
Initializes a new `FastaDir` instance, establishing a connection to the database.

### Method
POST

### Endpoint
`/api/fasta_dir/new`

### Parameters
#### Query Parameters
- **root_dir** (string) - Required - The root directory path for the FASTA files.

### Request Body
```json
{
  "root_dir": "/path/to/fasta/directory"
}
```

### Response
#### Success Response (200)
- **FastaDir** (object) - The initialized FastaDir instance.

#### Response Example
```json
{
  "message": "FastaDir initialized successfully"
}
```

## GET /api/fasta_dir/schema_version

### Description
Retrieves the schema version of the `FastaDir` database.

### Method
GET

### Endpoint
`/api/fasta_dir/schema_version`

### Response
#### Success Response (200)
- **schema_version** (integer) - The current schema version.

#### Response Example
```json
{
  "schema_version": 1
}
```
```

--------------------------------

### Implement CloneToUninit for T

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Nightly-only experimental API for copying data to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Construct AliasDb

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDb.html

Creates a new instance of AliasDb. Requires the SeqRepo root directory path and instance name. Returns a Result which can be an Error.

```rust
pub fn new<P>(sr_root_dir: &P, sr_instance: &str) -> Result<Self, Error>
where P: AsRef<Path>
```

--------------------------------

### GET fetch_sequence_part

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/trait.Interface.html

Retrieves a specific segment of a sequence based on an alias or sequence identifier.

```APIDOC
## GET /fetch_sequence_part

### Description
Fetch a specific part of a sequence given an alias or sequence identifier.

### Method
GET

### Parameters
#### Query Parameters
- **alias_or_seq_id** (AliasOrSeqId) - Required - The alias or sequence identifier to look up.
- **begin** (Option<usize>) - Optional - The starting index of the sequence segment.
- **end** (Option<usize>) - Optional - The ending index of the sequence segment.

### Response
#### Success Response (200)
- **String** - The requested sequence segment.
```

--------------------------------

### Namespace Constructors

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Functions to create new Namespace instances.

```APIDOC
## Namespace Constructors

### `new(value: &str) -> Self`
Creates a new Namespace from a string slice.

### `from(value: String) -> Self`
Creates a new Namespace from a String.
```

--------------------------------

### pub fn trim_ascii_start(&self) -> &str

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns a string slice with leading ASCII whitespace removed.

```APIDOC
## pub fn trim_ascii_start(&self) -> &str

### Description
Returns a string slice with leading ASCII whitespace removed, based on u8::is_ascii_whitespace.

### Response
#### Success Response (200)
- **&str** - The trimmed string slice.
```

--------------------------------

### match_indices

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns an iterator over the disjoint matches of a pattern within a string slice along with the start index.

```APIDOC
## match_indices

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

### Parameters
#### Path Parameters
- **pat** (Pattern) - Required - The pattern to search for (can be &str, char, slice of chars, or closure).
```

--------------------------------

### Retrieving Match Indices with match_indices

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns an iterator over disjoint matches and their starting indices in forward order.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### SeqRepo Interface Implementation

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Documentation for the sequence fetching methods provided by the SeqRepo's Interface implementation.

```APIDOC
## SeqRepo Interface

### impl Interface for SeqRepo

#### `fetch_sequence_part(&self, alias_or_seq_id: &AliasOrSeqId, begin: Option<usize>, end: Option<usize>) -> Result<String, Error>`

*   **Description**: Fetches a specific part of a sequence given an alias or sequence ID, and optional start and end points.
*   **Parameters**:
    *   `alias_or_seq_id` (&AliasOrSeqId) - The alias or sequence ID of the sequence.
    *   `begin` (Option<usize>) - The starting position (inclusive).
    *   `end` (Option<usize>) - The ending position (exclusive).
*   **Returns**: `Result<String, Error>` - The requested sequence part as a String, or an error.

#### `fetch_sequence(&self, alias_or_seq_id: &AliasOrSeqId) -> Result<String, Error>`

*   **Description**: Fetches the entire sequence given an alias or sequence ID.
*   **Parameters**:
    *   `alias_or_seq_id` (&AliasOrSeqId) - The alias or sequence ID of the sequence.
*   **Returns**: `Result<String, Error>` - The full sequence as a String, or an error.
```

--------------------------------

### trim_start

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Removes leading whitespace from a string slice.

```APIDOC
## trim_start

### Description
Returns a string slice with leading whitespace removed. 'Start' refers to the first position of the byte string.
```

--------------------------------

### Get Substring Range

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Finds the byte range of a substring within a string slice without searching.

```APIDOC
## substr_range

### Description
Returns the byte range that a substring points to. Returns `None` if `substr` does not point within `self`. This method uses pointer arithmetic and does not search the string. It may return false positives for zero-length substrings at the beginning or end of the string.

### Method
`pub fn substr_range(&self, substr: &str) -> Option<Range<usize>>`

### Endpoint
N/A (local string method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(substr_range)]

let data = "a, b, b, a";
let mut iter = data.split(", ").map(|s| data.substr_range(s).unwrap());

assert_eq!(iter.next(), Some(0..1));
assert_eq!(iter.next(), Some(3..4));
assert_eq!(iter.next(), Some(6..7));
assert_eq!(iter.next(), Some(9..10));
```

### Response
#### Success Response (200)
- **Option<Range<usize>>**: An `Option` containing the byte range of the substring if found, otherwise `None`.

#### Response Example
```rust
Some(0..1)
```
```

--------------------------------

### Implement Any for T

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Provides runtime type information for any type T.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Retrieving Reverse Match Indices with rmatch_indices

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns an iterator over disjoint matches and their starting indices in reverse order.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

--------------------------------

### FastaDir Interface

Source: https://docs.rs/seqrepo

Documentation for the FastaDir structure for managing compressed FASTA files.

```APIDOC
## FastaDir

### Description
Provides a simple key-value interface to a directory of compressed FASTA files.
```

--------------------------------

### Safe Subslice Retrieval

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Details the `get` and `get_mut` methods for safely retrieving subslices of a string, returning `None` on invalid indices.

```APIDOC
## Safe Subslice Retrieval

### Description
The `get` and `get_mut` methods provide safe ways to obtain subslices of a string. They return an `Option` containing the subslice if the indices are valid and within bounds, otherwise `None`.

### Method
`get` (safe), `get_mut` (safe)

### Endpoint
N/A (Rust methods)

### Parameters
- `i`: A type that implements `SliceIndex<str>`, typically a range (e.g., `0..4`).

### Request Body
N/A

### Request Example
```rust
let v = String::from("🗻∈🌏");

// Safe retrieval
assert_eq!(Some("🗻"), v.get(0..4));
assert!(v.get(1..).is_none()); // Index not on UTF-8 boundary
assert!(v.get(..42).is_none()); // Out of bounds

let mut v_mut = String::from("hello");
if let Some(subslice) = v_mut.get_mut(0..2) {
    subslice.make_ascii_uppercase();
}
assert_eq!("HEllo", v_mut);
```

### Response
- `Option<&str>` for `get`
- `Option<&mut str>` for `get_mut`
```

--------------------------------

### Get subslice unchecked

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Provides high-performance, unchecked indexing for string slices. Requires manual verification of UTF-8 boundaries and bounds.

```rust
let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}
```

```rust
let mut v = String::from("🗻∈🌏");
unsafe {
    assert_eq!("🗻", v.get_unchecked_mut(0..4));
    assert_eq!("∈", v.get_unchecked_mut(4..7));
    assert_eq!("🌏", v.get_unchecked_mut(7..11));
}
```

--------------------------------

### pub fn make_ascii_uppercase(&mut self)

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Converts the string to its ASCII upper case equivalent in-place.

```APIDOC
## pub fn make_ascii_uppercase(&mut self)

### Description
Converts this string to its ASCII upper case equivalent in-place. ASCII letters 'a' to 'z' are mapped to 'A' to 'Z'.
```

--------------------------------

### Implement Equivalent<K> for Q

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Checks for equivalence between types that can be borrowed as Q.

```rust
fn equivalent(&self, key: &K) -> bool
```

--------------------------------

### Trim ASCII Whitespace from Start in Rust

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Removes leading ASCII whitespace characters from a string slice. Whitespace is defined by `u8::is_ascii_whitespace`.

```rust
assert_eq!(" 	 hello world\n".trim_ascii_start(), "hello world\n");
assert_eq!("  ".trim_ascii_start(), "");
assert_eq!("".trim_ascii_start(), "");
```

--------------------------------

### Splitting a String Slice at an Index

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Shows how to divide a string slice into two parts at a specified byte index using `split_at`. The index must be on a UTF-8 code point boundary.

```rust
let s = "Per Martin-Löf";

let (first, last) = s.split_at(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);
```

--------------------------------

### SeqRepo::root_dir Method

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Provides read-only access to the root directory of the SeqRepo instance. Returns a reference to a Path.

```rust
pub fn root_dir(&self) -> &Path
```

--------------------------------

### Find the last occurrence of a pattern in a string

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Use `rfind` to get the byte index of the last match. Similar to `find`, it supports various patterns including closures. Returns `None` if the pattern is not found.

```rust
let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));
assert_eq!(s.rfind("pard"), Some(24));
```

```rust
let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind(char::is_whitespace), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));
```

```rust
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.rfind(x), None);
```

--------------------------------

### Splitting a Mutable String Slice

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Illustrates dividing a mutable string slice into two mutable parts using `split_at_mut`. Modifications to the first part are shown, with the original string updated accordingly.

```rust
let mut s = "Per Martin-Löf".to_string();
{
    let (first, last) = s.split_at_mut(3);
    first.make_ascii_uppercase();
    assert_eq!("PER", first);
    assert_eq!(" Martin-Löf", last);
}
assert_eq!("PER Martin-Löf", s);
```

--------------------------------

### Find All Disjoint Matches

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Use `matches` to get an iterator over all disjoint matches of a pattern within a string slice. The pattern can be a `&str`, `char`, slice of `char`s, or a closure. The iterator may be `DoubleEndedIterator` depending on the pattern.

```rust
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
```

```rust
let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);
```

--------------------------------

### TryInto Trait Implementation

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/enum.Error.html

Details the TryInto trait implementation for type conversions.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides a way to attempt a conversion from type `T` into type `U`, returning a `Result`.

### Method
`try_into`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (Result<U, Error>)
- **U** (type) - The target type after successful conversion.
- **Error** (type) - The error type returned on conversion failure.

#### Error Response
- **Error** (type) - The specific error type indicating conversion failure.
```

--------------------------------

### SeqRepo::instance Method

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Provides read-only access to the instance name of the SeqRepo. Returns a string slice.

```rust
pub fn instance(&self) -> &str
```

--------------------------------

### String Mutability and Byte Access

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Demonstrates how to obtain a mutable byte slice from a String and modify its contents, ensuring UTF-8 validity.

```APIDOC
## String Mutability and Byte Access

### Description
This example shows how to get a mutable byte slice from a `String` and modify its contents. It's crucial to ensure that modifications maintain UTF-8 validity.

### Method
`as_bytes_mut` (unsafe)

### Endpoint
N/A (Rust method)

### Request Body
N/A

### Request Example
```rust
let mut s = String::from("🗻∈🌏");

unsafe {
    let bytes = s.as_bytes_mut();

    bytes[0] = 0xF0;
    bytes[1] = 0x9F;
    bytes[2] = 0x8D;
    bytes[3] = 0x94;
}

assert_eq!("🍔∈🌏", s);
```

### Response
N/A
```

--------------------------------

### Define SeqInfoRecord struct

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqInfoRecord.html

Represents a database record containing sequence metadata.

```rust
pub struct SeqInfoRecord {
    pub seq_id: String,
    pub len: usize,
    pub alpha: String,
    pub added: NaiveDateTime,
    pub relpath: String,
}
```

--------------------------------

### TryFrom Trait Implementation

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/enum.Error.html

Details the TryFrom trait implementation for type conversions.

```APIDOC
## impl<T, U> TryFrom<U> for T

### Description
Provides a way to attempt a conversion from type `U` into type `T`, returning a `Result`.

### Method
`try_from`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (Result<T, Error>)
- **T** (type) - The target type after successful conversion.
- **Error** (type) - The error type returned on conversion failure.

#### Error Response
- **Error** (type) - The specific error type indicating conversion failure.
```

--------------------------------

### Namespace Struct

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Represents a namespace within SeqRepo, storing its value as a String.

```APIDOC
## Struct Namespace

### Description
Namespaces as stored in the database. The string values returned by the `Display` trait are the values stored in the database.

### Fields
- **value** (String) - The string value of the namespace.
```

--------------------------------

### Implement From<T> for T

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Provides a trivial conversion from a type to itself.

```rust
fn from(t: T) -> T
```

--------------------------------

### AliasDb Access

Source: https://docs.rs/seqrepo

Documentation for the AliasDb structure used to query the aliases database.

```APIDOC
## AliasDb

### Description
Provides access to the aliases database of the SeqRepo.

### Structures
- **AliasDb** - Interface for querying aliases.
- **AliasDbRecord** - The record returned by AliasDb::find().
- **Query** - Data structure used for defining a query to AliasDb::find().
```

--------------------------------

### Trim Matches

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Removes all prefixes and suffixes that match a given pattern repeatedly.

```APIDOC
## trim_matches

### Description
Returns a string slice with all prefixes and suffixes that match a pattern repeatedly removed. The pattern can be a `char`, a slice of `char`s, or a function or closure that determines if a character matches.

### Method
`&self` (implicit)

### Endpoint
N/A (Method on string slice)

### Parameters
- **pat** (Pattern) - Required - The pattern to match for trimming from both ends.

### Request Body
None

### Response
#### Success Response (200)
- **&str** - The string slice with matching prefixes and suffixes removed.

### Response Example
```rust
assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");

// Using a closure
assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
```
```

--------------------------------

### String Pattern Matching Methods

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Methods for checking string content and finding patterns within string slices.

```APIDOC
## contains<P>(pat: P) -> bool

### Description
Returns true if the given pattern matches a sub-slice of this string slice.

### Parameters
- **pat** (Pattern) - Required - The pattern to search for (can be &str, char, slice of chars, or closure).

## starts_with<P>(pat: P) -> bool

### Description
Returns true if the given pattern matches a prefix of this string slice.

### Parameters
- **pat** (Pattern) - Required - The pattern to check as a prefix.

## ends_with<P>(pat: P) -> bool

### Description
Returns true if the given pattern matches a suffix of this string slice.

### Parameters
- **pat** (Pattern) - Required - The pattern to check as a suffix.

## find<P>(pat: P) -> Option<usize>

### Description
Returns the byte index of the first character of this string slice that matches the pattern.

### Parameters
- **pat** (Pattern) - Required - The pattern to search for.
```

--------------------------------

### Repeat a string

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Creates a new String by repeating the original string n times. Panics if capacity overflows.

```rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
```

```rust
// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

--------------------------------

### String to Raw Pointer Conversion

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Provides methods to convert string slices into raw pointers for byte access.

```APIDOC
## String to Raw Pointer Conversion

### Description
These methods allow converting string slices into raw pointers to their underlying bytes. `as_ptr` provides an immutable pointer, while `as_mut_ptr` provides a mutable pointer.

### Method
`as_ptr` (safe), `as_mut_ptr` (unsafe)

### Endpoint
N/A (Rust methods)

### Parameters
N/A

### Request Body
N/A

### Request Example
```rust
// Immutable pointer
let s = "Hello";
let ptr = s.as_ptr();

// Mutable pointer (unsafe)
let mut s_mut = String::from("World");
let mut_ptr = s_mut.as_mut_ptr();
```

### Response
N/A
```

--------------------------------

### Implement PartialEq for NamespacedAlias

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Allows for equality comparison between two NamespacedAlias instances.

```rust
fn eq(&self, other: &NamespacedAlias) -> bool
```

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

--------------------------------

### String Iteration Methods

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Methods for iterating over string content, including lines and whitespace-separated segments.

```APIDOC
## lines() -> Lines<'_>

### Description
Returns an iterator over the lines of a string, as string slices. Lines are split at '\n' or '\r\n'.

## split_ascii_whitespace() -> SplitAsciiWhitespace<'_>

### Description
Splits a string slice by ASCII whitespace and returns an iterator over the resulting segments.

## encode_utf16() -> EncodeUtf16<'_>

### Description
Returns an iterator of u16 over the string encoded as native endian UTF-16.
```

--------------------------------

### AliasDb - Clone

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDb.html

Provides a way to clone the AliasDb instance. This operation might fail if a new SQLite connection cannot be established.

```APIDOC
## pub fn try_clone(&self) -> Result<Self, Error>

### Description
Attempts to clone the `AliasDb`. This operation requires creating a new SQLite connection, which can potentially fail.

### Returns
- Result<Self, Error> - A cloned `AliasDb` instance or an error if the cloning process fails.
```

--------------------------------

### SeqRepo Core Components

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/all.html

Overview of the primary structs and traits available in the SeqRepo library for managing sequence data and aliases.

```APIDOC
## Core Structs

### AliasDb
- Description: Manages the database of sequence aliases.

### AliasDbRecord
- Description: Represents a single record within the Alias database.

### FastaDir
- Description: Handles directory-based FASTA sequence storage.

### Namespace
- Description: Defines a namespace for sequence identifiers.

### NamespacedAlias
- Description: Represents an alias associated with a specific namespace.

### Query
- Description: Structure used for executing queries against the repository.

### SeqInfoRecord
- Description: Contains metadata information for a sequence record.

### SeqRepo
- Description: The primary interface for interacting with the sequence repository.

## Enums

### AliasOrSeqId
- Description: Represents either an alias string or a sequence identifier.

### Error
- Description: Standard error types for the SeqRepo library.

## Traits

### Interface
- Description: Defines the standard interface for repository operations.
```

--------------------------------

### String Case Conversion and Repetition

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Methods for converting strings to lowercase/uppercase and repeating string content.

```APIDOC
## to_lowercase

### Description
Returns the lowercase equivalent of this string slice, as a new String, defined by Unicode Derived Core Property.

### Method
Function

### Response
- **String** - The lowercase version of the input string.

## to_uppercase

### Description
Returns the uppercase equivalent of this string slice, as a new String, defined by Unicode Derived Core Property.

### Method
Function

### Response
- **String** - The uppercase version of the input string.

## repeat

### Description
Creates a new String by repeating a string n times.

### Method
Function

### Parameters
- **n** (usize) - Required - The number of times to repeat the string.

### Response
- **String** - The repeated string.

## to_ascii_uppercase

### Description
Returns a copy of this string where each ASCII character is mapped to its uppercase equivalent.

### Method
Function

### Response
- **String** - The ASCII-uppercased string.

## to_ascii_lowercase

### Description
Returns a copy of this string where each ASCII character is mapped to its lowercase equivalent.

### Method
Function

### Response
- **String** - The ASCII-lowercased string.
```

--------------------------------

### Deref<Target = str> Methods

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Methods available on Namespace due to its Deref implementation for str.

```APIDOC
## Methods from Deref<Target = str>

### `len(&self) -> usize`
Returns the length of `self` in bytes.

### `is_empty(&self) -> bool`
Returns `true` if `self` has a length of zero bytes.

### `is_char_boundary(&self, index: usize) -> bool`
Checks that `index`-th byte is the first byte in a UTF-8 code point sequence or the end of the string.

### `floor_char_boundary(&self, index: usize) -> usize`
Finds the closest `x` not exceeding `index` where `is_char_boundary(x)` is `true`.

### `ceil_char_boundary(&self, index: usize) -> usize`
Finds the closest `x` not below `index` where `is_char_boundary(x)` is `true`.

### `as_bytes(&self) -> &[u8]`
Converts a string slice to a byte slice.

### `as_bytes_mut(&mut self) -> &mut [u8]`
Converts a mutable string slice to a mutable byte slice. **Safety**: The caller must ensure that the content of the slice is valid UTF-8 before the borrow ends and the underlying `str` is used.
```

--------------------------------

### Implement Clone for NamespacedAlias

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Provides functionality to create a duplicate of a NamespacedAlias instance.

```rust
fn clone(&self) -> NamespacedAlias
```

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

--------------------------------

### SeqRepo::fetch_sequence Implementation

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqRepo.html

Fetches the entire sequence given an alias or sequence ID. Returns the full sequence as a String or an Error.

```rust
fn fetch_sequence( &self, alias_or_seq_id: &AliasOrSeqId, ) -> Result<String, Error>
```

--------------------------------

### Checked String Splitting

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Demonstrates `split_at_checked` which returns an `Option` to safely split a string slice. It returns `None` if the index is invalid (not on a UTF-8 boundary or out of bounds).

```rust
let s = "Per Martin-Löf";

let (first, last) = s.split_at_checked(3).unwrap();
assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);

assert_eq!(None, s.split_at_checked(13));  // Inside “ö”
assert_eq!(None, s.split_at_checked(16));  // Beyond the string length
```

--------------------------------

### SeqInfoRecord Struct

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.SeqInfoRecord.html

Defines the structure of a sequence information record.

```APIDOC
## Struct SeqInfoRecord

### Summary
```
pub struct SeqInfoRecord {
    pub seq_id: String,
    pub len: usize,
    pub alpha: String,
    pub added: NaiveDateTime,
    pub relpath: String,
}
```

### Description
A record from the `db.sqlite3` database.

### Fields
- `seq_id` (String) - The sequence identifier.
- `len` (usize) - The length of the sequence.
- `alpha` (String) - An alphanumeric representation of the sequence.
- `added` (NaiveDateTime) - The date and time the record was added.
- `relpath` (String) - The relative path to the sequence data.
```

--------------------------------

### Implement Borrow<T> for T

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Allows borrowing a reference to T from T.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Deref<Target = String> Methods

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Methods available on Namespace due to its Deref implementation for String.

```APIDOC
## Methods from Deref<Target = String>

### `as_str(&self) -> &str`
Extracts a string slice containing the entire `String`.

### `capacity(&self) -> usize`
Returns this `String`’s capacity, in bytes.

### `as_bytes(&self) -> &[u8]`
Returns a byte slice of this `String`’s contents.

### `len(&self) -> usize`
Returns the length of this `String`, in bytes, not `char`s or graphemes.

### `is_empty(&self) -> bool`
Returns `true` if this `String` has a length of zero, and `false` otherwise.
```

--------------------------------

### AliasDbRecord Trait Implementations

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDbRecord.html

Details the trait implementations for the AliasDbRecord struct.

```APIDOC
## Trait Implementations for AliasDbRecord

### Debug
Implements the `Debug` trait for formatting the struct.

### Auto Traits
- `Freeze`
- `RefUnwindSafe`
- `Send`
- `Sync`
- `Unpin`
- `UnwindSafe`

### Blanket Implementations
- `Any`
- `Borrow<T>`
- `BorrowMut<T>`
- `From<T>`
- `Instrument`
- `Into<U>`
- `TryFrom<U>`
- `TryInto<U>`
- `WithSubscriber`
```

--------------------------------

### Clone AliasDb

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDb.html

Attempts to clone the AliasDb. This operation can fail because it requires creating a new SQLite connection.

```rust
pub fn try_clone(&self) -> Result<Self, Error>
```

--------------------------------

### Implement TryInto<U> for T

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.NamespacedAlias.html

Provides a fallible conversion from type T into type U.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### pub fn rfind<P>(&self, pat: P) -> Option<usize>

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Returns the byte index for the first character of the last match of the pattern in this string slice. Returns None if the pattern doesn't match.

```APIDOC
## rfind

### Description
Returns the byte index for the first character of the last match of the pattern in this string slice. Returns None if the pattern doesn't match.

### Parameters
#### Path Parameters
- **pat** (Pattern) - Required - The pattern to search for. Can be a &str, char, a slice of chars, or a function/closure.
```

--------------------------------

### AliasDbRecord Struct

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDbRecord.html

Represents a record in the Alias database, as returned by AliasDb::find().

```APIDOC
## Struct AliasDbRecord

### Description
Record as returned by `AliasDb::find()`.

### Fields
- **seqalias_id** (u64) - Unique identifier for the alias record.
- **seqid** (String) - The sequence identifier associated with the alias.
- **alias** (String) - The alias name.
- **added** (NaiveDateTime) - The timestamp when the alias was added.
- **is_current** (bool) - Indicates if this is the current alias record.
- **namespace** (Namespace) - The namespace of the alias.
```

--------------------------------

### Unsafe String Slicing in Rust

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.Namespace.html

Demonstrates the use of `slice_unchecked` for creating string slices without safety checks. Use with extreme caution as it bypasses bounds and UTF-8 validation.

```rust
let s = "Löwe 老虎 Léopard";

unsafe {
    assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
}

let s = "Hello, world!";

unsafe {
    assert_eq!("world", s.slice_unchecked(7, 12));
}
```

--------------------------------

### Into Conversion

Source: https://docs.rs/seqrepo/0.10.3/seqrepo/struct.AliasDb.html

Implements the Into trait for conversion to another type that implements From.

```rust
fn into(self) -> U
where U: From<T>
```
Tokens:
Raw