├── .gitignore
├── .gitmodules
├── test
    ├── build_utils
    │   ├── CMakeForLibs
    │   └── setof_encode_uper.c
    ├── common
    │   ├── intTests.cpp
    │   ├── boolTests.cpp
    │   ├── enumTests.cpp
    │   ├── stringTests.cpp
    │   ├── definitions.asn1
    │   ├── nestedTests.cpp
    │   ├── optionalTests.cpp
    │   ├── setofTests.cpp
    │   └── sequenceofTests.cpp
    └── CMakeLists.txt
├── docstyle
    ├── footer.html
    ├── header.html
    ├── customdoxygen.css
    └── doxy-boot.js
├── CMakeLists.txt
├── README.md
├── include
    └── asn1cpp
    │   ├── SequenceOf.hpp
    │   ├── Utils.hpp
    │   ├── Encoding.hpp
    │   ├── Getter.hpp
    │   ├── Setter.hpp
    │   ├── SetOf.hpp
    │   ├── Seq.hpp
    │   └── View.hpp
├── .ycm_extra_conf.py
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | *.swp
2 | build/
3 | debugbuild/
4 | html/
5 | *.pyc
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "deps/asn1c"]
2 | 	path = deps/asn1c
3 | 	url = https://github.com/vlm/asn1c.git
4 | 


--------------------------------------------------------------------------------
/test/build_utils/CMakeForLibs:
--------------------------------------------------------------------------------
1 | cmake_minimum_required (VERSION 3.3)
2 | 
3 | project (asn1lib)
4 | 
5 | file(GLOB BUILD_FILES "*.c" "*.h")
6 | 
7 | include_directories(${PROJECT_SOURCE_DIR})
8 | add_library(asn1 ${BUILD_FILES})
9 | 


--------------------------------------------------------------------------------
/test/build_utils/setof_encode_uper.c:
--------------------------------------------------------------------------------
 1 | #include "constr_SEQUENCE_OF.h"
 2 | 
 3 | /* This function is missing and would lead to a compilation error.
 4 |  * See https://github.com/vlm/asn1c/issues/42 */
 5 | 
 6 | asn_enc_rval_t
 7 | SET_OF_encode_uper(asn_TYPE_descriptor_t *td,
 8 |                    asn_per_constraints_t *constraints, void *sptr,
 9 |                    asn_per_outp_t *po)
10 | {
11 |     return SEQUENCE_OF_encode_uper(td, constraints, sptr, po);
12 | }
13 | 


--------------------------------------------------------------------------------
/docstyle/footer.html:
--------------------------------------------------------------------------------
 1 | <!-- HTML footer for doxygen 1.8.8-->
 2 | <!-- start footer part -->
 3 | <!--BEGIN GENERATE_TREEVIEW-->
 4 | <div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
 5 |   <ul>
 6 |     $navpath
 7 |     <li class="footer">$generatedby
 8 |     <a href="http://www.doxygen.org/index.html">
 9 |     <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
10 |   </ul>
11 | </div>
12 | <!--END GENERATE_TREEVIEW-->
13 | </div>
14 | </div>
15 | </div>
16 | </div>
17 | </div>
18 | <!--BEGIN !GENERATE_TREEVIEW-->
19 | <hr class="footer"/><address class="footer"><small>
20 | $generatedby &#160;<a href="http://www.doxygen.org/index.html">
21 | <img class="footer" src="$relpath^doxygen.png" alt="doxygen"/>
22 | </a> $doxygenversion
23 | </small></address>
24 | <!--END !GENERATE_TREEVIEW-->
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.3)
 2 | 
 3 | project (asn1cpp)
 4 | 
 5 | add_definitions(
 6 |     -std=c++11
 7 |     -Wall
 8 |     -Wextra
 9 | )
10 | 
11 | set(ASN_OPTIONS -fwide-types -gen-PER)
12 | 
13 | set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
14 | set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
15 | 
16 | # Add library directories
17 | include_directories(${PROJECT_SOURCE_DIR}/include)
18 | 
19 | if (NOT DEFINED MAKE_TESTS)
20 |     set(MAKE_TESTS 1)
21 | endif()
22 | 
23 | # If enabled, add tests
24 | if (MAKE_TESTS)
25 |     if (NOT EXISTS ${PROJECT_SOURCE_DIR}/deps/asn1c/.git)
26 |         message(FATAL_ERROR "Asn1c repo not initialized, did you run 'git submodule init; git submodule update'?")
27 |     endif()
28 |     # Add and compile asn1c
29 |     include(ExternalProject)
30 |     ExternalProject_Add(asn1c
31 |         SOURCE_DIR ${PROJECT_SOURCE_DIR}/deps/asn1c
32 |         CONFIGURE_COMMAND ${PROJECT_SOURCE_DIR}/deps/asn1c/configure --prefix=${PROJECT_BINARY_DIR}
33 |         BUILD_COMMAND ${MAKE}
34 |     )
35 | 
36 |     ExternalProject_Add_Step(asn1c autoreconf
37 |          COMMAND autoreconf -iv
38 |          WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/deps/asn1c/
39 |          DEPENDERS configure
40 |     )
41 | 
42 |     include(CTest)
43 |     add_subdirectory (${PROJECT_SOURCE_DIR}/test)
44 | endif()
45 | 


--------------------------------------------------------------------------------
/test/common/intTests.cpp:
--------------------------------------------------------------------------------
 1 | #define BOOST_TEST_MODULE intTests
 2 | #define BOOST_TEST_DYN_LINK
 3 | #define BOOST_TEST_MAIN
 4 | #include <boost/test/unit_test.hpp>
 5 | 
 6 | #include "TestInteger.h"
 7 | 
 8 | #include "asn1cpp/Seq.hpp"
 9 | #include "asn1cpp/Getter.hpp"
10 | #include "asn1cpp/Setter.hpp"
11 | #include "asn1cpp/Encoding.hpp"
12 | 
13 | BOOST_AUTO_TEST_CASE( construction ) {
14 |     auto test = asn1cpp::makeSeq(TestInteger);
15 | }
16 | 
17 | BOOST_AUTO_TEST_CASE( assignment ) {
18 |     constexpr int value = 5;
19 | 
20 |     auto test = asn1cpp::makeSeq(TestInteger);
21 | 
22 |     asn1cpp::setField(test->integer, value);
23 | 
24 |     auto v = asn1cpp::getField(test->integer, int);
25 | 
26 |     BOOST_CHECK_EQUAL(value, v);
27 | }
28 | 
29 | BOOST_AUTO_TEST_CASE( encoding ) {
30 |     constexpr int value = 64;
31 | 
32 |     auto test = asn1cpp::makeSeq(TestInteger);
33 | 
34 |     asn1cpp::setField(test->integer, value);
35 | 
36 |     auto str = asn1cpp::ber::encode(test);
37 |     auto recoveredTest = asn1cpp::ber::decode(str, TestInteger);
38 | 
39 |     BOOST_CHECK(recoveredTest);
40 | 
41 |     auto v = asn1cpp::getField(recoveredTest->integer, int);
42 | 
43 |     BOOST_CHECK_EQUAL(value, v);
44 | }
45 | 
46 | BOOST_AUTO_TEST_CASE( copy ) {
47 |     constexpr int value = 5;
48 | 
49 |     auto test = asn1cpp::makeSeq(TestInteger);
50 | 
51 |     asn1cpp::setField(test->integer, value);
52 | 
53 |     auto copy = asn1cpp::Seq<TestInteger>(test);
54 | 
55 |     auto v = asn1cpp::getField(copy->integer, int);
56 | 
57 |     BOOST_CHECK_EQUAL(value, v);
58 |     BOOST_CHECK_EQUAL(test, copy);
59 | }
60 | 


--------------------------------------------------------------------------------
/test/common/boolTests.cpp:
--------------------------------------------------------------------------------
 1 | #define BOOST_TEST_MODULE boolTests
 2 | #define BOOST_TEST_DYN_LINK
 3 | #define BOOST_TEST_MAIN
 4 | #include <boost/test/unit_test.hpp>
 5 | 
 6 | #include "TestBoolean.h"
 7 | 
 8 | #include "asn1cpp/Seq.hpp"
 9 | #include "asn1cpp/Getter.hpp"
10 | #include "asn1cpp/Setter.hpp"
11 | #include "asn1cpp/Encoding.hpp"
12 | 
13 | BOOST_AUTO_TEST_CASE( construction ) {
14 |     auto test = asn1cpp::makeSeq(TestBoolean);
15 | }
16 | 
17 | BOOST_AUTO_TEST_CASE( assignment ) {
18 |     constexpr bool value = true;
19 | 
20 |     auto test = asn1cpp::makeSeq(TestBoolean);
21 | 
22 |     asn1cpp::setField(test->boolean, value);
23 | 
24 |     auto v = asn1cpp::getField(test->boolean, bool);
25 | 
26 |     BOOST_CHECK_EQUAL(value, v);
27 | }
28 | 
29 | BOOST_AUTO_TEST_CASE( encoding ) {
30 |     constexpr bool value = true;
31 | 
32 |     auto test = asn1cpp::makeSeq(TestBoolean);
33 | 
34 |     asn1cpp::setField(test->boolean, value);
35 | 
36 |     auto str = asn1cpp::ber::encode(test);
37 |     auto recoveredTest = asn1cpp::ber::decode(str, TestBoolean);
38 | 
39 |     BOOST_CHECK(recoveredTest);
40 | 
41 |     auto v = asn1cpp::getField(recoveredTest->boolean, bool);
42 | 
43 |     BOOST_CHECK_EQUAL(value, v);
44 | }
45 | 
46 | BOOST_AUTO_TEST_CASE( copy ) {
47 |     constexpr bool value = true;
48 | 
49 |     auto test = asn1cpp::makeSeq(TestBoolean);
50 | 
51 |     asn1cpp::setField(test->boolean, value);
52 | 
53 |     auto copy = asn1cpp::Seq<TestBoolean>(test);
54 | 
55 |     auto v = asn1cpp::getField(copy->boolean, bool);
56 | 
57 |     BOOST_CHECK_EQUAL(value, v);
58 |     BOOST_CHECK_EQUAL(test, copy);
59 | }
60 | 


--------------------------------------------------------------------------------
/test/common/enumTests.cpp:
--------------------------------------------------------------------------------
 1 | #define BOOST_TEST_MODULE enumTests
 2 | #define BOOST_TEST_DYN_LINK
 3 | #define BOOST_TEST_MAIN
 4 | #include <boost/test/unit_test.hpp>
 5 | 
 6 | #include "TestEnum.h"
 7 | 
 8 | #include "asn1cpp/Seq.hpp"
 9 | #include "asn1cpp/Getter.hpp"
10 | #include "asn1cpp/Setter.hpp"
11 | #include "asn1cpp/Encoding.hpp"
12 | 
13 | BOOST_AUTO_TEST_CASE( construction ) {
14 |     auto test = asn1cpp::makeSeq(TestEnum);
15 | }
16 | 
17 | BOOST_AUTO_TEST_CASE( assignment ) {
18 |     constexpr TestEnumType value = TestEnumType_value0;
19 | 
20 |     auto test = asn1cpp::makeSeq(TestEnum);
21 | 
22 |     asn1cpp::setField(test->enm, value);
23 | 
24 |     auto v = asn1cpp::getField(test->enm, TestEnumType);
25 | 
26 |     BOOST_CHECK_EQUAL(value, v);
27 | }
28 | 
29 | BOOST_AUTO_TEST_CASE( encoding ) {
30 |     constexpr TestEnumType value = TestEnumType_value2;
31 | 
32 |     auto test = asn1cpp::makeSeq(TestEnum);
33 | 
34 |     asn1cpp::setField(test->enm, value);
35 | 
36 |     auto str = asn1cpp::ber::encode(test);
37 |     auto recoveredTest = asn1cpp::ber::decode(str, TestEnum);
38 | 
39 |     BOOST_CHECK(recoveredTest);
40 | 
41 |     auto v = asn1cpp::getField(recoveredTest->enm, TestEnumType);
42 | 
43 |     BOOST_CHECK_EQUAL(value, v);
44 | }
45 | 
46 | BOOST_AUTO_TEST_CASE( copy ) {
47 |     constexpr TestEnumType value = TestEnumType_value1;
48 | 
49 |     auto test = asn1cpp::makeSeq(TestEnum);
50 | 
51 |     asn1cpp::setField(test->enm, value);
52 | 
53 |     auto copy = asn1cpp::Seq<TestEnum>(test);
54 | 
55 |     auto v = asn1cpp::getField(copy->enm, TestEnumType);
56 | 
57 |     BOOST_CHECK_EQUAL(value, v);
58 |     BOOST_CHECK_EQUAL(test, copy);
59 | }
60 | 


--------------------------------------------------------------------------------
/test/common/stringTests.cpp:
--------------------------------------------------------------------------------
 1 | #define BOOST_TEST_MODULE stringTests
 2 | #define BOOST_TEST_DYN_LINK
 3 | #define BOOST_TEST_MAIN
 4 | #include <boost/test/unit_test.hpp>
 5 | 
 6 | #include "TestPrintableString.h"
 7 | 
 8 | #include "asn1cpp/Seq.hpp"
 9 | #include "asn1cpp/Getter.hpp"
10 | #include "asn1cpp/Setter.hpp"
11 | #include "asn1cpp/Encoding.hpp"
12 | 
13 | BOOST_AUTO_TEST_CASE( construction ) {
14 |     auto test = asn1cpp::makeSeq(TestPrintableString);
15 | }
16 | 
17 | BOOST_AUTO_TEST_CASE( assignment ) {
18 |     const std::string value = "abcd";
19 | 
20 |     auto test = asn1cpp::makeSeq(TestPrintableString);
21 | 
22 |     asn1cpp::setField(test->string, value);
23 | 
24 |     auto v = asn1cpp::getField(test->string, std::string);
25 | 
26 |     BOOST_CHECK_EQUAL(value, v);
27 | }
28 | 
29 | BOOST_AUTO_TEST_CASE( encoding ) {
30 |     const std::string value = "qwerty";
31 | 
32 |     auto test = asn1cpp::makeSeq(TestPrintableString);
33 | 
34 |     asn1cpp::setField(test->string, value);
35 | 
36 |     auto str = asn1cpp::ber::encode(test);
37 |     auto recoveredTest = asn1cpp::ber::decode(str, TestPrintableString);
38 | 
39 |     BOOST_CHECK(recoveredTest);
40 | 
41 |     auto v = asn1cpp::getField(recoveredTest->string, std::string);
42 | 
43 |     BOOST_CHECK_EQUAL(value, v);
44 | }
45 | 
46 | BOOST_AUTO_TEST_CASE( copy ) {
47 |     const std::string value = "asdfgh";
48 | 
49 |     auto test = asn1cpp::makeSeq(TestPrintableString);
50 | 
51 |     asn1cpp::setField(test->string, value);
52 | 
53 |     auto copy = asn1cpp::Seq<TestPrintableString>(test);
54 | 
55 |     auto v = asn1cpp::getField(copy->string, std::string);
56 | 
57 |     BOOST_CHECK_EQUAL(value, v);
58 |     BOOST_CHECK_EQUAL(test, copy);
59 | }
60 | 


