This is a singleton class for creating data instances. More...

#include "pvData.h"

Public Member Functions
PVFieldPtr	createPVField (FieldConstPtr const &field)

PVFieldPtr	createPVField (PVFieldPtr const &fieldToClone)

PVScalarPtr	createPVScalar (ScalarConstPtr const &scalar)

PVScalarPtr	createPVScalar (ScalarType scalarType)

PVScalarPtr	createPVScalar (PVScalarPtr const &scalarToClone)

template<typename PVT >
std::tr1::shared_ptr< PVT >	createPVScalar ()

PVStructurePtr	createPVStructure (StructureConstPtr const &structure)

PVStructurePtr	createPVStructure (StringArray const &fieldNames, PVFieldPtrArray const &pvFields)

PVStructurePtr	createPVStructure (PVStructurePtr const &structToClone)

PVUnionPtr	createPVUnion (UnionConstPtr const &punion)

PVUnionPtr	createPVUnion (PVUnionPtr const &unionToClone)

PVUnionPtr	createPVVariantUnion ()

PVScalarArrayPtr	createPVScalarArray (ScalarArrayConstPtr const &scalarArray)

PVScalarArrayPtr	createPVScalarArray (ScalarType elementType)

PVScalarArrayPtr	createPVScalarArray (PVScalarArrayPtr const &scalarArrayToClone)

template<typename PVAT >
std::tr1::shared_ptr< PVAT >	createPVScalarArray ()

PVStructureArrayPtr	createPVStructureArray (StructureArrayConstPtr const &structureArray)

PVStructureArrayPtr	createPVStructureArray (StructureConstPtr const &structure)

PVUnionArrayPtr	createPVUnionArray (UnionArrayConstPtr const &unionArray)

PVUnionArrayPtr	createPVUnionArray (UnionConstPtr const &punion)

PVUnionArrayPtr	createPVVariantUnionArray ()

Static Public Member Functions
static const PVDataCreatePtr &	getPVDataCreate ()

Friends
struct	detail::pvfield_factory

Detailed Description

This is a singleton class for creating data instances.

Definition at line 1474 of file pvData.h.

Member Function Documentation

PVFieldPtr epics::pvData::PVDataCreate::createPVField ( FieldConstPtr const & field )

Create a PVField using given Field introspection data.

Parameters

field The introspection data to be used to create PVField.

Returns: The PVField implementation.

Definition at line 471 of file PVDataCreateFactory.cpp.

 {
      switch(field->getType()) {
      case scalar: {
          ScalarConstPtr xx = static_pointer_cast<const Scalar>(field);
          return createPVScalar(xx);
      }
      case scalarArray: {
          ScalarArrayConstPtr xx = static_pointer_cast<const ScalarArray>(field);
          return createPVScalarArray(xx);
      }
      case structure: {
          StructureConstPtr xx = static_pointer_cast<const Structure>(field);
          return createPVStructure(xx);
      }
      case structureArray: {
          StructureArrayConstPtr xx = static_pointer_cast<const StructureArray>(field);
          return createPVStructureArray(xx);
      }
      case union_: {
          UnionConstPtr xx = static_pointer_cast<const Union>(field);
          return createPVUnion(xx);
      }
      case unionArray: {
          UnionArrayConstPtr xx = static_pointer_cast<const UnionArray>(field);
          return createPVUnionArray(xx);
      }
      }
      throw std::logic_error("PVDataCreate::createPVField should never get here");
 }

PVFieldPtr epics::pvData::PVDataCreate::createPVField ( PVFieldPtr const & fieldToClone )

Create a PVField using given a PVField to clone. This method calls the appropriate createPVScalar, createPVArray, or createPVStructure.

Parameters

fieldToClone The field to clone.

Returns: The PVField implementation

