Struct Map

pub struct Map<T> { /* private fields */ }

A wrapper type to represent maps in Google Schema-friendly format.

Google Schema doesn’t natively support maps, so this represents them as arrays of key-value pairs using the Entry struct. Provides schema generation through AsSchema and optional serde deserialization.

Examples

Basic usage with HashMap:

use std::collections::HashMap;
use google_ai_rs::{Map, Schema, AsSchema};

type MyMap = Map<HashMap<String, i32>>;

let schema = Schema {
    r#type: SchemaType::Array as i32,
    items: Some(
        Schema {
            r#type: SchemaType::Object as i32,
            properties: [
                ("key".to_string(), String::as_schema()),
                ("value".to_string(), i32::as_schema()),
            ]
            .into(),
            required: ["key".to_string(), "value".to_string()].into(),
            ..Default::default()
        }
        .into(),
    ),
    nullable: true,
    ..Default::default()
};

assert_eq!(schema, MyMap::as_schema())

Custom field identifiers and description:

use google_ai_rs::{MapTrait, Map};

struct CustomMap;
impl MapTrait for CustomMap {
    type Key = String;
    type Value = i32;
    const KEY_IDENT: &str = "id";
    const VALUE_IDENT: &str = "count";
    const DESCRIPTION: Option<&str> = Some("Custom mapped values");
}

type SpecialMap = Map<CustomMap>;
// Schema will have "id" and "count" fields with description

Deserialization Note:
Requires serde feature. Works best when T uses MapAccess::next_entry variants.

Implementations

impl<T> Map<T>

pub fn new(inner: T) -> Self

pub fn into_inner(self) -> T

Trait Implementations

impl<T> AsSchema for Map<T>

where T: MapTrait, T::Key: AsSchema, T::Value: AsSchema,

fn as_schema() -> Schema

Generates the OpenAPI schema for this type

impl<T> Debug for Map<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T: Default> Default for Map<T>

fn default() -> Map<T>

Returns the “default value” for a type.

impl<T> Deref for Map<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Map<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<T> for Map<T>

fn from(value: T) -> Self

Converts to this type from the input type.