--------------------------------------------------------------------------------
/test/common/definitions.asn1:
--------------------------------------------------------------------------------
 1 | TEST DEFINITIONS AUTOMATIC TAGS ::= BEGIN
 2 | 
 3 |     TestInteger ::= SEQUENCE
 4 |     {
 5 |         integer             INTEGER
 6 |     }
 7 | 
 8 |     TestBoolean ::= SEQUENCE
 9 |     {
10 |         boolean             BOOLEAN
11 |     }
12 | 
13 |     TestPrintableString ::= SEQUENCE
14 |     {
15 |         string              PrintableString
16 |     }
17 | 
18 |     TestEnumType ::= ENUMERATED
19 |     {
20 |         value0              (0),
21 |         value1              (1),
22 |         value2              (2)
23 |     }
24 | 
25 |     TestEnum ::= SEQUENCE
26 |     {
27 |         enm                 TestEnumType
28 |     }
29 | 
30 |     TestNested ::= SEQUENCE
31 |     {
32 |         nested              TestInteger
33 |     }
34 | 
35 |     TestOptional ::= SEQUENCE
36 |     {
37 |         integer             INTEGER OPTIONAL,
38 |         string              PrintableString OPTIONAL,
39 |         boolean             BOOLEAN OPTIONAL,
40 |         sequence            SEQUENCE OF INTEGER OPTIONAL,
41 |         nested              SEQUENCE OF TestInteger OPTIONAL
42 |     }
43 | 
44 |     TestSequenceOf ::= SEQUENCE
45 |     {
46 |         integer             SEQUENCE OF INTEGER,
47 |         string              SEQUENCE OF PrintableString,
48 |         boolean             SEQUENCE OF BOOLEAN,
49 |         nested              SET OF TestInteger
50 |     }
51 | 
52 |     -- Unfortunately even if SEQUENCE OF depends on the SET OF code, we have an
53 |     -- inverse dependency since the asn1 compiler does not produce the
54 |     -- SET_OF_encode_uper function, and we use the SEQUENCE OF one to fix this
55 |     -- and allow compilation of the generated sources.
56 |     TestSetOf ::= SEQUENCE
57 |     {
58 |         integer             SET OF INTEGER,
59 |         string              SET OF PrintableString,
60 |         boolean             SET OF BOOLEAN,
61 |         nested              SET OF TestInteger
62 |     }
63 | 
64 | END
65 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | asn1cpp: A memory-safe C++ wrapper on top of asn1c
 2 | ==================================================
 3 | 
 4 | This project tries to create a memory-safe and easy to use modern C++ wrapper
 5 | around the code generated by the [asn1c project](https://github.com/vlm/asn1c).
 6 | 
 7 | The project is completely header-only: just include the headers in your project
 8 | and you're ready to use it.
 9 | 
10 | Feel free to explore the `test` folder in order to see examples on how the
11 | library is used.
12 | 
13 | Requirements
14 | ------------
15 | 
16 | This library only requires that you have a C++11 compliant compiler, and nothing
17 | else.
18 | 
19 | Building the tests
20 | ------------------
21 | 
22 | The repository includes a series of tests. The tests are not necessary if you
23 | just wish to use the library.
24 | 
25 | If you wish to build and run them, you need first to install the [Boost
26 | Test](http://www.boost.org/doc/libs/1_64_0/libs/test/doc/html/index.html)
27 | library.
28 | 
29 | Then you can simply follow the following instructions from the repository's
30 | root folder:
31 | 
32 | ```
33 | git submodule init
34 | git submodule update
35 | mkdir build
36 | cd build
37 | cmake ..
38 | make
39 | ```
40 | 
41 | This will build all the tests. To run the tests, run:
42 | 
43 | ```
44 | ctest -V
45 | ```
46 | 
47 | from the `build` folder you have created.
48 | 
49 | To run the tests with `valgrind`, run:
50 | 
51 | ```
52 | ctest -D ExperimentalMemCheck -V
53 | ```
54 | 
55 | Documentation
56 | -------------
57 | 
58 | The asn1cpp library is fully documented.
59 | 
60 | The Doxygen documentation will export only the API of the library, so to avoid
61 | providing you with unnecessary text to read. To generate the Doxygen
62 | documentation simply run
63 | 
64 | ```
65 | doxygen
66 | ```
67 | 
68 | Within the project's folder. It will automatically create an `html` folder which
69 | contains the generated documentation. Detailed informations on the library's
70 | usage can be found under the `Related Pages` section.
71 | 
72 | In order to have more information about the internals feel free to read the
73 | documentation in the code itself. This should be unnecessary in order to simply
74 | use the library, and should be needed only if you need to extend some particular
75 | functionality.
76 | 


--------------------------------------------------------------------------------
/docstyle/header.html:
--------------------------------------------------------------------------------
 1 | <!-- HTML header for doxygen 1.8.8-->
 2 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 3 | <html xmlns="http://www.w3.org/1999/xhtml">
 4 |     <head>
 5 |         <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |         <!-- For Mobile Devices -->
 7 |         <meta name="viewport" content="width=device-width, initial-scale=1">
 8 | 
 9 |         <meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
10 |         <meta name="generator" content="Doxygen $doxygenversion"/>
11 |         
12 |         <script type="text/javascript" src="https://code.jquery.com/jquery-2.1.1.min.js"></script>
13 | 
14 |         <!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
15 |         <!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
16 |         <!--<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>-->
17 |         <script type="text/javascript" src="$relpath^dynsections.js"></script>
18 |         $treeview
19 |         $search
20 |         $mathjax
21 |         <link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
22 |         $extrastylesheet
23 |         <link href='https://fonts.googleapis.com/css?family=Roboto+Slab' rel='stylesheet' type='text/css'>
24 |         <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/css/bootstrap.min.css">
25 |         <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js"></script>
26 |         <script type="text/javascript" src="$relpath^doxy-boot.js"></script>
27 |     </head>
28 |     <body>
29 |         <nav class="navbar navbar-default" role="navigation">
30 |             <div class="container">
31 |                 <div class="navbar-header">
32 |                     <a class="navbar-brand">$projectname $projectnumber</a>
33 |                 </div>
34 |             </div>
35 |         </nav>
36 |         <div id="top"><!-- do not remove this div, it is closed by doxygen! -->
37 |             <div class="content" id="content">
38 |                 <div class="container">
39 |                     <div class="row">
40 |                         <div class="col-sm-12 panel " style="padding-bottom: 15px;">
41 |                             <div style="margin-bottom: 15px;">
42 | <!-- end header part -->
43 | 


--------------------------------------------------------------------------------
/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.3)
 2 | 
 3 | set(GEN_FOLDER ${PROJECT_BINARY_DIR}/gen)
 4 | set(ASN_CMAKE ${PROJECT_SOURCE_DIR}/test/build_utils/CMakeForLibs)
 5 | set(ADDITIONAL_SOURCES ${PROJECT_SOURCE_DIR}/test/build_utils/setof_encode_uper.c)
 6 | 
 7 | function (SetupSuite SUITE)
 8 |     set(ASN1_FILE ${PROJECT_SOURCE_DIR}/test/${SUITE}/definitions.asn1)
 9 |     set(SUITE_FOLDER ${GEN_FOLDER}/${SUITE})
10 | 
11 |     # Generating asn1 C files for this suite
12 |     add_custom_command(OUTPUT ${SUITE_FOLDER}
13 |         COMMAND rm -rf ${SUITE_FOLDER}
14 |         COMMAND mkdir -p ${SUITE_FOLDER}
15 |         COMMAND cd ${SUITE_FOLDER} && ${PROJECT_BINARY_DIR}/bin/asn1c ${ASN_OPTIONS} ${ASN1_FILE}
16 |         COMMAND rm -f ${SUITE_FOLDER}/converter-sample.c
17 |         COMMAND cp ${ADDITIONAL_SOURCES} ${SUITE_FOLDER}
18 |         COMMAND cp ${ASN_CMAKE} ${SUITE_FOLDER}/CMakeLists.txt
19 |         WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
20 |         DEPENDS asn1c ${ASN1_FILE} ${ASN_CMAKE}
21 |     )
22 |     add_custom_target(gen_${SUITE} DEPENDS ${SUITE_FOLDER})
23 | 
24 |     # Building library on the fly
25 |     add_custom_command(OUTPUT ${SUITE_FOLDER}/build/libasn1.a
26 |         COMMAND mkdir -p build
27 |         COMMAND cd build && cmake .. && make
28 |         WORKING_DIRECTORY ${SUITE_FOLDER}
29 |         DEPENDS gen_${SUITE}
30 |     )
31 |     add_custom_target(libasn1 DEPENDS ${SUITE_FOLDER}/build/libasn1.a)
32 | 
33 |     # Export the library so it can be used
34 |     add_library(${SUITE}_lib STATIC IMPORTED GLOBAL)
35 |     add_dependencies(${SUITE}_lib libasn1)
36 |     set_target_properties(${SUITE}_lib PROPERTIES
37 |         IMPORTED_LOCATION ${SUITE_FOLDER}/build/libasn1.a)
38 | endfunction (SetupSuite)
39 | 
40 | function (AddTest SUITE TEST)
41 |     set(SUITE_FOLDER ${GEN_FOLDER}/${SUITE})
42 |     set(EXE ${SUITE}_${TEST})
43 |     add_executable(${EXE}Tests ./${SUITE}/${TEST}Tests.cpp)
44 |     target_link_libraries(${EXE}Tests ${SUITE}_lib ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
45 |     target_include_directories(${EXE}Tests PRIVATE ${SUITE_FOLDER})
46 |     add_test(NAME ${EXE} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND $<TARGET_FILE:${EXE}Tests>)
47 | endfunction (AddTest)
48 | 
49 | find_package(Boost 1.53 COMPONENTS unit_test_framework REQUIRED)
50 | include_directories(${Boost_INCLUDE_DIRS})
51 | 
52 | SetupSuite(common)
53 | AddTest(common int)
54 | AddTest(common bool)
55 | AddTest(common string)
56 | AddTest(common enum)
57 | AddTest(common optional)
58 | AddTest(common nested)
59 | AddTest(common setof)
60 | AddTest(common sequenceof)
61 | 


--------------------------------------------------------------------------------
/include/asn1cpp/SequenceOf.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef ASN1CPP_SEQUENCEOF_HEADER_FILE
 2 | #define ASN1CPP_SEQUENCEOF_HEADER_FILE
 3 | 
 4 | #include "asn1cpp/SetOf.hpp"
 5 | 
 6 | namespace asn1cpp {
 7 |     namespace sequenceof {
 8 |         template <typename T>
 9 |         int getSize(const T& field) {
10 |             return setof::getSize(field);
11 |         }
12 | 
13 |         template <typename R, typename T>
14 |         R getterField(const T& field, int id, bool *ok = nullptr) {
15 |             return setof::getterField<R>(field, id, ok);
16 |         }
17 | 
18 |         template <typename T>
19 |         Seq<typename setof::Impl::ArrayType<T>::type> getterSeq(const T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
20 |             return setof::getterSeq(field, def, id, ok);
21 |         }
22 | 
23 |         template <typename T>
24 |         View<const typename setof::Impl::ArrayType<T>::type> getterView(const T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
25 |             return setof::getterView(field, def, id, ok);
26 |         }
27 | 
28 |         template <typename T>
29 |         View<typename setof::Impl::ArrayType<T>::type> getterView(T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
30 |             return setof::getterView(field, def, id, ok);
31 |         }
32 | 
33 |         template <typename T, typename V>
34 |         bool setterField(T & field, const V & value, int id) {
35 |             return setof::setterField(field, value, id);
36 |         }
37 | 
38 |         template <typename T, typename V>
39 |         bool adderElement(T & field, const V & value) {
40 |             return setof::adderElement(field, value);
41 |         }
42 | 
43 |         template <typename T>
44 |         bool removerElement(T & field, int id, asn_TYPE_descriptor_t * def) {
45 |             if (id < 0 || id >= getSize(field))
46 |                 return false;
47 | 
48 |             auto p = field.list.array[id];
49 |             // Note that here we use the sequence del, not the set
50 |             asn_sequence_del(&field, id, 0);
51 |             def->free_struct(def, p, 0);
52 |             return true;
53 |         }
54 | 
55 |         template <typename T>
56 |         bool removerElement(T *& field, int id, asn_TYPE_descriptor_t * def) {
57 |             if (!field) return false;
58 | 
59 |             return removerElement(*field, id, def);
60 |         }
61 | 
62 |         template <typename T>
63 |         void clearerField(T & field, asn_TYPE_descriptor_t * def) {
64 |             setof::clearerField(field, def);
65 |         }
66 |     }
67 | }
68 | 
69 | #endif
70 | 


--------------------------------------------------------------------------------
/test/common/nestedTests.cpp:
--------------------------------------------------------------------------------
  1 | #define BOOST_TEST_MODULE nestedTests
  2 | #define BOOST_TEST_DYN_LINK
  3 | #define BOOST_TEST_MAIN
  4 | #include <boost/test/unit_test.hpp>
  5 | 
  6 | #include "TestNested.h"
  7 | 
  8 | #include "asn1cpp/Seq.hpp"
  9 | #include "asn1cpp/View.hpp"
 10 | #include "asn1cpp/Getter.hpp"
 11 | #include "asn1cpp/Setter.hpp"
 12 | #include "asn1cpp/Encoding.hpp"
 13 | 
 14 | BOOST_AUTO_TEST_CASE( construction ) {
 15 |     auto test = asn1cpp::makeSeq(TestNested);
 16 | }
 17 | 
 18 | BOOST_AUTO_TEST_CASE( assignment ) {
 19 |     constexpr unsigned value = 98;
 20 | 
 21 |     auto test = asn1cpp::makeSeq(TestNested);
 22 | 
 23 |     asn1cpp::setField(test->nested.integer, value);
 24 | 
 25 |     auto v = asn1cpp::getField(test->nested.integer, unsigned);
 26 | 
 27 |     BOOST_CHECK_EQUAL(v, value);
 28 | }
 29 | 
 30 | BOOST_AUTO_TEST_CASE( view_assignment ) {
 31 |     constexpr unsigned value = 44;
 32 |     auto test = asn1cpp::makeSeq(TestNested);
 33 | 
 34 |     auto view = asn1cpp::getView(test->nested, TestInteger);
 35 | 
 36 |     asn1cpp::setField(view->integer, value);
 37 | 
 38 |     auto v = asn1cpp::getField(test->nested.integer, unsigned);
 39 | 
 40 |     BOOST_CHECK_EQUAL(v, value);
 41 | }
 42 | 
 43 | BOOST_AUTO_TEST_CASE( view_copy ) {
 44 |     constexpr unsigned value = 44;
 45 |     auto test = asn1cpp::makeSeq(TestNested);
 46 | 
 47 |     auto view = asn1cpp::getView(test->nested, TestInteger);
 48 | 
 49 |     asn1cpp::setField(view->integer, value);
 50 | 
 51 |     auto copy = asn1cpp::Seq<TestInteger>(view);
 52 | 
 53 |     auto v = asn1cpp::getField(copy->integer, unsigned);
 54 | 
 55 |     BOOST_CHECK_EQUAL(v, value);
 56 |     BOOST_CHECK_EQUAL(view, copy);
 57 | }
 58 | 
 59 | BOOST_AUTO_TEST_CASE( view_const ) {
 60 |     constexpr unsigned value = 44;
 61 |     auto test = asn1cpp::makeSeq(TestNested);
 62 |     asn1cpp::setField(test->nested.integer, value);
 63 | 
 64 |     asn1cpp::View<const TestInteger> view = asn1cpp::getView(test->nested, TestInteger);
 65 | 
 66 |     auto testValue = asn1cpp::getField(test->nested.integer, unsigned);
 67 |     auto viewValue = asn1cpp::getField(view->integer, unsigned);
 68 | 
 69 |     BOOST_CHECK_EQUAL(testValue, viewValue);
 70 | 
 71 |     const auto const_view = asn1cpp::getView(test->nested, TestInteger);
 72 |     asn1cpp::View<const TestInteger> internal_const_view = const_view;
 73 | 
 74 |     auto v1 = asn1cpp::getField(const_view->integer, unsigned);
 75 |     auto v2 = asn1cpp::getField(internal_const_view->integer, unsigned);
 76 | 
 77 |     BOOST_CHECK_EQUAL(testValue, v1);
 78 |     BOOST_CHECK_EQUAL(v1, v2);
 79 | }
 80 | 
 81 | BOOST_AUTO_TEST_CASE( to_view_assignment ) {
 82 |     constexpr unsigned value = 897;
 83 |     auto test = asn1cpp::makeSeq(TestNested);
 84 | 
 85 |     auto view = asn1cpp::getView(test->nested, TestInteger);
 86 | 
 87 |     asn1cpp::setField(view->integer, value);
 88 | 
 89 |     auto v = asn1cpp::getField(test->nested.integer, unsigned);
 90 | 
 91 |     BOOST_CHECK_EQUAL(v, value);
 92 | 
 93 |     constexpr unsigned otherValue = 777;
 94 |     auto other = asn1cpp::makeSeq(TestInteger);
 95 |     asn1cpp::setField(other->integer, otherValue);
 96 | 
 97 |     view = other;
 98 |     auto vv = asn1cpp::getField(test->nested.integer, unsigned);
 99 |     auto otherv = asn1cpp::getField(other->integer, unsigned);
100 | 
101 |     BOOST_CHECK_EQUAL(vv, otherValue);
102 |     BOOST_CHECK_EQUAL(otherv, otherValue);
103 | }
104 | 
105 | BOOST_AUTO_TEST_CASE( encoding ) {
106 |     constexpr unsigned value = 98;
107 |     auto test = asn1cpp::makeSeq(TestNested);
108 | 
109 |     asn1cpp::setField(test->nested.integer, value);
110 | 
111 |     auto str = asn1cpp::ber::encode(test);
112 |     auto recoveredTest = asn1cpp::ber::decode(str, TestNested);
113 | 
114 |     BOOST_CHECK_EQUAL(test, recoveredTest);
115 | }
116 | 


--------------------------------------------------------------------------------
/include/asn1cpp/Utils.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_UTILS_HEADER_FILE
  2 | #define ASN1CPP_UTILS_HEADER_FILE
  3 | 
  4 | #include <type_traits>
  5 | 
  6 | #include "asn_application.h"
  7 | 
  8 | // This macro is used in order to be able to access an asn1c struct definition
  9 | // just by the type name.
 10 | #define ASN1CPP_ASN1C_DEF(T) asn_DEF_##T
 11 | 
 12 | namespace asn1cpp {
 13 |     /**
 14 |      * @brief This struct represents whether a particular class fulfills our asn1c wrapped interface.
 15 |      *
 16 |      * This is used in order to enable template constructors from classes that
 17 |      * fulfill the asn1c wrapped interface we use in this library.
 18 |      *
 19 |      * Note that simply implementing the interface is not a guarantee that
 20 |      * everything will work right: if your interface breaks any invariants we
 21 |      * assume it will break (for example, we assume that getTypeDescriptor()
 22 |      * never returns nullptr).
 23 |      */
 24 |     template <typename W>
 25 |     struct is_asn1_wrapper {
 26 |         enum { value = false };
 27 |     };
 28 | 
 29 |     template <template <typename> class W, typename T>
 30 |     struct is_asn1_wrapper<W<T>>{
 31 |         private:
 32 |             template <typename Z> static constexpr auto test(int) -> decltype(
 33 | 
 34 |                     static_cast<asn_TYPE_descriptor_t * (Z::*)() const>                     (&Z::getTypeDescriptor),
 35 |                     static_cast<T & (Z::*)()>                                               (&Z::operator*),
 36 |                     static_cast<const T & (Z::*)() const>                                   (&Z::operator*),
 37 |                     static_cast<T * (Z::*)()>                                               (&Z::operator->),
 38 |                     static_cast<const T * (Z::*)() const>                                   (&Z::operator->),
 39 | 
 40 |                     bool()
 41 |             ) { return true; }
 42 | 
 43 |             template <typename Z> static constexpr auto test(...) -> bool
 44 |             { return false; }
 45 | 
 46 |         public:
 47 |             enum { value = test<W<T>>(0) };
 48 |     };
 49 | 
 50 |     /**
 51 |      * @brief This struct represents whether two asn1 wrappers contain the same type.
 52 |      */
 53 |     template <typename A, typename B>
 54 |     struct are_compatible_asn1_wrappers {
 55 |         enum { value = false };
 56 |     };
 57 | 
 58 |     template <template <typename> class W, typename T,
 59 |               template <typename> class Z, typename Y>
 60 |     struct are_compatible_asn1_wrappers<W<T>, Z<Y>> {
 61 |         public:
 62 |             enum {
 63 |                 value = is_asn1_wrapper<W<T>>::value &&
 64 |                         is_asn1_wrapper<Z<Y>>::value &&
 65 |                         std::is_same<
 66 |                             typename std::remove_cv<T>::type,
 67 |                             typename std::remove_cv<Y>::type
 68 |                         >::value
 69 |             };
 70 |     };
 71 | 
 72 |     /**
 73 |      * @brief This struct represents whether an asn1 wrapper can be converted to another.
 74 |      *
 75 |      * This checks whether the first input both has the same type as the second
 76 |      * input, and that the first input is at least as const as the second.
 77 |      *
 78 |      * This avoids bypassing const and having non-const wrappers from const
 79 |      * wrappers.
 80 |      */
 81 |     template <typename A, typename B>
 82 |     struct is_convertible_asn1_wrapper {
 83 |         enum { value = false };
 84 |     };
 85 | 
 86 |     template <template <typename> class W, typename T,
 87 |               template <typename> class Z, typename Y>
 88 |     struct is_convertible_asn1_wrapper<W<T>, Z<Y>> {
 89 |         public:
 90 |             enum {
 91 |                 value = is_asn1_wrapper<W<T>>::value &&
 92 |                         is_asn1_wrapper<Z<Y>>::value &&
 93 |                         (
 94 |                          std::is_same<T, Y>::value ||
 95 |                          std::is_same<
 96 |                             typename std::remove_cv<T>::type,
 97 |                             Y
 98 |                          >::value
 99 |                         )
100 |             };
101 |     };
102 | }
103 | 
104 | #endif
105 | 


--------------------------------------------------------------------------------
/.ycm_extra_conf.py:
--------------------------------------------------------------------------------
  1 | # This file is NOT licensed under the GPLv3, which is the license for the rest
  2 | # of YouCompleteMe.
  3 | #
  4 | # Here's the license text for this file:
  5 | #
  6 | # This is free and unencumbered software released into the public domain.
  7 | #
  8 | # Anyone is free to copy, modify, publish, use, compile, sell, or
  9 | # distribute this software, either in source code form or as a compiled
 10 | # binary, for any purpose, commercial or non-commercial, and by any
 11 | # means.
 12 | #
 13 | # In jurisdictions that recognize copyright laws, the author or authors
 14 | # of this software dedicate any and all copyright interest in the
 15 | # software to the public domain. We make this dedication for the benefit
 16 | # of the public at large and to the detriment of our heirs and
 17 | # successors. We intend this dedication to be an overt act of
 18 | # relinquishment in perpetuity of all present and future rights to this
 19 | # software under copyright law.
 20 | #
 21 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 22 | # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 23 | # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 24 | # IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 25 | # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 26 | # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 27 | # OTHER DEALINGS IN THE SOFTWARE.
 28 | #
 29 | # For more information, please refer to <http://unlicense.org/>
 30 | 
 31 | import os
 32 | import ycm_core
 33 | 
 34 | # These are the compilation flags that will be used in case there's no
 35 | # compilation database set (by default, one is not set).
 36 | # CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
 37 | flags = [
 38 | '-Wall',
 39 | '-Wextra',
 40 | '-Werror',
 41 | '-Wno-long-long',
 42 | '-Wno-variadic-macros',
 43 | '-fexceptions',
 44 | '-DNDEBUG',
 45 | '-DUSE_CLANG_COMPLETER',
 46 | # THIS IS IMPORTANT! Without a "-std=<something>" flag, clang won't know which
 47 | # language to use when compiling headers. So it will guess. Badly. So C++
 48 | # headers will be compiled as C headers. You don't want that so ALWAYS specify
 49 | # a "-std=<something>".
 50 | # For a C project, you would set this to something like 'c99' instead of
 51 | # 'c++11'.
 52 | '-std=c++11',
 53 | # ...and the same thing goes for the magic -x option which specifies the
 54 | # language that the files to be compiled are written in. This is mostly
 55 | # relevant for c++ headers.
 56 | # For a C project, you would set this to 'c' instead of 'c++'.
 57 | '-x',
 58 | 'c++',
 59 | '-Iinclude/',
 60 | '-Ibuild/gen/common/'
 61 | ]
 62 | 
 63 | # Set this to the absolute path to the folder (NOT the file!) containing the
 64 | # compile_commands.json file to use that instead of 'flags'. See here for
 65 | # more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
 66 | #
 67 | # Most projects will NOT need to set this to anything; you can just change the
 68 | # 'flags' list of compilation flags. Notice that YCM itself uses that approach.
 69 | compilation_database_folder = ''
 70 | 
 71 | if compilation_database_folder:
 72 |   database = ycm_core.CompilationDatabase( compilation_database_folder )
 73 | else:
 74 |   database = None
 75 | 
 76 | 
 77 | def DirectoryOfThisScript():
 78 |   return os.path.dirname( os.path.abspath( __file__ ) )
 79 | 
 80 | 
 81 | def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
 82 |   if not working_directory:
 83 |     return list( flags )
 84 |   new_flags = []
 85 |   make_next_absolute = False
 86 |   path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
 87 |   for flag in flags:
 88 |     new_flag = flag
 89 | 
 90 |     if make_next_absolute:
 91 |       make_next_absolute = False
 92 |       if not flag.startswith( '/' ):
 93 |         new_flag = os.path.join( working_directory, flag )
 94 | 
 95 |     for path_flag in path_flags:
 96 |       if flag == path_flag:
 97 |         make_next_absolute = True
 98 |         break
 99 | 
100 |       if flag.startswith( path_flag ):
101 |         path = flag[ len( path_flag ): ]
102 |         new_flag = path_flag + os.path.join( working_directory, path )
103 |         break
104 | 
105 |     if new_flag:
106 |       new_flags.append( new_flag )
107 |   return new_flags
108 | 
109 | 
110 | def FlagsForFile( filename ):
111 |   if database:
112 |     # Bear in mind that compilation_info.compiler_flags_ does NOT return a
113 |     # python list, but a "list-like" StringVec object
114 |     compilation_info = database.GetCompilationInfoForFile( filename )
115 |     final_flags = MakeRelativePathsInFlagsAbsolute(
116 |       compilation_info.compiler_flags_,
117 |       compilation_info.compiler_working_dir_ )
118 | 
119 |     # NOTE: This is just for YouCompleteMe; it's highly likely that your project
120 |     # does NOT need to remove the stdlib flag. DO NOT USE THIS IN YOUR
121 |     # ycm_extra_conf IF YOU'RE NOT 100% YOU NEED IT.
122 |     try:
123 |       final_flags.remove( '-stdlib=libc++' )
124 |     except ValueError:
125 |       pass
126 |   else:
127 |     relative_to = DirectoryOfThisScript()
128 |     final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
129 | 
130 |   return {
131 |     'flags': final_flags,
132 |     'do_cache': True
133 |   }
134 | 


--------------------------------------------------------------------------------
/include/asn1cpp/Encoding.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_ENCODING_HEADER_FILE
  2 | #define ASN1CPP_ENCODING_HEADER_FILE
  3 | 
  4 | #include <string>
  5 | 
  6 | #include "asn_application.h"
  7 | 
  8 | #include "asn1cpp/Utils.hpp"
  9 | 
 10 | namespace asn1cpp {
 11 |     template <typename T>
 12 |     class Seq;
 13 | 
 14 |     namespace Impl {
 15 |         inline int fill(const void * buffer, size_t size, void * appKey) {
 16 |             std::string * str = static_cast<std::string*>(appKey);
 17 |             if (!str)
 18 |                 return -1;
 19 |             str->append((const char*)buffer, size);
 20 |             return 0;
 21 |         }
 22 |     }
 23 | 
 24 |     namespace ber {
 25 |         /**
 26 |          * @ingroup API
 27 |          * @brief Encodes an asn1cpp wrapper to an std::string.
 28 |          *
 29 |          * \sa decode(m, T)
 30 |          */
 31 |         template <typename T, typename = typename std::enable_if<is_asn1_wrapper<T>::value>::type>
 32 |         std::string encode(const T & m) {
 33 |             if (!m) return {};
 34 |             std::string retval;
 35 |             const auto er = der_encode(m.getTypeDescriptor(), (void*)(&*m), Impl::fill, &retval);
 36 |             return er.encoded < 0 ? std::string() : retval;
 37 |         }
 38 | 
 39 |         template <typename T>
 40 |         Seq<T> decode(asn_TYPE_descriptor_t * def, const std::string & buffer) {
 41 |             if (buffer.size() == 0) return Seq<T>();
 42 | 
 43 |             T * m = nullptr;
 44 |             const auto dr = ber_decode(0, def, (void**)&m, buffer.data(), buffer.size());
 45 | 
 46 |             if (dr.code != RC_OK) {
 47 |                 def->free_struct(def, m, 0);
 48 |                 return Seq<T>();
 49 |             }
 50 | 
 51 |             return Seq<T>(def, m);
 52 |         }
 53 |     }
 54 | 
 55 |     namespace xer {
 56 |         /**
 57 |          * @ingroup API
 58 |          * @brief Encodes an asn1cpp wrapper to an std::string.
 59 |          *
 60 |          * \sa decode(m, T)
 61 |          */
 62 |         template <typename T, typename = typename std::enable_if<is_asn1_wrapper<T>::value>::type>
 63 |         std::string encode(const T & m) {
 64 |             if (!m) return {};
 65 |             std::string retval;
 66 |             const auto er = xer_encode(m.getTypeDescriptor(), (void*)(&*m), XER_F_BASIC, Impl::fill, &retval);
 67 |             return er.encoded < 0 ? std::string() : retval;
 68 |         }
 69 |     }
 70 | 
 71 |     namespace uper {
 72 |         /**
 73 |          * @ingroup API
 74 |          * @brief Encodes an asn1cpp wrapper to an std::string.
 75 |          *
 76 |          * \sa decode(m, T)
 77 |          */
 78 |         template <typename T, typename = typename std::enable_if<is_asn1_wrapper<T>::value>::type>
 79 |         std::string encode(const T & m) {
 80 |             if (!m) return {};
 81 |             std::string retval;
 82 |             const auto er = uper_encode(m.getTypeDescriptor(), (void*)(&*m), Impl::fill, &retval);
 83 |             return er.encoded < 0 ? std::string() : retval;
 84 |         }
 85 | 
 86 |         template <typename T>
 87 |         Seq<T> decode(asn_TYPE_descriptor_t * def, const std::string & buffer) {
 88 |             if (buffer.size() == 0) return Seq<T>();
 89 | 
 90 |             T * m = nullptr;
 91 |             const auto dr = uper_decode_complete(0, def, (void**)&m, buffer.data(), buffer.size());
 92 | 
 93 |             if (dr.code != RC_OK) {
 94 |                 def->free_struct(def, m, 0);
 95 |                 return Seq<T>();
 96 |             }
 97 | 
 98 |             return Seq<T>(def, m);
 99 |         }
100 |     }
101 | }
102 | 
103 | /**
104 |  * @page EncodingPage Encoding and Decoding with asn1cpp
105 |  *
106 |  * All functions described here can be found in the \ref API group.
107 |  *
108 |  * Note that in asn1cpp some functions are macros due to the need to
109 |  * automatically access the asn1c type descriptors from type names. This may
110 |  * not play nice with your autocompletion features.
111 |  *
112 |  * Encoding and Decoding
113 |  * ---------------------
114 |  *
115 |  * Encoding and decoding is done through the `encode` and `decode` functions.
116 |  * Accessing a specific type of encoding/decoding is done through namespaces.
117 |  * The `ber` namespace offers access to the `encode` and `decode` functions for
118 |  * BER encoding, the `uper` namespaces does the same for UPER, and so on.
119 |  *
120 |  * Encoding and decoding an asn1cpp wrapper (be it a asn1cpp::Seq or a
121 |  * asn1cpp::View) is extremely simple. For example:
122 |  *
123 |  * ```
124 |  * auto s = asn1cpp::makeSeq(MyAsnType);
125 |  * // set fields through setField functions...
126 |  *
127 |  * // We encode the Seq, and we obtain an std::string
128 |  * auto enc = asn1cpp::ber::encode(s);
129 |  *
130 |  * // ...
131 |  * // Somewhere else, we decode
132 |  * auto decoded = asn1cpp::ber::decode(enc, MyAsnType);
133 |  * ```
134 |  *
135 |  * Note that only decoding needs the type specification, since the asn1cpp
136 |  * wrappers already know the type of their wrapped value.
137 |  */
138 | 
139 | 
140 | /**
141 |  * @def decode(m, T)
142 |  * @ingroup API
143 |  * @brief Decodes an std::string to an asn1cpp wrapper for the specified type.
144 |  *
145 |  * This macro must be prefixed with both the asn1cpp namespace and the
146 |  * namespace of the encoding you want (ber, uper, ...).
147 |  *
148 |  * This macro allows specifying the name of the underlying asn1c type, and it
149 |  * will automatically find the appropriate asn1c type descriptor for you.
150 |  */
151 | #define decode(m, T) \
152 |     decode<T>(&ASN1CPP_ASN1C_DEF(T), m)
153 | 
154 | #endif
155 | 


--------------------------------------------------------------------------------
/docstyle/customdoxygen.css:
--------------------------------------------------------------------------------
  1 | h1, .h1, h2, .h2, h3, .h3{
  2 |     font-weight: 200 !important;
  3 | }
  4 | 
  5 | #navrow1, #navrow2, #navrow3, #navrow4, #navrow5{
  6 |     border-bottom: 1px solid #EEEEEE;
  7 | }
  8 | 
  9 | .adjust-right {
 10 | margin-left: 30px !important;
 11 | font-size: 1.15em !important;
 12 | }
 13 | .navbar{
 14 |  border: 0px solid #222 !important;
 15 | }
 16 | table{
 17 |     white-space:pre-wrap !important;
 18 | }
 19 | /*
 20 |  ===========================
 21 |  */
 22 | 
 23 | 
 24 | /* Sticky footer styles
 25 | -------------------------------------------------- */
 26 | html,
 27 | body {
 28 |     height: 100%;
 29 |     /* The html and body elements cannot have any padding or margin. */
 30 | }
 31 | 
 32 | /* Wrapper for page content to push down footer */
 33 | #wrap {
 34 |     min-height: 100%;
 35 |     height: auto;
 36 |     /* Negative indent footer by its height */
 37 |     margin: 0 auto -60px;
 38 |     /* Pad bottom by footer height */
 39 |     padding: 0 0 60px;
 40 | }
 41 | 
 42 | /* Set the fixed height of the footer here */
 43 | #footer {
 44 |     font-size: 0.9em;
 45 |     padding: 8px 0px;
 46 |     background-color: #f5f5f5;
 47 | }
 48 | 
 49 | .footer-row {
 50 |     line-height: 44px;
 51 | }
 52 | 
 53 | #footer > .container {
 54 |     padding-left: 15px;
 55 |     padding-right: 15px;
 56 | }
 57 | 
 58 | .footer-follow-icon {
 59 |     margin-left: 3px;
 60 |     text-decoration: none !important;
 61 | }
 62 | 
 63 | .footer-follow-icon img {
 64 |     width: 20px;
 65 | }
 66 | 
 67 | .footer-link {
 68 |     padding-top: 5px;
 69 |     display: inline-block;
 70 |     color: #999999;
 71 |     text-decoration: none;
 72 | }
 73 | 
 74 | .footer-copyright {
 75 |     text-align: center;
 76 | }
 77 | 
 78 | 
 79 | @media (min-width: 992px) {
 80 |     .footer-row {
 81 |         text-align: left;
 82 |     }
 83 | 
 84 |     .footer-icons {
 85 |         text-align: right;
 86 |     }
 87 | }
 88 | @media (max-width: 991px) {
 89 |     .footer-row {
 90 |         text-align: center;
 91 |     }
 92 | 
 93 |     .footer-icons {
 94 |         text-align: center;
 95 |     }
 96 | }
 97 | 
 98 | /* DOXYGEN Code Styles
 99 | ----------------------------------- */
