android-8.1.0_r81/s

#ifndef _RSGVARIABLEMANAGER_HPP
#define _RSGVARIABLEMANAGER_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program Random Shader Generator
 * ----------------------------------------------------
 *
 * 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 Variable manager.
 *
 * Memory management:
 *  Variable manager owns variable objects until they are either explictly
 *  removed or moved to currently active scope. After that the ownership
 *  is transferred to Scope or the object that called removeEntry().
 *//*--------------------------------------------------------------------*/

#include "rsgDefs.hpp"
#include "rsgVariable.hpp"
#include "rsgVariableValue.hpp"
#include "rsgNameAllocator.hpp"

#include <iterator>
#include <vector>
#include <set>

namespace rsg
{

class ValueEntry
{
public:
							ValueEntry				(const Variable* variable);
							~ValueEntry				(void) {}

	const Variable*			getVariable				(void) const	{ return m_variable;	}

	ConstValueRangeAccess	getValueRange			(void) const	{ return m_valueRange.asAccess();	}
	ValueRangeAccess		getValueRange			(void)			{ return m_valueRange.asAccess();	}

private:
	const Variable*			m_variable;
	ValueRange				m_valueRange;
};

// Variable scope manages variable allocation.
class VariableScope
{
public:
										VariableScope			(void);
										~VariableScope			(void);

	Variable*							allocate				(const VariableType& type, Variable::Storage storage, const char* name);
	void								declare					(Variable* variable);		//!< Move from live set to declared set
	void								removeLive				(const Variable* variable);	//!< Just remove from live set (when migrating to parent).

	const std::vector<Variable*>&		getDeclaredVariables	(void) const	{ return m_declaredVariables;	}

	std::vector<Variable*>&				getLiveVariables		(void)			{ return m_liveVariables;		}
	const std::vector<Variable*>&		getLiveVariables		(void) const	{ return m_liveVariables;		}

private:
										VariableScope			(const VariableScope& other);
	VariableScope&						operator=				(const VariableScope& other);

	std::vector<Variable*>				m_declaredVariables;	//!< Variables declared in this scope. Not available for expressions.
	std::vector<Variable*>				m_liveVariables;		//!< Live variables (available for expression) that can be declared in this scope.
};

class ValueScope
{
public:
										ValueScope				(void);
										~ValueScope				(void);

	ValueEntry*							allocate				(const Variable* variable);
	ValueEntry*							findEntry				(const Variable* variable) const;
	void								setValue				(const Variable* variable, ConstValueRangeAccess value);
	void								removeValue				(const Variable* variable);

	std::vector<ValueEntry*>&			getValues				(void)			{ return m_entries;	}
	const std::vector<ValueEntry*>&		getValues				(void) const	{ return m_entries; }

	void								clear					(void);

private:
										ValueScope				(const ValueScope& other);
	ValueScope&							operator=				(const ValueScope& other);

	std::vector<ValueEntry*>			m_entries;
};

class ReservedScalars
{
public:
	int numScalars;

	ReservedScalars (void)
		: numScalars(0)
	{
	}
};

// \todo [2011-05-26 pyry] Clean up this a bit, separate const variant.
template <typename Item, typename Iterator, class Filter>
class FilteredIterator : public std::iterator<std::input_iterator_tag, Item>
{
public:
	FilteredIterator (Iterator iter, Iterator end, Filter filter)
		: m_iter	(iter)
		, m_end		(end)
		, m_filter	(filter)
	{
	}

	FilteredIterator operator+ (ptrdiff_t offset) const
	{
		Iterator nextEntry = m_iter;
		while (offset--)
			nextEntry = findNext(m_filter, nextEntry, m_end);
		return FilteredIterator(nextEntry, m_end, m_filter);
	}

	FilteredIterator& operator++ ()
	{
		// Pre-increment
		m_iter = findNext(m_filter, m_iter, m_end);
		return *this;
	}

	FilteredIterator operator++ (int)
	{
		// Post-increment
		FilteredIterator copy = *this;
		m_iter = findNext(m_filter, m_iter, m_end);
		return copy;
	}

	bool operator== (const FilteredIterator& other) const
	{
		return m_iter == other.m_iter;
	}

	bool operator!= (const FilteredIterator& other) const
	{
		return m_iter != other.m_iter;
	}

	const Item& operator* (void)
	{
		DE_ASSERT(m_iter != m_end);
		DE_ASSERT(m_filter(*m_iter));
		return *m_iter;
	}

private:
	static Iterator findNext (Filter filter, Iterator iter, Iterator end)
	{
		do
			iter++;
		while (iter != end && !filter(*iter));
		return iter;
	}

	Iterator		m_iter;
	Iterator		m_end;
	Filter			m_filter;
};

template <class Filter>
class ValueEntryIterator : public FilteredIterator<const ValueEntry*, std::vector<const ValueEntry*>::const_iterator, Filter>
{
public:
	ValueEntryIterator (std::vector<const ValueEntry*>::const_iterator begin, std::vector<const ValueEntry*>::const_iterator end, Filter filter)
		: FilteredIterator<const ValueEntry*, std::vector<const ValueEntry*>::const_iterator, Filter>(begin, end, filter)
	{
	}
};

class VariableManager
{
public:
									VariableManager					(NameAllocator& nameAllocator);
									~VariableManager				(void);