Definition at line 502 of file PVDataCreateFactory.cpp.

 {
      switch(fieldToClone->getField()->getType()) {
      case scalar:
         {
             PVScalarPtr pvScalar = static_pointer_cast<PVScalar>(fieldToClone);
             return createPVScalar(pvScalar);
         }
      case scalarArray:
         {
              PVScalarArrayPtr pvScalarArray
                  = static_pointer_cast<PVScalarArray>(fieldToClone);
              return createPVScalarArray(pvScalarArray);
         }
      case structure:
          {
              PVStructurePtr pvStructure
                    = static_pointer_cast<PVStructure>(fieldToClone);
              StringArray const & fieldNames = pvStructure->getStructure()->getFieldNames();
              PVFieldPtrArray const & pvFieldPtrArray = pvStructure->getPVFields();
              return createPVStructure(fieldNames,pvFieldPtrArray);
          }
      case structureArray:
          {
              PVStructureArrayPtr from
                  = static_pointer_cast<PVStructureArray>(fieldToClone);
              StructureArrayConstPtr structureArray = from->getStructureArray();
              PVStructureArrayPtr to = createPVStructureArray(
                  structureArray);
              to->copyUnchecked(*from);
              return to;
          }
      case union_:
          {
              PVUnionPtr pvUnion
                    = static_pointer_cast<PVUnion>(fieldToClone);
              return createPVUnion(pvUnion);
          }
      case unionArray:
          {
              PVUnionArrayPtr from
                  = static_pointer_cast<PVUnionArray>(fieldToClone);
              UnionArrayConstPtr unionArray = from->getUnionArray();
              PVUnionArrayPtr to = createPVUnionArray(unionArray);
              to->copyUnchecked(*from);
              return to;
          }
      }
      throw std::logic_error("PVDataCreate::createPVField should never get here");
 }

PVScalarPtr epics::pvData::PVDataCreate::createPVScalar ( ScalarConstPtr const & scalar )

Create an implementation of a scalar field reusing the Scalar introspection interface.

Parameters

scalar The introspection interface.

Returns: The PVScalar implementation.

Definition at line 553 of file PVDataCreateFactory.cpp.

 {
      ScalarType scalarType = scalar->getScalarType();
      switch(scalarType) {
      case pvBoolean:
          return PVScalarPtr(new PVBoolean(scalar));
      case pvByte:
          return PVScalarPtr(new PVByte(scalar));
      case pvShort:
          return PVScalarPtr(new PVShort(scalar));
      case pvInt:
          return PVScalarPtr(new PVInt(scalar));
      case pvLong:
          return PVScalarPtr(new PVLong(scalar));
      case pvUByte:
          return PVScalarPtr(new PVUByte(scalar));
      case pvUShort:
          return PVScalarPtr(new PVUShort(scalar));
      case pvUInt:
          return PVScalarPtr(new PVUInt(scalar));
      case pvULong:
          return PVScalarPtr(new PVULong(scalar));
      case pvFloat:
          return PVScalarPtr(new PVFloat(scalar));
      case pvDouble:
          return PVScalarPtr(new PVDouble(scalar));
      case pvString:
          return PVScalarPtr(new PVString(scalar));
      }
      throw std::logic_error("PVDataCreate::createPVScalar should never get here");
 }

PVScalarPtr epics::pvData::PVDataCreate::createPVScalar ( ScalarType scalarType )

Create an implementation of a scalar field. A Scalar introspection interface is created.

Parameters

scalarType The scalar type.

Returns: The PVScalar implementation.

Definition at line 585 of file PVDataCreateFactory.cpp.

 {
      ScalarConstPtr scalar = fieldCreate->createScalar(scalarType);
      return createPVScalar(scalar);
 }

PVScalarPtr epics::pvData::PVDataCreate::createPVScalar ( PVScalarPtr const & scalarToClone )

Create an implementation of a scalar field by cloning an existing PVScalar. The new PVScalar will have the same value and auxInfo as the original.

Parameters

scalarToClone The PVScalar to clone.

Returns: The PVScalar implementation.

Definition at line 592 of file PVDataCreateFactory.cpp.

 {
      ScalarType scalarType = scalarToClone->getScalar()->getScalarType();
      PVScalarPtr pvScalar = createPVScalar(scalarType);
      pvScalar->copyUnchecked(*scalarToClone);
      return pvScalar;
 }

template<typename PVT >

std::tr1::shared_ptr<PVT> epics::pvData::PVDataCreate::createPVScalar ( )

inline

template version

Template Parameters

PVT	must be a valid PVType

Returns: The PVScalar implementation.

Definition at line 1521 of file pvData.h.

     {
         return std::tr1::static_pointer_cast<PVT>(createPVScalar(PVT::typeCode));   
     }

PVScalarArrayPtr epics::pvData::PVDataCreate::createPVScalarArray ( ScalarArrayConstPtr const & scalarArray )

Create an implementation of an array field reusing the Array introspection interface.

Parameters

scalarArray The introspection interface.

Returns: The PVScalarArray implementation.