100 | 
101 | 
102 | a.qindex {
103 |     font-weight: bold;
104 | }
105 | 
106 | a.qindexHL {
107 |     font-weight: bold;
108 |     background-color: #9CAFD4;
109 |     color: #ffffff;
110 |     border: 1px double #869DCA;
111 | }
112 | 
113 | .contents a.qindexHL:visited {
114 |     color: #ffffff;
115 | }
116 | 
117 | a.code, a.code:visited, a.line, a.line:visited {
118 |     color: #4665A2;
119 | }
120 | 
121 | a.codeRef, a.codeRef:visited, a.lineRef, a.lineRef:visited {
122 |     color: #4665A2;
123 | }
124 | 
125 | /* @end */
126 | 
127 | dl.el {
128 |     margin-left: -1cm;
129 | }
130 | 
131 | pre.fragment {
132 |     border: 1px solid #C4CFE5;
133 |     background-color: #FBFCFD;
134 |     padding: 4px 6px;
135 |     margin: 4px 8px 4px 2px;
136 |     overflow: auto;
137 |     word-wrap: break-word;
138 |     font-size:  9pt;
139 |     line-height: 125%;
140 |     font-family: monospace, fixed;
141 |     font-size: 105%;
142 | }
143 | 
144 | div.fragment {
145 |     padding: 4px 6px;
146 |     margin: 4px 8px 4px 2px;
147 |     border: 1px solid #C4CFE5;
148 | }
149 | 
150 | div.line {
151 |     font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
152 |     font-size: 12px;
153 |     min-height: 13px;
154 |     line-height: 1.0;
155 |     text-wrap: unrestricted;
156 |     white-space: -moz-pre-wrap; /* Moz */
157 |     white-space: -pre-wrap;     /* Opera 4-6 */
158 |     white-space: -o-pre-wrap;   /* Opera 7 */
159 |     white-space: pre-wrap;      /* CSS3  */
160 |     word-wrap: normal;      /* IE 5.5+ */
161 |     text-indent: -53px;
162 |     padding-left: 53px;
163 |     padding-bottom: 0px;
164 |     margin: 0px;
165 |     -webkit-transition-property: background-color, box-shadow;
166 |     -webkit-transition-duration: 0.5s;
167 |     -moz-transition-property: background-color, box-shadow;
168 |     -moz-transition-duration: 0.5s;
169 |     -ms-transition-property: background-color, box-shadow;
170 |     -ms-transition-duration: 0.5s;
171 |     -o-transition-property: background-color, box-shadow;
172 |     -o-transition-duration: 0.5s;
173 |     transition-property: background-color, box-shadow;
174 |     transition-duration: 0.5s;
175 | }
176 | div.line:hover{
177 |     background-color: #FBFF00;
178 | }
179 | 
180 | div.line.glow {
181 |     background-color: cyan;
182 |     box-shadow: 0 0 10px cyan;
183 | }
184 | 
185 | 
186 | span.lineno {
187 |     padding-right: 4px;
188 |     text-align: right;
189 |     color:rgba(0,0,0,0.3);
190 |     border-right: 1px solid #EEE;
191 |     border-left: 1px solid #EEE;
192 |     background-color: #FFF;
193 |     white-space: pre;
194 |     font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace ;
195 | }
196 | span.lineno a {
197 |     background-color: #FAFAFA;
198 |     cursor:pointer;
199 | }
200 | 
201 | span.lineno a:hover {
202 |     background-color: #EFE200;
203 |     color: #1e1e1e;
204 | }
205 | 
206 | div.groupHeader {
207 |     margin-left: 16px;
208 |     margin-top: 12px;
209 |     font-weight: bold;
210 | }
211 | 
212 | div.groupText {
213 |     margin-left: 16px;
214 |     font-style: italic;
215 | }
216 | 
217 | /* @group Code Colorization */
218 | 
219 | span.keyword {
220 |     color: #008000
221 | }
222 | 
223 | span.keywordtype {
224 |     color: #604020
225 | }
226 | 
227 | span.keywordflow {
228 |     color: #e08000
229 | }
230 | 
231 | span.comment {
232 |     color: #800000
233 | }
234 | 
235 | span.preprocessor {
236 |     color: #806020
237 | }
238 | 
239 | span.stringliteral {
240 |     color: #002080
241 | }
242 | 
243 | span.charliteral {
244 |     color: #008080
245 | }
246 | 
247 | span.vhdldigit {
248 |     color: #ff00ff
249 | }
250 | 
251 | span.vhdlchar {
252 |     color: #000000
253 | }
254 | 
255 | span.vhdlkeyword {
256 |     color: #700070
257 | }
258 | 
259 | span.vhdllogic {
260 |     color: #ff0000
261 | }
262 | 
263 | blockquote {
264 |     background-color: #F7F8FB;
265 |     border-left: 2px solid #9CAFD4;
266 |     margin: 0 24px 0 4px;
267 |     padding: 0 12px 0 16px;
268 | }
269 | 
270 | /*---------------- Search Box */
271 | 
272 | #search-box {
273 |   margin: 10px 0px;
274 | }
275 | #search-box .close {
276 |   display: none;
277 |   position: absolute;
278 |   right: 0px;
279 |   padding: 6px 12px;
280 |   z-index: 5;
281 | }
282 | 
283 | /*---------------- Search results window */
284 | 
285 | #search-results-window {
286 |   display: none;
287 | }
288 | 
289 | iframe#MSearchResults {
290 |   width: 100%;
291 |   height: 15em;
292 | }
293 | 
294 | .SRChildren {
295 |   padding-left: 3ex; padding-bottom: .5em
296 | }
297 | .SRPage .SRChildren {
298 |   display: none;
299 | }
300 | a.SRScope {
301 |   display: block;
302 | }
303 | a.SRSymbol:focus, a.SRSymbol:active,
304 | a.SRScope:focus, a.SRScope:active {
305 |   text-decoration: underline;
306 | }
307 | span.SRScope {
308 |   padding-left: 4px;
309 | }
310 | .SRResult {
311 |   display: none;
312 | }
313 | 
314 | /* class and file list */
315 | .directory .icona,
316 | .directory .arrow {
317 |   height: auto;
318 | }
319 | .directory .icona .icon {
320 |   height: 16px;
321 | }
322 | .directory .icondoc {
323 |   background-position: 0px 0px;
324 |   height: 20px;
325 | }
326 | .directory .iconfopen {
327 |   background-position: 0px 0px;
328 | }
329 | .directory td.entry {
330 |   padding: 7px 8px 6px 8px;
331 | }
332 | 
333 | .table > tbody > tr > td.memSeparator {
334 |   line-height: 0;
335 |   .table-hover;
336 | 
337 | }
338 | 
339 | .memItemLeft, .memTemplItemLeft {
340 |   white-space: normal;
341 | }
342 | 
343 | /* enumerations */
344 | .panel-body thead > tr {
345 |   background-color: #e0e0e0;
346 | }
347 | 
348 | /* todo lists */
349 | .todoname,
350 | .todoname a {
351 |   font-weight: bold;
352 | }
353 | 
354 | /* Class title */
355 | .summary {
356 |   margin-top: 25px;
357 | }
358 | .page-header {
359 |   margin: 20px 0px !important;
360 | }
361 | .page-header .title {
362 |   display: inline-block;
363 | }
364 | .page-header .pull-right {
365 |   margin-top: 0.3em;
366 |   margin-left: 0.5em;
367 | }
368 | .page-header .label {
369 |   font-size: 50%;
370 | }
371 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 | 


