#include "pdb.h"

Inheritance diagram for PDBProvider:

Collaboration diagram for PDBProvider:

Public Types
typedef std::map< std::string, PDBPV::shared_pointer >	persist_pv_map_t

typedef weak_value_map< std::string, PDBPV >	transient_pv_map_t

Public Types inherited from epics::pvAccess::ChannelFind
typedef ChannelFindRequester	requester_type

Public Member Functions
	POINTER_DEFINITIONS (PDBProvider)

	PDBProvider (const epics::pvAccess::Configuration::const_shared_pointer &=epics::pvAccess::Configuration::const_shared_pointer())

virtual	~PDBProvider ()

virtual void	destroy () OVERRIDE FINAL

virtual std::string	getProviderName () OVERRIDE FINAL

virtual epics::pvAccess::ChannelFind::shared_pointer	channelFind (std::string const &channelName, epics::pvAccess::ChannelFindRequester::shared_pointer const &channelFindRequester) OVERRIDE FINAL

virtual epics::pvAccess::ChannelFind::shared_pointer	channelList (epics::pvAccess::ChannelListRequester::shared_pointer const &channelListRequester) OVERRIDE FINAL

virtual epics::pvAccess::Channel::shared_pointer	createChannel (std::string const &channelName, epics::pvAccess::ChannelRequester::shared_pointer const &channelRequester, short priority=PRIORITY_DEFAULT) OVERRIDE FINAL

virtual epics::pvAccess::Channel::shared_pointer	createChannel (std::string const &channelName, epics::pvAccess::ChannelRequester::shared_pointer const &channelRequester, short priority, std::string const &address) OVERRIDE FINAL

virtual std::tr1::shared_ptr< ChannelProvider >	getChannelProvider () OVERRIDE FINAL

virtual void	cancel () OVERRIDE FINAL

Public Member Functions inherited from epics::pvAccess::ChannelProvider
	POINTER_DEFINITIONS (ChannelProvider)

	ChannelProvider ()

virtual	~ChannelProvider ()

virtual ChannelFind::shared_pointer	channelFind (std::string const &name, ChannelFindRequester::shared_pointer const &requester)=0

virtual ChannelFind::shared_pointer	channelList (ChannelListRequester::shared_pointer const &requester)

virtual Channel::shared_pointer	createChannel (std::string const &name, ChannelRequester::shared_pointer const &requester=DefaultChannelRequester::build(), short priority=PRIORITY_DEFAULT)

virtual Channel::shared_pointer	createChannel (std::string const &name, ChannelRequester::shared_pointer const &requester, short priority, std::string const &address)=0

Public Member Functions inherited from epics::pvAccess::Destroyable
	POINTER_DEFINITIONS (Destroyable)

Public Member Functions inherited from epics::pvAccess::ChannelFind
	POINTER_DEFINITIONS (ChannelFind)

	ChannelFind ()

virtual	~ChannelFind ()

Public Attributes
persist_pv_map_t	persist_pv_map

transient_pv_map_t	transient_pv_map

dbEventCtx	event_context

Static Public Attributes
static size_t	num_instances

Static Public Attributes inherited from epics::pvAccess::ChannelProvider
static const short	PRIORITY_MIN = 0

static const short	PRIORITY_MAX = 99

static const short	PRIORITY_DEFAULT = PRIORITY_MIN

static const short	PRIORITY_LINKS_DB = PRIORITY_MAX

static const short	PRIORITY_ARCHIVE = (PRIORITY_MAX + PRIORITY_MIN) / 2

static const short	PRIORITY_OPI = PRIORITY_MIN

static size_t	num_instances

Additional Inherited Members
Static Public Member Functions inherited from epics::pvAccess::ChannelFind
static ChannelFind::shared_pointer	buildDummy (const std::tr1::shared_ptr< ChannelProvider > &provider)

Protected Member Functions inherited from epics::pvAccess::Destroyable
virtual	~Destroyable ()

Detailed Description

Definition at line 33 of file pdb.h.

Member Typedef Documentation

typedef std::map<std::string, PDBPV::shared_pointer> PDBProvider::persist_pv_map_t

Definition at line 59 of file pdb.h.

