interoptopus_csharp 0.16.0-alpha.18

The C# backend for Interoptopus.
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

//! Provides conversion expressions for managed/unmanaged type marshalling.

use crate::lang::TypeId;
use crate::lang::types::ManagedConversion;
use crate::pass::{OutputResult, PassInfo, model};
use std::collections::HashMap;

#[derive(Default)]
pub struct Config {}

pub struct Pass {
    info: PassInfo,
    conversions: HashMap<TypeId, ManagedConversion>,
}

impl Pass {
    #[must_use]
    pub fn new(_: Config) -> Self {
        Self { info: PassInfo { name: file!() }, conversions: HashMap::default() }
    }

    pub fn process(
        &mut self,
        _pass_meta: &mut crate::pass::PassMeta,
        managed_conversion: &model::common::types::info::managed_conversion::Pass,
        types: &model::common::types::all::Pass,
    ) -> OutputResult {
        for (type_id, _) in types.iter() {
            if let Some(mc) = managed_conversion.managed_conversion(*type_id) {
                self.conversions.insert(*type_id, mc);
            }
        }

        Ok(())
    }

    #[must_use]
    pub fn to_unmanaged_suffix(&self, ty: TypeId) -> &'static str {
        match self.conversions.get(&ty) {
            Some(ManagedConversion::AsIs) => "",
            Some(ManagedConversion::To) => ".ToUnmanaged()",
            Some(ManagedConversion::Into) => ".IntoUnmanaged()",
            None => panic!("Unknown conversion for type {ty:?}"),
        }
    }

    #[must_use]
    pub fn to_managed_suffix(&self, ty: TypeId) -> &'static str {
        match self.conversions.get(&ty) {
            Some(ManagedConversion::AsIs) => "",
            Some(ManagedConversion::To) => ".ToManaged()",
            Some(ManagedConversion::Into) => ".IntoManaged()",
            None => panic!("Unknown conversion for type {ty:?}"),
        }
    }

    #[must_use]
    pub fn to_unmanaged_name(&self, ty: TypeId) -> &'static str {
        match self.conversions.get(&ty) {
            Some(ManagedConversion::AsIs) => "",
            Some(ManagedConversion::To) => "ToUnmanaged",
            Some(ManagedConversion::Into) => "IntoUnmanaged",
            None => panic!("Unknown conversion for type {ty:?}"),
        }
    }

    #[must_use]
    pub fn to_managed_name(&self, ty: TypeId) -> &'static str {
        match self.conversions.get(&ty) {
            Some(ManagedConversion::AsIs) => "",
            Some(ManagedConversion::To) => "ToManaged",
            Some(ManagedConversion::Into) => "IntoManaged",
            None => panic!("Unknown conversion for type {ty:?}"),
        }
    }

    #[must_use]
    pub fn as_unmanaged_suffix(&self, ty: TypeId) -> &'static str {
        match self.conversions.get(&ty) {
            Some(ManagedConversion::AsIs) => "",
            Some(ManagedConversion::To) => ".AsUnmanaged()",
            Some(ManagedConversion::Into) => ".AsUnmanaged()",
            None => panic!("Unknown conversion for type {ty:?}"),
        }
    }
}