--------------------------------------------------------------------------------
/include/asn1cpp/Getter.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_GETTER_HEADER_FILE
  2 | #define ASN1CPP_GETTER_HEADER_FILE
  3 | 
  4 | #include <cerrno>
  5 | #include <string>
  6 | #include <type_traits>
  7 | 
  8 | #include "BOOLEAN.h"
  9 | #include "INTEGER.h"
 10 | #include "OCTET_STRING.h"
 11 | 
 12 | #include "asn1cpp/Seq.hpp"
 13 | #include "asn1cpp/View.hpp"
 14 | 
 15 | namespace asn1cpp {
 16 |     namespace Impl {
 17 |         template <typename R, typename T, typename Check = void>
 18 |         struct Getter {
 19 |             static_assert(!std::is_same<T, T>::value, "Getter not implemented for this type!");
 20 |         };
 21 | 
 22 |         template <>
 23 |         struct Getter<bool, BOOLEAN_t> {
 24 |             bool operator()(const BOOLEAN_t * field, bool & ok) {
 25 |                 ok = true;
 26 |                 return !!*field;
 27 |             }
 28 |         };
 29 | 
 30 |         template <>
 31 |         struct Getter<long, INTEGER_t> {
 32 |             long operator()(const INTEGER_t * field, bool & ok) {
 33 |                 long retval;
 34 |                 if (asn_INTEGER2long(field, &retval) == 0) {
 35 |                     ok = true;
 36 |                     return retval;
 37 |                 } else {
 38 |                     ok = (errno == EINVAL);
 39 |                     return 0;
 40 |                 }
 41 |             }
 42 |         };
 43 | 
 44 |         template <>
 45 |         struct Getter<unsigned long, INTEGER_t> {
 46 |             unsigned long operator()(const INTEGER_t * field, bool & ok) {
 47 |                 unsigned long retval;
 48 |                 if (asn_INTEGER2ulong(field, &retval) == 0) {
 49 |                     ok = true;
 50 |                     return retval;
 51 |                 } else {
 52 |                     ok = (errno == EINVAL);
 53 |                     return 0;
 54 |                 }
 55 |             }
 56 |         };
 57 | 
 58 |         template <typename R>
 59 |         struct Getter<R, INTEGER_t, typename std::enable_if<std::is_integral<R>::value && std::is_signed<R>::value>::type> {
 60 |             R operator()(const INTEGER_t * field, bool & ok) {
 61 |                 return static_cast<R>(Getter<long, INTEGER_t>()(field, ok));
 62 |             }
 63 |         };
 64 | 
 65 |         template <typename R>
 66 |         struct Getter<R, INTEGER_t, typename std::enable_if<std::is_integral<R>::value && std::is_unsigned<R>::value>::type> {
 67 |             R operator()(const INTEGER_t * field, bool & ok) {
 68 |                 return static_cast<R>(Getter<unsigned long, INTEGER_t>()(field, ok));
 69 |             }
 70 |         };
 71 | 
 72 |         template <typename R>
 73 |         struct Getter<R, long, typename std::enable_if<std::is_arithmetic<R>::value>::type> {
 74 |             R operator()(const long * field, bool & ok) {
 75 |                 ok = true;
 76 |                 return static_cast<R>(*field);
 77 |             }
 78 |         };
 79 | 
 80 |         template <>
 81 |         struct Getter<std::string, OCTET_STRING_t> {
 82 |             std::string operator()(const OCTET_STRING_t * field, bool & ok) {
 83 |                 ok = true;
 84 |                 return std::string((const char *)field->buf, field->size);
 85 |             }
 86 |         };
 87 | 
 88 |         template <typename R, typename T>
 89 |         struct Getter<R, T, typename std::enable_if<std::is_enum<R>::value && std::is_enum<T>::value>::type> {
 90 |             R operator()(const T * field, bool & ok) {
 91 |                 ok = true;
 92 |                 return static_cast<R>(*field);
 93 |             }
 94 |         };
 95 | 
 96 |         template <typename R, typename T>
 97 |         struct Getter<R, T, typename std::enable_if<std::is_enum<R>::value && !std::is_enum<T>::value>::type> {
 98 |             R operator()(const T * field, bool & ok) {
 99 |                 return static_cast<R>(Getter<int, T>()(field, ok));
100 |             }
101 |         };
102 | 
103 |         template <typename T>
104 |         struct Getter<Seq<T>, T> {
105 |             Seq<T> operator()(const T * field, asn_TYPE_descriptor_t * def, bool & ok) {
106 |                 ok = true;
107 |                 return Seq<T>(View<const T>(def, field));
108 |             }
109 |         };
110 | 
111 |         template <typename T>
112 |         struct Getter<View<T>, T> {
113 |             View<T> operator()(T * field, asn_TYPE_descriptor_t * def, bool & ok) {
114 |                 ok = true;
115 |                 return View<T>(def, field);
116 |             }
117 |         };
118 |     }
119 | 
120 |     template <typename R, typename T>
121 |     R getterField(const T & field, bool * ok = nullptr) {
122 |         bool iok;
123 |         return Impl::Getter<R, T>()(&field, ok ? *ok : iok);
124 |     }
125 | 
126 |     template <typename R, typename T>
127 |     R getterField(const T * const & field, bool * ok = nullptr) {
128 |         if (field) {
129 |             bool iok;
130 |             return Impl::Getter<R, T>()(field, ok ? *ok : iok);
131 |         } else {
132 |             if (ok) *ok = false;
133 |             return R();
134 |         }
135 |     }
136 | 
137 |     template <typename R, typename T>
138 |     R getterField(T * const & field, bool * ok = nullptr) {
139 |         return getterField<R>(const_cast<const T *>(field), ok);
140 |     }
141 | 
142 |     template <typename T>
143 |     Seq<T> getterSeq(const T & field, asn_TYPE_descriptor_t * def, bool * ok = nullptr) {
144 |         bool iok;
145 |         return Impl::Getter<Seq<T>, T>()(&field, def, ok ? *ok : iok);
146 |     }
147 | 
148 |     template <typename T>
149 |     View<T> getterView(T & field, asn_TYPE_descriptor_t * def, bool * ok = nullptr) {
150 |         bool iok;
151 |         return Impl::Getter<View<T>, T>()(&field, def, ok ? *ok : iok);
152 |     }
153 | 
154 |     template <typename T>
155 |     View<const T> getterView(const T & field, asn_TYPE_descriptor_t * def, bool * ok = nullptr) {
156 |         bool iok;
157 |         return Impl::Getter<View<const T>, const T>()(&field, def, ok ? *ok : iok);
158 |     }
159 | }
160 | 
161 | // For user documentation about the getter function, see the Setter.hpp file.
162 | 
163 | /**
164 |  * @def getField(field, R, ...)
165 |  * @ingroup API
166 |  * @brief Gets a value from a field of an asn1cpp wrapper or element in SET OF/SEQUENCE OF.
167 |  *
168 |  * This macro must only be used for asn1c primitive types, not types you have
169 |  * defined.
170 |  *
171 |  * This macro takes a reference to the field you want to set and the C++ type
172 |  * name you want to extract from it. It accepts an optional boolean pointer
173 |  * parameter indicating whether the extraction process was successful, which is
174 |  * useful for optional fields.
175 |  *
176 |  * This macro is also used to get elements inside SET OF or SEQUENCE OF fields.
177 |  * For these, the macro takes the input field, the C++ type name you want to
178 |  * extract and the index of the item to get the value from (0 based). Once
179 |  * again a boolean pointer as last parameter is available although it is not
180 |  * that useful.
181 |  *
182 |  * This macro must be prefixed with the asn1cpp namespace to work.
183 |  */
184 | #define getField(field, R, ...) \
185 |     getterField<R>(field, ## __VA_ARGS__)
186 | 
187 | /**
188 |  * @def getSeq(field, R, ...)
189 |  * @ingroup API
190 |  * @brief Copies and wraps a non-primitive value from a field of an asn1cpp wrapper or element in SET OF/SEQUENCE OF.
191 |  *
192 |  * This macro must only be used for asn1c types you have defined, and not on
193 |  * asn1c primitive types.
194 |  *
195 |  * This macro copies the underlying field into a separate, memory-managed
196 |  * asn1cpp::Seq.
197 |  *
198 |  * This macro API is the same as the #getField macro.
199 |  */
200 | #define getSeq(field, R, ...) \
201 |     getterSeq(field, &ASN1CPP_ASN1C_DEF(R), ## __VA_ARGS__)
202 | 
203 | /**
204 |  * @def getView(field, R, ...)
205 |  * @ingroup API
206 |  * @brief Wraps a non-primitive value from a field of an asn1cpp wrapper or element in SET OF/SEQUENCE OF.
207 |  *
208 |  * This macro must only be used for asn1c types you have defined, and not on
209 |  * asn1c primitive types.
210 |  *
211 |  * This macro provides a asn1cpp::View on the underlying field.
212 |  *
213 |  * This macro API is the same as the #getField macro.
214 |  */
215 | #define getView(field, R, ...) \
216 |     getterView(field, &ASN1CPP_ASN1C_DEF(R), ## __VA_ARGS__)
217 | 
218 | #endif
219 | 


--------------------------------------------------------------------------------
/include/asn1cpp/Setter.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_SETTER_HEADER_FILE
  2 | #define ASN1CPP_SETTER_HEADER_FILE
  3 | 
  4 | #include <type_traits>
  5 | 
  6 | #include "BOOLEAN.h"
  7 | #include "INTEGER.h"
  8 | #include "OCTET_STRING.h"
  9 | 
 10 | #include "asn1cpp/Utils.hpp"
 11 | #include "asn1cpp/View.hpp"
 12 | 
 13 | namespace asn1cpp {
 14 |     namespace Impl {
 15 |         template <typename T, typename Check = void>
 16 |         struct Setter {
 17 |             template <template <typename> class S, typename = typename std::enable_if<is_asn1_wrapper<S<T>>::value>::type>
 18 |             bool operator()(T * field, const S<T> & v) {
 19 |                 if (!field) return false;
 20 | 
 21 |                 View<T> vf(field);
 22 |                 vf = v;
 23 | 
 24 |                 return true;
 25 |             }
 26 |         };
 27 | 
 28 |         template <typename T>
 29 |         struct Setter<T, typename std::enable_if<std::is_fundamental<T>::value || std::is_enum<T>::value>::type> {
 30 |             bool operator()(T * field, const T & value) {
 31 |                 if (!field) return false;
 32 |                 *field = value;
 33 |                 return true;
 34 |             }
 35 |         };
 36 | 
 37 |         template <>
 38 |         struct Setter<BOOLEAN_t> {
 39 |             bool operator()(BOOLEAN_t * field, bool value) {
 40 |                 *field = static_cast<BOOLEAN_t>(value);
 41 |                 return true;
 42 |             }
 43 |         };
 44 | 
 45 |         template <>
 46 |         struct Setter<INTEGER_t> {
 47 |             bool operator()(INTEGER_t * field, long value) {
 48 |                 return asn_long2INTEGER(field, value) == 0;
 49 |             }
 50 |             bool operator()(INTEGER_t * field, int value) {
 51 |                 return operator()(field, static_cast<long>(value));
 52 |             }
 53 |             bool operator()(INTEGER_t * field, unsigned long value) {
 54 |                 return asn_ulong2INTEGER(field, value) == 0;
 55 |             }
 56 |             bool operator()(INTEGER_t * field, unsigned int value) {
 57 |                 return operator()(field, static_cast<unsigned long>(value));
 58 |             }
 59 |         };
 60 | 
 61 |         template <>
 62 |         struct Setter<OCTET_STRING_t> {
 63 |             bool operator()(OCTET_STRING_t * field, const std::string & value) {
 64 |                 return OCTET_STRING_fromBuf(field, value.data(), value.size()) == 0;
 65 |             }
 66 |             bool operator()(OCTET_STRING_t * field, const char * value) {
 67 |                 return operator()(field, std::string(value));
 68 |             }
 69 |             bool operator()(OCTET_STRING_t * field, const OCTET_STRING_t * value) {
 70 |                 return OCTET_STRING_fromBuf(field, reinterpret_cast<const char *>(value->buf), value->size) == 0;
 71 |             }
 72 |         };
 73 |     }
 74 | 
 75 |     template <typename F, typename V>
 76 |     bool setterField(F & field, const V & value) {
 77 |         return Impl::Setter<F>()(&field, value);
 78 |     }
 79 | 
 80 |     template <typename F, typename V>
 81 |     bool setterField(F *& field, const V & value) {
 82 |         if (!field) field = static_cast<F*>(calloc(1, sizeof(F)));
 83 |         return Impl::Setter<F>()(field, value);
 84 |     }
 85 | 
 86 |     template <typename F>
 87 |     bool clearerField(F *& field, asn_TYPE_descriptor_t * def) {
 88 |         if (field) {
 89 |             def->free_struct(def, field, 0);
 90 |             field = nullptr;
 91 |         }
 92 |         return true;
 93 |     }
 94 | }
 95 | 
 96 | /**
 97 |  * @page SetGetPage Setting and Getting fields with asn1cpp
 98 |  *
 99 |  * All functions described here can be found in the \ref API group.
100 |  *
101 |  * Note that in asn1cpp some functions are macros due to the need to
102 |  * automatically access the asn1c type descriptors from type names. This may
103 |  * not play nice with your autocompletion features.
104 |  *
105 |  * Setting Fields
106 |  * --------------
107 |  *
108 |  * Once a asn1cpp::Seq or asn1cpp::View is obtained, we can set the fields of
109 |  * the underlying struct using the `setField` function. This function accepts
110 |  * both C++ primitive/string values for fields containing asn1c primitive
111 |  * values, or asn1cpp wrappers for fields which correspond to nested
112 |  * structures.
113 |  *
114 |  * The `setField` function returns a `boolean` that represents whether the
115 |  * value was set correctly (most of the times it will be). Errors may happen
116 |  * due to string conversion errors, but not for mismatched types: those just
117 |  * won't compile.
118 |  *
119 |  * ```
120 |  * auto seq = asn1cpp::makeSeq(MyAsnType);
121 |  *
122 |  * asn1cpp::setField(seq->someIntegerField, 15);
123 |  * asn1cpp::setField(seq->someStringField, "mystring");
124 |  *
125 |  * auto nested = asn1cpp::makeSeq(MyNestedType);
126 |  *
127 |  * asn1cpp::setField(seq->nestedField, nested);
128 |  * ```
129 |  *
130 |  * This works for both normal and optional fields, with no difference.
131 |  * Additionally, an optional field can be cleared with the `clrField` function:
132 |  *
133 |  * ```
134 |  * asn1cpp::clrField(seq->optionalField, OptionalType);
135 |  * ```
136 |  *
137 |  * Note that here `OptionalType` represents the underlying asn1c type, such as
138 |  * `INTEGER`, `BOOLEAN`, `OCTET_STRING`. This is unavoidable as we need an
139 |  * indication of the asn1c type in order to free memory correctly. The correct
140 |  * types for a `clrField` call can be found in the generated headers of ans1c
141 |  * for your specific type and field.
142 |  *
143 |  * Getting Fields
144 |  * --------------
145 |  *
146 |  * Getting specific fields' contents has a similar interface, through the
147 |  * `getField`, `getSeq` and `getView` functions.
148 |  *
149 |  * The `getField` function is used to obtain a C++ value from an asn1c
150 |  * primitive type. The `getSeq` function is used to obtain a copy of a nested
151 |  * structure. The `getView` function is used to obtain access to a nested
152 |  * structure without performing a copy.
153 |  *
154 |  * All functions require the C++ type (or your custom type for nested
155 |  * structures) that needs to be returned to you. All functions accept an
156 |  * additional `bool*` parameter that returns whether the value was returned
157 |  * successfully. This needs to be checked only for optional fields.
158 |  *
159 |  * ```
160 |  * // build and fill a seq variable
161 |  *
162 |  * auto x = asn1cpp::getField(seq->someInteger,      int);
163 |  * auto y = asn1cpp::getField(seq->someOtherInteger, unsigned);
164 |  * auto z = asn1cpp::getField(seq->someOtherInt,     long);
165 |  *
166 |  * auto str = asn1cpp::getField(seq->someString, std::string);
167 |  *
168 |  * bool ok;
169 |  * auto result = asn1cpp::getField(seq->optionalInt, int, &ok);
170 |  * if (ok)
171 |  *     do_work(result);
172 |  *
173 |  * auto copy = asn1cpp::getSeq(seq->nested, MyNestedType);
174 |  * auto view = asn1cpp::getView(seq->nested, MyNestedType);
175 |  * ```
176 |  */
177 | 
178 | /**
179 |  * @def setField(field, V, ...)
180 |  * @ingroup API
181 |  * @brief Sets a value inside a field of an asn1cpp wrapper or element in SET OF/SEQUENCE OF.
182 |  *
183 |  * This macro takes a reference to the field you want to set and the value you
184 |  * want to set inside it. It returns a boolean indicating whether the setting
185 |  * process was performed correctly.
186 |  *
187 |  * This macro is also used to set elements inside SET OF or SEQUENCE OF fields.
188 |  * For these, the macro takes the input field, the value to set and the index
189 |  * of the item to set the value (0 based).
190 |  *
191 |  * This macro must be prefixed with the asn1cpp namespace to work.
192 |  */
193 | #define setField(field, V, ...) \
194 |     setterField(field, V, ## __VA_ARGS__)
195 | 
196 | /**
197 |  * @def clrField(field, V, ...)
198 |  * @ingroup API
199 |  * @brief Clears the value inside an optional field of an asn1cpp wrapper or the list of a SET OF/SEQUENCE OF.
200 |  *
201 |  * If used on an optional field, this macro takes a reference to the field you
202 |  * want to set and the name of its asn1c type. The optional field is then
203 |  * cleared.
204 |  *
205 |  * If used on a SET OF or SEQUENCE OF field, it removes all items from their
206 |  * list. If the SET OF/SEQUENCE OF are also optional, they are too cleared. The
207 |  * asn1c type of the elements in the list must be specified as the second
208 |  * input.
209 |  *
210 |  * This macro must be prefixed with the asn1cpp namespace to work.
211 |  */
212 | #define clrField(field, T, ...) \
213 |     clearerField(field, &ASN1CPP_ASN1C_DEF(T), ## __VA_ARGS__)
214 | 
215 | #endif
216 | 


--------------------------------------------------------------------------------
/test/common/optionalTests.cpp:
--------------------------------------------------------------------------------
  1 | #define BOOST_TEST_MODULE optionalTests
  2 | #define BOOST_TEST_DYN_LINK
  3 | #define BOOST_TEST_MAIN
  4 | #include <boost/test/unit_test.hpp>
  5 | 
  6 | #include "TestOptional.h"
  7 | #include "TestInteger.h"
  8 | 
  9 | #include "asn1cpp/Seq.hpp"
 10 | #include "asn1cpp/Getter.hpp"
 11 | #include "asn1cpp/Setter.hpp"
 12 | #include "asn1cpp/Encoding.hpp"
 13 | #include "asn1cpp/SequenceOf.hpp"
 14 | 
 15 | BOOST_AUTO_TEST_CASE( construction ) {
 16 |     auto test = asn1cpp::makeSeq(TestOptional);
 17 | }
 18 | 
 19 | BOOST_AUTO_TEST_CASE( assignment ) {
 20 |     const std::string str = "abcd";
 21 |     constexpr unsigned integer = 98;
 22 |     constexpr bool boolean = false;
 23 |     constexpr std::array<int, 3> values = {{5, 54, 190}};
 24 | 
 25 |     auto test = asn1cpp::makeSeq(TestOptional);
 26 | 
 27 |     BOOST_CHECK(asn1cpp::setField(test->string, str));
 28 |     BOOST_CHECK(asn1cpp::setField(test->integer, integer));
 29 |     BOOST_CHECK(asn1cpp::setField(test->boolean, boolean));
 30 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->sequence, values[0]));
 31 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->sequence, values[1]));
 32 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->sequence, values[2]));
 33 | 
 34 |     bool strOk;
 35 |     bool intOk;
 36 |     bool boolOk;
 37 | 
 38 |     auto vstr = asn1cpp::getField(test->string, std::string, &strOk);
 39 |     auto vint = asn1cpp::getField(test->integer, unsigned, &intOk);
 40 |     auto vbool = asn1cpp::getField(test->boolean, bool, &boolOk);
 41 | 
 42 |     BOOST_CHECK(strOk);
 43 |     BOOST_CHECK(intOk);
 44 |     BOOST_CHECK(boolOk);
 45 | 
 46 |     for (size_t i = 0; i < values.size(); ++i) {
 47 |         BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->sequence, int, i, &intOk), values[i]);
 48 |         BOOST_CHECK(intOk);
 49 |     }
 50 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->sequence), values.size());
 51 | 
 52 |     BOOST_CHECK_EQUAL(str, vstr);
 53 |     BOOST_CHECK_EQUAL(integer, vint);
 54 |     BOOST_CHECK_EQUAL(boolean, vbool);
 55 | }
 56 | 
 57 | BOOST_AUTO_TEST_CASE( nonassignment ) {
 58 |     auto test = asn1cpp::makeSeq(TestOptional);
 59 | 
 60 |     bool strOk;
 61 |     bool intOk;
 62 |     bool boolOk;
 63 |     bool seqOk;
 64 | 
 65 |     asn1cpp::getField(test->string, std::string, &strOk);
 66 |     asn1cpp::getField(test->integer, unsigned, &intOk);
 67 |     asn1cpp::getField(test->boolean, bool, &boolOk);
 68 |     asn1cpp::sequenceof::getField(test->sequence, int, 0, &seqOk);
 69 | 
 70 |     BOOST_CHECK(!strOk);
 71 |     BOOST_CHECK(!intOk);
 72 |     BOOST_CHECK(!boolOk);
 73 |     BOOST_CHECK(!seqOk);
 74 | }
 75 | 
 76 | BOOST_AUTO_TEST_CASE( encoding ) {
 77 |     const std::string str = "qwerty";
 78 |     constexpr bool boolean = true;
 79 |     constexpr std::array<int, 2> values = {{19, 1}};
 80 | 
 81 |     auto test = asn1cpp::makeSeq(TestOptional);
 82 | 
 83 |     asn1cpp::setField(test->string, str);
 84 |     asn1cpp::setField(test->boolean, boolean);
 85 |     asn1cpp::sequenceof::pushList(test->sequence, values[0]);
 86 |     asn1cpp::sequenceof::pushList(test->sequence, values[1]);
 87 | 
 88 |     auto encoded = asn1cpp::ber::encode(test);
 89 |     auto recoveredTest = asn1cpp::ber::decode(encoded, TestOptional);
 90 | 
 91 |     BOOST_CHECK(recoveredTest);
 92 | 
 93 |     bool strOk;
 94 |     bool intOk;
 95 |     bool boolOk;
 96 | 
 97 |     auto vstr = asn1cpp::getField(recoveredTest->string, std::string, &strOk);
 98 |     asn1cpp::getField(recoveredTest->integer, unsigned, &intOk);
 99 |     auto vbool = asn1cpp::getField(recoveredTest->boolean, bool, &boolOk);
100 | 
101 |     BOOST_CHECK(strOk);
102 |     BOOST_CHECK(!intOk);
103 |     BOOST_CHECK(boolOk);
104 | 
105 |     BOOST_CHECK_EQUAL(str, vstr);
106 |     BOOST_CHECK_EQUAL(boolean, vbool);
107 | 
108 |     for (size_t i = 0; i < values.size(); ++i) {
109 |         BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(recoveredTest->sequence, int, i, &intOk), values[i]);
110 |         BOOST_CHECK(intOk);
111 |     }
112 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->sequence), values.size());
113 | }
114 | 
115 | BOOST_AUTO_TEST_CASE( copy ) {
116 |     const std::string str = "lkjhgf";
117 |     constexpr unsigned integer = 9571;
118 |     constexpr bool boolean = true;
119 |     constexpr std::array<int, 4> values = {{99, -15, 220, 15914}};
120 | 
121 |     auto test = asn1cpp::makeSeq(TestOptional);
122 | 
123 |     asn1cpp::setField(test->string, str);
124 |     asn1cpp::setField(test->integer, integer);
125 |     asn1cpp::setField(test->boolean, boolean);
126 |     for (size_t i = 0; i < values.size(); ++i)
127 |         asn1cpp::sequenceof::pushList(test->sequence, values[i]);
128 | 
129 |     auto copy = test;
130 | 
131 |     auto vstr = asn1cpp::getField(copy->string, std::string);
132 |     auto vint = asn1cpp::getField(copy->integer, unsigned);
133 |     auto vbool = asn1cpp::getField(copy->boolean, bool);
134 | 
135 |     BOOST_CHECK_EQUAL(str, vstr);
136 |     BOOST_CHECK_EQUAL(integer, vint);
137 |     BOOST_CHECK_EQUAL(boolean, vbool);
138 |     BOOST_CHECK_EQUAL(test, copy);
139 |     for (size_t i = 0; i < values.size(); ++i) {
140 |         bool testOk, copyOk;
141 |         BOOST_CHECK_EQUAL(
142 |             asn1cpp::sequenceof::getField(test->sequence, int, i, &testOk),
143 |             asn1cpp::sequenceof::getField(copy->sequence, int, i, &copyOk)
144 |         );
145 |         BOOST_CHECK(testOk);
146 |         BOOST_CHECK(copyOk);
147 |     }
148 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(copy->sequence), values.size());
149 | 
150 |     BOOST_CHECK(test == copy);
151 |     BOOST_CHECK(!(test != copy));
152 | 
153 |     asn1cpp::setField(copy->string, "ooooo");
154 |     BOOST_CHECK(test != copy);
155 |     BOOST_CHECK(!(test == copy));
156 | 
157 |     asn1cpp::sequenceof::setField(test->sequence, 20, 0);
158 |     BOOST_CHECK(test != copy);
159 | }
160 | 
161 | BOOST_AUTO_TEST_CASE( clear ) {
162 |     const std::string str = "abcd";
163 |     constexpr unsigned integer = 98;
164 |     constexpr bool boolean = false;
165 |     constexpr std::array<int, 4> values = {{99, -15, 220, 15914}};
166 | 
167 |     auto test = asn1cpp::makeSeq(TestOptional);
168 | 
169 |     asn1cpp::setField(test->string, str);
170 |     asn1cpp::setField(test->integer, integer);
171 |     asn1cpp::setField(test->boolean, boolean);
172 |     for (size_t i = 0; i < values.size(); ++i)
173 |         asn1cpp::sequenceof::pushList(test->sequence, values[i]);
174 | 
175 |     bool strOk;
176 |     bool intOk;
177 |     bool boolOk;
178 | 
179 |     auto vstr = asn1cpp::getField(test->string, std::string, &strOk);
180 |     auto vint = asn1cpp::getField(test->integer, unsigned, &intOk);
181 |     auto vbool = asn1cpp::getField(test->boolean, bool, &boolOk);
182 | 
183 |     BOOST_CHECK(strOk);
184 |     BOOST_CHECK(intOk);
185 |     BOOST_CHECK(boolOk);
186 | 
187 |     BOOST_CHECK_EQUAL(str, vstr);
188 |     BOOST_CHECK_EQUAL(integer, vint);
189 |     BOOST_CHECK_EQUAL(boolean, vbool);
190 | 
191 |     for (size_t i = 0; i < values.size(); ++i) {
192 |         BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->sequence, int, i, &intOk), values[i]);
193 |         BOOST_CHECK(intOk);
194 |     }
195 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->sequence), values.size());
196 | 
197 |     asn1cpp::clrField(test->string, OCTET_STRING);
198 |     asn1cpp::clrField(test->integer, INTEGER);
199 |     asn1cpp::clrField(test->boolean, BOOLEAN);
200 |     asn1cpp::sequenceof::clrField(test->sequence, INTEGER);
201 | 
202 |     asn1cpp::getField(test->string, std::string, &strOk);
203 |     asn1cpp::getField(test->integer, unsigned, &intOk);
204 |     asn1cpp::getField(test->boolean, bool, &boolOk);
205 | 
206 |     BOOST_CHECK(!strOk);
207 |     BOOST_CHECK(!intOk);
208 |     BOOST_CHECK(!boolOk);
209 |     for (size_t i = 0; i < values.size(); ++i) {
210 |         asn1cpp::sequenceof::getField(test->sequence, int, i, &intOk);
211 |         BOOST_CHECK(!intOk);
212 |     }
213 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->sequence), -1);
214 | }
215 | 
216 | BOOST_AUTO_TEST_CASE( add_nested ) {
217 |     auto insert0 = asn1cpp::makeSeq(TestInteger);
218 |     BOOST_CHECK(asn1cpp::setField(insert0->integer, 45));
219 | 
220 |     auto seq = asn1cpp::makeSeq(TestInteger);
221 |     BOOST_CHECK(asn1cpp::setField(seq->integer, 23));
222 |     asn1cpp::View<TestInteger> insert1 = seq;
223 | 
224 |     auto test = asn1cpp::makeSeq(TestOptional);
225 | 
226 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert0));
227 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert1));
228 | 
229 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 2);
230 | 
231 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 0), insert0);
232 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 0), insert0);
233 | 
234 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 1), insert1);
235 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1), insert1);
236 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 1), seq);
237 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1), seq);
238 | }
239 | 


