1 #ifndef _TCUFORMATUTIL_HPP 2 #define _TCUFORMATUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program Tester Core 5 * ---------------------------------------- 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief String format utilities. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "deString.h" 28 29 #include <ostream> 30 #include <string> 31 32 namespace tcu 33 { 34 namespace Format 35 { 36 37 // Hexadecimal value formatter. 38 template <size_t NumDigits> 39 class Hex 40 { 41 public: 42 Hex (deUint64 value_) : value(value_) {} 43 44 std::ostream& toStream (std::ostream& stream) const 45 { 46 return stream << this->toString(); 47 } 48 49 std::string toString (void) const 50 { 51 DE_STATIC_ASSERT(0 < NumDigits && NumDigits <= 16); 52 53 const char longFmt[] = {'0', 'x', '%', '0', '0' + NumDigits/10, '0' + NumDigits%10, 'l', 'l', 'x', 0}; 54 const char shortFmt[] = {'0', 'x', '%', '0', '0' + NumDigits, 'l', 'l', 'x', 0}; 55 56 char buf[sizeof(deUint64)*2 + 3]; 57 deSprintf(buf, sizeof(buf), NumDigits > 9 ? longFmt : shortFmt, value); 58 59 return std::string(buf); 60 } 61 62 private: 63 deUint64 value; 64 }; 65 66 template <size_t NumDigits> 67 std::ostream& operator<< (std::ostream& stream, tcu::Format::Hex<NumDigits> hex) 68 { 69 return hex.toStream(stream); 70 } 71 72 // Bitfield formatter. 73 74 class BitDesc 75 { 76 public: 77 deUint64 bit; 78 const char* name; 79 80 BitDesc (deUint64 bit_, const char* name_) : bit(bit_), name(name_) {} 81 }; 82 83 #define TCU_BIT_DESC(BIT) tcu::Format::BitDesc(BIT, #BIT) 84 85 template <size_t BitfieldSize> 86 class Bitfield 87 { 88 public: 89 Bitfield (deUint64 value, const BitDesc* begin, const BitDesc* end) 90 : m_value (value) 91 , m_begin (begin) 92 , m_end (end) 93 { 94 } 95 96 std::ostream& toStream (std::ostream& stream) 97 { 98 deUint64 bitsLeft = m_value; 99 for (const BitDesc* curDesc = m_begin; curDesc != m_end; curDesc++) 100 { 101 if (curDesc->bit & bitsLeft) 102 { 103 if (bitsLeft != m_value) 104 stream << "|"; 105 stream << curDesc->name; 106 bitsLeft ^= curDesc->bit; 107 } 108 } 109 110 if (bitsLeft != 0) 111 { 112 if (bitsLeft != m_value) 113 stream << "|"; 114 stream << Hex<BitfieldSize/4>(bitsLeft); 115 } 116 117 return stream; 118 } 119 120 private: 121 deUint64 m_value; 122 const BitDesc* m_begin; 123 const BitDesc* m_end; 124 }; 125 126 template <size_t BitfieldSize> 127 inline std::ostream& operator<< (std::ostream& stream, Bitfield<BitfieldSize> decoder) 128 { 129 return decoder.toStream(stream); 130 } 131 132 // Enum formatter. 133 // \todo [2012-10-30 pyry] Use template for GetName. 134 template <typename T, size_t NumBytes = sizeof(T)> 135 class Enum 136 { 137 public: 138 typedef const char* (*GetNameFunc) (T value); 139 140 Enum (GetNameFunc getName, T value) 141 : m_getName (getName) 142 , m_value (value) 143 { 144 } 145 146 std::ostream& toStream (std::ostream& stream) const 147 { 148 const char* name = m_getName(m_value); 149 if (name) 150 return stream << name; 151 else 152 return stream << Hex<NumBytes*2>((deUint64)m_value); 153 } 154 155 std::string toString (void) const 156 { 157 const char* name = m_getName(m_value); 158 if (name) 159 return std::string(name); 160 else 161 return Hex<NumBytes*2>((deUint64)m_value).toString(); 162 } 163 164 private: 165 const GetNameFunc m_getName; 166 const T m_value; 167 }; 168 169 template <typename T, size_t NumBytes> 170 inline std::ostream& operator<< (std::ostream& stream, const Enum<T, NumBytes>& fmt) { return fmt.toStream(stream); } 171 172 // Array formatters. 173 174 template <typename Iterator> 175 class Array 176 { 177 public: 178 Iterator begin; 179 Iterator end; 180 181 Array (const Iterator& begin_, const Iterator& end_) : begin(begin_), end(end_) {} 182 }; 183 184 template <typename T> 185 class ArrayPointer 186 { 187 public: 188 const T* arr; 189 int size; 190 191 ArrayPointer (const T* arr_, int size_) : arr(arr_), size(size_) {} 192 }; 193 194 template <typename Iterator> 195 std::ostream& operator<< (std::ostream& str, const Array<Iterator>& fmt) 196 { 197 str << "{ "; 198 for (Iterator cur = fmt.begin; cur != fmt.end; ++cur) 199 { 200 if (cur != fmt.begin) 201 str << ", "; 202 str << *cur; 203 } 204 str << " }"; 205 return str; 206 } 207 208 template <typename T> 209 std::ostream& operator<< (std::ostream& str, const ArrayPointer<T>& fmt) 210 { 211 if (fmt.arr != DE_NULL) 212 return str << Array<const T*>(fmt.arr, fmt.arr+fmt.size); 213 else 214 return str << "(null)"; 215 } 216 217 // Hex format iterator (useful for combining with ArrayFormatter). 218 // \todo [2012-10-30 pyry] Implement more generic format iterator. 219 220 template <typename T, typename Iterator = const T*> 221 class HexIterator 222 { 223 public: 224 HexIterator (Iterator iter) : m_iter(iter) {} 225 226 HexIterator<T, Iterator>& operator++ (void) { ++m_iter; return *this; } 227 HexIterator<T, Iterator> operator++ (int) { return HexIterator(m_iter++); } 228 229 bool operator== (const HexIterator<T, Iterator>& other) const { return m_iter == other.m_iter; } 230 bool operator!= (const HexIterator<T, Iterator>& other) const { return m_iter != other.m_iter; } 231 232 #if !defined(__INTELLISENSE__) 233 // Intellisense in VS2013 crashes when parsing this. 234 Hex<sizeof(T)*2> operator* (void) const { return Hex<sizeof(T)*2>(*m_iter); } 235 #endif 236 237 private: 238 Iterator m_iter; 239 }; 240 241 } // Format 242 243 template <int Bits> inline deUint64 makeMask64 (void) { return (1ull<<Bits)-1; } 244 template <> inline deUint64 makeMask64<64> (void) { return ~0ull; } 245 template <typename T> inline deUint64 toUint64 (T value) { return (deUint64)value & makeMask64<sizeof(T)*8>(); } 246 247 /** Format value as hexadecimal number. */ 248 template <size_t NumDigits, typename T> 249 inline Format::Hex<NumDigits> toHex (T value) 250 { 251 return Format::Hex<NumDigits>(toUint64(value)); 252 } 253 254 /** Format value as hexadecimal number. */ 255 template <typename T> 256 inline Format::Hex<sizeof(T)*2> toHex (T value) 257 { 258 return Format::Hex<sizeof(T)*2>(toUint64(value)); 259 } 260 261 /** Decode and format bitfield. */ 262 template <typename T, size_t Size> 263 inline Format::Bitfield<sizeof(T)*8> formatBitfield (T value, const Format::BitDesc (&desc)[Size]) 264 { 265 return Format::Bitfield<sizeof(T)*8>((deUint64)value, &desc[0], &desc[Size]); 266 } 267 268 /** Format array contents. */ 269 template <typename Iterator> 270 inline Format::Array<Iterator> formatArray (const Iterator& begin, const Iterator& end) 271 { 272 return Format::Array<Iterator>(begin, end); 273 } 274 275 /** Format array contents. */ 276 template <typename T> 277 inline Format::ArrayPointer<T> formatArray (const T* arr, int size) 278 { 279 return Format::ArrayPointer<T>(arr, size); 280 } 281 282 /** Format array contents. */ 283 template <typename T, int Size> 284 inline Format::ArrayPointer<T> formatArray (const T (&arr)[Size]) 285 { 286 return Format::ArrayPointer<T>(arr, Size); 287 } 288 289 } // tcu 290 291 #endif // _TCUFORMATUTIL_HPP 292