	int								getNumAllocatedScalars			(void) const { return m_numAllocatedScalars; }
	int								getNumAllocatedShaderInScalars	(void) const { return m_numAllocatedShaderInScalars; }
	int								getNumAllocatedShaderInVariables(void) const { return m_numAllocatedShaderInVariables; }
	int								getNumAllocatedUniformScalars	(void) const { return m_numAllocatedUniformScalars; }

	void							reserve							(ReservedScalars& store, int numScalars);
	void							release							(ReservedScalars& store);

	Variable*						allocate						(const VariableType& type);
	Variable*						allocate						(const VariableType& type, Variable::Storage storage, const char* name);

	void							setStorage						(Variable* variable, Variable::Storage storage);

	void							setValue						(const Variable* variable, ConstValueRangeAccess value);
	const ValueEntry*				getValue						(const Variable* variable) const;
	const ValueEntry*				getParentValue					(const Variable* variable) const;

	void							removeValueFromCurrentScope		(const Variable* variable);

	void							declareVariable					(Variable* variable);
	bool							canDeclareInCurrentScope		(const Variable* variable) const;
	const std::vector<Variable*>&	getLiveVariables				(void) const;

	void							pushVariableScope				(VariableScope& scope);
	void							popVariableScope				(void);

	void							pushValueScope					(ValueScope& scope);
	void							popValueScope					(void);

	template <class Filter>
	ValueEntryIterator<Filter>		getBegin						(Filter filter = Filter()) const;

	template <class Filter>
	ValueEntryIterator<Filter>		getEnd							(Filter filter = Filter()) const;

	template <class Filter>
	bool							hasEntry						(Filter filter = Filter()) const;

private:
									VariableManager					(const VariableManager& other);
	VariableManager&				operator=						(const VariableManager& other);

	VariableScope&					getCurVariableScope				(void)			{ return *m_variableScopeStack.back();	}
	const VariableScope&			getCurVariableScope				(void) const	{ return *m_variableScopeStack.back();	}

	ValueScope&						getCurValueScope				(void)			{ return *m_valueScopeStack.back();	}
	const ValueScope&				getCurValueScope				(void) const	{ return *m_valueScopeStack.back();	}

	std::vector<VariableScope*>		m_variableScopeStack;
	std::vector<ValueScope*>		m_valueScopeStack;

	std::vector<const ValueEntry*>	m_entryCache;	//!< For faster value entry access.

	int								m_numAllocatedScalars;
	int								m_numAllocatedShaderInScalars;
	int								m_numAllocatedShaderInVariables;
	int								m_numAllocatedUniformScalars;
	NameAllocator&					m_nameAllocator;
};

template <class Filter>
ValueEntryIterator<Filter> VariableManager::getBegin (Filter filter) const
{
	std::vector<const ValueEntry*>::const_iterator first = m_entryCache.begin();
	while (first != m_entryCache.end() && !filter(*first))
		first++;
	return ValueEntryIterator<Filter>(first, m_entryCache.end(), filter);
}

template <class Filter>
ValueEntryIterator<Filter> VariableManager::getEnd (Filter filter) const
{
	return ValueEntryIterator<Filter>(m_entryCache.end(), m_entryCache.end(), filter);
}

template <class Filter>
bool VariableManager::hasEntry (Filter filter) const
{
	for (std::vector<const ValueEntry*>::const_iterator i = m_entryCache.begin(); i != m_entryCache.end(); i++)
	{
		if (filter(*i))
			return true;
	}
	return false;
}

// Common filters

class AnyEntry
{
public:
	typedef ValueEntryIterator<AnyEntry> Iterator;

	bool operator() (const ValueEntry* entry) const
	{
		DE_UNREF(entry);
		return true;
	}
};

class IsWritableEntry
{
public:
	bool operator() (const ValueEntry* entry) const
	{
		switch (entry->getVariable()->getStorage())
		{
			case Variable::STORAGE_LOCAL:
			case Variable::STORAGE_SHADER_OUT:
			case Variable::STORAGE_PARAMETER_IN:
			case Variable::STORAGE_PARAMETER_OUT:
			case Variable::STORAGE_PARAMETER_INOUT:
				return true;

			default:
				return false;
		}
	}
};

template <Variable::Storage Storage>
class EntryStorageFilter
{
public:
	typedef ValueEntryIterator<EntryStorageFilter<Storage> > Iterator;

	bool operator() (const ValueEntry* entry) const
	{
		return entry->getVariable()->getStorage() == Storage;
	}
};

typedef EntryStorageFilter<Variable::STORAGE_LOCAL>			LocalEntryFilter;
typedef EntryStorageFilter<Variable::STORAGE_SHADER_IN>		ShaderInEntryFilter;
typedef EntryStorageFilter<Variable::STORAGE_SHADER_OUT>	ShaderOutEntryFilter;

} // rsg

#endif // _RSGVARIABLEMANAGER_HPP