--------------------------------------------------------------------------------
/include/asn1cpp/SetOf.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_SETOF_HEADER_FILE
  2 | #define ASN1CPP_SETOF_HEADER_FILE
  3 | 
  4 | #include "asn1cpp/Setter.hpp"
  5 | #include "asn1cpp/Getter.hpp"
  6 | #include "asn1cpp/Seq.hpp"
  7 | #include "asn1cpp/View.hpp"
  8 | 
  9 | namespace asn1cpp {
 10 |     namespace setof {
 11 |         namespace Impl {
 12 |             template <typename T>
 13 |             struct ArrayType {
 14 |                 using type = typename std::remove_reference<decltype(**std::declval<T>().list.array)>::type;
 15 |             };
 16 |             template <typename T>
 17 |             struct ArrayType<T*> {
 18 |                 using type = typename std::remove_reference<decltype(**std::declval<T>().list.array)>::type;
 19 |             };
 20 |         }
 21 | 
 22 |         template <typename T>
 23 |         int getSize(const T& field) {
 24 |             return field.list.count;
 25 |         }
 26 | 
 27 |         template <typename T>
 28 |         int getSize(const T * const & field) {
 29 |             if (!field) return -1;
 30 |             return getSize(*field);
 31 |         }
 32 | 
 33 |         template <typename T>
 34 |         int getSize(T * const & field) {
 35 |             return getSize(const_cast<const T*>(field));
 36 |         }
 37 | 
 38 |         template <typename R, typename T>
 39 |         R getterField(const T& field, int id, bool *ok = nullptr) {
 40 |             if (id < 0 || id >= getSize(field)) {
 41 |                 if (ok) *ok = false;
 42 |                 return R();
 43 |             }
 44 |             bool iok;
 45 |             return asn1cpp::getterField<R, typename Impl::ArrayType<T>::type>(*field.list.array[id], ok ? ok : &iok);
 46 |         }
 47 | 
 48 |         template <typename R, typename T>
 49 |         R getterField(const T* const & field, int id, bool *ok = nullptr) {
 50 |             if (!field) {
 51 |                 if (ok) *ok = false;
 52 |                 return R();
 53 |             }
 54 |             return getterField<R>(*field, id, ok);
 55 |         }
 56 | 
 57 |         template <typename R, typename T>
 58 |         R getterField(T* const & field, int id, bool *ok = nullptr) {
 59 |             return getterField<R>(const_cast<const T*>(field), id, ok);
 60 |         }
 61 | 
 62 |         // ### GETTER SEQ ###
 63 | 
 64 |         template <typename T>
 65 |         Seq<typename Impl::ArrayType<T>::type> getterSeq(const T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
 66 |             using R = typename Impl::ArrayType<T>::type;
 67 |             if (id < 0 || id >= getSize(field)) {
 68 |                 if (ok) *ok = false;
 69 |                 return Seq<R>();
 70 |             }
 71 |             bool iok;
 72 |             return asn1cpp::getterSeq(*field.list.array[id], def, ok ? ok : &iok);
 73 |         }
 74 | 
 75 |         template <typename T>
 76 |         Seq<typename Impl::ArrayType<T>::type> getterSeq(const T * const & field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
 77 |             using R = typename Impl::ArrayType<T>::type;
 78 |             if (!field) {
 79 |                 if (ok) *ok = false;
 80 |                 return Seq<R>();
 81 |             }
 82 |             return getterSeq(*field, def, id, ok);
 83 |         }
 84 | 
 85 |         template <typename T>
 86 |         Seq<typename Impl::ArrayType<T>::type> getterSeq(T * const & field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
 87 |             return getterSeq(const_cast<const T*>(field), def, id, ok);
 88 |         }
 89 | 
 90 |         // ### GETTER VIEW CONST ###
 91 | 
 92 |         template <typename T>
 93 |         View<const typename Impl::ArrayType<T>::type> getterView(const T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
 94 |             using R = const typename Impl::ArrayType<T>::type;
 95 |             if (id < 0 || id >= getSize(field)) {
 96 |                 if (ok) *ok = false;
 97 |                 return View<R>();
 98 |             }
 99 |             bool iok;
100 |             return asn1cpp::getterView(*field.list.array[id], def, ok ? ok : &iok);
101 |         }
102 | 
103 |         template <typename T>
104 |         View<const typename Impl::ArrayType<T>::type> getterView(const T * const & field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
105 |             using R = typename Impl::ArrayType<T>::type;
106 |             if (!field) {
107 |                 if (ok) *ok = false;
108 |                 return View<R>();
109 |             }
110 |             return getterView(*field, def, id, ok);
111 |         }
112 | 
113 |         // ### GETTER VIEW NON-CONST ###
114 | 
115 |         template <typename T>
116 |         View<typename Impl::ArrayType<T>::type> getterView(T& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
117 |             using R = typename Impl::ArrayType<T>::type;
118 |             if (id < 0 || id >= getSize(field)) {
119 |                 if (ok) *ok = false;
120 |                 return View<R>();
121 |             }
122 |             bool iok;
123 |             return asn1cpp::getterView(*field.list.array[id], def, ok ? ok : &iok);
124 |         }
125 | 
126 |         template <typename T>
127 |         View<typename Impl::ArrayType<T>::type> getterView(T *& field, asn_TYPE_descriptor_t * def, int id, bool *ok = nullptr) {
128 |             using R = typename Impl::ArrayType<T>::type;
129 |             if (!field) {
130 |                 if (ok) *ok = false;
131 |                 return View<R>();
132 |             }
133 |             return getterView(*field, def, id, ok);
134 |         }
135 | 
136 |         template <typename T, typename V>
137 |         bool setterField(T & field, const V & value, int id) {
138 |             if (id < 0 || id >= getSize(field))
139 |                 return false;
140 |             return asn1cpp::setterField(field.list.array[id], value);
141 |         }
142 | 
143 |         template <typename T, typename V>
144 |         bool setterField(T *& field, const V & value, int id) {
145 |             if (!field)
146 |                 return false;
147 |             return setterField(*field, value, id);
148 |         }
149 | 
150 |         template <typename T, typename V>
151 |         bool adderElement(T & field, const V & value) {
152 |             typename Impl::ArrayType<T>::type * ptr = nullptr;
153 |             if (!asn1cpp::setterField(ptr, value))
154 |                 return false;
155 |             return asn_set_add(&field, ptr) == 0;
156 |         }
157 | 
158 |         template <typename T, typename V>
159 |         bool adderElement(T *& field, const V & value) {
160 |             if (!field) field = static_cast<T*>(calloc(1, sizeof(T)));
161 |             return adderElement(*field, value);
162 |         }
163 | 
164 |         template <typename T>
165 |         bool removerElement(T & field, int id, asn_TYPE_descriptor_t * def) {
166 |             if (id < 0 || id >= getSize(field))
167 |                 return false;
168 | 
169 |             auto p = field.list.array[id];
170 |             asn_set_del(&field, id, 0);
171 |             def->free_struct(def, p, 0);
172 |             return true;
173 |         }
174 | 
175 |         template <typename T, typename V>
176 |         bool removerElement(T *& field, const V & value) {
177 |             if (!field) return false;
178 |             return removerElement(*field, value);
179 |         }
180 | 
181 |         template <typename T>
182 |         void clearerField(T & field, asn_TYPE_descriptor_t * def) {
183 |             for (int i = 0; i < getSize(field); ++i)
184 |                 def->free_struct(def, field.list.array[i], 0);
185 |             field.list.count = 0;
186 |         }
187 | 
188 |         template <typename T>
189 |         void clearerField(T *& field, asn_TYPE_descriptor_t * def) {
190 |             if (!field) return;
191 |             for (int i = 0; i < getSize(field); ++i)
192 |                 def->free_struct(def, field->list.array[i], 0);
193 | 
194 |             asn_set_empty(field);
195 |             free(field);
196 | 
197 |             field = nullptr;
198 |         }
199 |     }
200 | }
201 | 
202 | /**
203 |  * @def pushList(field, V, ...)
204 |  * @ingroup API
205 |  * @brief Inserts an element at the end of the input list for SET OF/SEQUENCE OF.
206 |  *
207 |  * Inserts at the end of the specified field a new element. The second input is
208 |  * the value of the new element. A boolean is returned to report whether the
209 |  * operation was successful.
210 |  *
211 |  * This macro must be prefixed with both the asn1cpp namespace and the
212 |  * namespace of the underlying list type (setof, sequenceof).
213 |  */
214 | #define pushList(field, V, ...) \
215 |     adderElement(field, V, ## __VA_ARGS__)
216 | 
217 | /**
218 |  * @def popList(field, T, id, ...)
219 |  * @ingroup API
220 |  * @brief Removes an element from the input list for SET OF/SEQUENCE OF.
221 |  *
222 |  * This macro takes an input SET OF or SEQUENCE OF field, the asn1c type of the
223 |  * elements of the list and an integer id. The specified element is removed
224 |  * from the list. A boolean value is returned to report whether the operation
225 |  * was successful.
226 |  *
227 |  * This macro must be prefixed with both the asn1cpp namespace and the
228 |  * namespace of the underlying list type (setof, sequenceof).
229 |  */
230 | #define popList(field, T, id, ...) \
231 |     removerElement(field, id, &ASN1CPP_ASN1C_DEF(T), ## __VA_ARGS__)
232 | 
233 | #endif
234 | 


--------------------------------------------------------------------------------
/docstyle/doxy-boot.js:
--------------------------------------------------------------------------------
  1 | $( document ).ready(function() {
  2 | 
  3 |     $("div.headertitle").addClass("page-header");
  4 |     $("div.title").addClass("h1");
  5 | 
  6 |     $('li > a[href="index.html"] > span').before("<i class='fa fa-cog'></i> ");
  7 |     $('li > a[href="modules.html"] > span').before("<i class='fa fa-square'></i> ");
  8 |     $('li > a[href="namespaces.html"] > span').before("<i class='fa fa-bars'></i> ");
  9 |     $('li > a[href="annotated.html"] > span').before("<i class='fa fa-list-ul'></i> ");
 10 |     $('li > a[href="classes.html"] > span').before("<i class='fa fa-book'></i> ");
 11 |     $('li > a[href="inherits.html"] > span').before("<i class='fa fa-sitemap'></i> ");
 12 |     $('li > a[href="functions.html"] > span').before("<i class='fa fa-list'></i> ");
 13 |     $('li > a[href="functions_func.html"] > span').before("<i class='fa fa-list'></i> ");
 14 |     $('li > a[href="functions_vars.html"] > span').before("<i class='fa fa-list'></i> ");
 15 |     $('li > a[href="functions_enum.html"] > span').before("<i class='fa fa-list'></i> ");
 16 |     $('li > a[href="functions_eval.html"] > span').before("<i class='fa fa-list'></i> ");
 17 |     $('img[src="ftv2ns.png"]').replaceWith('<span class="label label-danger">N</span> ');
 18 |     $('img[src="ftv2cl.png"]').replaceWith('<span class="label label-danger">C</span> ');
 19 | 
 20 |     $("ul.tablist").addClass("nav nav-pills nav-justified");
 21 |     $("ul.tablist").css("margin-top", "0.5em");
 22 |     $("ul.tablist").css("margin-bottom", "0.5em");
 23 |     $("li.current").addClass("active");
 24 |     $("iframe").attr("scrolling", "yes");
 25 | 
 26 |     $("#nav-path > ul").addClass("breadcrumb");
 27 | 
 28 |     $("table.params").addClass("table");
 29 |     $("div.ingroups").wrapInner("<span class='text-nowrap'></span>");
 30 |     $("div.levels").css("margin", "0.5em");
 31 |     $("div.levels > span").addClass("btn btn-default btn-xs");
 32 |     $("div.levels > span").css("margin-right", "0.25em");
 33 | 
 34 |     $("table.directory").addClass("table table-striped");
 35 |     $("div.summary > a").addClass("btn btn-default btn-xs");
 36 |     $("table.fieldtable").addClass("table");
 37 |     $(".fragment").addClass("well");
 38 |     $(".memitem").addClass("panel panel-default");
 39 |     $(".memproto").addClass("panel-heading");
 40 |     $(".memdoc").addClass("panel-body");
 41 |     $("span.mlabel").addClass("label label-info");
 42 | 
 43 |     $("table.memberdecls").addClass("table");
 44 |     $("[class^=memitem]").addClass("active");
 45 | 
 46 |     $("div.ah").addClass("btn btn-default");
 47 |     $("span.mlabels").addClass("pull-right");
 48 |     $("table.mlabels").css("width", "100%")
 49 |     $("td.mlabels-right").addClass("pull-right");
 50 | 
 51 |     $("div.ttc").addClass("panel panel-primary");
 52 |     $("div.ttname").addClass("panel-heading");
 53 |     $("div.ttname a").css("color", 'white');
 54 |     $("div.ttdef,div.ttdoc,div.ttdeci").addClass("panel-body");
 55 | 
 56 |     $('div.fragment.well div.line:first').css('margin-top', '2px');
 57 |     $('div.fragment.well div.line:last').css('margin-bottom', '2px');
 58 | 
 59 | 	$('table.doxtable').removeClass('doxtable').addClass('table table-striped table-bordered').each(function(){
 60 | 		$(this).prepend('<thead></thead>');
 61 | 		$(this).find('tbody > tr:first').prependTo($(this).find('thead'));
 62 | 
 63 | 		$(this).find('td > span.success').parent().addClass('success');
 64 | 		$(this).find('td > span.warning').parent().addClass('warning');
 65 | 		$(this).find('td > span.danger').parent().addClass('danger');
 66 | 	});
 67 | 
 68 | 
 69 | 
 70 |     if($('div.fragment.well div.ttc').length > 0)
 71 |     {
 72 |         $('div.fragment.well div.line:first').parent().removeClass('fragment well');
 73 |     }
 74 | 
 75 |     $('table.memberdecls').find('.memItemRight').each(function(){
 76 |         $(this).contents().appendTo($(this).siblings('.memItemLeft'));
 77 |         $(this).siblings('.memItemLeft').attr('align', 'left');
 78 |     });
 79 | 
 80 |     $('table.memberdecls').find('.memTemplItemRight').each(function(){
 81 |         $(this).contents().appendTo($(this).siblings('.memTemplItemLeft'));
 82 |         $(this).siblings('.memTemplItemLeft').attr('align', 'left');
 83 |     });
 84 | 
 85 | 	function getOriginalWidthOfImg(img_element) {
 86 | 		var t = new Image();
 87 | 		t.src = (img_element.getAttribute ? img_element.getAttribute("src") : false) || img_element.src;
 88 | 		return t.width;
 89 | 	}
 90 | 
 91 | 	$('div.dyncontent').find('img').each(function(){
 92 | 		if(getOriginalWidthOfImg($(this)[0]) > $('#content>div.container').width())
 93 | 			$(this).css('width', '100%');
 94 | 	});
 95 | 
 96 | 
 97 |   /* responsive search box */
 98 |   $('#MSearchBox').parent().remove();
 99 | 
100 |   var nav_container = $('<div class="row"></div>');
101 |   $('#navrow1').parent().prepend(nav_container);
102 | 
103 |   var left_nav = $('<div class="col-md-9"></div>');
104 |   for (i = 0; i < 6; i++) {
105 |     var navrow = $('#navrow' + i + ' > ul.tablist').detach();
106 |     left_nav.append(navrow);
107 |     $('#navrow' + i).remove();
108 |   }
109 |   var right_nav = $('<div class="col-md-3"></div>').append('\
110 |     <div id="search-box" class="input-group">\
111 |       <div class="input-group-btn">\
112 |         <button aria-expanded="false" type="button" class="btn btn-default dropdown-toggle" data-toggle="dropdown">\
113 |           <span class="glyphicon glyphicon-search"></span> <span class="caret"></span>\
114 |         </button>\
115 |         <ul class="dropdown-menu">\
116 |         </ul>\
117 |       </div>\
118 |       <button id="search-close" type="button" class="close" aria-label="Close"><span aria-hidden="true">&times;</span></button>\
119 |       <input id="search-field" class="form-control" accesskey="S" onkeydown="searchBox.OnSearchFieldChange(event);" placeholder="Search ..." type="text">\
120 |     </div>');
121 |   $(nav_container).append(left_nav);
122 |   $(nav_container).append(right_nav);
123 | 
124 |   $('#MSearchSelectWindow .SelectionMark').remove();
125 |   var search_selectors = $('#MSearchSelectWindow .SelectItem');
126 |   for (var i = 0; i < search_selectors.length; i += 1) {
127 |     var element_a = $('<a href="#"></a>').text($(search_selectors[i]).text());
128 | 
129 |     element_a.click(function(){
130 |       $('#search-box .dropdown-menu li').removeClass('active');
131 |       $(this).parent().addClass('active');
132 |       searchBox.OnSelectItem($('#search-box li a').index(this));
133 |       searchBox.Search();
134 |       return false;
135 |     });
136 | 
137 |     var element = $('<li></li>').append(element_a);
138 |     $('#search-box .dropdown-menu').append(element);
139 |   }
140 |   $('#MSearchSelectWindow').remove();
141 | 
142 |   $('#search-box .close').click(function (){
143 |     searchBox.CloseResultsWindow();
144 |   });
145 | 
146 |   $('body').append('<div id="MSearchClose"></div>');
147 |   $('body').append('<div id="MSearchBox"></div>');
148 |   $('body').append('<div id="MSearchSelectWindow"></div>');
149 | 
150 |   searchBox.searchLabel = '';
151 |   searchBox.DOMSearchField = function() {
152 |     return document.getElementById("search-field");
153 |   }
154 |   searchBox.DOMSearchClose = function(){
155 |     return document.getElementById("search-close");
156 |   }
157 | 
158 | 
159 |   /* search results */
160 |   var results_iframe = $('#MSearchResults').detach();
161 |   $('#MSearchResultsWindow')
162 |     .attr('id', 'search-results-window')
163 |     .addClass('panel panel-default')
164 |     .append(
165 |       '<div class="panel-heading">\
166 |         <h3 class="panel-title">Search Results</h3>\
167 |       </div>\
168 |       <div class="panel-body"></div>'
169 |     );
170 |   $('#search-results-window .panel-body').append(results_iframe);
171 | 
172 |   searchBox.DOMPopupSearchResultsWindow = function() {
173 |     return document.getElementById("search-results-window");
174 |   }
175 | 
176 |   function update_search_results_window() {
177 |     $('#search-results-window').removeClass('panel-default panel-success panel-warning panel-danger')
178 |     var status = $('#MSearchResults').contents().find('.SRStatus:visible');
179 |     if (status.length > 0) {
180 |       switch(status.attr('id')) {
181 |         case 'Loading':
182 |         case 'Searching':
183 |           $('#search-results-window').addClass('panel-warning');
184 |           break;
185 |         case 'NoMatches':
186 |           $('#search-results-window').addClass('panel-danger');
187 |           break;
188 |         default:
189 |           $('#search-results-window').addClass('panel-default');
190 |       }
191 |     } else {
192 |       $('#search-results-window').addClass('panel-success');
193 |     }
194 |   }
195 |   $('#MSearchResults').load(function() {
196 |     $('#MSearchResults').contents().find('link[href="search.css"]').attr('href','../doxygen.css');
197 |     $('#MSearchResults').contents().find('head').append(
198 |       '<link href="../customdoxygen.css" rel="stylesheet" type="text/css">');
199 | 
200 |     update_search_results_window();
201 | 
202 |     // detect status changes (only for search with external search backend)
203 |     var observer = new MutationObserver(function(mutations) {
204 |       update_search_results_window();
205 |     });
206 |     var config = { attributes: true};
207 | 
208 |     var targets = $('#MSearchResults').contents().find('.SRStatus');
209 |     for (i = 0; i < targets.length; i++) {
210 |       observer.observe(targets[i], config);
211 |     }
212 |   });
213 | 
214 | 
215 |   /* enumerations */
216 |   $('table.fieldtable').removeClass('fieldtable').addClass('table table-striped table-bordered').each(function(){
217 |     $(this).prepend('<thead></thead>');
218 |     $(this).find('tbody > tr:first').prependTo($(this).find('thead'));
219 | 
220 |     $(this).find('td > span.success').parent().addClass('success');
221 |     $(this).find('td > span.warning').parent().addClass('warning');
222 |     $(this).find('td > span.danger').parent().addClass('danger');
223 |   });
224 | 
225 |   /* todo list */
226 |   var todoelements = $('.contents > .textblock > dl.reflist > dt, .contents > .textblock > dl.reflist > dd');
227 |   for (var i = 0; i < todoelements.length; i += 2) {
228 |     $('.contents > .textblock').append(
229 |       '<div class="panel panel-default active">'
230 |         + "<div class=\"panel-heading todoname\">" + $(todoelements[i]).html() + "</div>"
231 |         + "<div class=\"panel-body\">" + $(todoelements[i+1]).html() + "</div>"
232 |       + '</div>');
233 |   }
234 |   $('.contents > .textblock > dl').remove();
235 | 
236 | 
237 | 	$(".memitem").removeClass('memitem');
238 |     $(".memproto").removeClass('memproto');
239 |     $(".memdoc").removeClass('memdoc');
240 | 	$("span.mlabel").removeClass('mlabel');
241 | 	$("table.memberdecls").removeClass('memberdecls');
242 |     $("[class^=memitem]").removeClass('memitem');
243 |     $("span.mlabels").removeClass('mlabels');
244 |     $("table.mlabels").removeClass('mlabels');
245 |     $("td.mlabels-right").removeClass('mlabels-right');
246 | 	$(".navpath").removeClass('navpath');
247 | 	$("li.navelem").removeClass('navelem');
248 | 	$("a.el").removeClass('el');
249 | 	$("div.ah").removeClass('ah');
250 | 	$("div.header").removeClass("header");
251 | 
252 | 	$('.mdescLeft').each(function(){
253 | 		if($(this).html()=="&nbsp;") {
254 | 			$(this).siblings('.mdescRight').attr('colspan', 2);
255 | 			$(this).remove();
256 | 		}
257 | 	});
258 |   $('td.memItemLeft').each(function(){
259 |     if($(this).siblings('.memItemRight').html()=="") {
260 |       $(this).attr('colspan', 2);
261 |       $(this).siblings('.memItemRight').remove();
262 |     }
263 |   });
264 | 	$('td.memTemplItemLeft').each(function(){
265 | 		if($(this).siblings('.memTemplItemRight').html()=="") {
266 | 			$(this).attr('colspan', 2);
267 | 			$(this).siblings('.memTemplItemRight').remove();
268 | 		}
269 | 	});
270 |   searchBox.CloseResultsWindow();
271 | });
272 | 


--------------------------------------------------------------------------------
/include/asn1cpp/Seq.hpp:
--------------------------------------------------------------------------------
  1 | /** @file */
  2 | #ifndef ASN1CPP_SEQ_HEADER_FILE
  3 | #define ASN1CPP_SEQ_HEADER_FILE
  4 | 
  5 | #include <stdexcept>
  6 | #include <type_traits>
  7 | #include <cstdlib>
  8 | 
  9 | #include "asn_application.h"
 10 | 
 11 | #include "asn1cpp/Utils.hpp"
 12 | #include "asn1cpp/Encoding.hpp"
 13 | 
 14 | namespace asn1cpp {
 15 |     /**
 16 |      * @brief This class wraps and owns an asn1c non-primitive structure.
 17 |      *
 18 |      * This class is used to take ownership of asn1c structures so that they
 19 |      * can be manipulated without risking a memory leak. This class will
 20 |      * automatically clean up after itself upon destruction.
 21 |      *
 22 |      * Reading/writing the underlying asn1c structures should only be done
 23 |      * through the appropriate helper functions found in the Setter/Getter
 24 |      * files. Avoid bypassing them and directly read stuff unless you know what
 25 |      * you are doing.
 26 |      *
 27 |      * This class cannot be used to contain asn1c primitive types, such as
 28 |      * INTEGER_t, BOOLEAN_t, OCTET_STRING_t and so on. Those types can be read
 29 |      * and set through the setField() and getField() functions.
 30 |      */
 31 |     template <typename T>
 32 |     class Seq {
 33 |         public:
 34 |             /**
 35 |              * @brief Basic constructor.
 36 |              *
 37 |              * This constructor takes ownership of the input pointer, and uses
 38 |              * the input asn1c type descriptor to deallocate it upon
 39 |              * destruction. The type descriptor will also be used when encoding
 40 |              * and decoding this class.
 41 |              *
 42 |              * @param def The asn1c generated type descriptor for the input pointer.
 43 |              * @param p The asn1c struct.
 44 |              */
 45 |             Seq(asn_TYPE_descriptor_t * def, T * p);
 46 | 
 47 |             /**
 48 |              * @brief Null constructor.
 49 |              *
 50 |              * This constructor is used in order to produce a null Seq. This
 51 |              * can be useful to notify errors when encoding/decoding/etc.
 52 |              */
 53 |             Seq();
 54 | 
 55 |             /**
 56 |              * @brief New constructor.
 57 |              *
 58 |              * This constructor allocates the memory necessary to store the
 59 |              * underlying type, so that it can be used with the other library
 60 |              * functions.
 61 |              *
 62 |              * @param def The asn1c generated type descriptor for the stored type.
 63 |              */
 64 |             Seq(asn_TYPE_descriptor_t * def);
 65 | 
 66 |             /**
 67 |              * @brief Basic destructor.
 68 |              *
 69 |              * This destructor destroys, if present, the owned structure
 70 |              * pointer, using the type descriptor to correctly destroy it
 71 |              * through asn1c functions.
 72 |              */
 73 |             ~Seq();
 74 | 
 75 |             /**
 76 |              * @brief Copy constructor.
 77 |              *
 78 |              * This constructor creates a new copy of the input Seq, so that in
 79 |              * the end they will both own a separate, although equivalent,
 80 |              * copy.
 81 |              *
 82 |              * @param other The Seq to copy.
 83 |              */
 84 |             Seq(const Seq & other);
 85 | 
 86 |             /**
 87 |              * @brief Copy constructor from other classes.
 88 |              *
 89 |              * This constructor creates a new copy of the input so that the
 90 |              * input and this instance will compare equal afterwards.
 91 |              *
 92 |              * This constructor is able to work with any compatible asn1c
 93 |              * wrappers which fulfill the wrapper API.
 94 |              *
 95 |              * @param other The asn1c wrapper to copy.
 96 |              */
 97 |             template <template <typename> class S, typename Y,
 98 |                       typename = typename std::enable_if<are_compatible_asn1_wrappers<Seq<T>, S<Y>>::value>::type>
 99 |             Seq(const S<Y> & other);
100 | 
101 |             /**
102 |              * @brief Assignment operator.
103 |              *
104 |              * This operator deallocates the currently owned asn1c structure
105 |              * and creates a new one from scratch which copies the input.
106 |              *
107 |              * @param other The Seq to copy.
108 |              *
109 |              * @return A reference to this instance.
110 |              */
111 |             Seq & operator=(Seq other);
112 | 
113 |             /**
114 |              * @brief Dereference operator.
115 |              *
116 |              * @return A reference to the underlying asn1c structure.
117 |              */
118 |             T & operator*();
119 | 
120 |             /**
121 |              * @brief Const dereference operator.
122 |              *
123 |              * @return A const reference to the underlying asn1c structure.
124 |              */
125 |             const T & operator*() const;
126 | 
127 |             /**
128 |              * @brief Arrow operator.
129 |              *
130 |              * @return A pointer to the underlying asn1c structure, can be nullptr.
131 |              */
132 |             T * operator->();
133 | 
134 |             /**
135 |              * @brief Const arrow operator.
136 |              *
137 |              * @return A const pointer to the underlying asn1c structure, can be nullptr.
138 |              */
139 |             const T * operator->() const;
140 | 
141 |             /**
142 |              * @brief Whether this instance is valid or not.
143 |              *
144 |              * This operator returns whether the currently held asn1c structure
145 |              * is nullptr or not. Invalid structures will return false.
146 |              *
147 |              * @return True if the underlying structure is not null, false otherwise.
148 |              */
149 |             operator bool() const;
150 | 
151 |             /**
152 |              * @brief Returns the underlying asn1c type descriptor.
153 |              *
154 |              * @return The underlying asn1c type descriptor, which can be null.
155 |              */
156 |             asn_TYPE_descriptor_t * getTypeDescriptor() const;
157 | 
158 |             /**
159 |              * @brief Swaps two instances of Seq.
160 |              *
161 |              * @param lhs The left hand side.
162 |              * @param rhs The right hand side.
163 |              */
164 |             static void swap(Seq & lhs, Seq & rhs);
165 | 
166 |         private:
167 |             template <template <typename> class S, typename Y,
168 |                       typename = typename std::enable_if<are_compatible_asn1_wrappers<Seq<T>, S<Y>>::value>::type>
169 |             void deepCopy(const S<Y> & other);
170 | 
171 |             T * seq_;
172 |             asn_TYPE_descriptor_t * def_;
173 |     };
174 | 
175 |     /**
176 |      * @relates Seq
177 |      * @brief Equality operator between Seq and an asn1 wrapper.
178 |      *
179 |      * This function uses encoding in order to perform equality comparisons.
180 |      * This allows us to perform equality checks independently of the wrapped
181 |      * type.
182 |      *
183 |      * @param lhs The left hand side.
184 |      * @param rhs The right hand side.
185 |      *
186 |      * @return True if the two instances encode to the same string, false otherwise.
187 |      */
188 |     template <typename T, template <typename> class S, typename Y,
189 |               typename = typename std::enable_if<are_compatible_asn1_wrappers<Seq<T>, S<Y>>::value>::type>
190 |     bool operator==(const Seq<T> &lhs, const S<Y> &rhs) {
191 |         return ber::encode(lhs) == ber::encode(rhs);
192 |     }
193 | 
194 |     /**
195 |      * @relates Seq
196 |      * @brief Inequality operator between Seq and an asn1 wrapper.
197 |      *
198 |      * \sa operator==
199 |      *
200 |      * @param lhs The left hand side.
201 |      * @param rhs The right hand side.
202 |      *
203 |      * @return False if the two instances encode to the same string, true otherwise.
204 |      */
205 |     template <typename T, template <typename> class S, typename Y,
206 |               typename = typename std::enable_if<are_compatible_asn1_wrappers<Seq<T>, S<Y>>::value>::type>
207 |     bool operator!=(const Seq<T> &lhs, const S<Y> &rhs) {
208 |         return !(lhs == rhs);
209 |     }
210 | 
211 |     // Implementations...
212 | 
213 |     template <typename T>
214 |     Seq<T>::Seq(asn_TYPE_descriptor_t * def, T * p) :
215 |             seq_(p), def_(def)
216 |     {
217 |         if (seq_ && !def_)
218 |             throw std::runtime_error("Cannot build non-empty Seq with no ASN descriptors!");
219 |     }
220 | 
221 |     template <typename T>
222 |     Seq<T>::Seq() : Seq(nullptr, nullptr) {}
223 | 
224 |     template <typename T>
225 |     Seq<T>::Seq(asn_TYPE_descriptor_t * def) :
226 |             seq_(static_cast<T*>(calloc(1, sizeof(T)))), def_(def)
227 |     {
228 |         if (!seq_)
229 |             throw std::runtime_error("Allocation for Seq failed!");
230 |     }
231 | 
232 |     template <typename T>
233 |     Seq<T>::~Seq() {
234 |         if (seq_)
235 |             def_->free_struct(def_, seq_, 0);
236 |     }
237 | 
238 |     template <typename T>
239 |     Seq<T>::Seq(const Seq & other) {
240 |         deepCopy(other);
241 |     }
242 | 
243 |     template <typename T>
244 |     template <template <typename> class S, typename Y, typename>
245 |     Seq<T>::Seq(const S<Y> & other) {
246 |         deepCopy(other);
247 |     }
248 | 
249 |     template <typename T>
250 |     Seq<T> & Seq<T>::operator=(Seq other) {
251 |         swap(*this, other);
252 |         return *this;
253 |     }
254 | 
255 |     template <typename T>
256 |     asn_TYPE_descriptor_t * Seq<T>::getTypeDescriptor() const {
257 |         return def_;
258 |     }
259 | 
260 |     template <typename T>
261 |     Seq<T>::operator bool() const {
262 |         return seq_;
263 |     }
264 | 
265 |     template <typename T>
266 |     T & Seq<T>::operator*() {
267 |         if (!seq_)
268 |             throw std::runtime_error("Cannot dereference null pointer");
269 |         return *seq_;
270 |     }
271 | 
272 |     template <typename T>
273 |     const T & Seq<T>::operator*() const {
274 |         if (!seq_)
275 |             throw std::runtime_error("Cannot dereference null pointer");
276 |         return *seq_;
277 |     }
278 | 
279 |     template <typename T>
280 |     T * Seq<T>::operator->() {
281 |         return seq_;
282 |     }
283 | 
284 |     template <typename T>
285 |     const T * Seq<T>::operator->() const {
286 |         return seq_;
287 |     }
288 | 
289 |     template <typename T>
290 |     void Seq<T>::swap(Seq & lhs, Seq & rhs) {
291 |         std::swap(lhs.seq_, rhs.seq_);
292 |         std::swap(lhs.def_, rhs.def_);
293 |     }
294 | 
295 |     template <typename T>
296 |     template <template <typename> class S, typename Y, typename>
297 |     void Seq<T>::deepCopy(const S<Y> & other) {
298 |         // Note: in here we haven't been built yet so we can't use our own
299 |         // data. We also have to set seq_ to nullptr so that the swap happening
300 |         // during the assignment won't cause a Seq<T> to try to delete an
301 |         // uninitialized pointer.
302 |         seq_ = nullptr;
303 |         if (other && other.getTypeDescriptor()) {
304 |             *this = ber::decode<T>(other.getTypeDescriptor(), ber::encode(other));
305 |         } else {
306 |             def_ = other.getTypeDescriptor();
307 |         }
308 |     }
309 | 
310 |     template <typename T>
311 |     Seq<T> makeSeq(asn_TYPE_descriptor_t * def) {
312 |         return Seq<T>(def);
313 |     }
314 | }
315 | 
316 | /**
317 |  * @defgroup API
318 |  * @brief Library public API
319 |  *
320 |  * This group contains all free functions and macros which should be used by
321 |  * the user in order to correctly use the library. Note that all macros should
322 |  * still be prefaced by the correct namespace indicator, as they still refer to
323 |  * namespaced functions.
324 |  *
325 |  * In addition to the functions and macros referenced in this page, you should
326 |  * look at the documentation for asn1cpp::Seq and asn1cpp::View, which are the
327 |  * main ways that asn1cpp uses in order to manage memory and provide an easy
328 |  * way to access asn1c fields.
329 |  *
330 |  * @def makeSeq(T)
331 |  * @ingroup API
332 |  * @brief Creates a Seq instance for the specified type.
333 |  *
334 |  * This macro allows specifying the name of the underlying asn1c type, and it
335 |  * will automatically find the appropriate asn1c type descriptor for you.
336 |  */
337 | #define makeSeq(T) \
338 |     makeSeq<T>(&ASN1CPP_ASN1C_DEF(T))
339 | 
340 | #endif
341 | 


--------------------------------------------------------------------------------
/test/common/setofTests.cpp:
--------------------------------------------------------------------------------
  1 | #define BOOST_TEST_MODULE setofTests
  2 | #define BOOST_TEST_DYN_LINK
  3 | #define BOOST_TEST_MAIN
  4 | #include <boost/test/unit_test.hpp>
  5 | 
  6 | #include <array>
  7 | 
  8 | #include "TestSetOf.h"
  9 | 
 10 | #include "asn1cpp/Seq.hpp"
 11 | #include "asn1cpp/Getter.hpp"
 12 | #include "asn1cpp/Setter.hpp"
 13 | #include "asn1cpp/Encoding.hpp"
 14 | #include "asn1cpp/SetOf.hpp"
 15 | 
 16 | BOOST_AUTO_TEST_CASE( construction ) {
 17 |     auto test = asn1cpp::makeSeq(TestSetOf);
 18 | }
 19 | 
 20 | BOOST_AUTO_TEST_CASE( add_integer ) {
 21 |     constexpr std::array<int, 3> values = {{5, 54, 190}};
 22 | 
 23 |     auto test = asn1cpp::makeSeq(TestSetOf);
 24 | 
 25 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[0]));
 26 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[1]));
 27 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[2]));
 28 | 
 29 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 3);
 30 | 
 31 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 0), values[0]);
 32 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 1), values[1]);
 33 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 2), values[2]);
 34 | }
 35 | 
 36 | BOOST_AUTO_TEST_CASE( set_integer ) {
 37 |     constexpr std::array<int, 3> values = {{5, 54, 190}};
 38 |     constexpr int newValue = 778;
 39 | 
 40 |     auto test = asn1cpp::makeSeq(TestSetOf);
 41 | 
 42 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[0]));
 43 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[1]));
 44 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[2]));
 45 | 
 46 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 3);
 47 | 
 48 |     BOOST_CHECK(asn1cpp::setof::setField(test->integer, newValue, 1));
 49 |     BOOST_CHECK(!asn1cpp::setof::setField(test->integer, newValue, 3));
 50 | 
 51 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 0), values[0]);
 52 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 1), newValue);
 53 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 2), values[2]);
 54 | }
 55 | 
 56 | BOOST_AUTO_TEST_CASE( remove_integer ) {
 57 |     constexpr std::array<int, 3> values = {{12, 23, 34}};
 58 | 
 59 |     auto test = asn1cpp::makeSeq(TestSetOf);
 60 | 
 61 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[0]));
 62 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[1]));
 63 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[2]));
 64 | 
 65 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 3);
 66 | 
 67 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 0), values[0]);
 68 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 1), values[1]);
 69 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 2), values[2]);
 70 | 
 71 |     BOOST_CHECK(asn1cpp::setof::popList(test->integer, INTEGER, 1));
 72 | 
 73 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 2);
 74 | 
 75 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 0), values[0]);
 76 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->integer, int, 1), values[2]);
 77 | }
 78 | 
 79 | BOOST_AUTO_TEST_CASE( clear_integer ) {
 80 |     constexpr std::array<int, 3> values = {{12, 23, 34}};
 81 | 
 82 |     auto test = asn1cpp::makeSeq(TestSetOf);
 83 | 
 84 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[0]));
 85 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[1]));
 86 |     BOOST_CHECK(asn1cpp::setof::pushList(test->integer, values[2]));
 87 | 
 88 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 3);
 89 | 
 90 |     asn1cpp::setof::clrField(test->integer, INTEGER);
 91 | 
 92 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->integer), 0);
 93 | }
 94 | 
 95 | BOOST_AUTO_TEST_CASE( add_string ) {
 96 |     const std::array<std::string, 3> values = {{"alpha", "beta", "gamma"}};
 97 | 
 98 |     auto test = asn1cpp::makeSeq(TestSetOf);
 99 | 
100 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[0]));
101 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[1]));
102 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[2]));
103 | 
104 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->string), 3);
105 | 
106 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 0), values[0]);
107 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 1), values[1]);
108 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 2), values[2]);
109 | }
110 | 
111 | BOOST_AUTO_TEST_CASE( remove_string ) {
112 |     const std::array<std::string, 3> values = {{"veni", "vidi", "vici"}};
113 | 
114 |     auto test = asn1cpp::makeSeq(TestSetOf);
115 | 
116 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[0]));
117 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[1]));
118 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[2]));
119 | 
120 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->string), 3);
121 | 
122 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 0), values[0]);
123 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 1), values[1]);
124 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 2), values[2]);
125 | 
126 |     BOOST_CHECK(asn1cpp::setof::popList(test->string, OCTET_STRING, 1));
127 | 
128 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->string), 2);
129 | 
130 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 0), values[0]);
131 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->string, std::string, 1), values[2]);
132 | }
133 | 
134 | BOOST_AUTO_TEST_CASE( clear_string ) {
135 |     const std::array<std::string, 3> values = {{"god", "is", "dead"}};
136 | 
137 |     auto test = asn1cpp::makeSeq(TestSetOf);
138 | 
139 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[0]));
140 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[1]));
141 |     BOOST_CHECK(asn1cpp::setof::pushList(test->string, values[2]));
142 | 
143 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->string), 3);
144 | 
145 |     asn1cpp::setof::clrField(test->string, OCTET_STRING);
146 | 
147 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->string), 0);
148 | }
149 | 
150 | BOOST_AUTO_TEST_CASE( add_boolean ) {
151 |     constexpr std::array<bool, 3> values = {{false, true, false}};
152 | 
153 |     auto test = asn1cpp::makeSeq(TestSetOf);
154 | 
155 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[0]));
156 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[1]));
157 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[2]));
158 | 
159 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->boolean), 3);
160 | 
161 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 0), values[0]);
162 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 1), values[1]);
163 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 2), values[2]);
164 | }
165 | 
166 | BOOST_AUTO_TEST_CASE( remove_boolean ) {
167 |     constexpr std::array<bool, 3> values = {{true, true, false}};
168 | 
169 |     auto test = asn1cpp::makeSeq(TestSetOf);
170 | 
171 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[0]));
172 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[1]));
173 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[2]));
174 | 
175 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->boolean), 3);
176 | 
177 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 0), values[0]);
178 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 1), values[1]);
179 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 2), values[2]);
180 | 
181 |     BOOST_CHECK(asn1cpp::setof::popList(test->boolean, BOOLEAN, 1));
182 | 
183 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->boolean), 2);
184 | 
185 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 0), values[0]);
186 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getField(test->boolean, bool, 1), values[2]);
187 | }
188 | 
189 | BOOST_AUTO_TEST_CASE( clear_boolean ) {
190 |     constexpr std::array<bool, 3> values = {{false, false, true}};
191 | 
192 |     auto test = asn1cpp::makeSeq(TestSetOf);
193 | 
194 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[0]));
195 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[1]));
196 |     BOOST_CHECK(asn1cpp::setof::pushList(test->boolean, values[2]));
197 | 
198 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->boolean), 3);
199 | 
200 |     asn1cpp::setof::clrField(test->boolean, BOOLEAN);
201 | 
202 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->boolean), 0);
203 | }
204 | 
205 | BOOST_AUTO_TEST_CASE( add_nested ) {
206 |     auto insert0 = asn1cpp::makeSeq(TestInteger);
207 |     BOOST_CHECK(asn1cpp::setField(insert0->integer, 45));
208 | 
209 |     auto seq = asn1cpp::makeSeq(TestInteger);
210 |     BOOST_CHECK(asn1cpp::setField(seq->integer, 23));
211 |     asn1cpp::View<TestInteger> insert1 = seq;
212 | 
213 |     auto test = asn1cpp::makeSeq(TestSetOf);
214 | 
215 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert0));
216 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert1));
217 | 
218 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->nested), 2);
219 | 
220 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSeq(test->nested, TestInteger, 0), insert0);
221 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getView(test->nested, TestInteger, 0), insert0);
222 | 
223 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSeq(test->nested, TestInteger, 1), insert1);
224 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getView(test->nested, TestInteger, 1), insert1);
225 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSeq(test->nested, TestInteger, 1), seq);
226 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getView(test->nested, TestInteger, 1), seq);
227 | }
228 | 
229 | BOOST_AUTO_TEST_CASE( remove_nested ) {
230 |     constexpr std::array<int, 3> values = {{99, 202, 101}};
231 |     auto insert = asn1cpp::makeSeq(TestInteger);
232 | 
233 |     auto test = asn1cpp::makeSeq(TestSetOf);
234 | 
235 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[0]));
236 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
237 | 
238 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[1]));
239 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
240 | 
241 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[2]));
242 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
243 | 
244 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->nested), 3);
245 | 
246 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
247 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 1)->integer, int), values[1]);
248 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 2)->integer, int), values[2]);
249 | 
250 |     BOOST_CHECK(asn1cpp::setof::popList(test->nested, TestInteger, 1));
251 | 
252 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->nested), 2);
253 | 
254 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
255 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 1)->integer, int), values[2]);
256 | }
257 | 
258 | BOOST_AUTO_TEST_CASE( clear_nested ) {
259 |     constexpr std::array<int, 3> values = {{142, 798, 442}};
260 |     auto insert = asn1cpp::makeSeq(TestInteger);
261 | 
262 |     auto test = asn1cpp::makeSeq(TestSetOf);
263 | 
264 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[0]));
265 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
266 | 
267 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[1]));
268 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
269 | 
270 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[2]));
271 |     BOOST_CHECK(asn1cpp::setof::pushList(test->nested, insert));
272 | 
273 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->nested), 3);
274 | 
275 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
276 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 1)->integer, int), values[1]);
277 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::setof::getView(test->nested, TestInteger, 2)->integer, int), values[2]);
278 | 
279 |     asn1cpp::setof::clrField(test->nested, TestInteger);
280 | 
281 |     BOOST_CHECK_EQUAL(asn1cpp::setof::getSize(test->nested), 0);
282 | }
283 | 


