152 lines
4.5 KiB
C++
152 lines
4.5 KiB
C++
/**
|
|
* Copyright - See the COPYRIGHT that is included with this distribution.
|
|
* pvAccessCPP is distributed subject to a Software License Agreement found
|
|
* in file LICENSE that is included with this distribution.
|
|
*/
|
|
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include <pv/lock.h>
|
|
#include <pv/noDefaultMethods.h>
|
|
#include <pv/pvData.h>
|
|
|
|
#define epicsExportSharedSymbols
|
|
#include <pv/pvAccess.h>
|
|
#include <pv/factory.h>
|
|
|
|
using namespace epics::pvData;
|
|
using std::string;
|
|
|
|
namespace epics {
|
|
namespace pvAccess {
|
|
|
|
ChannelProviderRegistry::ChannelProviderRegistry()
|
|
{
|
|
std::cout << "ChannelProviderRegistry\n";
|
|
}
|
|
|
|
ChannelProviderRegistry::~ChannelProviderRegistry()
|
|
{
|
|
std::cout << "~ChannelProviderRegistry\n";
|
|
}
|
|
|
|
|
|
ChannelProviderRegistry::shared_pointer ChannelProviderRegistry::getChannelProviderRegistry()
|
|
{
|
|
static Mutex mutex;
|
|
static ChannelProviderRegistry::shared_pointer global_reg;
|
|
Lock guard(mutex);
|
|
if(!global_reg) {
|
|
global_reg = ChannelProviderRegistry::build();
|
|
}
|
|
return global_reg;
|
|
}
|
|
|
|
void ChannelProviderRegistry::registerChannelProviderFactory(
|
|
ChannelProviderFactory::shared_pointer const & channelProviderFactory)
|
|
{
|
|
assert(channelProviderFactory);
|
|
add(channelProviderFactory);
|
|
}
|
|
|
|
void ChannelProviderRegistry::unregisterChannelProviderFactory(
|
|
ChannelProviderFactory::shared_pointer const & channelProviderFactory)
|
|
{
|
|
assert(channelProviderFactory);
|
|
remove(channelProviderFactory->getFactoryName());
|
|
}
|
|
|
|
ChannelProvider::shared_pointer ChannelProviderRegistry::getProvider(std::string const & providerName) {
|
|
ChannelProviderFactory::shared_pointer fact(getFactory(providerName));
|
|
if(fact)
|
|
return fact->sharedInstance();
|
|
else
|
|
return ChannelProvider::shared_pointer();
|
|
}
|
|
|
|
ChannelProvider::shared_pointer ChannelProviderRegistry::createProvider(std::string const & providerName) {
|
|
ChannelProviderFactory::shared_pointer fact(getFactory(providerName));
|
|
if(fact)
|
|
return fact->newInstance();
|
|
else
|
|
return ChannelProvider::shared_pointer();
|
|
}
|
|
|
|
ChannelProvider::shared_pointer ChannelProviderRegistry::createProvider(std::string const & providerName,
|
|
const std::tr1::shared_ptr<Configuration>& conf) {
|
|
ChannelProviderFactory::shared_pointer fact(getFactory(providerName));
|
|
if(fact)
|
|
return fact->newInstance(conf);
|
|
else
|
|
return ChannelProvider::shared_pointer();
|
|
}
|
|
|
|
ChannelProviderFactory::shared_pointer ChannelProviderRegistry::getFactory(std::string const & providerName)
|
|
{
|
|
Lock G(mutex);
|
|
providers_t::const_iterator iter = providers.find(providerName);
|
|
if (iter == providers.end())
|
|
return ChannelProviderFactory::shared_pointer();
|
|
else
|
|
return iter->second;
|
|
}
|
|
|
|
std::auto_ptr<ChannelProviderRegistry::stringVector_t> ChannelProviderRegistry::getProviderNames()
|
|
{
|
|
Lock G(mutex);
|
|
std::auto_ptr<stringVector_t> ret(new stringVector_t);
|
|
for (providers_t::const_iterator iter = providers.begin();
|
|
iter != providers.end(); iter++)
|
|
ret->push_back(iter->first);
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool ChannelProviderRegistry::add(const ChannelProviderFactory::shared_pointer& fact, bool replace)
|
|
{
|
|
Lock G(mutex);
|
|
std::string name(fact->getFactoryName());
|
|
if(!replace && providers.find(name)!=providers.end())
|
|
throw false;
|
|
providers[name] = fact;
|
|
return true;
|
|
}
|
|
|
|
ChannelProviderFactory::shared_pointer ChannelProviderRegistry::remove(const std::string& name)
|
|
|
|
{
|
|
ChannelProviderFactory::shared_pointer ret;
|
|
providers_t::iterator iter(providers.find(name));
|
|
if(iter!=providers.end()) {
|
|
ret = iter->second;
|
|
providers.erase(iter);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ChannelProviderRegistry::shared_pointer getChannelProviderRegistry() {
|
|
std::cerr << "getChannelProviderRegistry should not be used\n";
|
|
return ChannelProviderRegistry::getChannelProviderRegistry();
|
|
}
|
|
|
|
void registerChannelProviderFactory(ChannelProviderFactory::shared_pointer const & channelProviderFactory) {
|
|
std::cerr << "registerChannelProviderFactory should not be used\n";
|
|
getChannelProviderRegistry()->registerChannelProviderFactory(channelProviderFactory);
|
|
}
|
|
|
|
void unregisterChannelProviderFactory(ChannelProviderFactory::shared_pointer const & channelProviderFactory) {
|
|
std::cerr << "unregisterChannelProviderFactory should not be used\n";
|
|
getChannelProviderRegistry()->unregisterChannelProviderFactory(channelProviderFactory);
|
|
}
|
|
|
|
epicsShareFunc void unregisterAllChannelProviderFactory()
|
|
{
|
|
getChannelProviderRegistry()->clear();
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|