typedef weak_value_map<std::string, PDBPV> PDBProvider::transient_pv_map_t

Definition at line 62 of file pdb.h.

Constructor & Destructor Documentation

PDBProvider::PDBProvider ( const epics::pvAccess::Configuration::const_shared_pointer & = epics::pvAccess::Configuration::const_shared_pointer() )

explicit

Definition at line 321 of file pdb.cpp.

 {
     /* Long view
      * 1. PDBProcessor collects info() tags and builds config of groups and group fields
      *    (including those w/o a dbChannel)
      * 2. Build pvd::Structure and discard those w/o dbChannel
      * 3. Build the lockers for the triggers of each group field
      */
     PDBProcessor proc;
     pvd::FieldCreatePtr fcreate(pvd::getFieldCreate());
     pvd::PVDataCreatePtr pvbuilder(pvd::getPVDataCreate());
 
     pvd::StructureConstPtr _options(fcreate->createFieldBuilder()
                                     ->addNestedStructure("_options")
                                         ->add("queueSize", pvd::pvUInt)
                                         ->add("atomic", pvd::pvBoolean)
                                     ->endNested()
                                     ->createStructure());
 
 #ifdef USE_MULTILOCK
     // assemble group PVD structure definitions and build dbLockers
     FOREACH(PDBProcessor::groups_t::const_iterator, it, end, proc.groups)
     {
         const GroupInfo &info=it->second;
         try{
             if(persist_pv_map.find(info.name)!=persist_pv_map.end())
                 throw std::runtime_error("name already in used");
 
             PDBGroupPV::shared_pointer pv(new PDBGroupPV());
             pv->weakself = pv;
             pv->name = info.name;
 
             pv->pgatomic = info.atomic!=GroupInfo::False; // default true if Unset
             pv->monatomic = info.hastriggers;
 
             // some gymnastics because Info isn't copyable
             pvd::shared_vector<PDBGroupPV::Info> members;
             typedef std::map<std::string, size_t> members_map_t;
             members_map_t members_map;
             {
                 size_t nchans = 0;
                 for(size_t i=0, N=info.members.size(); i<N; i++)
                     if(!info.members[i].pvname.empty())
                         nchans++;
                 pvd::shared_vector<PDBGroupPV::Info> temp(nchans);
                 members.swap(temp);
             }
 
             std::vector<dbCommon*> records(members.size());
 
             pvd::FieldBuilderPtr builder(fcreate->createFieldBuilder());
             builder = builder->add("record", _options);
 
             if(!info.structID.empty())
                 builder = builder->setId(info.structID);
 
             for(size_t i=0, J=0, N=info.members.size(); i<N; i++)
             {
                 const GroupMemberInfo &mem = info.members[i];
 
                 // parse down attachment point to build/traverse structure
                 FieldName parts(mem.pvfldname);
 
                 if(!parts.empty()) {
                     for(size_t j=0; j<parts.size()-1; j++) {
                         if(parts[j].isArray())
                             builder = builder->addNestedStructureArray(parts[j].name);
                         else
                             builder = builder->addNestedStructure(parts[j].name);
                     }
                 }
 
                 if(!mem.structID.empty())
                     builder = builder->setId(mem.structID);
 
                 DBCH chan;
                 if(!mem.pvname.empty()) {
                     DBCH temp(mem.pvname);
                     unsigned ftype = dbChannelFieldType(temp);
 
                     // can't include in multi-locking
                     if(ftype>=DBF_INLINK && ftype<=DBF_FWDLINK)
                         throw std::runtime_error("Can't include link fields in group");
 
                     chan.swap(temp);
                 }
 
                 if(!parts.empty())
                     builder = mem.builder->dtype(builder, parts.back().name, chan);
                 else
                     builder = mem.builder->dtype(builder, "", chan);
 
                 if(!parts.empty()) {
                     for(size_t j=0; j<parts.size()-1; j++)
                         builder = builder->endNested();
                 }
 
                 if(!mem.pvname.empty()) {
                     members_map[mem.pvfldname] = J;
                     PDBGroupPV::Info& info = members[J];
 
                     info.allowProc = mem.putorder != std::numeric_limits<int>::min();
                     info.builder = PTRMOVE(mem.builder);
                     assert(info.builder.get());
 
                     info.attachment.swap(parts);
                     info.chan.swap(chan);
 
                     // info.triggers populated below
 
                     assert(info.chan);
                     records[J] = dbChannelRecord(info.chan);
 
                     J++;
                 }
             }
             pv->members.swap(members);
 
             pv->fielddesc = builder->createStructure();
             pv->complete = pvbuilder->createPVStructure(pv->fielddesc);
 
             pv->complete->getSubFieldT<pvd::PVBoolean>("record._options.atomic")->put(pv->monatomic);
 
             DBManyLock L(&records[0], records.size(), 0);
             pv->locker.swap(L);
 
             // construct locker for records triggered by each member
             for(size_t i=0, J=0, N=info.members.size(); i<N; i++)
             {
                 const GroupMemberInfo &mem = info.members[i];
                 if(mem.pvname.empty()) continue;
                 PDBGroupPV::Info& info = pv->members[J++];
 
                 if(mem.triggers.empty()) continue;
 
                 std::vector<dbCommon*> trig_records;
                 trig_records.reserve(mem.triggers.size());
 
                 FOREACH(GroupMemberInfo::triggers_t::const_iterator, it, end, mem.triggers) {
                     members_map_t::const_iterator imap(members_map.find(*it));
                     if(imap==members_map.end())
                         throw std::logic_error("trigger resolution missed map to non-dbChannel");
 
                     info.triggers.push_back(imap->second);
                     trig_records.push_back(records[imap->second]);
                 }
 
                 DBManyLock L(&trig_records[0], trig_records.size(), 0);
                 info.locker.swap(L);
             }
 
             persist_pv_map[info.name] = pv;
 
         }catch(std::exception& e){
             fprintf(stderr, "%s: Error Group not created: %s\n", info.name.c_str(), e.what());
         }
     }
 #else
     if(!proc.groups.empty()) {
         fprintf(stderr, "Group(s) were defined, but need Base >=3.16.0.2 to function.  Ignoring.\n");
     }
 #endif // USE_MULTILOCK
 
     event_context = db_init_events();
     if(!event_context)
         throw std::runtime_error("Failed to create dbEvent context");
     int ret = db_start_events(event_context, "PDB-event", NULL, NULL, epicsThreadPriorityCAServerLow-1);
     if(ret!=DB_EVENT_OK)
         throw std::runtime_error("Failed to stsart dbEvent context");
 
     // setup group monitors
 #ifdef USE_MULTILOCK
     for(persist_pv_map_t::iterator next = persist_pv_map.begin(),
                                     end = persist_pv_map.end(),
                                      it = next!=end ? next++ : end;
         it != end; it = next==end ? end : next++)
     {
         const PDBPV::shared_pointer& ppv = it->second;
         PDBGroupPV *pv = dynamic_cast<PDBGroupPV*>(ppv.get());
         if(!pv)
             continue;
         try {
 
             // prepare for monitor
 
             size_t i=0;
             FOREACH(PDBGroupPV::members_t::iterator, it2, end2, pv->members)
             {
                 PDBGroupPV::Info& info = *it2;
                 info.evt_VALUE.index = info.evt_PROPERTY.index = i++;
                 info.evt_VALUE.self = info.evt_PROPERTY.self = pv;
                 assert(info.chan);
 
                 info.pvif.reset(info.builder->attach(info.chan, pv->complete, info.attachment));
 
                 // TODO: don't need evt_PROPERTY for PVIF plain
                 info.evt_PROPERTY.create(event_context, info.chan, &pdb_group_event, DBE_PROPERTY);
 
                 if(!info.triggers.empty()) {
                     info.evt_VALUE.create(event_context, info.chan, &pdb_group_event, DBE_VALUE|DBE_ALARM);
                 }
             }
         }catch(std::exception& e){
             fprintf(stderr, "%s: Error during dbEvent setup : %s\n", pv->name.c_str(), e.what());
             persist_pv_map.erase(it);
         }
     }
 #endif // USE_MULTILOCK
     epics::atomic::increment(num_instances);
 }

