cfsp 1.0.1

A JVM Bytecode Manipulation Framework inspired by ASM.
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

use serde::{Deserialize, Serialize};

use crate::node::access_flag::{ExportsAccessFlag, OpensAccessFlag, RequiresAccessFlag};
use crate::node::constant::{ConstantPool, Module, Package, Utf8};

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Requires {
    pub requires_index: u16,
    pub requires_flags: RequiresAccessFlag,
    pub requires_version_index: u16,
}

impl Requires {
    pub fn requires<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Module> {
        constant_pool.get_module(self.requires_index)
    }

    pub fn requires_version<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Utf8> {
        constant_pool.get_utf8(self.requires_version_index)
    }
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Exports {
    pub exports_index: u16,
    pub exports_flags: ExportsAccessFlag,
    pub exports_to_count: u16,
    pub exports_to_index: Vec<u16>,
}

impl Exports {
    pub fn exports<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Package> {
        constant_pool.get_package(self.exports_index)
    }

    pub fn exports_to<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        index: usize,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Module> {
        self.exports_to_index
            .get(index)
            .and_then(|exports_to_index| constant_pool.get_module(*exports_to_index))
    }
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Opens {
    pub opens_index: u16,
    pub opens_flags: OpensAccessFlag,
    pub opens_to_count: u16,
    pub opens_to_index: Vec<u16>,
}

impl Opens {
    pub fn opens<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Package> {
        constant_pool.get_package(self.opens_index)
    }

    pub fn opens_to<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        index: usize,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Module> {
        self.opens_to_index
            .get(index)
            .and_then(|opens_to_index| constant_pool.get_module(*opens_to_index))
    }
}

#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Provides {
    pub provides_index: u16,
    pub provides_with_count: u16,
    pub provides_with_index: Vec<u16>,
}

impl Provides {
    pub fn provides<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Package> {
        constant_pool.get_package(self.provides_index)
    }

    pub fn provides_to<'attribute, 'constant_pool: 'attribute>(
        &'attribute self,
        index: usize,
        constant_pool: &'constant_pool ConstantPool,
    ) -> Option<&'constant_pool Module> {
        self.provides_with_index
            .get(index)
            .and_then(|provides_with_index| constant_pool.get_module(*provides_with_index))
    }
}