i2cbus-api 0.1.2

HTTP RESTful API and skeleton server/client implement for I2C bus control
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Server implementation of openapi_client.

#![allow(unused_imports)]

use futures::{self, Future};
use chrono;
use std::collections::HashMap;
use std::marker::PhantomData;

use swagger;
use swagger::{Has, XSpanIdString};

use openapi_client::{Api, ApiError,
                      I2cBusApiResponse,
                      I2cBusListResponse,
                      I2cBusReadByteResponse,
                      I2cBusReadBytesResponse,
                      I2cBusReadRegResponse,
                      I2cBusWriteByteResponse,
                      I2cBusWriteByteRegResponse,
                      I2cBusWriteBytesResponse,
                      I2cBusWriteBytesRegResponse
};
use openapi_client::models;

#[derive(Copy, Clone)]
pub struct Server<C> {
    marker: PhantomData<C>,
}

impl<C> Server<C> {
    pub fn new() -> Self {
        Server{marker: PhantomData}
    }
}

impl<C> Api<C> for Server<C> where C: Has<XSpanIdString>{


    fn i2c_bus_api(&self, context: &C) -> Box<Future<Item=I2cBusApiResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_api() - X-Span-ID: {:?}", context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_list(&self, context: &C) -> Box<Future<Item=I2cBusListResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_list() - X-Span-ID: {:?}", context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_read_byte(&self, bus_id: models::BusId, addr: models::Addr, context: &C) -> Box<Future<Item=I2cBusReadByteResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_read_byte({:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_read_bytes(&self, bus_id: models::BusId, addr: models::Addr, num_bytes: models::NumBytes, context: &C) -> Box<Future<Item=I2cBusReadBytesResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_read_bytes({:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, num_bytes, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_read_reg(&self, bus_id: models::BusId, addr: models::Addr, reg: models::Reg, num_bytes: models::NumBytes, context: &C) -> Box<Future<Item=I2cBusReadRegResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_read_reg({:?}, {:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, reg, num_bytes, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_write_byte(&self, bus_id: models::BusId, addr: models::Addr, value: models::Value, context: &C) -> Box<Future<Item=I2cBusWriteByteResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_write_byte({:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, value, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_write_byte_reg(&self, bus_id: models::BusId, addr: models::Addr, reg: models::Reg, value: models::Value, context: &C) -> Box<Future<Item=I2cBusWriteByteRegResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_write_byte_reg({:?}, {:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, reg, value, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_write_bytes(&self, bus_id: models::BusId, addr: models::Addr, values: models::Values, context: &C) -> Box<Future<Item=I2cBusWriteBytesResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_write_bytes({:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, values, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }


    fn i2c_bus_write_bytes_reg(&self, bus_id: models::BusId, addr: models::Addr, reg: models::Reg, values: models::Values, context: &C) -> Box<Future<Item=I2cBusWriteBytesRegResponse, Error=ApiError>> {
        let context = context.clone();
        println!("i2c_bus_write_bytes_reg({:?}, {:?}, {:?}, {:?}) - X-Span-ID: {:?}", bus_id, addr, reg, values, context.get().0.clone());
        Box::new(futures::failed("Generic failure".into()))
    }

}