| Directory: | ./ |
|---|---|
| File: | include/hpp/corbaserver/conversions.hh |
| Date: | 2024-12-13 15:50:05 |
| Exec | Total | Coverage | |
|---|---|---|---|
| Lines: | 17 | 46 | 37.0% |
| Branches: | 3 | 24 | 12.5% |
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | // Copyright (c) 2016, Joseph Mirabel | ||
| 2 | // Authors: Joseph Mirabel (joseph.mirabel@laas.fr) | ||
| 3 | // | ||
| 4 | |||
| 5 | // Redistribution and use in source and binary forms, with or without | ||
| 6 | // modification, are permitted provided that the following conditions are | ||
| 7 | // met: | ||
| 8 | // | ||
| 9 | // 1. Redistributions of source code must retain the above copyright | ||
| 10 | // notice, this list of conditions and the following disclaimer. | ||
| 11 | // | ||
| 12 | // 2. Redistributions in binary form must reproduce the above copyright | ||
| 13 | // notice, this list of conditions and the following disclaimer in the | ||
| 14 | // documentation and/or other materials provided with the distribution. | ||
| 15 | // | ||
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | ||
| 20 | // HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | ||
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | ||
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | ||
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | ||
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH | ||
| 27 | // DAMAGE. | ||
| 28 | |||
| 29 | #ifndef HPP_CORBASERVER_CONVERSIONS_HH | ||
| 30 | #define HPP_CORBASERVER_CONVERSIONS_HH | ||
| 31 | |||
| 32 | #include <hpp/common-idl.hh> | ||
| 33 | #include <hpp/corbaserver/fwd.hh> | ||
| 34 | #include <hpp/core/parameter.hh> | ||
| 35 | #include <hpp/util/exception-factory.hh> | ||
| 36 | |||
| 37 | namespace hpp { | ||
| 38 | namespace corbaServer { | ||
| 39 | typedef Eigen::Matrix<CORBA::Long, Eigen::Dynamic, Eigen::Dynamic> IntMatrix_t; | ||
| 40 | |||
| 41 | void toTransform3s(const Transform_ in, Transform3s& out); | ||
| 42 | |||
| 43 | Transform3s toTransform3s(const Transform_ in); | ||
| 44 | |||
| 45 | std::vector<Transform3s> toTransform3s(const TransformSeq in); | ||
| 46 | |||
| 47 | void toHppTransform(const Transform3s& in, Transform_ out); | ||
| 48 | |||
| 49 | Transform__slice* toHppTransform(const Transform3s& in); | ||
| 50 | |||
| 51 | void toIntSeq(std::vector<int> const& in, intSeq& out); | ||
| 52 | |||
| 53 | floatSeq* vectorToFloatSeq(core::vectorIn_t input); | ||
| 54 | |||
| 55 | void vectorToFloatSeq(core::vectorIn_t input, floatSeq& output); | ||
| 56 | |||
| 57 | /// Returns a sequence of the rows of the input matrix. | ||
| 58 | // Return [ [input.row(0)], [input.row(1)], ...] | ||
| 59 | floatSeqSeq* matrixToFloatSeqSeq(core::matrixIn_t input); | ||
| 60 | |||
| 61 | intSeqSeq* matrixToIntSeqSeq(Eigen::Ref<const IntMatrix_t> input); | ||
| 62 | |||
| 63 | std::vector<int> intSeqToVector(const intSeq& dofArray); | ||
| 64 | |||
| 65 | vector3_t floatSeqToVector3(const floatSeq& dofArray); | ||
| 66 | |||
| 67 | vector_t floatSeqToVector(const floatSeq& dofArray, | ||
| 68 | const size_type expectedSize = -1); | ||
| 69 | |||
| 70 | Configuration_t floatSeqToConfig(const DevicePtr_t& robot, | ||
| 71 | const floatSeq& dofArray, | ||
| 72 | bool throwIfNotNormalized); | ||
| 73 | |||
| 74 | core::matrix_t floatSeqSeqToMatrix(const floatSeqSeq& input, | ||
| 75 | const size_type expectedRows = -1, | ||
| 76 | const size_type expectedCols = -1); | ||
| 77 | |||
| 78 | IntMatrix_t intSeqSeqToMatrix(const intSeqSeq& input, | ||
| 79 | const size_type expectedRows = -1, | ||
| 80 | const size_type expectedCols = -1); | ||
| 81 | |||
| 82 | std::vector<bool> boolSeqToVector(const hpp::boolSeq& mask, | ||
| 83 | unsigned int length = 3); | ||
| 84 | |||
| 85 | stringSeqSeq* vectorToStringSeqSeq(std::vector<std::vector<std::string>> input); | ||
| 86 | |||
| 87 | 59 | inline char* c_str(const std::string& in) { | |
| 88 | 59 | char* out = new char[in.length() + 1]; | |
| 89 | 59 | strcpy(out, in.c_str()); | |
| 90 | 59 | return out; | |
| 91 | } | ||
| 92 | |||
| 93 | template <typename InputIt> | ||
| 94 | 4 | inline Names_t* toNames_t(InputIt begin, InputIt end) { | |
| 95 | 4 | std::size_t len = std::distance(begin, end); | |
| 96 | 4 | char** nameList = Names_t::allocbuf((CORBA::ULong)len); | |
| 97 | 4 | Names_t* ret = | |
| 98 |
1/2✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
4 | new Names_t((CORBA::ULong)len, (CORBA::ULong)len, nameList, true); |
| 99 | |||
| 100 | 4 | std::size_t i = 0; | |
| 101 |
2/2✓ Branch 1 taken 25 times.
✓ Branch 2 taken 1 times.
|
67 | while (begin != end) { |
| 102 | 63 | nameList[i] = c_str(*begin); | |
| 103 | 63 | ++begin; | |
| 104 | 63 | ++i; | |
| 105 | } | ||
| 106 | 4 | return ret; | |
| 107 | } | ||
| 108 | |||
| 109 | template <typename Iterable> | ||
| 110 | 1 | inline Names_t* toNames_t(const Iterable& iterable) { | |
| 111 | 1 | return toNames_t(iterable.begin(), iterable.end()); | |
| 112 | } | ||
| 113 | |||
| 114 | template <typename InputIt> | ||
| 115 | ✗ | inline intSeq* toIntSeq(InputIt begin, InputIt end) { | |
| 116 | ✗ | std::size_t len = std::distance(begin, end); | |
| 117 | ✗ | intSeq* indexes = new intSeq(); | |
| 118 | ✗ | indexes->length((CORBA::ULong)len); | |
| 119 | |||
| 120 | ✗ | std::size_t i = 0; | |
| 121 | ✗ | while (begin != end) { | |
| 122 | ✗ | (*indexes)[(CORBA::ULong)i] = *begin; | |
| 123 | ✗ | ++begin; | |
| 124 | ✗ | ++i; | |
| 125 | } | ||
| 126 | ✗ | return indexes; | |
| 127 | } | ||
| 128 | |||
| 129 | intSeq* toIntSeq(std::vector<int> const& in); | ||
| 130 | |||
| 131 | template <typename InputIt> | ||
| 132 | ✗ | inline boolSeq* toBoolSeq(InputIt begin, InputIt end) { | |
| 133 | ✗ | std::size_t len = std::distance(begin, end); | |
| 134 | ✗ | boolSeq* indexes = new boolSeq(); | |
| 135 | ✗ | indexes->length((CORBA::ULong)len); | |
| 136 | |||
| 137 | ✗ | std::size_t i = 0; | |
| 138 | ✗ | while (begin != end) { | |
| 139 | ✗ | (*indexes)[(CORBA::ULong)i] = *begin; | |
| 140 | ✗ | ++begin; | |
| 141 | ✗ | ++i; | |
| 142 | } | ||
| 143 | ✗ | return indexes; | |
| 144 | } | ||
| 145 | |||
| 146 | template <typename OutputType> | ||
| 147 | ✗ | inline OutputType toStrings(const Names_t& names) { | |
| 148 | ✗ | OutputType ret; | |
| 149 | ✗ | for (CORBA::ULong i = 0; i < names.length(); ++i) | |
| 150 | ✗ | ret.push_back(std::string(names[i])); | |
| 151 | ✗ | return ret; | |
| 152 | } | ||
| 153 | |||
| 154 | /// Convert CORBA comparison types to C++ comparison type. | ||
| 155 | constraints::ComparisonTypes_t convertComparison(hpp::ComparisonTypes_t comp); | ||
| 156 | |||
| 157 | /// Convert C++ comparison type to CORBA comparison types. | ||
| 158 | hpp::ComparisonTypes_t* convertComparison(constraints::ComparisonTypes_t comp); | ||
| 159 | |||
| 160 | core::Parameter toParameter(const CORBA::Any& any); | ||
| 161 | |||
| 162 | CORBA::Any toCorbaAny(const core::Parameter& parameter); | ||
| 163 | |||
| 164 | ✗ | inline CORBA::Any* toCorbaAnyPtr(const core::Parameter& parameter) { | |
| 165 | ✗ | CORBA::Any* ap = new CORBA::Any; | |
| 166 | ✗ | *ap = toCorbaAny(parameter); | |
| 167 | ✗ | return ap; | |
| 168 | } | ||
| 169 | |||
| 170 | } // namespace corbaServer | ||
| 171 | } // namespace hpp | ||
| 172 | |||
| 173 | #endif // HPP_CORBASERVER_CONVERSIONS_HH | ||
| 174 |