--------------------------------------------------------------------------------
/test/common/sequenceofTests.cpp:
--------------------------------------------------------------------------------
  1 | #define BOOST_TEST_MODULE sequenceofTests
  2 | #define BOOST_TEST_DYN_LINK
  3 | #define BOOST_TEST_MAIN
  4 | #include <boost/test/unit_test.hpp>
  5 | 
  6 | #include <array>
  7 | 
  8 | #include "TestSequenceOf.h"
  9 | 
 10 | #include "asn1cpp/Seq.hpp"
 11 | #include "asn1cpp/Getter.hpp"
 12 | #include "asn1cpp/Setter.hpp"
 13 | #include "asn1cpp/Encoding.hpp"
 14 | #include "asn1cpp/SequenceOf.hpp"
 15 | 
 16 | BOOST_AUTO_TEST_CASE( construction ) {
 17 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 18 | }
 19 | 
 20 | BOOST_AUTO_TEST_CASE( add_integer ) {
 21 |     constexpr std::array<int, 3> values = {{5, 54, 190}};
 22 | 
 23 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 24 | 
 25 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[0]));
 26 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[1]));
 27 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[2]));
 28 | 
 29 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 3);
 30 | 
 31 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 0), values[0]);
 32 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 1), values[1]);
 33 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 2), values[2]);
 34 | }
 35 | 
 36 | BOOST_AUTO_TEST_CASE( set_integer ) {
 37 |     constexpr std::array<int, 3> values = {{5, 54, 190}};
 38 |     constexpr int newValue = 778;
 39 | 
 40 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 41 | 
 42 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[0]));
 43 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[1]));
 44 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[2]));
 45 | 
 46 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 3);
 47 | 
 48 |     BOOST_CHECK(asn1cpp::sequenceof::setField(test->integer, newValue, 1));
 49 |     BOOST_CHECK(!asn1cpp::sequenceof::setField(test->integer, newValue, 3));
 50 | 
 51 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 0), values[0]);
 52 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 1), newValue);
 53 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 2), values[2]);
 54 | }
 55 | 
 56 | BOOST_AUTO_TEST_CASE( remove_integer ) {
 57 |     constexpr std::array<int, 3> values = {{12, 23, 34}};
 58 | 
 59 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 60 | 
 61 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[0]));
 62 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[1]));
 63 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[2]));
 64 | 
 65 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 3);
 66 | 
 67 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 0), values[0]);
 68 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 1), values[1]);
 69 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 2), values[2]);
 70 | 
 71 |     BOOST_CHECK(asn1cpp::sequenceof::popList(test->integer, INTEGER, 1));
 72 | 
 73 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 2);
 74 | 
 75 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 0), values[0]);
 76 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->integer, int, 1), values[2]);
 77 | }
 78 | 
 79 | BOOST_AUTO_TEST_CASE( clear_integer ) {
 80 |     constexpr std::array<int, 3> values = {{12, 23, 34}};
 81 | 
 82 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 83 | 
 84 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[0]));
 85 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[1]));
 86 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->integer, values[2]));
 87 | 
 88 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 3);
 89 | 
 90 |     asn1cpp::sequenceof::clrField(test->integer, INTEGER);
 91 | 
 92 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->integer), 0);
 93 | }
 94 | 
 95 | BOOST_AUTO_TEST_CASE( add_string ) {
 96 |     const std::array<std::string, 3> values = {{"alpha", "beta", "gamma"}};
 97 | 
 98 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
 99 | 
100 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[0]));
101 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[1]));
102 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[2]));
103 | 
104 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->string), 3);
105 | 
106 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 0), values[0]);
107 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 1), values[1]);
108 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 2), values[2]);
109 | }
110 | 
111 | BOOST_AUTO_TEST_CASE( remove_string ) {
112 |     const std::array<std::string, 3> values = {{"veni", "vidi", "vici"}};
113 | 
114 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
115 | 
116 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[0]));
117 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[1]));
118 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[2]));
119 | 
120 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->string), 3);
121 | 
122 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 0), values[0]);
123 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 1), values[1]);
124 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 2), values[2]);
125 | 
126 |     BOOST_CHECK(asn1cpp::sequenceof::popList(test->string, OCTET_STRING, 1));
127 | 
128 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->string), 2);
129 | 
130 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 0), values[0]);
131 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->string, std::string, 1), values[2]);
132 | }
133 | 
134 | BOOST_AUTO_TEST_CASE( clear_string ) {
135 |     const std::array<std::string, 3> values = {{"god", "is", "dead"}};
136 | 
137 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
138 | 
139 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[0]));
140 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[1]));
141 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->string, values[2]));
142 | 
143 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->string), 3);
144 | 
145 |     asn1cpp::sequenceof::clrField(test->string, OCTET_STRING);
146 | 
147 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->string), 0);
148 | }
149 | 
150 | BOOST_AUTO_TEST_CASE( add_boolean ) {
151 |     constexpr std::array<bool, 3> values = {{false, true, false}};
152 | 
153 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
154 | 
155 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[0]));
156 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[1]));
157 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[2]));
158 | 
159 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->boolean), 3);
160 | 
161 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 0), values[0]);
162 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 1), values[1]);
163 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 2), values[2]);
164 | }
165 | 
166 | BOOST_AUTO_TEST_CASE( remove_boolean ) {
167 |     constexpr std::array<bool, 3> values = {{true, true, false}};
168 | 
169 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
170 | 
171 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[0]));
172 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[1]));
173 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[2]));
174 | 
175 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->boolean), 3);
176 | 
177 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 0), values[0]);
178 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 1), values[1]);
179 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 2), values[2]);
180 | 
181 |     BOOST_CHECK(asn1cpp::sequenceof::popList(test->boolean, BOOLEAN, 1));
182 | 
183 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->boolean), 2);
184 | 
185 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 0), values[0]);
186 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getField(test->boolean, bool, 1), values[2]);
187 | }
188 | 
189 | BOOST_AUTO_TEST_CASE( clear_boolean ) {
190 |     constexpr std::array<bool, 3> values = {{false, false, true}};
191 | 
192 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
193 | 
194 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[0]));
195 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[1]));
196 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->boolean, values[2]));
197 | 
198 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->boolean), 3);
199 | 
200 |     asn1cpp::sequenceof::clrField(test->boolean, BOOLEAN);
201 | 
202 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->boolean), 0);
203 | }
204 | 
205 | BOOST_AUTO_TEST_CASE( add_nested ) {
206 |     auto insert0 = asn1cpp::makeSeq(TestInteger);
207 |     BOOST_CHECK(asn1cpp::setField(insert0->integer, 45));
208 | 
209 |     auto seq = asn1cpp::makeSeq(TestInteger);
210 |     BOOST_CHECK(asn1cpp::setField(seq->integer, 23));
211 |     asn1cpp::View<TestInteger> insert1 = seq;
212 | 
213 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
214 | 
215 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert0));
216 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert1));
217 | 
218 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 2);
219 | 
220 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 0), insert0);
221 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 0), insert0);
222 | 
223 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 1), insert1);
224 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1), insert1);
225 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSeq(test->nested, TestInteger, 1), seq);
226 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1), seq);
227 | }
228 | 
229 | BOOST_AUTO_TEST_CASE( remove_nested ) {
230 |     constexpr std::array<int, 3> values = {{99, 202, 101}};
231 |     auto insert = asn1cpp::makeSeq(TestInteger);
232 | 
233 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
234 | 
235 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[0]));
236 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
237 | 
238 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[1]));
239 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
240 | 
241 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[2]));
242 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
243 | 
244 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 3);
245 | 
246 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
247 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1)->integer, int), values[1]);
248 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 2)->integer, int), values[2]);
249 | 
250 |     BOOST_CHECK(asn1cpp::sequenceof::popList(test->nested, TestInteger, 1));
251 | 
252 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 2);
253 | 
254 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
255 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1)->integer, int), values[2]);
256 | }
257 | 
258 | BOOST_AUTO_TEST_CASE( clear_nested ) {
259 |     constexpr std::array<int, 3> values = {{142, 798, 442}};
260 |     auto insert = asn1cpp::makeSeq(TestInteger);
261 | 
262 |     auto test = asn1cpp::makeSeq(TestSequenceOf);
263 | 
264 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[0]));
265 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
266 | 
267 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[1]));
268 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
269 | 
270 |     BOOST_CHECK(asn1cpp::setField(insert->integer, values[2]));
271 |     BOOST_CHECK(asn1cpp::sequenceof::pushList(test->nested, insert));
272 | 
273 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 3);
274 | 
275 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 0)->integer, int), values[0]);
276 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 1)->integer, int), values[1]);
277 |     BOOST_CHECK_EQUAL(asn1cpp::getField(asn1cpp::sequenceof::getView(test->nested, TestInteger, 2)->integer, int), values[2]);
278 | 
279 |     asn1cpp::sequenceof::clrField(test->nested, TestInteger);
280 | 
281 |     BOOST_CHECK_EQUAL(asn1cpp::sequenceof::getSize(test->nested), 0);
282 | }
283 | 