Definition at line 600 of file PVDataCreateFactory.cpp.

 {
      switch(scalarArray->getElementType()) {
      case pvBoolean:
            return PVScalarArrayPtr(new PVBooleanArray(scalarArray));
      case pvByte:
            return PVScalarArrayPtr(new PVByteArray(scalarArray));
      case pvShort:
            return PVScalarArrayPtr(new PVShortArray(scalarArray));
      case pvInt:
            return PVScalarArrayPtr(new PVIntArray(scalarArray));
      case pvLong:
            return PVScalarArrayPtr(new PVLongArray(scalarArray));
      case pvUByte:
            return PVScalarArrayPtr(new PVUByteArray(scalarArray));
      case pvUShort:
            return PVScalarArrayPtr(new PVUShortArray(scalarArray));
      case pvUInt:
            return PVScalarArrayPtr(new PVUIntArray(scalarArray));
      case pvULong:
            return PVScalarArrayPtr(new PVULongArray(scalarArray));
      case pvFloat:
            return PVScalarArrayPtr(new PVFloatArray(scalarArray));
      case pvDouble:
            return PVScalarArrayPtr(new PVDoubleArray(scalarArray));
      case pvString:
            return PVScalarArrayPtr(new PVStringArray(scalarArray));
      }
      throw std::logic_error("PVDataCreate::createPVScalarArray should never get here");
 
 }

PVScalarArrayPtr epics::pvData::PVDataCreate::createPVScalarArray ( ScalarType elementType )

Create an implementation for an array field. An Array introspection interface is created.

Parameters

elementType The element type.

Returns: The PVScalarArray implementation.

Definition at line 633 of file PVDataCreateFactory.cpp.

 {
      ScalarArrayConstPtr scalarArray = fieldCreate->createScalarArray(elementType);
      return createPVScalarArray(scalarArray);
 }

PVScalarArrayPtr epics::pvData::PVDataCreate::createPVScalarArray ( PVScalarArrayPtr const & scalarArrayToClone )

Create an implementation of an array field by cloning an existing PVArray. The new PVArray will have the same value and auxInfo as the original.

Parameters

scalarArrayToClone The PVScalarArray to clone.

Returns: The PVScalarArray implementation.

Definition at line 640 of file PVDataCreateFactory.cpp.

 {
      PVScalarArrayPtr pvArray = createPVScalarArray(
           arrayToClone->getScalarArray()->getElementType());
      pvArray->assign(*arrayToClone.get());
     return pvArray;
 }

template<typename PVAT >

std::tr1::shared_ptr<PVAT> epics::pvData::PVDataCreate::createPVScalarArray ( )

inline

template version

Template Parameters

PVT	must be a valid pvType

Returns: The PVScalarArray implementation.

Definition at line 1590 of file pvData.h.

     {
         return std::tr1::static_pointer_cast<PVAT>(createPVScalarArray(PVAT::typeCode));   
     }

PVStructurePtr epics::pvData::PVDataCreate::createPVStructure ( StructureConstPtr const & structure )

Create implementation for PVStructure.

Parameters

structure The introspection interface.

Returns: The PVStructure implementation

Definition at line 655 of file PVDataCreateFactory.cpp.

 {
      return PVStructurePtr(new PVStructure(structure));
 }

PVStructurePtr epics::pvData::PVDataCreate::createPVStructure	(	StringArray const &	fieldNames,
		PVFieldPtrArray const &	pvFields
	)

Create implementation for PVStructure.

Parameters

fieldNames	The field names.
pvFields	Array of PVFields

Returns: The PVStructure implementation

Definition at line 683 of file PVDataCreateFactory.cpp.

 {
      size_t num = fieldNames.size();
      FieldConstPtrArray fields(num);
      for (size_t i=0;i<num;i++) fields[i] = pvFields[i]->getField();
      StructureConstPtr structure = fieldCreate->createStructure(fieldNames,fields);
      PVStructurePtr pvStructure(new PVStructure(structure,pvFields));
      return pvStructure;
 }

PVStructurePtr epics::pvData::PVDataCreate::createPVStructure ( PVStructurePtr const & structToClone )

Create implementation for PVStructure.

Parameters

structToClone A structure. Each subfield and any auxInfo is cloned and added to the newly created structure.

Returns: The PVStructure implementation.

Definition at line 694 of file PVDataCreateFactory.cpp.

 {
     FieldConstPtrArray field;
     if(!structToClone) {
         // is this correct?!
         FieldConstPtrArray fields(0);
         StringArray fieldNames(0);
         StructureConstPtr structure = fieldCreate->createStructure(fieldNames,fields);
         return PVStructurePtr(new PVStructure(structure));
     }
     StructureConstPtr structure = structToClone->getStructure();
     PVStructurePtr pvStructure(new PVStructure(structure));
     pvStructure->copyUnchecked(*structToClone);
     return pvStructure;
 }

