codama_nodes/shared/
instruction_input_value_node.rs

1use crate::{
2    AccountBumpValueNode, AccountValueNode, ArgumentValueNode, ArrayValueNode, BooleanValueNode,
3    BytesValueNode, ConditionalValueNode, ConstantValueNode, EnumValueNode, HasKind,
4    IdentityValueNode, MapValueNode, NoneValueNode, NumberValueNode, PayerValueNode, PdaValueNode,
5    ProgramIdValueNode, ProgramLinkNode, PublicKeyValueNode, ResolverValueNode, SetValueNode,
6    SomeValueNode, StringValueNode, StructValueNode, TupleValueNode, ValueNode,
7};
8use codama_errors::CodamaError;
9use codama_nodes_derive::node_union;
10
11#[node_union]
12pub enum InstructionInputValueNode {
13    // ContextualValueNodes.
14    Account(AccountValueNode),
15    AccountBump(AccountBumpValueNode),
16    Argument(ArgumentValueNode),
17    Conditional(ConditionalValueNode),
18    Identity(IdentityValueNode),
19    Payer(PayerValueNode),
20    Pda(PdaValueNode),
21    ProgramId(ProgramIdValueNode),
22    Resolver(ResolverValueNode),
23
24    // ValueNodes.
25    Array(ArrayValueNode),
26    Boolean(BooleanValueNode),
27    Bytes(BytesValueNode),
28    Constant(ConstantValueNode),
29    Enum(EnumValueNode),
30    Map(MapValueNode),
31    None(NoneValueNode),
32    Number(NumberValueNode),
33    PublicKey(PublicKeyValueNode),
34    Set(SetValueNode),
35    Some(SomeValueNode),
36    String(StringValueNode),
37    Struct(StructValueNode),
38    Tuple(TupleValueNode),
39
40    // LinkNodes.
41    ProgramLink(ProgramLinkNode),
42}
43
44impl From<ValueNode> for InstructionInputValueNode {
45    fn from(value: ValueNode) -> Self {
46        match value {
47            ValueNode::Array(value) => Self::Array(value),
48            ValueNode::Boolean(value) => Self::Boolean(value),
49            ValueNode::Bytes(value) => Self::Bytes(value),
50            ValueNode::Constant(value) => Self::Constant(value),
51            ValueNode::Enum(value) => Self::Enum(value),
52            ValueNode::Map(value) => Self::Map(value),
53            ValueNode::None(value) => Self::None(value),
54            ValueNode::Number(value) => Self::Number(value),
55            ValueNode::PublicKey(value) => Self::PublicKey(value),
56            ValueNode::Set(value) => Self::Set(value),
57            ValueNode::Some(value) => Self::Some(value),
58            ValueNode::String(value) => Self::String(value),
59            ValueNode::Struct(value) => Self::Struct(value),
60            ValueNode::Tuple(value) => Self::Tuple(value),
61        }
62    }
63}
64
65impl TryFrom<InstructionInputValueNode> for ValueNode {
66    type Error = CodamaError;
67
68    fn try_from(value: InstructionInputValueNode) -> Result<Self, Self::Error> {
69        match value {
70            InstructionInputValueNode::Array(value) => Ok(Self::Array(value)),
71            InstructionInputValueNode::Boolean(value) => Ok(Self::Boolean(value)),
72            InstructionInputValueNode::Bytes(value) => Ok(Self::Bytes(value)),
73            InstructionInputValueNode::Constant(value) => Ok(Self::Constant(value)),
74            InstructionInputValueNode::Enum(value) => Ok(Self::Enum(value)),
75            InstructionInputValueNode::Map(value) => Ok(Self::Map(value)),
76            InstructionInputValueNode::None(value) => Ok(Self::None(value)),
77            InstructionInputValueNode::Number(value) => Ok(Self::Number(value)),
78            InstructionInputValueNode::PublicKey(value) => Ok(Self::PublicKey(value)),
79            InstructionInputValueNode::Set(value) => Ok(Self::Set(value)),
80            InstructionInputValueNode::Some(value) => Ok(Self::Some(value)),
81            InstructionInputValueNode::String(value) => Ok(Self::String(value)),
82            InstructionInputValueNode::Struct(value) => Ok(Self::Struct(value)),
83            InstructionInputValueNode::Tuple(value) => Ok(Self::Tuple(value)),
84            _ => Err(CodamaError::InvalidNodeConversion {
85                from: value.kind().to_string(),
86                into: "ValueNode".to_string(),
87            }),
88        }
89    }
90}