RDB 2
dataTypes.hpp
Go to the documentation of this file.
1 /*
2  *******************************************************************************
3  *
4  * Copyright 2021 RIEGL Laser Measurement Systems
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  * SPDX-License-Identifier: Apache-2.0
19  *
20  *******************************************************************************
21  */
22 /*!
23  *******************************************************************************
24  *
25  * \file dataTypes.hpp
26  * \author RIEGL LMS GmbH, Austria
27  * \brief Point attribute access data types
28  * \version 2015-10-14/AW: Initial version
29  * \version 2018-07-05/AW: Add tools to get data type enum and pointer of data
30  *
31  *******************************************************************************
32  */
33 
34 #ifndef RIEGL_RDB_POINTCLOUD_DATATYPES_HPP
35 #define RIEGL_RDB_POINTCLOUD_DATATYPES_HPP
36 
37 //---< INCLUDES >---------------------------------------------------------------
38 
39 #include <array>
40 #include <vector>
41 #include <limits>
42 #include <cstdint>
43 #include <type_traits>
44 
45 //---< NAMESPACE >--------------------------------------------------------------
46 
47 namespace riegl {
48 namespace rdb {
49 namespace pointcloud {
50 
51 //---< ENUM DataType >----------------------------------------------------------
52 /*!
53  * \brief Point attribute access data type
54  */
56 {
57  NONE = 0, //!< undefined data type
58  UINT8 = 1, //!< 8 bit unsigned integer
59  INT8 = 2, //!< 8 bit signed integer
60  UINT16 = 3, //!< 16 bit unsigned integer
61  INT16 = 4, //!< 16 bit signed integer
62  UINT32 = 5, //!< 32 bit unsigned integer
63  INT32 = 6, //!< 32 bit signed integer
64  UINT64 = 7, //!< 64 bit unsigned integer
65  INT64 = 8, //!< 64 bit signed integer
66  SINGLE = 9, //!< 32 bit single precision floating point value
67  DOUBLE = 10, //!< 64 bit double precision floating point value
68  FLOAT32 = SINGLE, //!< 32 bit single precision floating point value
69  FLOAT64 = DOUBLE //!< 64 bit double precision floating point value
70 };
71 
72 //______________________________________________________________________________
73 /*!
74  * \brief Get RDB data type enumerator from data type
75  *
76  * \see dataTypeOf()
77  */
78 template <typename ValueType>
80 {
81 private:
82  template <bool Integer, bool Signed, size_t Size, typename dummy = void> struct data_type_of { /* void */ };
83  template <typename dummy> struct data_type_of<true, false, 1, dummy> { static const auto type = UINT8; };
84  template <typename dummy> struct data_type_of<true, true, 1, dummy> { static const auto type = INT8; };
85  template <typename dummy> struct data_type_of<true, false, 2, dummy> { static const auto type = UINT16; };
86  template <typename dummy> struct data_type_of<true, true, 2, dummy> { static const auto type = INT16; };
87  template <typename dummy> struct data_type_of<true, false, 4, dummy> { static const auto type = UINT32; };
88  template <typename dummy> struct data_type_of<true, true, 4, dummy> { static const auto type = INT32; };
89  template <typename dummy> struct data_type_of<true, false, 8, dummy> { static const auto type = UINT64; };
90  template <typename dummy> struct data_type_of<true, true, 8, dummy> { static const auto type = INT64; };
91  template <typename dummy> struct data_type_of<false, true, 4, dummy> { static const auto type = FLOAT32; };
92  template <typename dummy> struct data_type_of<false, true, 8, dummy> { static const auto type = FLOAT64; };
93 
94 private:
95  template <typename SomeType>
96  struct remove_container // no container at all or not supported container
97  {
98  typedef SomeType type;
99  };
100 
101  template <typename SomeType, size_t Size>
102  struct remove_container< SomeType[Size] > // C style array
103  {
104  typedef SomeType type;
105  };
106 
107  template <typename SomeType, size_t Size>
108  struct remove_container< std::array<SomeType, Size> > // C++ array
109  {
110  typedef SomeType type;
111  };
112 
113  template <typename SomeType, class Allocator>
114  struct remove_container< std::vector<SomeType, Allocator> > // C++ vector
115  {
116  typedef SomeType type;
117  };
118 
119 private:
120  typedef typename std::remove_cv <ValueType>::type TempType1;
121  typedef typename std::remove_pointer<TempType1>::type TempType2;
122  typedef typename std::remove_cv <TempType2>::type TempType3;
123  typedef typename remove_container <TempType3>::type TempType4;
124  typedef typename remove_container <TempType4>::type CoreType;
125 
126 public:
127  //! Result RDB data type enumerator for given ValueType
128  static const DataType type = data_type_of<
129  std::numeric_limits<CoreType>::is_integer,
130  std::numeric_limits<CoreType>::is_signed,
131  sizeof(CoreType)
132  >::type;
133 };
134 
135 //______________________________________________________________________________
136 /*!
137  * \brief Convenience wrapper for DataTypeOf class
138  *
139  * Example:
140  * \code
141  * std::cout << int(dataTypeOf< int32_t >()); // prints "6"
142  * std::cout << int(dataTypeOf< std::array<double,3> >()); // prints "10"
143  * \endcode
144  */
145 template <typename ValueType>
147 {
149 }
150 
151 //______________________________________________________________________________
152 /*!
153  * \brief Convenience wrapper for DataTypeOf class
154  *
155  * Example:
156  * \code
157  * float amplitude;
158  * std::array<double,3> xyz;
159  * std::cout << int(dataTypeOf(amplitude)); // prints "9"
160  * std::cout << int(dataTypeOf(xyz)); // prints "10"
161  * \endcode
162  */
163 template <typename ValueType>
164 DataType dataTypeOf(const ValueType& value)
165 {
167  (void)value; // unused
168 }
169 
170 //______________________________________________________________________________
171 /*!
172  * \brief Get pointer to variable or to data in a std::array or vector container
173  */
174 template <typename ValueType>
175 ValueType* dataPointerOf(ValueType* const value)
176 {
177  return value;
178 }
179 //! \copydoc dataPointerOf()
180 template <typename ValueType>
181 const ValueType* dataPointerOf(const ValueType* const value)
182 {
183  return value;
184 }
185 //! \copydoc dataPointerOf()
186 template <typename ValueType>
187 ValueType* dataPointerOf(ValueType& value)
188 {
189  return &value;
190 }
191 //! \copydoc dataPointerOf()
192 template <typename ValueType>
193 const ValueType* dataPointerOf(const ValueType& value)
194 {
195  return &value;
196 }
197 //! \copydoc dataPointerOf()
198 template <typename ValueType, size_t Size>
199 ValueType* dataPointerOf(std::array<ValueType, Size>& value)
200 {
201  return value.data();
202 }
203 //! \copydoc dataPointerOf()
204 template <typename ValueType, size_t Size>
205 const ValueType* dataPointerOf(const std::array<ValueType, Size>& value)
206 {
207  return value.data();
208 }
209 //! \copydoc dataPointerOf()
210 template <typename ValueType, class Allocator>
211 ValueType* dataPointerOf(std::vector<ValueType, Allocator>& value)
212 {
213  return value.data();
214 }
215 //! \copydoc dataPointerOf()
216 template <typename ValueType, class Allocator>
217 const ValueType* dataPointerOf(const std::vector<ValueType, Allocator>& value)
218 {
219  return value.data();
220 }
221 
222 }}} // namespace riegl::rdb::pointcloud
223 
224 #endif // RIEGL_RDB_POINTCLOUD_DATATYPES_HPP
riegl::rdb::pointcloud::INT16
16 bit signed integer
Definition: dataTypes.hpp:61
riegl::rdb::pointcloud::UINT32
32 bit unsigned integer
Definition: dataTypes.hpp:62
riegl::rdb::pointcloud::SINGLE
32 bit single precision floating point value
Definition: dataTypes.hpp:66
riegl::rdb::pointcloud::NONE
undefined data type
Definition: dataTypes.hpp:57
riegl::rdb::pointcloud::DataTypeOf
Get RDB data type enumerator from data type.
Definition: dataTypes.hpp:79
riegl::rdb::pointcloud::FLOAT64
64 bit double precision floating point value
Definition: dataTypes.hpp:69
riegl
RIEGL Laser Measurement Systems GmbH, Austria.
Definition: context.hpp:48
riegl::rdb::pointcloud::dataTypeOf
DataType dataTypeOf()
Convenience wrapper for DataTypeOf class.
Definition: dataTypes.hpp:146
riegl::rdb::pointcloud::UINT64
64 bit unsigned integer
Definition: dataTypes.hpp:64
riegl::rdb::pointcloud::DOUBLE
64 bit double precision floating point value
Definition: dataTypes.hpp:67
riegl::rdb::pointcloud::DataTypeOf::type
static const DataType type
Result RDB data type enumerator for given ValueType.
Definition: dataTypes.hpp:128
riegl::rdb::pointcloud::INT32
32 bit signed integer
Definition: dataTypes.hpp:63
riegl::rdb::pointcloud::FLOAT32
32 bit single precision floating point value
Definition: dataTypes.hpp:68
riegl::rdb::pointcloud::dataPointerOf
ValueType * dataPointerOf(ValueType *const value)
Get pointer to variable or to data in a std::array or vector container.
Definition: dataTypes.hpp:175
riegl::rdb::pointcloud::INT64
64 bit signed integer
Definition: dataTypes.hpp:65
riegl::rdb::pointcloud::INT8
8 bit signed integer
Definition: dataTypes.hpp:59
riegl::rdb::pointcloud::UINT16
16 bit unsigned integer
Definition: dataTypes.hpp:60
riegl::rdb::pointcloud::UINT8
8 bit unsigned integer
Definition: dataTypes.hpp:58
riegl::rdb::pointcloud::DataType
DataType
Point attribute access data type.
Definition: dataTypes.hpp:55