Struct JSONBuildGuide 

pub struct JSONBuildGuide {

    pub name: String,
    pub description: String,
    pub version: String,
    pub extension: String,
    pub projection: Projection,
    pub encoding: Encoding,
    pub attribution: Attributions,
    pub format: FormatOutput,
    pub vector_sources: Vec<Source>,
    pub raster_sources: Vec<Source>,
    pub grid_sources: Vec<Source>,
    pub build_indices: bool,
    pub layer_guides: Vec<LayerGuide>,
    pub threads: usize,
    pub tile_writer: WhichTileWriting,
}

A user defined guide on building the vector tiles

Fields

name: String

The name of the data

description: String

The description of the data

version: String

User defined versioning for their data

extension: String

Specify the image type. e.g. “pbf”, “png”, “jpg”, “webp”, etc. [Default: “pbf”]

projection: Projection

What kind of output format should be used. Used for describing either S2 or WM projections. [Default: “fzxy”]

encoding: Encoding

The encoding format. Can be either “gz”, “br”, “zstd” or “none”. [Default: “none”]

attribution: Attributions

The attribution of the data. Store as { "presentation name": "href" }.

format: FormatOutput

The vector format if applicable helps define how the vector data is stored.

• The more modern vector format is the “open-s2” which supports things like m-values and 3D geometries.
• The new vector format is the “open-s2” which only supports 2D & 3D geometries, supports M-Values, properties and M-Values can have nested properties and/or arrays, and is decently fast to parse.
• The basic vector format is the “flat-open-s2” which only supports 2D geometries and works on older map engines like Mapbox-gl-js, is faster to parse and often lighter in size.
• The older vector format is the “mapbox” which is the legacy format used by Mapbox and slow to parse.
• The raster format is used speciially for raster ONLY data. Ensures the data is stored as a raster

Defaults to "open-s2"

vector_sources: Vec<Source>

The vector sources that the tile is built from and how the layers are to be stored. Created using { [source_name: string]: Source } See: crate::parsers::FeatureReader

raster_sources: Vec<Source>

The raster sources that will be conjoined into a single rgba pixel index for tile extraction

grid_sources: Vec<Source>

The grid sources that will be conjoined into a single grid index for tile extraction

build_indices: bool

Should the indices be built for polygon data for faster rendering (file cost increases). [Default: true]

layer_guides: Vec<LayerGuide>

The guides on how to build the various data See: {@link LayerGuide}

threads: usize

Set the number of threads to use. [Default: 1]

tile_writer: WhichTileWriting

tileWriter

Trait Implementations

impl Clone for JSONBuildGuide

fn clone(&self) -> JSONBuildGuide

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JSONBuildGuide

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

Formats the value using the given formatter.

impl Default for JSONBuildGuide

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for JSONBuildGuide

where JSONBuildGuide: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for JSONBuildGuide

fn eq(&self, other: &JSONBuildGuide) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for JSONBuildGuide

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for JSONBuildGuide