--- /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
+
+// Local Includes: Application specific classes, functions, and libraries
+#include "asn/per/common.hpp"
+#include "asn/per/visitor.hpp"
+
+namespace asn {
+namespace per {
+
+/******************************************************************
+ * Adapter
+ *****************************************************************/
+template <class Container, typename IE, class Enabler = void>
+struct Adapter
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx, Container const& cont)
+ {
+ Element<IE, IE::ie_type>::run(ie, ctx);
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, Container const& cont)
+ {
+ Element<IE, IE::ie_type>::run(ie, ctx);
+ }
+};
+template <class Container, typename IE>
+struct Adapter<Container, IE, std::enable_if_t< (IE::ie_type == element_type::T_OBJFIELD_FTV) >>
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx, Container const& cont)
+ {
+ VisitorEncoder v(ctx);
+ bool rv = ie.encode(v, cont);
+ if(!rv && static_cast<bool>(ctx))
+ {
+ ctx.refErrorCtx().errorNoObject(Container::name());
+ }
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, Container const& cont)
+ {
+ VisitorDecoder v(ctx);
+ bool rv = ie.decode(v, cont);
+ if(!rv && static_cast<bool>(ctx))
+ {
+ ctx.refErrorCtx().errorNoObject(Container::name());
+ }
+ }
+};
+template <class Container, typename IE>
+struct Adapter<Container, IE, std::enable_if_t< (IE::ie_type == element_type::T_OBJFIELD_TF)> >
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx, Container const& cont)
+ {
+ OpenTypeVisitorEncoder v(ctx);
+ bool rv = ie.encode(v, cont);
+ if(!rv && static_cast<bool>(ctx))
+ {
+ ctx.refErrorCtx().errorNoObject(Container::name());
+ }
+ }
+
+ static void inline run(IE& ie, DecoderCtx& ctx, Container const& cont)
+ {
+ OpenTypeVisitorDecoder v(ctx);
+ bool rv = ie.decode(v, cont);
+ if(!rv && static_cast<bool>(ctx))
+ {
+ ctx.refErrorCtx().errorNoObject(Container::name());
+ }
+ if(ie.is_unknown()) //skip the unknown Open Type
+ {
+ size_t size = LengthDeterminantDefault::run(ctx);
+ DecoderCtx::buf_type& buffer = ctx.refBuffer();
+ if (buffer.getBytesLeft() < size)
+ ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), size);
+ else
+ buffer.advance(size);
+ }
+ }
+};
+
+/******************************************************************
+ * RootEncoder
+ *****************************************************************/
+template <class Container>
+struct RootEncoder
+{
+ RootEncoder(EncoderCtx& ctx, Container const& cont) : m_ctx(ctx), m_cont(cont) {}
+
+ template <typename IE>
+ bool operator() (IE const& ie) const
+ {
+ if(!IE::extension)
+ {
+ if(IE::optional && !ie.is_valid())
+ return static_cast<bool>(m_ctx);
+ Adapter<Container, IE>::run(ie, m_ctx, m_cont);
+ }
+ return static_cast<bool>(m_ctx);
+ }
+ EncoderCtx& m_ctx;
+ Container const& m_cont;
+};
+
+/******************************************************************
+ * RootDecoder
+ *****************************************************************/
+template <class Container>
+struct RootDecoder
+{
+ RootDecoder(DecoderCtx& ctx, Container const& cont) : m_ctx(ctx), m_cont(cont) {}
+
+ template <typename IE>
+ bool operator() (IE& ie) const
+ {
+ if(!IE::extension)
+ {
+ if(IE::optional)
+ {
+ if(m_ctx.map_elm())
+ {
+ ie.setpresent(true);
+ Adapter<Container, IE>::run(ie, m_ctx, m_cont);
+ }
+ else
+ ie.setpresent(false);
+ }
+ else
+ {
+ Adapter<Container, IE>::run(ie, m_ctx, m_cont);
+ }
+ }
+ return static_cast<bool>(m_ctx);
+ }
+ DecoderCtx& m_ctx;
+ Container const& m_cont;
+};
+
+/******************************************************************
+ * ExtEncoder
+ *****************************************************************/
+template <class Container>
+struct ExtEncoder
+{
+ explicit ExtEncoder(EncoderCtx& ctx, Container const& cont) : m_ctx(ctx), m_cont(cont) {}
+
+ template <typename IE>
+ bool operator() (IE const& ie) const
+ {
+ if(!IE::extension)
+ return static_cast<bool>(m_ctx);
+
+ if(IE::optional && !ie.is_valid())
+ return static_cast<bool>(m_ctx);
+
+ size_t reserved_size = 1; //1 byte length is most likely
+ Tools::bit_accessor::padByte(m_ctx.refBuffer());
+
+ if (m_ctx.refBuffer().getBytesLeft())
+ {
+ EncoderCtx::buf_type::pointer p = m_ctx.refBuffer().advance(reserved_size);
+ EncoderCtx::buf_type::pointer start = p + reserved_size;
+
+ Adapter<Container, IE>::run(ie, m_ctx, m_cont);
+
+ if (m_ctx)
+ {
+ Tools::bit_accessor::padByte(m_ctx.refBuffer());
+ EncoderCtx::buf_type::pointer p_new = m_ctx.refBuffer().begin();
+ size_t size = p_new - start;
+ size_t needed = LengthDeterminantDefault::bytes_needed(size) - reserved_size;
+ if (needed) //1 byte is not enough for the length determinant. it is hardly possible
+ {
+ if (m_ctx.refBuffer().getBytesLeft() < needed) {
+ m_ctx.refErrorCtx().lengthErrorBytes(m_ctx.refBuffer().getBytesLeft(), needed);
+ return false;
+ }
+ memmove(start + needed, start, size);
+ p_new += needed;
+ }
+ m_ctx.refBuffer().set_begin(p, 0);
+ LengthDeterminantDefault::run(m_ctx, size);
+ if (m_ctx) {
+ m_ctx.refBuffer().set_begin(p_new, 0);
+ Tools::bit_accessor::padByte(m_ctx.refBuffer());
+ }
+ }
+ }
+ else
+ {
+ m_ctx.refErrorCtx().lengthErrorBytes(m_ctx.refBuffer().getBytesLeft(), reserved_size);
+ return false;
+ }
+ return static_cast<bool>(m_ctx);
+ }
+ EncoderCtx& m_ctx;
+ Container const& m_cont;
+};
+
+/******************************************************************
+ * ExtDecoder
+ *****************************************************************/
+template <class Container>
+struct ExtDecoder
+{
+ explicit ExtDecoder(DecoderCtx& ctx, Container const& cont) : m_ctx(ctx), m_cont(cont) {}
+
+ template <typename IE>
+ bool operator() (IE& ie) const
+ {
+ if(!IE::extension)
+ return static_cast<bool>(m_ctx);
+
+ if (m_ctx.map_elm())
+ {
+ ie.setpresent(true);
+ size_t size = LengthDeterminantDefault::run(m_ctx);
+ DecoderCtx::buf_type& buffer = m_ctx.refBuffer();
+ if (buffer.getBytesLeft() < size)
+ {
+ m_ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), size);
+ return false;
+ }
+ DecoderCtx::buf_type::pointer end = buffer.end();
+ buffer.set_end(buffer.begin() + size);
+ Adapter<Container, IE>::run(ie, m_ctx, m_cont);
+ Tools::bit_accessor::padByte(m_ctx.refBuffer());
+ buffer.set_end(end);
+ }
+ else
+ {
+ ie.setpresent(false);
+ }
+
+ return static_cast<bool>(m_ctx);
+ }
+ DecoderCtx& m_ctx;
+ Container const& m_cont;
+};
+
+/******************************************************************
+ * SeqMap
+ *****************************************************************/
+template<class IE, class Enabler = void>
+struct SeqMap;
+
+/*
+template <class IE>
+struct SeqMap<IE, std::enable_if_t< (IE::num_opt_entries > 8) > >
+{
+ static void inline run(EncoderCtx& ctx, size_t val)
+ {
+ u8 k = IE::num_opt_entries / 8; // num of full bytes in a seq map mask
+ u8 fb_bits = IE::num_opt_entries % 8; // num of first byte bits (without padding)
+
+ if (fb_bits) {
+ // Put a part of a first byte (without padding, only seq map own bits)
+ Tools::bit_accessor::put((u8)(val >> 8*k), fb_bits, ctx.refBuffer());
+ }
+
+ // Put other bytes (full bytes)
+ for (int i = (k-1); i >= 0; i--) {
+ Tools::bit_accessor::put((u8)(val >> 8*i), 8, ctx.refBuffer());
+ }
+ }
+
+ static DecoderCtx::map_type inline run(DecoderCtx& ctx)
+ {
+ uint num_opts = IE::num_opt_entries;
+ u64 res = 0;
+ u8 k = 1;
+ u8 lb_bits = IE::num_opt_entries % 8; // num of last byte bits (without padding)
+
+ while (num_opts >= 8) {
+ size_t shift = sizeof(DecoderCtx::map_type) * CHAR_BIT - 8*k;
+
+ DecoderCtx::map_type rval = Tools::bit_accessor::get(8, ctx.refBuffer());
+
+ rval = rval << shift;
+ res |= rval;
+
+ k++;
+ num_opts -= 8;
+ }
+
+ if (lb_bits > 0) {
+ // (8 - lb_bits) - padding in a last byte
+ size_t shift = sizeof(DecoderCtx::map_type) * CHAR_BIT - 8*k + 8 - lb_bits;
+
+ DecoderCtx::map_type rval = Tools::bit_accessor::get(lb_bits, ctx.refBuffer());
+
+ rval = rval << shift;
+ res |= rval;
+ }
+
+ return res;
+ }
+}
+;
+*/
+
+template<class IE>
+struct SeqMap<IE, std::enable_if_t< (IE::num_opt_entries <= 8)> > //todo: to add code for more than 8 optional elements
+{
+ static void inline run(EncoderCtx& ctx, size_t val)
+ {
+ Tools::bit_accessor::put((u8)val, IE::num_opt_entries, ctx.refBuffer());
+ }
+ static DecoderCtx::map_type inline run(DecoderCtx& ctx)
+ {
+ size_t shift = sizeof(DecoderCtx::map_type) * CHAR_BIT - IE::num_opt_entries;
+ DecoderCtx::map_type rval = Tools::bit_accessor::get(IE::num_opt_entries, ctx.refBuffer());
+ rval = rval << shift;
+ return rval;
+ }
+};
+
+/******************************************************************
+ * SeqExtMap
+ *****************************************************************/
+template<class IE, bound_t NumExtEntries, class Enabler = void>
+struct SeqExtMap
+{
+ static void inline run(EncoderCtx& ctx, size_t val) {}
+ static DecoderCtx::map_type inline run(DecoderCtx& ctx)
+ {
+ size_t len = NormallySmallLength<1>::run(ctx);
+ size_t shift = sizeof(DecoderCtx::map_type) * CHAR_BIT - len;
+ u8 tmp;
+ DecoderCtx::map_type rval{ 0 };
+ u8 val;
+
+ while (len) {
+ tmp = len > 8 ? 8 : (u8)len;
+ val = Tools::bit_accessor::get(tmp, ctx.refBuffer());
+ rval = rval << tmp;
+ rval |= val;
+ len -= tmp;
+ }
+ rval = rval << shift;
+ return rval;
+ }
+};
+
+template<class IE, bound_t NumExtEntries>
+struct SeqExtMap<IE, NumExtEntries, std::enable_if_t< ((NumExtEntries <= 8) && (NumExtEntries > 0)) > >
+{
+ static void inline run(EncoderCtx& ctx, size_t val)
+ {
+ NormallySmallLength<NumExtEntries>::run(ctx);
+ Tools::bit_accessor::put((u8)val, NumExtEntries, ctx.refBuffer());
+ }
+};
+
+template<class IE, bound_t NumExtEntries>
+struct SeqExtMap<IE, NumExtEntries, std::enable_if_t< (NumExtEntries > 8) > >
+{
+ static void inline run(EncoderCtx& ctx, size_t val)
+ {
+ NormallySmallLength<NumExtEntries>::run(ctx);
+
+ size_t len = NumExtEntries;
+ size_t tmp;
+
+ while (len) {
+ tmp = len > 8 ? 8 : len;
+ Tools::bit_accessor::put((u8)val, tmp, ctx.refBuffer());
+ val = val >> tmp;
+ len -= tmp;
+ }
+ }
+};
+
+/******************************************************************
+ * SeqMapBuilder
+ *****************************************************************/
+struct SeqMapBuilder
+{
+ SeqMapBuilder(uint64_t& map) : m_map(map) {}
+
+ template<typename IE>
+ bool operator()(IE const& ie)
+ {
+ if(!IE::extension && IE::optional)
+ {
+ m_map = m_map << 1;
+ if(ie.is_valid())
+ m_map |= 1;
+ }
+ return true;
+ }
+ uint64_t& m_map;
+};
+
+/******************************************************************
+ * SeqExtMapBuilder
+ *****************************************************************/
+struct SeqExtMapBuilder
+{
+ SeqExtMapBuilder(uint64_t& map) : m_map(map) {}
+
+ template<typename IE>
+ bool operator()(IE const& ie)
+ {
+ if(IE::extension)
+ {
+ m_map = m_map << 1;
+ if(!IE::optional || (IE::optional && ie.is_valid()))
+ m_map |= 1;
+ }
+ return true;
+ }
+ uint64_t& m_map;
+};
+
+/******************************************************************
+ * SeqNoExtDefault
+ *****************************************************************/
+// Default (No OPT/DEF present within the extension root)
+template <class IE>
+struct SeqNoExtDefault
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ RootEncoder<IE> ve(ctx, ie);
+ ie.encode(ve);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx, DecoderCtx::map_type map = 0)
+ {
+ RootDecoder<IE> ve(ctx, ie);
+
+ DecoderCtx::map_type old_map = ctx.set_map(map);
+ ie.decode(ve);
+ ctx.set_map(old_map);
+ }
+};
+
+/******************************************************************
+ * SeqNoExt
+ *****************************************************************/
+// Default (No OPT/DEF present within the extension root)
+template <class IE, class Enabler = void>
+struct SeqNoExt
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ SeqNoExtDefault<IE>::run(ie, ctx);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx)
+ {
+ SeqNoExtDefault<IE>::run(ie, ctx);
+ }
+};
+
+//18.2 OPT/DEF present within the extension root
+template <class IE>
+struct SeqNoExt<IE, std::enable_if_t< (IE::num_opt_entries > 0) > >
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ uint64_t map = 0;
+ SeqMapBuilder mb(map);
+ ie.encode(mb);
+ SeqMap<IE>::run(ctx, map);
+ SeqNoExtDefault<IE>::run(ie, ctx);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx)
+ {
+ SeqNoExtDefault<IE>::run(ie, ctx, SeqMap<IE>::run(ctx));
+ }
+};
+
+/******************************************************************
+ * Seq
+ *****************************************************************/
+template <class IE, class Enable = void>
+struct Seq;
+
+template <class IE>
+struct Seq<IE, std::enable_if_t< (IE::constraint_t::extended == true)> >
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ uint64_t map = 0;
+ SeqExtMapBuilder emb(map);
+ ie.encode(emb);
+
+ if (map) {
+ Tools::bit_accessor::put(1, 1, ctx.refBuffer());
+ SeqNoExt<IE>::run(ie, ctx);
+ SeqExtMap<IE, IE::num_ext_entries>::run(ctx, map);
+ ExtEncoder<IE> ove(ctx, ie);
+ ie.encode(ove);
+ }
+ else {
+ Tools::bit_accessor::put(0, 1, ctx.refBuffer());
+ SeqNoExt<IE>::run(ie, ctx);
+ }
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx)
+ {
+ u8 ext = Tools::bit_accessor::get(1, ctx.refBuffer());
+ if (ext)
+ {
+ SeqNoExt<IE>::run(ie, ctx);
+
+ auto old_map = ctx.set_map(SeqExtMap<IE, 0>::run(ctx)); // we do not know how many exts can be received
+ {
+ ExtDecoder<IE> ove(ctx, ie);
+ ie.decode(ove);
+
+ auto& buffer = ctx.refBuffer();
+ while(ctx.get_map())
+ {
+ if(ctx.map_elm()) //skip unknown extensions
+ {
+ size_t size = LengthDeterminantDefault::run(ctx);
+ if (buffer.getBytesLeft() < size)
+ {
+ ctx.refErrorCtx().lengthErrorBytes(buffer.getBytesLeft(), size);
+ break;
+ }
+ buffer.advance(size);
+ }
+ }
+ }
+ ctx.set_map(old_map);
+ }
+ else
+ SeqNoExt<IE>::run(ie, ctx);
+ }
+};
+
+template <class IE>
+struct Seq<IE, std::enable_if_t< (IE::constraint_t::extended == false)> >
+{
+ static void inline run(IE const& ie, EncoderCtx& ctx)
+ {
+ SeqNoExt<IE>::run(ie, ctx);
+ }
+ static void inline run(IE& ie, DecoderCtx& ctx)
+ {
+ SeqNoExt<IE>::run(ie, ctx);
+ }
+};
+
+} //namespace per
+} //namespace asn
Code Review / sim / e2-interface.git / blobdiff