framework/egl/egluCallLogWrapper.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program EGL Utilities
 * ------------------------------------------
 *
 * 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 EGL call wrapper for logging.
 *//*--------------------------------------------------------------------*/

#include "egluCallLogWrapper.hpp"
#include "egluStrUtil.hpp"
#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"
#include "deStringUtil.hpp"
#include "deInt32.h"

namespace eglu
{

using tcu::toHex;
using tcu::TestLog;

CallLogWrapper::CallLogWrapper (const eglw::Library& egl, TestLog& log)
	: m_egl			(egl)
	, m_log			(log)
	, m_enableLog	(false)
{
}

CallLogWrapper::~CallLogWrapper (void)
{
}

// Pointer formatter.

template <typename T>
class PointerFmt
{
public:
	const T*	arr;
	deUint32	size;

	PointerFmt (const T* arr_, deUint32 size_) : arr(arr_), size(size_) {}
};

template <typename T>
std::ostream& operator<< (std::ostream& str, PointerFmt<T> fmt)
{
	if (fmt.arr != DE_NULL)
	{
		str << "{ ";
		for (deUint32 ndx = 0; ndx < fmt.size; ndx++)
		{
			if (ndx != 0)
				str << ", ";
			str << fmt.arr[ndx];
		}
		str << " }";
		return str;
	}
	else
		return str << "(null)";
}

template <typename T>
inline PointerFmt<T> getPointerStr (const T* arr, deUint32 size)
{
	return PointerFmt<T>(arr, size);
}

typedef const char* (*GetEnumNameFunc) (int value);

// Enum pointer formatter.

class EnumPointerFmt
{
public:
	const int*		value;
	GetEnumNameFunc	getName;

	EnumPointerFmt (const int* value_, GetEnumNameFunc getName_) : value(value_), getName(getName_) {}
};

inline std::ostream& operator<< (std::ostream& str, EnumPointerFmt fmt)
{
	if (fmt.value)
		return str << tcu::Format::Enum<int, 2>(fmt.getName, *fmt.value);
	else
		return str << "(null)";
}

inline EnumPointerFmt getEnumPointerStr (const int* value, GetEnumNameFunc getName)
{
	return EnumPointerFmt(value, getName);
}

// String formatter.

class StringFmt
{
public:
	const char* str;
	StringFmt (const char* str_) : str(str_) {}
};

inline std::ostream& operator<< (std::ostream& str, StringFmt fmt)
{
	return str << (fmt.str ? fmt.str : "NULL");
}

inline StringFmt getStringStr (const char* value) { return StringFmt(value); }

// Config attrib pointer formatter

class ConfigAttribValuePointerFmt
{
public:
	deUint32		attrib;
	const int*		value;
	ConfigAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {}
};

inline ConfigAttribValuePointerFmt getConfigAttribValuePointerStr (deUint32 attrib, const int* value) { return ConfigAttribValuePointerFmt(attrib, value); }

inline std::ostream& operator<< (std::ostream& str, const ConfigAttribValuePointerFmt& fmt)
{
	if (fmt.value)
		return str << getConfigAttribValueStr(fmt.attrib, *fmt.value);
	else
		return str << "NULL";
}

// Context attrib pointer formatter

class ContextAttribValuePointerFmt
{
public:
	deUint32		attrib;
	const int*		value;
	ContextAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {}
};

inline ContextAttribValuePointerFmt getContextAttribValuePointerStr (deUint32 attrib, const int* value) { return ContextAttribValuePointerFmt(attrib, value); }

inline std::ostream& operator<< (std::ostream& str, const ContextAttribValuePointerFmt& fmt)
{
	if (fmt.value)
		return str << getContextAttribValueStr(fmt.attrib, *fmt.value);
	else
		return str << "NULL";
}

// Surface attrib pointer formatter

class SurfaceAttribValuePointerFmt
{
public:
	deUint32		attrib;
	const int*		value;
	SurfaceAttribValuePointerFmt (deUint32 attrib_, const int* value_) : attrib(attrib_), value(value_) {}
};

inline SurfaceAttribValuePointerFmt getSurfaceAttribValuePointerStr (deUint32 attrib, const int* value) { return SurfaceAttribValuePointerFmt(attrib, value); }

inline std::ostream& operator<< (std::ostream& str, const SurfaceAttribValuePointerFmt& fmt)
{
	if (fmt.value)
		return str << getSurfaceAttribValueStr(fmt.attrib, *fmt.value);
	else
		return str << "NULL";
}

// EGLDisplay formatter

class EGLDisplayFmt
{
public:
	eglw::EGLDisplay display;
	EGLDisplayFmt (eglw::EGLDisplay display_) : display(display_) {}
};

inline EGLDisplayFmt getEGLDisplayStr (eglw::EGLDisplay display) { return EGLDisplayFmt(display); }

inline std::ostream& operator<< (std::ostream& str, const EGLDisplayFmt& fmt)
{
	if (fmt.display == EGL_NO_DISPLAY)
		return str << "EGL_NO_DISPLAY";
	else
		return str << toHex(fmt.display);
}

// EGLSurface formatter

class EGLSurfaceFmt
{
public:
	eglw::EGLSurface surface;
	EGLSurfaceFmt (eglw::EGLSurface surface_) : surface(surface_) {}
};

inline EGLSurfaceFmt getEGLSurfaceStr (eglw::EGLSurface surface) { return EGLSurfaceFmt(surface); }

inline std::ostream& operator<< (std::ostream& str, const EGLSurfaceFmt& fmt)
{
	if (fmt.surface == EGL_NO_SURFACE)
		return str << "EGL_NO_SURFACE";
	else
		return str << toHex(fmt.surface);
}

// EGLContext formatter

class EGLContextFmt
{
public:
	eglw::EGLContext context;
	EGLContextFmt (eglw::EGLContext context_) : context(context_) {}
};

inline EGLContextFmt getEGLContextStr (eglw::EGLContext context) { return EGLContextFmt(context); }

inline std::ostream& operator<< (std::ostream& str, const EGLContextFmt& fmt)
{
	if (fmt.context == EGL_NO_CONTEXT)
		return str << "EGL_NO_CONTEXT";
	else
		return str << toHex(fmt.context);
}

// API entry-point implementations are auto-generated
#include "egluCallLogWrapper.inl"

} // eglu