Add client cert to support mTLS
[it/test.git] / ric_benchmarking / e2-interface / e2sim / previous / src / ASN1 / asn / ber / visitor.hpp
1 #pragma once
2 /******************************************************************************
3 *
4 *   Copyright (c) 2019 AT&T Intellectual Property.
5 *   Copyright (c) 2018-2019 Nokia.
6 *
7 *   Licensed under the Apache License, Version 2.0 (the "License");
8 *   you may not use this file except in compliance with the License.
9 *   You may obtain a copy of the License at
10 *
11 *       http://www.apache.org/licenses/LICENSE-2.0
12 *
13 *   Unless required by applicable law or agreed to in writing, software
14 *   distributed under the License is distributed on an "AS IS" BASIS,
15 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 *   See the License for the specific language governing permissions and
17 *   limitations under the License.
18 *
19 ******************************************************************************/
20
21 // Standard Includes: ANSI C/C++, MSA, and Third-Party Libraries
22
23 // Local Includes: Application specific classes, functions, and libraries
24
25 namespace asn {
26 namespace ber {
27
28 /***************************************************************************************
29 * VisitorEncoder
30 ***************************************************************************************/
31 struct VisitorEncoder
32 {
33         VisitorEncoder(EncoderCtx& ctx) : m_ctx(ctx){}
34         
35         template<typename ELM> bool operator() (ELM const& elm) 
36         {
37                 if(m_ctx)
38                         Element<ELM>::run(elm, m_ctx);
39                 return static_cast<bool>(m_ctx);
40         }
41 private:
42         EncoderCtx&     m_ctx;
43 };
44
45 /***************************************************************************************
46 * VisitorDecoder
47 ***************************************************************************************/
48 struct VisitorDecoder
49 {
50         VisitorDecoder(DecoderCtx& ctx, tag_value_t tag) : m_ctx(ctx), m_tag(tag){}
51         
52         template<typename ELM> bool operator() (ELM& elm) 
53         {
54                 if(m_ctx)
55                         Element<ELM>::run(elm, m_ctx, &m_tag);
56                 return static_cast<bool>(m_ctx);
57         }
58
59 private:
60         DecoderCtx&     m_ctx;
61         tag_value_t     m_tag;
62 };
63
64 /***************************************************************************************
65 * VisitorAdapter
66 ***************************************************************************************/
67 template <class Container, class IE, class Enabler = void>
68 struct VisitorAdapter //default
69 {
70         static void inline run(IE const& ie, EncoderCtx& ctx, Container const& cont)
71         {
72                 Element<IE>::run(ie, ctx);
73         }
74         static void inline run(IE& ie, DecoderCtx& ctx, Container const& cont, tag_value_t tag)
75         {
76                 Element<IE>::run(ie, ctx, &tag);
77         }
78 };
79
80 template <class Container, class IE>
81 struct VisitorAdapter<Container, IE, std::enable_if_t<
82                                         (IE::ie_type == element_type::T_OBJFIELD_FTV)
83                                         || (IE::ie_type == element_type::T_OBJFIELD_TF)
84                                         > >
85 {
86         static void inline run(IE const& ie, EncoderCtx& ctx, Container const& cont)
87         {
88                 VisitorEncoder v(ctx);
89                 bool rv = ie.encode(v, cont);
90                 if(!rv && static_cast<bool>(ctx))
91                 {
92                         ctx.refErrorCtx().errorNoObject(Container::name());
93                 }
94         }
95         static void inline run(IE& ie, DecoderCtx& ctx, Container const& cont, tag_value_t tag)
96         {
97                 VisitorDecoder v(ctx, tag);
98                 bool rv = ie.decode(v, cont);
99                 if(!rv && static_cast<bool>(ctx))
100                 {
101                         ctx.refErrorCtx().errorNoObject(Container::name());
102                 }
103         }
104 };
105
106 /***************************************************************************************
107 * VisitorEncoderSeq
108 ***************************************************************************************/
109 template<typename CONT>
110 struct VisitorEncoderSeq
111 {
112         VisitorEncoderSeq(EncoderCtx& ctx, CONT const& cont) : m_ctx(ctx), m_cont(cont){}
113         
114         template<typename ELM> void operator() (ELM const& elm) 
115         {
116                 if(ELM::optional)
117                 {
118                         if(elm.is_valid())
119                                 VisitorAdapter<CONT, ELM>::run(elm, m_ctx, m_cont);
120                 }
121                 else
122                         VisitorAdapter<CONT, ELM>::run(elm, m_ctx, m_cont);
123         }
124         
125         EncoderCtx&     m_ctx;
126         CONT const&             m_cont;
127 };
128
129
130 /***************************************************************************************
131 * VisitorDecoderSeq
132 ***************************************************************************************/
133 template<typename CONT>
134 struct VisitorDecoderSeq
135 {
136         VisitorDecoderSeq(DecoderCtx& ctx, CONT const& cont) : m_ctx(ctx), m_cont(cont){}
137         
138         template<typename ELM> void operator() (ELM& elm) 
139         {
140                 if(m_ctx)
141                 {
142                         tag_value_t tag;
143                         
144                         if(invalid_tag == m_tag && m_ctx.refBuffer().getBytesLeft())
145                         {
146                                 m_tag = get_tag(m_ctx);
147                         }
148                         tag = m_tag;
149
150                         if(m_ctx)
151                         {
152                                 if (!Element<ELM>::is_matched(tag))
153                                 {
154                                         if(!ELM::optional)
155                                         {
156                                                 m_ctx.refErrorCtx().tagError(static_cast<uint32_t>(tag));
157                                         }
158                                 }
159                                 else
160                                 {
161                                         m_tag = invalid_tag;
162                                         VisitorAdapter<CONT, ELM>::run(elm, m_ctx, m_cont, tag);
163           elm.setpresent(true);
164                                 }
165                         }
166                 }
167         }
168         
169         tag_value_t get_unhandled_tag() const {return m_tag;}
170         
171         DecoderCtx&     m_ctx;
172         tag_value_t     m_tag {invalid_tag};
173         CONT const&             m_cont;
174 };
175
176 } //namespace ber
177 } //namespace asn