framework/common/tcuEither.hpp

#ifndef _TCUEITHER_HPP
#define _TCUEITHER_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program Tester Core
 * ----------------------------------------
 *
 * Copyright 2015 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 Template class that is either type of First or Second.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"

namespace tcu
{

/*--------------------------------------------------------------------*//*!
 * \brief Object containing Either First or Second type of object
 *
 * \note Type First and Second are always aligned to same alignment as
 *		 deUint64.
 * \note This type always uses at least sizeof(bool) + max(sizeof(First*),
 *		 sizeof(Second*)) + sizeof(deUint64) of memory.
 *//*--------------------------------------------------------------------*/
template<typename First, typename Second>
class Either
{
public:
					Either		(const First& first);
					Either		(const Second& second);
					~Either		(void);

					Either		(const Either<First, Second>& other);
	Either&			operator=	(const Either<First, Second>& other);

	Either&			operator=	(const First& first);
	Either&			operator=	(const Second& second);

	bool			isFirst		(void) const;
	bool			isSecond	(void) const;

	const First&	getFirst	(void) const;
	const Second&	getSecond	(void) const;

	template<typename Type>
	const Type&		get			(void) const;

	template<typename Type>
	bool			is			(void) const;

private:
	void			release		(void);

	bool			m_isFirst;

	union
	{
		First*		m_first;
		Second*		m_second;
	};

	union
	{
		deUint8		m_data[sizeof(First) > sizeof(Second) ? sizeof(First) : sizeof(Second)];
		deUint64	m_align;
	};
} DE_WARN_UNUSED_TYPE;

namespace EitherDetail
{

template<typename Type, typename First, typename Second>
struct Get;

template<typename First, typename Second>
struct Get<First, First, Second>
{
	static const First& get (const Either<First, Second>& either)
	{
		return either.getFirst();
	}
};

template<typename First, typename Second>
struct Get<Second, First, Second>
{
	static const Second& get (const Either<First, Second>& either)
	{
		return either.getSecond();
	}
};

template<typename Type, typename First, typename Second>
const Type& get (const Either<First, Second>& either)
{
	return Get<Type, First, Second>::get(either);
}

template<typename Type, typename First, typename Second>
struct Is;

template<typename First, typename Second>
struct Is<First, First, Second>
{
	static bool is (const Either<First, Second>& either)
	{
		return either.isFirst();
	}
};

template<typename First, typename Second>
struct Is<Second, First, Second>
{
	static bool is (const Either<First, Second>& either)
	{
		return either.isSecond();
	}
};

template<typename Type, typename First, typename Second>
bool is (const Either<First, Second>& either)
{
	return Is<Type, First, Second>::is(either);
}

} // EitherDetail

template<typename First, typename Second>
void Either<First, Second>::release (void)
{
	if (m_isFirst)
		m_first->~First();
	else
		m_second->~Second();

	m_isFirst	= true;
	m_first		= DE_NULL;
}

template<typename First, typename Second>
Either<First, Second>::Either (const First& first)
	: m_isFirst	(true)
{
	m_first = new(m_data)First(first);
}

template<typename First, typename Second>
Either<First, Second>::Either (const Second& second)
	: m_isFirst (false)
{
	m_second = new(m_data)Second(second);
}

template<typename First, typename Second>
Either<First, Second>::~Either (void)
{
	release();
}

template<typename First, typename Second>
Either<First, Second>::Either (const Either<First, Second>& other)
	: m_isFirst	(other.m_isFirst)
{
	if (m_isFirst)
		m_first = new(m_data)First(*other.m_first);
	else
		m_second = new(m_data)Second(*other.m_second);
}

template<typename First, typename Second>
Either<First, Second>& Either<First, Second>::operator= (const Either<First, Second>& other)
{
	if (this == &other)
		return *this;

	release();

	m_isFirst = other.m_isFirst;

	if (m_isFirst)
		m_first = new(m_data)First(*other.m_first);
	else
		m_second = new(m_data)Second(*other.m_second);

	return *this;
}

template<typename First, typename Second>
Either<First, Second>& Either<First, Second>::operator= (const First& first)
{
	release();

	m_isFirst = true;
	m_first = new(m_data)First(first);

	return *this;
}

template<typename First, typename Second>
Either<First, Second>& Either<First, Second>::operator= (const Second& second)
{
	release();

	m_isFirst = false;
	m_second = new(m_data)Second(second);

	return *this;
}

template<typename First, typename Second>
bool Either<First, Second>::isFirst (void) const
{
	return m_isFirst;
}

template<typename First, typename Second>
bool Either<First, Second>::isSecond (void) const
{
	return !m_isFirst;
}

template<typename First, typename Second>
const First& Either<First, Second>::getFirst (void) const
{
	DE_ASSERT(isFirst());
	return *m_first;
}

template<typename First, typename Second>
const Second& Either<First, Second>::getSecond (void) const
{
	DE_ASSERT(isSecond());
	return *m_second;
}

template<typename First, typename Second>
template<typename Type>
const Type& Either<First, Second>::get (void) const
{
	return EitherDetail::get<Type, First, Second>(*this);
}

template<typename First, typename Second>
template<typename Type>
bool Either<First, Second>::is (void) const
{
	return EitherDetail::is<Type, First, Second>(*this);
}

void Either_selfTest (void);

} // tcu

#endif // _TCUEITHER_HPP