EPICS_base/pva2pva
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

store dbChannel* in builder

Browse Source
This commit is contained in:
Michael Davidsaver
2020-05-31 12:15:38 -07:00
parent b69c25feb6
commit c68c0038e6
4 changed files with 61 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pdbApp/pdbsingle.cpp
View File

@ -96,7 +96,7 @@ void pdb_single_event(void *user_arg, struct dbChannel *chan,
PDBSinglePV::PDBSinglePV(DBCH& chan,
const PDBProvider::shared_pointer& prov)
:provider(prov)
,builder(new ScalarBuilder)
,builder(new ScalarBuilder(chan.chan))
,interested_iterating(false)
,evt_VALUE(this)
,evt_PROPERTY(this)

16
pdbApp/pvif.cpp
View File

@ -950,6 +950,7 @@ struct PVIFPlain : public PVIF
struct PlainBuilder : public PVIFBuilder
{
explicit PlainBuilder(dbChannel* chan) :PVIFBuilder(chan) {}
virtual ~PlainBuilder() {}
// fetch the structure description
@ -990,6 +991,7 @@ struct PlainBuilder : public PVIFBuilder
struct AnyScalarBuilder : public PVIFBuilder
{
explicit AnyScalarBuilder(dbChannel* chan) :PVIFBuilder(chan) {}
virtual ~AnyScalarBuilder() {}
// fetch the structure description
@ -1088,6 +1090,7 @@ struct PVIFMeta : public PVIF
struct MetaBuilder : public PVIFBuilder
{
explicit MetaBuilder(dbChannel* chan) :PVIFBuilder(chan) {}
virtual ~MetaBuilder() {}
// fetch the structure description
@ -1152,6 +1155,9 @@ struct PVIFProc : public PVIF
struct ProcBuilder : public PVIFBuilder
{
explicit ProcBuilder(dbChannel* chan) :PVIFBuilder(chan) {}
virtual ~ProcBuilder() {}
// fetch the structure description
virtual epics::pvData::FieldConstPtr dtype(dbChannel *channel) OVERRIDE FINAL {
throw std::logic_error("Don't call me");
@ -1232,15 +1238,15 @@ PVIFBuilder::dtype(epics::pvData::FieldBuilderPtr& builder,
PVIFBuilder* PVIFBuilder::create(const std::string& type, dbChannel* chan)
{
if(type.empty() || type=="scalar")
return new ScalarBuilder;
return new ScalarBuilder(chan);
else if(type=="plain")
return new PlainBuilder;
return new PlainBuilder(chan);
else if(type=="any")
return new AnyScalarBuilder;
return new AnyScalarBuilder(chan);
else if(type=="meta")
return new MetaBuilder;
return new MetaBuilder(chan);
else if(type=="proc")
return new ProcBuilder;
return new ProcBuilder(chan);
else
throw std::runtime_error(std::string("Unknown +type=")+type);
}

7
pdbApp/pvif.h
View File

@ -390,7 +390,9 @@ private:
* Caller than creates a PVStructure and uses PVIFBuilder::attach() to
* build mappings for each dbChannel in the composed locations.
*/
struct QSRV_API PVIFBuilder {
struct QSRV_API PVIFBuilder
{
dbChannel* const channel;
virtual ~PVIFBuilder() {}
@ -409,7 +411,7 @@ struct QSRV_API PVIFBuilder {
// entry point for Builder
static PVIFBuilder* create(const std::string& mapname, dbChannel* chan);
protected:
PVIFBuilder() {}
explicit PVIFBuilder(dbChannel* chan) : channel(chan) {}
private:
PVIFBuilder(const PVIFBuilder&);
PVIFBuilder& operator=(const PVIFBuilder&);
@ -417,6 +419,7 @@ private:
struct QSRV_API ScalarBuilder : public PVIFBuilder
{
explicit ScalarBuilder(dbChannel* chan) :PVIFBuilder(chan) {}
virtual ~ScalarBuilder() {}
virtual epics::pvData::FieldConstPtr dtype(dbChannel *channel) OVERRIDE FINAL;

56
testApp/testpvif.cpp
View File

@ -74,38 +74,56 @@ void testScalar()
testEqual(dbChannelFinalFieldType(chan_i64), DBR_INT64);
#endif
ScalarBuilder builder;
pvd::FieldConstPtr dtype_li(builder.dtype(chan_li));
pvd::PVStructurePtr root;
p2p::auto_ptr<PVIF> pvif_li;
#ifdef USE_INT64
pvd::FieldConstPtr dtype_i64(builder.dtype(chan_i64));
p2p::auto_ptr<PVIF> pvif_i64;
#endif
pvd::FieldConstPtr dtype_si(builder.dtype(chan_si));
pvd::FieldConstPtr dtype_ai(builder.dtype(chan_ai));
pvd::FieldConstPtr dtype_ai_rval(builder.dtype(chan_ai_rval));
pvd::FieldConstPtr dtype_mbbi(builder.dtype(chan_mbbi));
p2p::auto_ptr<PVIF> pvif_si;
p2p::auto_ptr<PVIF> pvif_ai;
p2p::auto_ptr<PVIF> pvif_ai_rval;
p2p::auto_ptr<PVIF> pvif_mbbi;
{
ScalarBuilder builder_li(chan_li);
#ifdef USE_INT64
ScalarBuilder builder_i64(chan_i64);
#endif
ScalarBuilder builder_si(chan_si);
ScalarBuilder builder_ai(chan_ai);
ScalarBuilder builder_ai_rval(chan_ai_rval);
ScalarBuilder builder_mbbi(chan_mbbi);
pvd::FieldConstPtr dtype_li(builder_li.dtype(chan_li));
#ifdef USE_INT64
pvd::FieldConstPtr dtype_i64(builder_i64.dtype(chan_i64));
#endif
pvd::FieldConstPtr dtype_si(builder_si.dtype(chan_si));
pvd::FieldConstPtr dtype_ai(builder_ai.dtype(chan_ai));
pvd::FieldConstPtr dtype_ai_rval(builder_ai_rval.dtype(chan_ai_rval));
pvd::FieldConstPtr dtype_mbbi(builder_mbbi.dtype(chan_mbbi));
pvd::StructureConstPtr dtype_root(pvd::getFieldCreate()->createFieldBuilder()
->add("li", dtype_li)
#ifdef USE_INT64
#ifdef USE_INT64
->add("i64", dtype_i64)
#endif
#endif
->add("si", dtype_si)
->add("ai", dtype_ai)
->add("ai_rval", dtype_ai_rval)
->add("mbbi", dtype_mbbi)
->createStructure());
pvd::PVStructurePtr root(pvd::getPVDataCreate()->createPVStructure(dtype_root));
root = pvd::getPVDataCreate()->createPVStructure(dtype_root);
p2p::auto_ptr<PVIF> pvif_li(builder.attach(chan_li, root, FieldName("li")));
#ifdef USE_INT64
p2p::auto_ptr<PVIF> pvif_i64(builder.attach(chan_i64, root, FieldName("i64")));
#endif
p2p::auto_ptr<PVIF> pvif_si(builder.attach(chan_si, root, FieldName("si")));
p2p::auto_ptr<PVIF> pvif_ai(builder.attach(chan_ai, root, FieldName("ai")));
p2p::auto_ptr<PVIF> pvif_ai_rval(builder.attach(chan_ai_rval, root, FieldName("ai_rval")));
p2p::auto_ptr<PVIF> pvif_mbbi(builder.attach(chan_mbbi, root, FieldName("mbbi")));
pvif_li.reset(builder_li.attach(chan_li, root, FieldName("li")));
#ifdef USE_INT64
pvif_i64.reset(builder_i64.attach(chan_i64, root, FieldName("i64")));
#endif
pvif_si.reset(builder_si.attach(chan_si, root, FieldName("si")));
pvif_ai.reset(builder_ai.attach(chan_ai, root, FieldName("ai")));
pvif_ai_rval.reset(builder_ai_rval.attach(chan_ai_rval, root, FieldName("ai_rval")));
pvif_mbbi.reset(builder_mbbi.attach(chan_mbbi, root, FieldName("mbbi")));
}
testShow()<<"Entire structure\n"<<root;