PDBProvider::~PDBProvider ( )

virtual

Definition at line 532 of file pdb.cpp.

 {
     epics::atomic::decrement(num_instances);
 
     destroy();
 }

Member Function Documentation

virtual void PDBProvider::cancel ( )

inlinevirtual

Implements epics::pvAccess::ChannelFind.

Definition at line 57 of file pdb.h.

57 {/* our channelFind() is synchronous, so nothing to cancel */}

pva::ChannelFind::shared_pointer PDBProvider::channelFind	(	std::string const &	channelName,
		epics::pvAccess::ChannelFindRequester::shared_pointer const &	channelFindRequester
	)

virtual

Definition at line 568 of file pdb.cpp.

 {
     pva::ChannelFind::shared_pointer ret(new ChannelFindRequesterNOOP(shared_from_this()));
 
     bool found = false;
     {
         epicsGuard<epicsMutex> G(transient_pv_map.mutex());
         if(persist_pv_map.find(channelName)!=persist_pv_map.end()
                 || transient_pv_map.find(channelName)
                 || dbChannelTest(channelName.c_str())==0)
             found = true;
     }
     requester->channelFindResult(pvd::Status(), ret, found);
     return ret;
 }

pva::ChannelFind::shared_pointer PDBProvider::channelList ( epics::pvAccess::ChannelListRequester::shared_pointer const & channelListRequester )