PVStructureArrayPtr epics::pvData::PVDataCreate::createPVStructureArray ( StructureArrayConstPtr const & structureArray )

Create an implementation of an array with structure elements.

Parameters

structureArray The introspection interface. All elements share the same introspection interface.

Returns: The PVStructureArray implementation.

Definition at line 649 of file PVDataCreateFactory.cpp.

 {
      return PVStructureArrayPtr(new PVStructureArray(structureArray));
 }

PVStructureArrayPtr epics::pvData::PVDataCreate::createPVStructureArray ( StructureConstPtr const & structure )

inline

Create an implementation of an array with structure elements.

Parameters

structure The introspection interface that is used to create StructureArrayConstPtr. All elements share the same introspection interface.

Returns: The PVStructureArray implementation.

Definition at line 1608 of file pvData.h.

     {
         return createPVStructureArray(fieldCreate->createStructureArray(structure));
     }

PVUnionPtr epics::pvData::PVDataCreate::createPVUnion ( UnionConstPtr const & punion )

Create implementation for PVUnion.

Parameters

punion The introspection interface.

Returns: The PVUnion implementation

Definition at line 667 of file PVDataCreateFactory.cpp.

 {
      return PVUnionPtr(new PVUnion(punion));
 }

PVUnionPtr epics::pvData::PVDataCreate::createPVUnion ( PVUnionPtr const & unionToClone )

Create implementation for PVUnion.

Parameters

unionToClone A union. Each subfield is cloned and added to the newly created union.

Returns: The PVUnion implementation.

Definition at line 710 of file PVDataCreateFactory.cpp.

 {
     PVUnionPtr punion(new PVUnion(unionToClone->getUnion()));
     // set cloned value
     punion->set(unionToClone->getSelectedIndex(), createPVField(unionToClone->get()));
     return punion;
 }

PVUnionArrayPtr epics::pvData::PVDataCreate::createPVUnionArray ( UnionArrayConstPtr const & unionArray )

Create an implementation of an array with union elements.

Parameters

unionArray The introspection interface. All elements share the same introspection interface.

Returns: The PVUnionArray implementation.

Definition at line 661 of file PVDataCreateFactory.cpp.

 {
      return PVUnionArrayPtr(new PVUnionArray(unionArray));
 }

PVUnionArrayPtr epics::pvData::PVDataCreate::createPVUnionArray ( UnionConstPtr const & punion )

inline

Create an implementation of an array with union elements.

Parameters

punion The introspection interface that is used to create UnionArrayConstPtr. All elements share the same introspection interface.

Returns: The PVUnionArray implementation.

Definition at line 1626 of file pvData.h.

     {
         return createPVUnionArray(fieldCreate->createUnionArray(punion));
     }

PVUnionPtr epics::pvData::PVDataCreate::createPVVariantUnion ( )

Create variant union implementation.

Returns: The variant PVUnion implementation.

Definition at line 673 of file PVDataCreateFactory.cpp.

 {
      return PVUnionPtr(new PVUnion(fieldCreate->createVariantUnion()));
 }

PVUnionArrayPtr epics::pvData::PVDataCreate::createPVVariantUnionArray ( )

Create variant union array implementation.

Returns: The variant PVUnionArray implementation.

Definition at line 678 of file PVDataCreateFactory.cpp.

 {
      return PVUnionArrayPtr(new PVUnionArray(fieldCreate->createVariantUnionArray()));
 }

const PVDataCreatePtr & epics::pvData::PVDataCreate::getPVDataCreate ( )

static

get the singleton

Returns: The PVDataCreate implementation

Definition at line 739 of file PVDataCreateFactory.cpp.

 {
     epicsThreadOnce(&pvfield_factory_once, &pvfield_factory_init, 0);
     if(!pvfield_factory_s->pvDataCreate)
         throw std::logic_error("getPVDataCreate() not initialized");
     return pvfield_factory_s->pvDataCreate;
 }

Friends And Related Function Documentation

friend struct detail::pvfield_factory

friend

Definition at line 1475 of file pvData.h.

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

modules/pvData/src/pv/pvData.h
modules/pvData/src/factory/PVDataCreateFactory.cpp

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Function Documentation

Friends And Related Function Documentation