stac_server

Trait Backend

Source 
pub trait Backend:
    Clone
    + Sync
    + Send
    + 'static {
    // Required methods
    fn has_item_search(&self) -> bool;
    fn has_filter(&self) -> bool;
    fn collections(
        &self,
    ) -> impl Future<Output = Result<Vec<Collection>>> + Send;
    fn collection(
        &self,
        id: &str,
    ) -> impl Future<Output = Result<Option<Collection>>> + Send;
    fn add_collection(
        &mut self,
        collection: Collection,
    ) -> impl Future<Output = Result<()>> + Send;
    fn add_item(
        &mut self,
        item: Item,
    ) -> impl Future<Output = Result<()>> + Send;
    fn items(
        &self,
        collection_id: &str,
        items: Items,
    ) -> impl Future<Output = Result<Option<ItemCollection>>> + Send;
    fn item(
        &self,
        collection_id: &str,
        item_id: &str,
    ) -> impl Future<Output = Result<Option<Item>>> + Send;
    fn search(
        &self,
        search: Search,
    ) -> impl Future<Output = Result<ItemCollection>> + Send;

    // Provided method
    fn add_items(
        &mut self,
        items: Vec<Item>,
    ) -> impl Future<Output = Result<()>> + Send { ... }
}
Expand description

Storage backend for a STAC API.

Required Methods§

Returns true if this backend has item search capabilities.

§Examples
use stac_server::{MemoryBackend, Backend};

assert!(MemoryBackend::new().has_item_search());
Source

fn has_filter(&self) -> bool

Returns true if this backend has filter capabilities.

§Examples
use stac_server::{MemoryBackend, Backend};

assert!(!MemoryBackend::new().has_filter());
Source

fn collections(&self) -> impl Future<Output = Result<Vec<Collection>>> + Send

Returns all collections.

§Examples
use stac_server::{MemoryBackend, Backend};
let backend = MemoryBackend::new();
let collections = backend.collections().await.unwrap();
assert!(collections.is_empty());
Source

fn collection( &self, id: &str, ) -> impl Future<Output = Result<Option<Collection>>> + Send

Returns a single collection.

§Examples
use stac_server::{MemoryBackend, Backend};
let backend = MemoryBackend::new();
let collection = backend.collection("does-not-exist").await.unwrap();
assert!(collection.is_none());
Source

fn add_collection( &mut self, collection: Collection, ) -> impl Future<Output = Result<()>> + Send

Adds a collection.

§Examples
use stac::Collection;
use stac_server::{MemoryBackend, Backend};

let mut backend = MemoryBackend::new();
backend.add_collection(Collection::new("an-id", "a description")).await.unwrap();
Source

fn add_item(&mut self, item: Item) -> impl Future<Output = Result<()>> + Send

Adds an item.

If the item doesn’t have its collection field set, or a collection with that id does not exist in the backend, throws an error.

§Examples
use stac::{Collection, Item};
use stac_server::{MemoryBackend, Backend};

let mut backend = MemoryBackend::new();
assert!(backend.add_item(Item::new("item-id")).await.is_err());

backend.add_collection(Collection::new("collection-id", "a description")).await.unwrap();
backend.add_item(Item::new("item-id").collection("collection-id")).await.unwrap();
Source

fn items( &self, collection_id: &str, items: Items, ) -> impl Future<Output = Result<Option<ItemCollection>>> + Send

Retrieves items for a given collection.

§Examples
use stac::{Collection, Item};
use stac_api::Items;
use stac_server::{MemoryBackend, Backend};

let mut backend = MemoryBackend::new();
backend.add_collection(Collection::new("collection-id", "a description")).await.unwrap();
backend.add_item(Item::new("item-id").collection("collection-id")).await.unwrap();
let items = backend.items("collection-id", Items::default()).await.unwrap();
Source

fn item( &self, collection_id: &str, item_id: &str, ) -> impl Future<Output = Result<Option<Item>>> + Send

Retrieves an item from a collection.

§Examples
use stac::{Collection, Item};
use stac_server::{MemoryBackend, Backend};

let mut backend = MemoryBackend::new();
backend.add_collection(Collection::new("collection-id", "a description")).await.unwrap();
backend.add_item(Item::new("item-id").collection("collection-id")).await.unwrap();
let item = backend.item("collection-id", "item-id").await.unwrap().unwrap();
Source

fn search( &self, search: Search, ) -> impl Future<Output = Result<ItemCollection>> + Send

Searches a backend.

§Examples
use stac_api::Search;
use stac_server::{MemoryBackend, Backend};

let mut backend = MemoryBackend::new();
let item_collection = backend.search(Search::default()).await.unwrap();

Provided Methods§

Source

fn add_items( &mut self, items: Vec<Item>, ) -> impl Future<Output = Result<()>> + Send

Adds multiple items.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§