virtual

Definition at line 585 of file pdb.cpp.

 {
     pva::ChannelFind::shared_pointer ret;
     pvd::PVStringArray::svector names;
     for(pdbRecordIterator rec; !rec.done(); rec.next())
     {
         names.push_back(rec.name());
     }
     {
         epicsGuard<epicsMutex> G(transient_pv_map.mutex());
 
         for(persist_pv_map_t::const_iterator it=persist_pv_map.begin(), end=persist_pv_map.end();
             it != end; ++it)
         {
             names.push_back(it->first);
         }
     }
     // check for duplicates?
     requester->channelListResult(pvd::Status::Ok,
                                  shared_from_this(),
                                  pvd::freeze(names), false);
     return ret;
 }

virtual epics::pvAccess::Channel::shared_pointer PDBProvider::createChannel	(	std::string const &	channelName,
		epics::pvAccess::ChannelRequester::shared_pointer const &	channelRequester,
		short	priority = `PRIORITY_DEFAULT`
	)

virtual

virtual epics::pvAccess::Channel::shared_pointer PDBProvider::createChannel	(	std::string const &	channelName,
		epics::pvAccess::ChannelRequester::shared_pointer const &	channelRequester,
		short	priority,
		std::string const &	address
	)

virtual

void PDBProvider::destroy ( )

virtual

Destroy this instance.

Implements epics::pvAccess::Destroyable.

Definition at line 539 of file pdb.cpp.

 {
     dbEventCtx ctxt = NULL;
 
     persist_pv_map_t ppv;
     {
         epicsGuard<epicsMutex> G(transient_pv_map.mutex());
         persist_pv_map.swap(ppv);
         std::swap(ctxt, event_context);
     }
     ppv.clear(); // indirectly calls all db_cancel_events()
     if(ctxt) db_close_events(ctxt);
 }

virtual std::tr1::shared_ptr<ChannelProvider> PDBProvider::getChannelProvider ( )

inlinevirtual

Implements epics::pvAccess::ChannelFind.

Definition at line 56 of file pdb.h.

56 { return shared_from_this(); }

std::string PDBProvider::getProviderName ( )

virtual

Get the provider name.

Returns: The name.

Implements epics::pvAccess::ChannelProvider.

Definition at line 553 of file pdb.cpp.

553 { return "QSRV"; }

PDBProvider::POINTER_DEFINITIONS ( PDBProvider )

Member Data Documentation

dbEventCtx PDBProvider::event_context

Definition at line 65 of file pdb.h.

size_t PDBProvider::num_instances

static

Definition at line 67 of file pdb.h.

persist_pv_map_t PDBProvider::persist_pv_map

Definition at line 60 of file pdb.h.

transient_pv_map_t PDBProvider::transient_pv_map

Definition at line 63 of file pdb.h.

The documentation for this struct was generated from the following files:

modules/pva2pva/pdbApp/pdb.h
modules/pva2pva/pdbApp/pdb.cpp

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation