Home | History | Annotate | Download | only in common 
      1 #ifndef _TCUFACTORYREGISTRY_HPP
      2 #define _TCUFACTORYREGISTRY_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 Generic registry class for factories
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "tcuDefs.hpp"
     27 
     28 #include <string>
     29 #include <vector>
     30 
     31 namespace tcu
     32 {
     33 
     34 class AbstractFactory
     35 {
     36 public:
     37 								AbstractFactory				(void);
     38 	virtual						~AbstractFactory			(void);
     39 
     40 	virtual const char*			getName						(void) const = 0;
     41 };
     42 
     43 class GenericFactoryRegistry
     44 {
     45 public:
     46 								GenericFactoryRegistry		(void);
     47 								~GenericFactoryRegistry		(void);
     48 
     49 	size_t						size						(void) const	{ return m_factories.size();	}
     50 	bool						empty						(void) const	{ return m_factories.empty();	}
     51 
     52 	void						registerFactory				(AbstractFactory* factory);
     53 
     54 	AbstractFactory*			getFactoryByName			(const std::string& name);
     55 	const AbstractFactory*		getFactoryByName			(const std::string& name) const;
     56 
     57 	AbstractFactory*			getFactoryByIndex			(size_t index);
     58 	const AbstractFactory*		getFactoryByIndex			(size_t index) const;
     59 
     60 private:
     61 								GenericFactoryRegistry		(const GenericFactoryRegistry&);
     62 	GenericFactoryRegistry&		operator=					(const GenericFactoryRegistry&);
     63 
     64 	std::vector<AbstractFactory*>							m_factories;
     65 };
     66 
     67 class FactoryBase : public AbstractFactory
     68 {
     69 public:
     70 								FactoryBase					(const std::string& name, const std::string& description);
     71 								~FactoryBase				(void);
     72 
     73 	const char*					getName						(void) const;
     74 	const char*					getDescription				(void) const;
     75 
     76 private:
     77 	const std::string			m_name;
     78 	const std::string			m_description;
     79 };
     80 
     81 template<class Factory>
     82 class FactoryRegistry
     83 {
     84 public:
     85 								FactoryRegistry		(void) {}
     86 								~FactoryRegistry	(void) {}
     87 
     88 	bool						empty				(void) const		{ return m_registry.empty();	}
     89 	size_t						size				(void) const		{ return m_registry.size();		}
     90 	size_t						getFactoryCount		(void) const		{ return m_registry.size();		}
     91 
     92 	void						registerFactory		(Factory* factory)	{ m_registry.registerFactory(factory);	}
     93 
     94 	Factory*					getFactoryByName	(const std::string& name);
     95 	const Factory*				getFactoryByName	(const std::string& name) const;
     96 
     97 	Factory*					getFactoryByIndex	(size_t index);
     98 	const Factory*				getFactoryByIndex	(size_t index) const;
     99 
    100 	Factory*					getDefaultFactory	(void)				{ return getFactoryByIndex(0);	}
    101 	const Factory*				getDefaultFactory	(void) const		{ return getFactoryByIndex(0);	}
    102 
    103 private:
    104 	GenericFactoryRegistry		m_registry;
    105 };
    106 
    107 template<class Factory>
    108 inline Factory* FactoryRegistry<Factory>::getFactoryByName (const std::string& name)
    109 {
    110 	return static_cast<Factory*>(m_registry.getFactoryByName(name));
    111 }
    112 
    113 template<class Factory>
    114 inline const Factory* FactoryRegistry<Factory>::getFactoryByName (const std::string& name) const
    115 {
    116 	return static_cast<const Factory*>(m_registry.getFactoryByName(name));
    117 }
    118 
    119 template<class Factory>
    120 inline Factory* FactoryRegistry<Factory>::getFactoryByIndex (size_t index)
    121 {
    122 	return static_cast<Factory*>(m_registry.getFactoryByIndex(index));
    123 }
    124 
    125 template<class Factory>
    126 inline const Factory* FactoryRegistry<Factory>::getFactoryByIndex (size_t index) const
    127 {
    128 	return static_cast<const Factory*>(m_registry.getFactoryByIndex(index));
    129 }
    130 
    131 } // tcu
    132 
    133 #endif // _TCUFACTORYREGISTRY_HPP
    134