--- /dev/null
+#pragma once
+
+/******************************************************************************
+*
+* Copyright (c) 2019 AT&T Intellectual Property.
+* Copyright (c) 2018-2019 Nokia.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+******************************************************************************/
+
+// Standard Includes: ANSI C/C++, MSA, and Third-Party Libraries
+#include <boost/intrusive/list.hpp>
+#include <cstring>
+
+// Local Includes: Application specific classes, functions, and libraries
+#include "asn/constraints.hpp"
+#include "asn/identifier.hpp"
+
+namespace asn {
+
+enum class element_type : uint8_t
+{
+ T_BOOLEAN
+ ,T_INTEGER
+ ,T_ENUMERATED
+ ,T_REAL
+ ,T_BITSTRING
+ ,T_OCTETSTRING
+ ,T_NULL
+ ,T_SEQUENCE
+ ,T_SEQUENCE_OF
+ ,T_SET
+ ,T_SET_OF
+ ,T_CHOICE
+ ,T_OBJECTIDENTIFIER
+ ,T_OBJFIELD_FTV
+ ,T_OBJFIELD_TF
+};
+
+/***************************************************************************************
+* BASE
+***************************************************************************************/
+
+struct base
+{
+ static constexpr bool optional = false;
+ static constexpr bool extension = false;
+
+ static constexpr char const* name() {return "";}
+
+ void setpresent(bool p) {is_set = p;}
+ void clear() {is_set = false;}
+
+ bool is_valid() const {return is_set;}
+
+protected:
+ base() {}
+ void set() {is_set = true;}
+protected:
+ bool is_set {false};
+
+ base& operator=(const base&) = delete;
+ base (const base&) = delete;
+};
+
+/***************************************************************************************
+* IE_NULL
+***************************************************************************************/
+
+struct nulltype : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::NULL_TYPE), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_NULL;
+ static constexpr const char* name() {return "NULL";}
+
+ void clear() {}
+};
+
+/***************************************************************************************
+* T_BOOLEAN
+***************************************************************************************/
+
+struct boolean : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::BOOLEAN), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_BOOLEAN;
+ static constexpr const char* name() {return "BOOLEAN";}
+
+ using value_type = bool;
+
+ void set(value_type vl) { m_value = vl; base::set();}
+ value_type get() const { return m_value; }
+ void clear() { m_value = false; base::clear();}
+
+private:
+ value_type m_value {false};
+};
+
+/***************************************************************************************
+* T_INTEGER
+***************************************************************************************/
+template < class Constraint = constraints<false> >
+struct integer : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::INTEGER), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_INTEGER;
+ static constexpr const char* name() {return "INTEGER";}
+
+ using constraint_t = Constraint;
+ using value_type = int64_t;
+
+ bool equal(value_type v) const {return m_value == v;}
+
+ void set(value_type v) { m_value = v; base::set();}
+ value_type get() const { return m_value; }
+
+ void clear() { m_value = 0; base::clear();}
+
+private:
+ value_type m_value;
+};
+
+/***************************************************************************************
+* T_ENUMERATED
+***************************************************************************************/
+template<int TotalNumEntries, int NumExtEntries, bool Extended>
+struct enumerated : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::ENUMERATED), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_ENUMERATED;
+ static constexpr const char* name() {return "ENUMERATED";}
+
+ using constraint_t = seq_range<TotalNumEntries, NumExtEntries, Extended>;
+ using value_type = typename constraint_t::value_type;
+
+ bool equal(value_type v) const {return m_value == v;}
+ void set(value_type vl) { m_value = vl; base::set();}
+ value_type get() const { return m_value; }
+ void clear() { m_value = constraint_t::default_value; base::clear();}
+
+private:
+ value_type m_value;
+};
+
+/***************************************************************************************
+* T_OCTETSTRING
+***************************************************************************************/
+template< class Constraint = constraints<false> >
+struct ostring : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::OCTET_STRING), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_OCTETSTRING;
+ static constexpr const char* name() {return "OCTET STING";}
+ using constraint_t = Constraint;
+
+ struct value_type
+ {
+ value_type() {}
+ value_type(size_t size, const char* data) : m_size(size), m_data(reinterpret_cast<const uint8_t*>(data)) {}
+
+ size_t size() const { return m_size; }
+ const uint8_t* data() const { return m_data; }
+
+ using const_iterator = uint8_t const*;
+ const_iterator begin() const { return data(); }
+ const_iterator end() const { return begin() + size(); }
+
+ void assign(void const* p, size_t sz) { m_data = static_cast<uint8_t const*>(p); m_size = sz; }
+
+ private:
+ const uint8_t* m_data{ 0 };
+ size_t m_size{ 0 };
+ };
+
+ value_type const& get() const { return m_value; }
+
+ //Use std::string, std::vector or IE_OSTR::value_type
+ template<typename T> value_type const& set(T const& tval)
+ {
+ set(tval.size(), tval.data());
+ base::set();
+ return m_value;
+ }
+
+ void set(size_t size, void const* data)
+ {
+ m_value.assign(data, size);
+ base::set();
+ }
+
+ template<class AT>
+ ostring& emplace(AT& allocator, size_t size, uint8_t const * data_in)
+ {
+ if(size)
+ {
+ base::clear();
+ uint8_t* data_out = allocator.alloc_bytes(size);
+ if (data_out)
+ {
+ memcpy(data_out, data_in, size);
+ set(size, data_out);
+ }
+ }
+ else
+ base::set();
+ return *this;
+ }
+
+ template<class AT, class T>
+ ostring& emplace(AT& allocator, T const& tval)
+ {
+ return emplace(allocator, tval.size(), reinterpret_cast<const uint8_t*>(tval.data()));
+ }
+
+ void clear() { m_value = value_type{}; base::clear();}
+
+private:
+ value_type m_value;
+};
+
+/***************************************************************************************
+* T_BITSTRING
+***************************************************************************************/
+template<class Constraint = constraints<false> >
+struct bstring : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::BIT_STRING), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_BITSTRING;
+ static constexpr const char* name() {return "BIT STING";}
+ using constraint_t = Constraint;
+
+ struct value_type
+ {
+ value_type() {}
+ value_type(size_t size, const char* data, size_t bitqty) : m_size(size), m_data(reinterpret_cast<const uint8_t*>(data)), m_bitqty(bitqty){}
+
+ size_t size() const { return m_size; }
+ const uint8_t* data() const { return m_data; }
+ size_t bitqty() const { return m_bitqty; }
+
+ void assign(void const* p, size_t sz, size_t bits) { m_data = static_cast<uint8_t const*>(p); m_size = sz; m_bitqty = bits; }
+
+ private:
+ const uint8_t* m_data{ nullptr };
+ size_t m_size{ 0 };
+ size_t m_bitqty{ 0 };
+ };
+
+ value_type const& get_buffer() const { return m_value; }
+
+ size_t get_bitqty() const { return m_value.bitqty(); }
+
+ //Use std::string, std::vector or IE_BSTR::value_type
+ template<typename T> value_type const& set_buffer(T& tval, size_t bitqty)
+ {
+ m_value.assign(tval.data(), tval.size(), bitqty);
+ base::set();
+ return m_value;
+ }
+
+ void set_buffer(size_t bitqty, const uint8_t* data)
+ {
+ m_value.assign(data, (bitqty +7) >> 3, bitqty);
+ base::set();
+ }
+
+ template<class AT>
+ bstring& emplace_buffer(AT& allocator, size_t bitqty, uint8_t const * data_in)
+ {
+ size_t size = (bitqty +7) >> 3;
+ uint8_t* data_out = allocator.alloc_bytes(size);
+ if (!data_out) {
+ throw std::bad_alloc();
+ }
+ memcpy(data_out, data_in, size);
+ set_buffer(bitqty, data_out);
+ return *this;
+ }
+
+ void clear() { m_value = value_type{}; base::clear();}
+
+ uint64_t get_number() const
+ {
+ uint64_t retval{0};
+ size_t i = 0;
+ for(; i < m_value.size() - 1; ++i)
+ {
+ retval <<= 8;
+ retval |= m_value.data()[i];
+ }
+
+ uint8_t shift = m_value.bitqty() % 8;
+ if (shift)
+ {
+ retval <<= shift;
+ }
+ else
+ {
+ retval <<= 8;
+ }
+
+ retval |= m_value.data()[i];
+
+ return retval;
+ }
+
+ template<class AT>
+ void set_number(AT& allocator, size_t bitqty, uint64_t data)
+ {
+ size_t size = (bitqty +7) >> 3;
+ uint8_t* data_out = allocator.alloc_bytes(size);
+ if (!data_out) {
+ throw std::bad_alloc();
+ }
+
+ const uint8_t shift = bitqty % 8;
+ if (shift)
+ {
+ data_out[size-1] = data & (0xFF >> (8 - shift));
+ data >>= shift;
+ }
+ else
+ {
+ data_out[size-1] = data & (0xFF);
+ data >>= 8;
+ }
+
+ for (size_t i = 1; i <= size - 1; i++)
+ {
+ data_out[size-1-i] = data & (0xFF);
+ data >>= 8;
+ }
+
+ m_value.assign(data_out, size, bitqty);
+ base::set();
+ }
+
+private:
+ value_type m_value;
+};
+
+/***************************************************************************************
+* T_CHOICE
+***************************************************************************************/
+template<int TotalNumEntries, int NumExtEntries, bool Extended>
+struct choice : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNSPECIFIED, static_cast<tag_value_t>(tag_rvalue_t::CHOICE), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_CHOICE;
+ static constexpr const char* name() {return "CHOICE";}
+
+ using constraint_t = seq_range<TotalNumEntries, NumExtEntries, Extended>;
+ using index_type = size_t;
+ using value_type = size_t;
+
+ static constexpr index_type fst_index = 1;
+ static constexpr index_type ext_index = fst_index + TotalNumEntries;
+
+ static index_type normalize(index_type idx) {return idx - fst_index;}
+ static index_type denormalize(index_type idx) {return idx + fst_index;}
+};
+
+/***************************************************************************************
+* T_SEQUENCE
+***************************************************************************************/
+template<int TotalNumEntries, int NumExtEntries, bool Extended, int NumOptEntries = 0>
+struct sequence : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SEQUENCE), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_SEQUENCE;
+ static constexpr const char* name() {return "SEQUENCE";}
+
+ static constexpr bound_t num_total_entries = TotalNumEntries;
+ static constexpr bound_t num_opt_entries = NumOptEntries;
+ static constexpr bound_t num_ext_entries = NumExtEntries;
+
+ using constraint_t = seq_range<TotalNumEntries, NumExtEntries, Extended>;
+
+};
+
+/***************************************************************************************
+* T_SEQUENCE_OF
+***************************************************************************************/
+template<typename T, class Constraint = constraints<false> >
+struct sequenceof : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SEQUENCE_OF), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_SEQUENCE_OF;
+ static constexpr const char* name() {return "SEQUENCE OF";}
+
+ struct value_type : T, boost::intrusive::list_base_hook< boost::intrusive::link_mode<boost::intrusive::auto_unlink> >
+ {
+ value_type(){}
+ private:
+ value_type& operator=(const value_type&) = delete;
+ value_type (const value_type&) = delete;
+ };
+
+ using values_t = boost::intrusive::list<value_type, boost::intrusive::constant_time_size<false>>;
+ using constraint_t = Constraint;
+ using element_t = T;
+
+ void clear() { m_list.clear(); base::clear();}
+ size_t size() const { return m_list.size(); }
+ template<class Predicate>
+ void sort(Predicate const& p) { m_list.sort(p); }
+
+ template<class V>
+ void set(V& v) {for(auto & e : v) {m_list.push_back(e);} base::set();}
+
+ void push_back(value_type& v) { m_list.push_back(v); base::set();}
+
+ template<class AT> //Note: Allocator must return word alligned buffer!
+ T& emplace_back(AT& allocator)
+ {
+ uint8_t* data = allocator.alloc_bytes(sizeof(value_type));
+ if(!data)
+ throw std::bad_alloc();
+ value_type* v = new (data) value_type;
+ push_back(*v);
+ return *v;
+ };
+
+ using iterator = typename values_t::iterator;
+ iterator begin() { return m_list.begin(); }
+ iterator end() { return m_list.end(); }
+
+ using const_iterator = typename values_t::const_iterator;
+ const_iterator begin() const { return m_list.begin(); }
+ const_iterator end() const { return m_list.end(); }
+
+ sequenceof(){}
+
+private:
+ values_t m_list;
+};
+
+/***************************************************************************************
+* T_OBJFIELD_FTV
+***************************************************************************************/
+template<typename T, bool>
+struct fixedtypefield : T
+{
+ static constexpr element_type ie_type = element_type::T_OBJFIELD_FTV;
+
+ T& ref_nested() {return *this;}
+ T const & ref_nested() const {return *this;}
+};
+
+/***************************************************************************************
+* T_OBJFIELD_TF
+***************************************************************************************/
+template<bool>
+struct typefield : base
+{
+ static constexpr element_type ie_type = element_type::T_OBJFIELD_TF;
+ static constexpr const char* name() {return "type-field";}
+
+ typefield& ref_nested() {return *this;}
+ typefield const& ref_nested() const {return *this;}
+
+ bool is_unknown() const {return false;}
+};
+
+/***************************************************************************************
+* T_OBJECTIDENTIFIER
+***************************************************************************************/
+struct oid : ostring<>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::OBJECT_IDENTIFIER), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_OBJECTIDENTIFIER;
+ static constexpr const char* name() {return "OBJECT IDENTIFIER";}
+};
+
+/***************************************************************************************
+* T_PRINTABLESTRING
+***************************************************************************************/
+template<class Constraint = constraints<false> >
+struct printable_string : ostring<Constraint>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::PrintableString), tag_type_t::IMPLICIT>;
+ static constexpr const char* name() {return "PrintableString";}
+};
+
+/***************************************************************************************
+* T_IA5_STRING
+***************************************************************************************/
+template<class Constraint = constraints<false> >
+struct ia5_string : ostring<Constraint>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::IA5String), tag_type_t::IMPLICIT>;
+ static constexpr const char* name() {return "IA5String";}
+};
+
+/***************************************************************************************
+* T_GRAPHIC_STRING
+***************************************************************************************/
+template<class Constraint = asn::constraints<false> >
+struct graphic_string : ostring<Constraint>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::GraphicString), tag_type_t::IMPLICIT>;
+ static constexpr const char* name() {return "IA5String";}
+};
+
+/***************************************************************************************
+* T_UTF8_STRING
+***************************************************************************************/
+template<class Constraint = asn::constraints<false> >
+struct utf8_string : ostring<Constraint>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::UTF8String), tag_type_t::IMPLICIT>;
+ static constexpr const char* name() {return "UTF8String";}
+};
+
+/***************************************************************************************
+* T_SET
+***************************************************************************************/
+template<int TotalNumEntries, int NumExtEntries, bool Extended, int NumOptEntries = 0>
+struct set : base
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SET), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_SET;
+ static constexpr const char* name() {return "SET";}
+
+ static constexpr bound_t num_total_entries = TotalNumEntries;
+ static constexpr bound_t num_opt_entries = NumOptEntries;
+ static constexpr bound_t num_ext_entries = NumExtEntries;
+
+ using constraint_t = seq_range<TotalNumEntries, NumExtEntries, Extended>;
+};
+
+/***************************************************************************************
+* T_SET_OF
+***************************************************************************************/
+template<typename T, class Constraint = constraints<false> >
+struct setof : sequenceof<T, Constraint>
+{
+ using asn_identifier_t = identifier<class_type_t::UNIVERSAL, static_cast<tag_value_t>(tag_rvalue_t::SET_OF), tag_type_t::IMPLICIT>;
+
+ static constexpr element_type ie_type = element_type::T_SET_OF;
+ static constexpr const char* name() {return "SET OF";}
+};
+} //namespace asn
Code Review / sim / e2-interface.git / blobdiff