Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
RColumnElement.cxx
Go to the documentation of this file.
1/// \file RColumnElement.cxx
2/// \ingroup NTuple ROOT7
3/// \author Jakob Blomer <jblomer@cern.ch>
4/// \date 2019-08-11
5/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback
6/// is welcome!
7
8/*************************************************************************
9 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers. *
10 * All rights reserved. *
11 * *
12 * For the licensing terms see $ROOTSYS/LICENSE. *
13 * For the list of contributors see $ROOTSYS/README/CREDITS. *
14 *************************************************************************/
15
16#include <ROOT/RColumnElement.hxx>
17
18#include <TError.h>
19
20#include <algorithm>
21#include <bitset>
22#include <cstdint>
23#include <memory>
24#include <utility>
25
26std::unique_ptr<ROOT::Experimental::Detail::RColumnElementBase>
27ROOT::Experimental::Detail::RColumnElementBase::Generate(EColumnType type) {
28 switch (type) {
29 case EColumnType::kReal32:
30 return std::make_unique<RColumnElement<float, EColumnType::kReal32>>(nullptr);
31 case EColumnType::kReal64:
32 return std::make_unique<RColumnElement<double, EColumnType::kReal64>>(nullptr);
33 case EColumnType::kChar:
34 return std::make_unique<RColumnElement<char, EColumnType::kChar>>(nullptr);
35 case EColumnType::kByte:
36 return std::make_unique<RColumnElement<std::uint8_t, EColumnType::kByte>>(nullptr);
37 case EColumnType::kInt8:
38 return std::make_unique<RColumnElement<std::int8_t, EColumnType::kInt8>>(nullptr);
39 case EColumnType::kInt16:
40 return std::make_unique<RColumnElement<std::int16_t, EColumnType::kInt16>>(nullptr);
41 case EColumnType::kInt32:
42 return std::make_unique<RColumnElement<std::int32_t, EColumnType::kInt32>>(nullptr);
43 case EColumnType::kInt64:
44 return std::make_unique<RColumnElement<std::int64_t, EColumnType::kInt64>>(nullptr);
45 case EColumnType::kBit:
46 return std::make_unique<RColumnElement<bool, EColumnType::kBit>>(nullptr);
47 case EColumnType::kIndex:
48 return std::make_unique<RColumnElement<ClusterSize_t, EColumnType::kIndex>>(nullptr);
49 case EColumnType::kSwitch:
50 return std::make_unique<RColumnElement<RColumnSwitch, EColumnType::kSwitch>>(nullptr);
51 default:
52 R__ASSERT(false);
53 }
54 // never here
55 return nullptr;
56}
57
58std::size_t ROOT::Experimental::Detail::RColumnElementBase::GetBitsOnStorage(EColumnType type) {
59 switch (type) {
60 case EColumnType::kReal32:
61 return 32;
62 case EColumnType::kReal64:
63 return 64;
64 case EColumnType::kChar:
65 return 8;
66 case EColumnType::kByte:
67 return 8;
68 case EColumnType::kInt8:
69 return 8;
70 case EColumnType::kInt16:
71 return 16;
72 case EColumnType::kInt32:
73 return 32;
74 case EColumnType::kInt64:
75 return 64;
76 case EColumnType::kBit:
77 return 1;
78 case EColumnType::kIndex:
79 return 32;
80 case EColumnType::kSwitch:
81 return 64;
82 default:
83 R__ASSERT(false);
84 }
85 // never here
86 return 0;
87}
88
89std::string ROOT::Experimental::Detail::RColumnElementBase::GetTypeName(EColumnType type) {
90 switch (type) {
91 case EColumnType::kReal32:
92 return "Real32";
93 case EColumnType::kReal64:
94 return "Real64";
95 case EColumnType::kChar:
96 return "Char";
97 case EColumnType::kByte:
98 return "Byte";
99 case EColumnType::kInt8:
100 return "Int8";
101 case EColumnType::kInt16:
102 return "Int16";
103 case EColumnType::kInt32:
104 return "Int32";
105 case EColumnType::kInt64:
106 return "Int64";
107 case EColumnType::kBit:
108 return "Bit";
109 case EColumnType::kIndex:
110 return "Index";
111 case EColumnType::kSwitch:
112 return "Switch";
113 default:
114 return "UNKNOWN";
115 }
116}
117
118void ROOT::Experimental::Detail::RColumnElement<ROOT::Experimental::RColumnSwitch,
119 ROOT::Experimental::EColumnType::kSwitch>::Pack(void *dst, void *src,
120 std::size_t count) const
121{
122 auto srcArray = reinterpret_cast<ROOT::Experimental::RColumnSwitch *>(src);
123 auto uint64Array = reinterpret_cast<std::uint64_t *>(dst);
124 for (std::size_t i = 0; i < count; ++i) {
125 uint64Array[i] =
126 (static_cast<std::uint64_t>(srcArray[i].GetTag()) << 44) | (srcArray[i].GetIndex() & 0x0fffffffffff);
127#if R__LITTLE_ENDIAN == 0
128 uint64Array[i] = RByteSwap<8>::bswap(uint64Array[i]);
129#endif
130 }
131}
132
133void ROOT::Experimental::Detail::RColumnElement<
134 ROOT::Experimental::RColumnSwitch, ROOT::Experimental::EColumnType::kSwitch>::Unpack(void *dst, void *src,
135 std::size_t count) const
136{
137 auto uint64Array = reinterpret_cast<std::uint64_t *>(src);
138 auto dstArray = reinterpret_cast<ROOT::Experimental::RColumnSwitch *>(dst);
139 for (std::size_t i = 0; i < count; ++i) {
140#if R__LITTLE_ENDIAN == 1
141 const auto value = uint64Array[i];
142#else
143 const auto value = RByteSwap<8>::bswap(uint64Array[i]);
144#endif
145 dstArray[i] = ROOT::Experimental::RColumnSwitch(
146 ClusterSize_t{static_cast<RClusterSize::ValueType>(value & 0x0fffffffffff)}, (value >> 44));
147 }
148}
149
150void ROOT::Experimental::Detail::RColumnElement<bool, ROOT::Experimental::EColumnType::kBit>::Pack(
151 void *dst, void *src, std::size_t count) const
152{
153 bool *boolArray = reinterpret_cast<bool *>(src);
154 char *charArray = reinterpret_cast<char *>(dst);
155 std::bitset<8> bitSet;
156 std::size_t i = 0;
157 for (; i < count; ++i) {
158 bitSet.set(i % 8, boolArray[i]);
159 if (i % 8 == 7) {
160 char packed = bitSet.to_ulong();
161 charArray[i / 8] = packed;
162 }
163 }
164 if (i % 8 != 0) {
165 char packed = bitSet.to_ulong();
166 charArray[i / 8] = packed;
167 }
168}
169
170void ROOT::Experimental::Detail::RColumnElement<bool, ROOT::Experimental::EColumnType::kBit>::Unpack(
171 void *dst, void *src, std::size_t count) const
172{
173 bool *boolArray = reinterpret_cast<bool *>(dst);
174 char *charArray = reinterpret_cast<char *>(src);
175 std::bitset<8> bitSet;
176 for (std::size_t i = 0; i < count; i += 8) {
177 bitSet = charArray[i / 8];
178 for (std::size_t j = i; j < std::min(count, i + 8); ++j) {
179 boolArray[j] = bitSet[j % 8];
180 }
181 }
182}
183
184
185void ROOT::Experimental::Detail::RColumnElement<std::int64_t, ROOT::Experimental::EColumnType::kInt32>::Pack(
186 void *dst, void *src, std::size_t count) const
187{
188 std::int64_t *int64Array = reinterpret_cast<std::int64_t *>(src);
189 std::int32_t *int32Array = reinterpret_cast<std::int32_t *>(dst);
190 for (std::size_t i = 0; i < count; ++i) {
191 int32Array[i] = int64Array[i];
192#if R__LITTLE_ENDIAN == 0
193 int32Array[i] = RByteSwap<4>::bswap(int32Array[i]);
194#endif
195 }
196}
197
198void ROOT::Experimental::Detail::RColumnElement<std::int64_t, ROOT::Experimental::EColumnType::kInt32>::Unpack(
199 void *dst, void *src, std::size_t count) const
200{
201 std::int32_t *int32Array = reinterpret_cast<std::int32_t *>(src);
202 std::int64_t *int64Array = reinterpret_cast<std::int64_t *>(dst);
203 for (std::size_t i = 0; i < count; ++i) {
204 int64Array[i] = int32Array[i];
205#if R__LITTLE_ENDIAN == 0
206 int64Array[i] = RByteSwap<8>::bswap(int64Array[i]);
207#endif
208 }
209}
R__ASSERT
#define R__ASSERT(e)
Definition TError.h:117
value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Definition TGWin32VirtualXProxy.cxx:142
src
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t src
Definition TGWin32VirtualXProxy.cxx:164
type
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Definition TGWin32VirtualXProxy.cxx:249
ROOT::Experimental::Detail::RColumnElementBase::Pack
virtual void Pack(void *destination, void *source, std::size_t count) const
If the on-storage layout and the in-memory layout differ, packing creates an on-disk page from an in-...
Definition RColumnElement.hxx:119
ROOT::Experimental::Detail::RColumnElementBase::Generate
static std::unique_ptr< RColumnElementBase > Generate(EColumnType type)
Definition RColumnElement.cxx:27
ROOT::Experimental::Detail::RColumnElementBase::GetTypeName
static std::string GetTypeName(EColumnType type)
Definition RColumnElement.cxx:89
ROOT::Experimental::Detail::RColumnElementBase::Unpack
virtual void Unpack(void *destination, void *source, std::size_t count) const
If the on-storage layout and the in-memory layout differ, unpacking creates a memory page from an on-...
Definition RColumnElement.hxx:125
ROOT::Experimental::Detail::RColumnElement
Pairs of C++ type and column type, like float and EColumnType::kReal32.
Definition RColumnElement.hxx:167
ROOT::Experimental::RColumnSwitch
Holds the index and the tag of a kSwitch column.
Definition RNTupleUtil.hxx:67
ROOT::Experimental::ClusterSize_t
RClusterSize ClusterSize_t
Definition RNTupleUtil.hxx:63
RByteSwap
Helper templated class for swapping bytes; specializations for N={2,4,8} are provided below.
Definition Byteswap.h:124