--------------------------------------------------------------------------------
/include/asn1cpp/View.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef ASN1CPP_VIEW_HEADER_FILE
  2 | #define ASN1CPP_VIEW_HEADER_FILE
  3 | 
  4 | #include <stdexcept>
  5 | 
  6 | #include "asn_application.h"
  7 | 
  8 | #include "asn1cpp/Utils.hpp"
  9 | #include "asn1cpp/Seq.hpp"
 10 | 
 11 | namespace asn1cpp {
 12 |     namespace Impl {
 13 |         template <typename T, typename Check>
 14 |         struct Setter;
 15 |     }
 16 | 
 17 |     /**
 18 |      * @brief This class wraps, without owning, an ans1c non-primitive structure.
 19 |      *
 20 |      * This class is used in order to edit, copy or otherwise manipulate asn1c
 21 |      * non-primitive structures through a non-owning interface. This allows
 22 |      * manipulation of nested non-primitive objects without the need to copy
 23 |      * them into a Seq first.
 24 |      *
 25 |      * Once initialized, a View cannot change where it is pointed, and all
 26 |      * operations on it will work directly on its underlying structure.
 27 |      *
 28 |      * Note that View uses a mechanism similar to iterators to enforce
 29 |      * constness. This is because copying a View simply results into another
 30 |      * View pointing to the same object. So copying a `const` View would result
 31 |      * in a non-`const` View which would be able to edit the underlying data.
 32 |      * This is thus not allowed.
 33 |      *
 34 |      * In order to create a `const` View, you must wrap a particular type in a
 35 |      * `const` way; e.g. `View<const MyType>`. This can be done by simply
 36 |      * specifying the const during View creation:
 37 |      *
 38 |      * ```
 39 |      * View<const NestedType> const_view = getView(mystruct->nestedField, NestedType);
 40 |      * ```
 41 |      *
 42 |      * or by declaring functions as
 43 |      *
 44 |      * ```
 45 |      * void myFunction(View<const NestedType> view);
 46 |      * ```
 47 |      *
 48 |      * Views are very cheap to copy since they only store pointers and do not
 49 |      * do manage them.
 50 |      *
 51 |      * This class cannot be used to contain asn1c primitive types, such as
 52 |      * INTEGER_t, BOOLEAN_t, OCTET_STRING_t and so on. Those types can be read
 53 |      * and set through the setField() and getField() functions.
 54 |      */
 55 |     template <typename T>
 56 |     class View {
 57 |         public:
 58 |             /**
 59 |              * @brief Basic constructor.
 60 |              *
 61 |              * @param def The asn1c generated type descriptor for the input pointer.
 62 |              * @param p The asn1c struct.
 63 |              */
 64 |             View(asn_TYPE_descriptor_t * def, T * p);
 65 | 
 66 |             /**
 67 |              * @brief Null constructor.
 68 |              *
 69 |              * This constructor is used in order to produce a null View. This
 70 |              * can be useful to notify errors when encoding/decoding/etc.
 71 |              */
 72 |             View();
 73 | 
 74 |             /**
 75 |              * @brief Copy constructor.
 76 |              *
 77 |              * This constructor creates a new View which will access the same
 78 |              * underlying structure as the input View. No hard copy is performed.
 79 |              *
 80 |              * @param other The View to copy.
 81 |              */
 82 |             View(View & other);
 83 | 
 84 |             /**
 85 |              * @brief Const copy constructor.
 86 |              *
 87 |              * **This constructor is enabled only if our wrapped type is const.**
 88 |              *
 89 |              * We prevent construction of a View from a `const` View, or
 90 |              * otherwise it would be possible to modify data which is supposed
 91 |              * to be protected with a `const` interface. If you need to copy a
 92 |              * `const` View, you can copy it to a `View<const T>`, which will
 93 |              * prevent future modifications and allow further copying.
 94 |              *
 95 |              * @param other The View to copy.
 96 |              */
 97 |             View(const View& other);
 98 | 
 99 |             /**
100 |              * @brief Move constructor.
101 |              *
102 |              * This constructor creates a new View which will access the same
103 |              * underlying structure as the input View. No hard copy is performed.
104 |              *
105 |              * @param other The View to copy.
106 |              */
107 |             View(View && other);
108 | 
109 |             /**
110 |              * @brief Templated copy constructor.
111 |              *
112 |              * **This constructor is enabled only if our wrapped type is at
113 |              * least as const as the input one.**
114 |              *
115 |              * We use this constructor to both copy from Seq, and from View
116 |              * which may wrap a type different from ours. The
117 |              * is_convertible_asn1_wrapper checks that we have at least the
118 |              * same constness in our wrapped type as the input.
119 |              *
120 |              * This constructor simply copies the pointers to the underlying
121 |              * struct.
122 |              *
123 |              * @param other The other asn1c wrapped we want to copy.
124 |              */
125 |             template <template <typename> class S, typename Y>
126 |             View(S<Y> & other);
127 | 
128 |             /**
129 |              * @brief Templated copy constructor.
130 |              *
131 |              * **This constructor is enabled only if our wrapped type is const.**
132 |              *
133 |              * We use this constructor to both copy from Seq, and from View
134 |              * which may wrap a type different from ours. The
135 |              * is_convertible_asn1_wrapper checks that we have at least the
136 |              * same constness in our wrapped type as the input.
137 |              *
138 |              * We prevent construction of a View from a `const` object, or
139 |              * otherwise it would be possible to modify data which is supposed
140 |              * to be protected with a `const` interface. If you need to copy a
141 |              * `const` View, you can copy it to a `View<const T>`, which will
142 |              * prevent future modifications and allow further copying.
143 |              *
144 |              * This constructor simply copies the pointers to the underlying
145 |              * struct.
146 |              *
147 |              * @param other The other asn1c wrapped we want to copy.
148 |              */
149 |             template <template <typename> class S, typename Y>
150 |             View(const S<Y> & other);
151 | 
152 |             /**
153 |              * @brief Templated move constructor.
154 |              *
155 |              * **This constructor is enabled only if our wrapped type is at
156 |              * least as const as the input one.**
157 |              *
158 |              * We use this constructor to both copy from Seq, and from View
159 |              * which may wrap a type different from ours. The
160 |              * is_convertible_asn1_wrapper checks that we have at least the
161 |              * same constness in our wrapped type as the input.
162 |              *
163 |              * This constructor simply copies the pointers to the underlying
164 |              * struct.
165 |              *
166 |              * @param other The other asn1c wrapped we want to copy.
167 |              */
168 |             template <template <typename> class S, typename Y>
169 |             View(S<Y> && other);
170 | 
171 |             /**
172 |              * @brief Operator =
173 |              *
174 |              * This operator acts on the wrapped structure, and not on the View
175 |              * itself (which cannot be "repointed" somewhere else after
176 |              * construction).
177 |              *
178 |              * The data passed by the input view is completely copied, and the
179 |              * copy is set in place of our old data, which is automatically
180 |              * deallocated and cleaned up.
181 |              *
182 |              * @param other The View we want to copy.
183 |              *
184 |              * @return A reference to this View.
185 |              */
186 |             View & operator=(const View & other);
187 | 
188 |             /**
189 |              * @brief Templated operator =
190 |              *
191 |              * This operator acts on the wrapped structure, and not on the View
192 |              * itself (which cannot be "repointed" somewhere else after
193 |              * construction).
194 |              *
195 |              * The data passed by the input is completely copied, and the copy
196 |              * is set in place of our old data, which is automatically
197 |              * deallocated and cleaned up.
198 |              *
199 |              * @param other The View we want to copy.
200 |              *
201 |              * @return A reference to this View.
202 |              */
203 |             template <template <typename> class S, typename Y>
204 |             View & operator=(const S<Y> & other);
205 | 
206 |             /**
207 |              * @brief Dereference operator.
208 |              *
209 |              * @return A reference to the underlying asn1c structure.
210 |              */
211 |             T & operator*();
212 | 
213 |             /**
214 |              * @brief Const dereference operator.
215 |              *
216 |              * @return A const reference to the underlying asn1c structure.
217 |              */
218 |             const T & operator*() const;
219 | 
220 |             /**
221 |              * @brief Arrow operator.
222 |              *
223 |              * @return A pointer to the underlying asn1c structure, can be nullptr.
224 |              */
225 |             T * operator->();
226 | 
227 |             /**
228 |              * @brief Const arrow operator.
229 |              *
230 |              * @return A const pointer to the underlying asn1c structure, can be nullptr.
231 |              */
232 |             const T * operator->() const;
233 | 
234 |             /**
235 |              * @brief Whether this instance is valid or not.
236 |              *
237 |              * This operator returns whether the currently held asn1c structure
238 |              * is nullptr or not. Invalid structures will return false.
239 |              *
240 |              * @return True if the underlying structure is not null, false otherwise.
241 |              */
242 |             operator bool() const;
243 | 
244 |             /**
245 |              * @brief Returns the underlying asn1c type descriptor.
246 |              *
247 |              * @return The underlying asn1c type descriptor, which can be null.
248 |              */
249 |             asn_TYPE_descriptor_t * getTypeDescriptor() const;
250 | 
251 |             /**
252 |              * @brief Templated swap.
253 |              *
254 |              * This function swaps the contents of the input and this View's
255 |              * structures, so that both them and all internal pointers are
256 |              * swapped.
257 |              *
258 |              * @param lhs The left hand side.
259 |              * @param rhs The right hand side.
260 |              */
261 |             template <template <typename> class S, typename Y>
262 |             static void swap(View & lhs, S<Y> & rhs);
263 | 
264 |             /**
265 |              * @brief Templated swap.
266 |              *
267 |              * \sa swap(View &, S<Y> &)
268 |              */
269 |             template <template <typename> class S, typename Y>
270 |             static void swap(S<Y> & lhs, View & rhs);
271 | 
272 |         private:
273 |             /**
274 |              * @brief Private constructor.
275 |              *
276 |              * This constructor is used by the internals in order to keep
277 |              * memory clean. It's not public since it does not get the asn1c
278 |              * type descriptor, and this does not allow for encoding/decoding.
279 |              *
280 |              * @param p A pointer to the underlying asn1c struct.
281 |              */
282 |             View(T * p);
283 | 
284 |             template <typename TT, typename Check>
285 |             friend struct Impl::Setter;
286 | 
287 |             T * seq_;
288 |             asn_TYPE_descriptor_t * def_;
289 |     };
290 | 
291 |     template <typename T>
292 |     View<T>::View(asn_TYPE_descriptor_t * def, T * p) :
293 |             seq_(p), def_(def)
294 |     {
295 |         if (!seq_)
296 |             throw std::runtime_error("Cannot build empty View!");
297 |         if (!def_)
298 |             throw std::runtime_error("Cannot build View with no ASN descriptors!");
299 |     }
300 | 
301 |     template <typename T>
302 |     View<T>::View(View & other) : View(other.def_, other.seq_) {}
303 | 
304 |     template <typename T>
305 |     View<T>::View(const View& other) : View(other.def_, other.seq_) {
306 |         static_assert(std::is_const<T>::value, "Cannot copy const View if our wrapped type is not const!");
307 |     }
308 | 
309 |     template <typename T>
310 |     View<T>::View(View && other) : View(other.def_, other.seq_) {}
311 | 
312 |     template <typename T>
313 |     template <template <typename> class S, typename Y>
314 |     View<T>::View(S<Y> & other) : View(other.getTypeDescriptor(), &(*other)) {
315 |         static_assert(is_convertible_asn1_wrapper<View<T>, S<Y>>::value, "Cannot copy unconvertible asn1 wrapper");
316 |     }
317 | 
318 |     template <typename T>
319 |     template <template <typename> class S, typename Y>
320 |     View<T>::View(const S<Y> & other) : View(other.getTypeDescriptor(), &(*other)) {
321 |         static_assert(is_convertible_asn1_wrapper<View<T>, S<Y>>::value, "Cannot copy unconvertible asn1 wrapper");
322 |         static_assert(std::is_const<T>::value, "Cannot copy const asn1 wrapper if our wrapped type is not const!");
323 |     }
324 | 
325 |     template <typename T>
326 |     template <template <typename> class S, typename Y>
327 |     View<T>::View(S<Y> && other) : View(other.getTypeDescriptor(), &(*other)) {
328 |         static_assert(is_convertible_asn1_wrapper<View<T>, S<Y>>::value, "Cannot copy unconvertible asn1 wrapper");
329 |     }
330 | 
331 |     template <typename T>
332 |     View<T>::View() : seq_(nullptr), def_(nullptr) {}
333 | 
334 |     template <typename T>
335 |     View<T>::View(T * seq) : seq_(seq), def_(nullptr) {}
336 | 
337 |     template <typename T>
338 |     asn_TYPE_descriptor_t * View<T>::getTypeDescriptor() const {
339 |         return def_;
340 |     }
341 | 
342 |     template <typename T>
343 |     View<T>::operator bool() const {
344 |         return seq_;
345 |     }
346 | 
347 |     template <typename T>
348 |     T & View<T>::operator*() {
349 |         if (!seq_)
350 |             throw std::runtime_error("Cannot dereference null pointer");
351 |         return *seq_;
352 |     }
353 | 
354 |     template <typename T>
355 |     const T & View<T>::operator*() const {
356 |         if (!seq_)
357 |             throw std::runtime_error("Cannot dereference null pointer");
358 |         return *seq_;
359 |     }
360 | 
361 |     template <typename T>
362 |     T * View<T>::operator->() {
363 |         return seq_;
364 |     }
365 | 
366 |     template <typename T>
367 |     const T * View<T>::operator->() const {
368 |         return seq_;
369 |     }
370 | 
371 |     template <typename T>
372 |     View<T> & View<T>::operator=(const View & other) {
373 |         Seq<T> copy = other;
374 |         swap(*this, copy);
375 |         return *this;
376 |     }
377 | 
378 |     template <typename T>
379 |     template <template <typename> class S, typename Y>
380 |     View<T> & View<T>::operator=(const S<Y> & other) {
381 |         static_assert(are_compatible_asn1_wrappers<View<T>, S<Y>>::value, "Cannot assign from an uncompatible asn1 wrapper");
382 |         Seq<T> copy = other;
383 |         swap(*this, copy);
384 |         return *this;
385 |     }
386 | 
387 |     template <typename T>
388 |     template <template <typename> class S, typename Y>
389 |     void View<T>::swap(View & lhs, S<Y> & rhs) {
390 |         static_assert(are_compatible_asn1_wrappers<View<T>, S<Y>>::value, "Cannot swap from an uncompatible asn1 wrapper");
391 |         if (!lhs && !rhs) return;
392 |         if (!(lhs && rhs))
393 |             throw std::runtime_error("Cannot swap null pointers!");
394 |         T tmp = *rhs;
395 |         *rhs = *lhs;
396 |         *lhs = tmp;
397 |     }
398 | 
399 |     template <typename T>
400 |     template <template <typename> class S, typename Y>
401 |     void View<T>::swap(S<Y> & lhs, View & rhs) {
402 |         swap(rhs, lhs);
403 |     }
404 | }
405 | 
406 | #endif
407 | 


--------------------------------------------------------------------------------