/usr/include/Poco/DynamicFactory.h is in libpoco-dev 1.8.0.1-1ubuntu4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | //
// DynamicFactory.h
//
// Library: Foundation
// Package: Core
// Module: DynamicFactory
//
// Definition of the DynamicFactory class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DynamicFactory_INCLUDED
#define Foundation_DynamicFactory_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Instantiator.h"
#include "Poco/Exception.h"
#include "Poco/Mutex.h"
#include <map>
#include <memory>
namespace Poco {
template <class Base>
class DynamicFactory
/// A factory that creates objects by class name.
{
public:
typedef AbstractInstantiator<Base> AbstractFactory;
DynamicFactory()
/// Creates the DynamicFactory.
{
}
~DynamicFactory()
/// Destroys the DynamicFactory and deletes the instantiators for
/// all registered classes.
{
for (typename FactoryMap::iterator it = _map.begin(); it != _map.end(); ++it)
{
delete it->second;
}
}
Base* createInstance(const std::string& className) const
/// Creates a new instance of the class with the given name.
/// The class must have been registered with registerClass.
/// If the class name is unknown, a NotFoundException is thrown.
{
FastMutex::ScopedLock lock(_mutex);
typename FactoryMap::const_iterator it = _map.find(className);
if (it != _map.end())
return it->second->createInstance();
else
throw NotFoundException(className);
}
template <class C>
void registerClass(const std::string& className)
/// Registers the instantiator for the given class with the DynamicFactory.
/// The DynamicFactory takes ownership of the instantiator and deletes
/// it when it's no longer used.
/// If the class has already been registered, an ExistsException is thrown
/// and the instantiator is deleted.
{
registerClass(className, new Instantiator<C, Base>);
}
void registerClass(const std::string& className, AbstractFactory* pAbstractFactory)
/// Registers the instantiator for the given class with the DynamicFactory.
/// The DynamicFactory takes ownership of the instantiator and deletes
/// it when it's no longer used.
/// If the class has already been registered, an ExistsException is thrown
/// and the instantiator is deleted.
{
poco_check_ptr (pAbstractFactory);
FastMutex::ScopedLock lock(_mutex);
#ifndef POCO_ENABLE_CPP11
std::auto_ptr<AbstractFactory> ptr(pAbstractFactory);
#else
std::unique_ptr<AbstractFactory> ptr(pAbstractFactory);
#endif // POCO_ENABLE_CPP11
typename FactoryMap::iterator it = _map.find(className);
if (it == _map.end())
_map[className] = ptr.release();
else
throw ExistsException(className);
}
void unregisterClass(const std::string& className)
/// Unregisters the given class and deletes the instantiator
/// for the class.
/// Throws a NotFoundException if the class has not been registered.
{
FastMutex::ScopedLock lock(_mutex);
typename FactoryMap::iterator it = _map.find(className);
if (it != _map.end())
{
delete it->second;
_map.erase(it);
}
else throw NotFoundException(className);
}
bool isClass(const std::string& className) const
/// Returns true iff the given class has been registered.
{
FastMutex::ScopedLock lock(_mutex);
return _map.find(className) != _map.end();
}
private:
DynamicFactory(const DynamicFactory&);
DynamicFactory& operator = (const DynamicFactory&);
typedef std::map<std::string, AbstractFactory*> FactoryMap;
FactoryMap _map;
mutable FastMutex _mutex;
};
} // namespace Poco
#endif // Foundation_DynamicFactory_INCLUDED
|