tf-bindgen 0.1.0

Automatically generates Rust bindings for Terraform providers.
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
103
104
105
106
107
108
109

use std::hash::{Hash, Hasher};
use std::marker::PhantomData;
use std::ops::Deref;
use std::rc::Rc;

use serde::{Serialize, Serializer};

mod cell;
mod prelude;
mod prepare;

pub use cell::Cell;
pub use prelude::*;
pub use prepare::Prepare;

#[derive(Clone, PartialEq, Eq)]
pub enum Value<T> {
    Ref {
        path: String,
        value: Option<Box<Value<T>>>,
    },
    Value {
        value: Rc<T>,
    },
}

pub struct Computed<T> {
    _p: PhantomData<T>,
}

impl<T> Value<T> {
    pub fn get(&self) -> Rc<T> {
        match &self {
            Value::Ref {
                value: Some(value), ..
            } => value.get(),
            Value::Value { value } => value.clone(),
            _ => unimplemented!("can not unknown referenced values"),
        }
    }
}

impl<T> Deref for Value<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        match self {
            Value::Ref {
                value: Some(value), ..
            } => value,
            Value::Value { value } => value,
            _ => unimplemented!("can not dereference computed values"),
        }
    }
}

impl<T: Hash> Hash for Value<T> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match self {
            Value::Ref { path, .. } => {
                state.write(b"${");
                path.hash(state);
                state.write(b"}");
            }
            Value::Value { value } => value.hash(state),
        }
    }
}

impl<T> Default for Computed<T> {
    fn default() -> Self {
        Self { _p: PhantomData }
    }
}

impl<T> Prepare for Computed<T> {
    fn prepare(self, _: impl Into<String>) -> Self {
        self
    }
}

impl<T> Clone for Computed<T> {
    fn clone(&self) -> Self {
        Self { _p: PhantomData }
    }
}

impl<T: Serialize> Serialize for Value<T> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self {
            Value::Ref { path, .. } => format!("${{{path}}}").serialize(serializer),
            Value::Value { value } => value.serialize(serializer),
        }
    }
}

impl<T: Prepare + Clone> Prepare for Value<T> {
    fn prepare(self, prefix: impl Into<String>) -> Self {
        match self {
            Value::Ref { .. } => self,
            Value::Value { value } => Self::Value {
                value: value.prepare(prefix),
            },
        }
    }
}