#ifndef _TCUFORMATUTIL_HPP
#define _TCUFORMATUTIL_HPP
/*-------------------------------------------------------------------------
* drawElements Quality Program Tester Core
* ----------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief String format utilities.
*//*--------------------------------------------------------------------*/
#include "tcuDefs.hpp"
#include "deString.h"
#include <ostream>
#include <string>
namespace tcu
{
namespace Format
{
// Hexadecimal value formatter.
template <size_t NumDigits>
class Hex
{
public:
Hex (deUint64 value_) : value(value_) {}
std::ostream& toStream (std::ostream& stream) const
{
return stream << this->toString();
}
std::string toString (void) const
{
DE_STATIC_ASSERT(0 < NumDigits && NumDigits <= 16);
const char longFmt[] = {'0', 'x', '%', '0', '0' + NumDigits/10, '0' + NumDigits%10, 'l', 'l', 'x', 0};
const char shortFmt[] = {'0', 'x', '%', '0', '0' + NumDigits, 'l', 'l', 'x', 0};
char buf[sizeof(deUint64)*2 + 3];
deSprintf(buf, sizeof(buf), NumDigits > 9 ? longFmt : shortFmt, value);
return std::string(buf);
}
private:
deUint64 value;
};
template <size_t NumDigits>
std::ostream& operator<< (std::ostream& stream, tcu::Format::Hex<NumDigits> hex)
{
return hex.toStream(stream);
}
// Bitfield formatter.
class BitDesc
{
public:
deUint64 bit;
const char* name;
BitDesc (deUint64 bit_, const char* name_) : bit(bit_), name(name_) {}
};
#define TCU_BIT_DESC(BIT) tcu::Format::BitDesc(BIT, #BIT)
template <size_t BitfieldSize>
class Bitfield
{
public:
Bitfield (deUint64 value, const BitDesc* begin, const BitDesc* end)
: m_value (value)
, m_begin (begin)
, m_end (end)
{
}
std::ostream& toStream (std::ostream& stream)
{
deUint64 bitsLeft = m_value;
for (const BitDesc* curDesc = m_begin; curDesc != m_end; curDesc++)
{
if (curDesc->bit & bitsLeft)
{
if (bitsLeft != m_value)
stream << "|";
stream << curDesc->name;
bitsLeft ^= curDesc->bit;
}
}
if (bitsLeft != 0)
{
if (bitsLeft != m_value)
stream << "|";
stream << Hex<BitfieldSize/4>(bitsLeft);
}
return stream;
}
private:
deUint64 m_value;
const BitDesc* m_begin;
const BitDesc* m_end;
};
template <size_t BitfieldSize>
inline std::ostream& operator<< (std::ostream& stream, Bitfield<BitfieldSize> decoder)
{
return decoder.toStream(stream);
}
// Enum formatter.
// \todo [2012-10-30 pyry] Use template for GetName.
template <typename T, size_t NumBytes = sizeof(T)>
class Enum
{
public:
typedef const char* (*GetNameFunc) (T value);
Enum (GetNameFunc getName, T value)
: m_getName (getName)
, m_value (value)
{
}
std::ostream& toStream (std::ostream& stream) const
{
const char* name = m_getName(m_value);
if (name)
return stream << name;
else
return stream << Hex<NumBytes*2>((deUint64)m_value);
}
std::string toString (void) const
{
const char* name = m_getName(m_value);
if (name)
return std::string(name);
else
return Hex<NumBytes*2>((deUint64)m_value).toString();
}
private:
const GetNameFunc m_getName;
const T m_value;
};
template <typename T, size_t NumBytes>
inline std::ostream& operator<< (std::ostream& stream, const Enum<T, NumBytes>& fmt) { return fmt.toStream(stream); }
// Array formatters.
template <typename Iterator>
class Array
{
public:
Iterator begin;
Iterator end;
Array (const Iterator& begin_, const Iterator& end_) : begin(begin_), end(end_) {}
};
template <typename T>
class ArrayPointer
{
public:
const T* arr;
int size;
ArrayPointer (const T* arr_, int size_) : arr(arr_), size(size_) {}
};
template <typename Iterator>
std::ostream& operator<< (std::ostream& str, const Array<Iterator>& fmt)
{
str << "{ ";
for (Iterator cur = fmt.begin; cur != fmt.end; ++cur)
{
if (cur != fmt.begin)
str << ", ";
str << *cur;
}
str << " }";
return str;
}
template <typename T>
std::ostream& operator<< (std::ostream& str, const ArrayPointer<T>& fmt)
{
if (fmt.arr != DE_NULL)
return str << Array<const T*>(fmt.arr, fmt.arr+fmt.size);
else
return str << "(null)";
}
// Hex format iterator (useful for combining with ArrayFormatter).
// \todo [2012-10-30 pyry] Implement more generic format iterator.
template <typename T, typename Iterator = const T*>
class HexIterator
{
public:
HexIterator (Iterator iter) : m_iter(iter) {}
HexIterator<T, Iterator>& operator++ (void) { ++m_iter; return *this; }
HexIterator<T, Iterator> operator++ (int) { return HexIterator(m_iter++); }
bool operator== (const HexIterator<T, Iterator>& other) const { return m_iter == other.m_iter; }
bool operator!= (const HexIterator<T, Iterator>& other) const { return m_iter != other.m_iter; }
#if !defined(__INTELLISENSE__)
// Intellisense in VS2013 crashes when parsing this.
Hex<sizeof(T)*2> operator* (void) const { return Hex<sizeof(T)*2>(*m_iter); }
#endif
private:
Iterator m_iter;
};
} // Format
template <int Bits> inline deUint64 makeMask64 (void) { return (1ull<<Bits)-1; }
template <> inline deUint64 makeMask64<64> (void) { return ~0ull; }
template <typename T> inline deUint64 toUint64 (T value) { return (deUint64)value & makeMask64<sizeof(T)*8>(); }
/** Format value as hexadecimal number. */
template <size_t NumDigits, typename T>
inline Format::Hex<NumDigits> toHex (T value)
{
return Format::Hex<NumDigits>(toUint64(value));
}
/** Format value as hexadecimal number. */
template <typename T>
inline Format::Hex<sizeof(T)*2> toHex (T value)
{
return Format::Hex<sizeof(T)*2>(toUint64(value));
}
/** Decode and format bitfield. */
template <typename T, size_t Size>
inline Format::Bitfield<sizeof(T)*8> formatBitfield (T value, const Format::BitDesc (&desc)[Size])
{
return Format::Bitfield<sizeof(T)*8>((deUint64)value, &desc[0], &desc[Size]);
}
/** Format array contents. */
template <typename Iterator>
inline Format::Array<Iterator> formatArray (const Iterator& begin, const Iterator& end)
{
return Format::Array<Iterator>(begin, end);
}
/** Format array contents. */
template <typename T>
inline Format::ArrayPointer<T> formatArray (const T* arr, int size)
{
return Format::ArrayPointer<T>(arr, size);
}
/** Format array contents. */
template <typename T, int Size>
inline Format::ArrayPointer<T> formatArray (const T (&arr)[Size])
{
return Format::ArrayPointer<T>(arr, Size);
}
} // tcu
#endif // _TCUFORMATUTIL_HPP