Struct wmclient::WmClient

pub struct WmClient {
    pub static_caps: Vec<String>,
    pub virtual_caps: Vec<String>,
    pub important_headers: Vec<String>,
    // some fields omitted
}

Client that interacts with a WURFL Microservice server (be it a docker image or a AWS/Azure or GCP virtual machine. This client exposes device lookup methods and some “enumration” methods, such as those for getting all OS names or all device brands used by the WURFL Microservice.

Fields

static_caps: Vec<String>

virtual_caps: Vec<String>

important_headers: Vec<String>

Implementations

impl WmClient

pub fn new(
    scheme: &str,
    host: &str,
    port: &str,
    base_uri: &str
) -> Result<WmClient, WmError>

Creates a new instance of the WURFL microservice client. Basic usage:

use wmclient::WmClient;
let client = WmClient::new("http", "localhost", "8080", "");

pub fn get_api_version(&self) -> &str

Returns the version of this Rust client API

pub fn set_http_timeout(&mut self, conn_timeout: u64, rw_timeout: u64)

sets the overall HTTP timeout in milliseconds

pub fn has_static_capability(&self, cap_name: &str) -> bool

returns true if WURFL microservice exposes the static capability with name cap_name, false otherwise

pub fn has_virtual_capability(&self, vcap_name: &str) -> bool

returns true if WURFL microservice exposes the virtual capability with name cap_name, false otherwise

pub fn get_info(&self) -> Result<JSONInfoData, WmError>

Returns a struct containing info about the running WURFL Microservice server to which this client is connected Basic usage:

use wmclient::WmClient;
let client = WmClient::new("http", "localhost", "8080", "");
let info_res = client.unwrap().get_info();
    if info_res.is_err(){
        // handle error...
    }
    let info = info_res.unwrap();
    println!("Server version: {}", info.wm_version);
    println!("WURFL API version: {}", info.wurfl_api_version);
    println!("WURFL file info: {}", info.wurfl_info);

pub fn lookup_useragent(
    &mut self,
    user_agent: String
) -> Result<JSONDeviceData, WmError>

lookup_useragent - Searches WURFL device data using the given user-agent for detection. Passing an empty string as user-agent will return a “generic” device.

pub fn lookup_device_id(
    &mut self,
    device_id: String
) -> Result<JSONDeviceData, WmError>

lookup_device_id - Searches WURFL device data using its wurfl_id value. Passing an empty or not existing wurfl_id value will make client return a WmError

pub fn lookup_headers<U, V, T: IntoIterator<Item = (U, V)>>(
    &mut self,
    in_headers: T
) -> Result<JSONDeviceData, WmError> where
    U: ToString,
    V: AsRef<[u8]>, 

lookup_headers - Performs a device detection based on HTTP request headers that can be passed in any data structures that implement the IntoIterator trait (for example: HashMap or Hyper framework HeaderMap.

pub fn clear_caches(&mut self)

Clear all the caches in this client

pub fn set_cache_size(&mut self, ua_max_entries: usize)

Sets the new cache size. Changing cache size will result in a cache purge.

pub fn set_requested_static_capabilities(&mut self, cap_list: Option<Vec<&str>>)

set_requested_static_capabilities - set list of standard static capabilities to return with the detected device. A device struct returned by the client may have up to 500 capabilities. This method is used mainly to limit the returned static capabilities to the ones you really need.

pub fn set_requested_virtual_capabilities(
    &mut self,
    vcap_list: Option<Vec<&str>>
)

set_requested_virtual_capabilities - set list of standard virtual capabilities to return with the detected device. A device struct returned by the client may have up to 500 capabilities. This method is used mainly to limit the returned virtual capabilities to the ones you really need.

pub fn set_requested_capabilities(&mut self, cap_list: Option<Vec<&str>>)

set_requested_capabilities - set list of standard capabilities to return with the detected device. Using this method you don’t have to know if the requested capability is either static or virtual, the method assigns the capability to the set it belongs.

pub fn get_actual_cache_sizes(&self) -> (usize, usize)

get_actual_cache_sizes returns the values of cache size. The first value being the device-id based cache, the second value being the size of the headers-based one

pub fn get_all_oses(&self) -> Result<Vec<String>, WmError>

get_all_oses returns a vec of all devices device_os capabilities in WM server

pub fn get_all_versions_for_os(
    &self,
    os_name: &str
) -> Result<Vec<String>, WmError>

Return a Vec containing all the versions for the given os_name. It returns a WmError i case the given os_name does not exist

pub fn get_all_device_makes(&self) -> Result<Vec<String>, WmError>

Returns the list of all device manufacturers in WURFL Microservice

pub fn get_all_devices_for_make(
    &self,
    brand_name: String
) -> Result<Vec<JSONModelMktName>, WmError>

Returns a list of structs that hold data about model a device and marketing names for the given brand_name. The method returns a WmError in case the brand_name does not exist.

Trait Implementations

impl Drop for WmClient

fn drop(&mut self)

Executes the destructor for this type.