epics::pvData::FieldCreate Class Reference

This is a singleton class for creating introspection interfaces. More...

#include "pvIntrospect.h"

Classes
struct	Helper

Public Member Functions
FieldBuilderPtr	createFieldBuilder () const
FieldBuilderPtr	createFieldBuilder (StructureConstPtr S) const
ScalarConstPtr	createScalar (ScalarType scalarType) const
BoundedStringConstPtr	createBoundedString (std::size_t maxLength) const PVD_DEPRECATED_52
ScalarArrayConstPtr	createScalarArray (ScalarType elementType) const
ScalarArrayConstPtr	createFixedScalarArray (ScalarType elementType, std::size_t size) const PVD_DEPRECATED_52
ScalarArrayConstPtr	createBoundedScalarArray (ScalarType elementType, std::size_t bound) const PVD_DEPRECATED_52
StructureArrayConstPtr	createStructureArray (StructureConstPtr const &structure) const
StructureConstPtr	createStructure () const
StructureConstPtr	createStructure (StringArray const &fieldNames, FieldConstPtrArray const &fields) const
StructureConstPtr	createStructure (std::string const &id, StringArray const &fieldNames, FieldConstPtrArray const &fields) const
UnionArrayConstPtr	createUnionArray (UnionConstPtr const &punion) const
UnionArrayConstPtr	createVariantUnionArray () const
UnionConstPtr	createVariantUnion () const
UnionConstPtr	createUnion (StringArray const &fieldNames, FieldConstPtrArray const &fields) const
UnionConstPtr	createUnion (std::string const &id, StringArray const &fieldNames, FieldConstPtrArray const &fields) const
StructureConstPtr	appendField (StructureConstPtr const &structure, std::string const &fieldName, FieldConstPtr const &field) const
StructureConstPtr	appendFields (StructureConstPtr const &structure, StringArray const &fieldNames, FieldConstPtrArray const &fields) const
FieldConstPtr	deserialize (ByteBuffer *buffer, DeserializableControl *control) const

Static Public Member Functions
static const FieldCreatePtr &	getFieldCreate ()

Friends
struct	detail::field_factory
class	Field

Detailed Description

This is a singleton class for creating introspection interfaces.

Definition at line 1250 of file pvIntrospect.h.

Member Function Documentation

StructureConstPtr epics::pvData::FieldCreate::appendField	(	StructureConstPtr const &	structure,
		std::string const &	fieldName,
		FieldConstPtr const &	field
	)		const

Append a field to a structure.

Parameters

structure	The structure to which the field is appended.
fieldName	The name of the field.
field	The field.

Returns

a Structure interface for the newly created object.

Definition at line 1395 of file FieldCreateFactory.cpp.

{
    StringArray const & oldNames = structure->getFieldNames();
    FieldConstPtrArray const & oldFields = structure->getFields();
    size_t oldLen = oldNames.size();
    StringArray newNames(oldLen+1);
    FieldConstPtrArray newFields(oldLen+1);
    for(size_t i = 0; i<oldLen; i++) {
        newNames[i] = oldNames[i];
        newFields[i] = oldFields[i];
    }
    newNames[oldLen] = fieldName;
    newFields[oldLen] = field;
    return createStructure(structure->getID(),newNames,newFields);
}

StructureConstPtr epics::pvData::FieldCreate::appendFields	(	StructureConstPtr const &	structure,
		StringArray const &	fieldNames,
		FieldConstPtrArray const &	fields
	)		const

Append fields to a structure.

Parameters

structure	The structure to which the fields appended.
fieldNames	The names of the fields.
fields	The fields.

Returns

a Structure interface for the newly created object.

Definition at line 1414 of file FieldCreateFactory.cpp.

{
    validateFieldNames(fieldNames);
    StringArray const & oldNames = structure->getFieldNames();
    FieldConstPtrArray const & oldFields = structure->getFields();
    size_t oldLen = oldNames.size();
    size_t extra = fieldNames.size();
    StringArray newNames(oldLen+extra);
    FieldConstPtrArray newFields(oldLen+extra);
    for(size_t i = 0; i<oldLen; i++) {
        newNames[i] = oldNames[i];
        newFields[i] = oldFields[i];
    }
    for(size_t i = 0; i<extra; i++) {
        newNames[oldLen +i] = fieldNames[i];
        newFields[oldLen +i] = fields[i];
    }
    return createStructure(structure->getID(),newNames,newFields);
}

ScalarArrayConstPtr epics::pvData::FieldCreate::createBoundedScalarArray	(	ScalarType	elementType,
		std::size_t	bound
	)		const

Create an Array field, bounded size array.

Parameters

elementType	The ScalarType for array elements
bound	Array maximum capacity.

Returns

An Array Interface for the newly created object.

Definition at line 1266 of file FieldCreateFactory.cpp.

{
    if(elementType<0 || elementType>MAX_SCALAR_TYPE) {
        std::ostringstream strm("Can't construct bounded ScalarArray from invalid ScalarType ");
        strm << elementType;
        THROW_EXCEPTION2(std::invalid_argument, strm.str());
    }

    std::tr1::shared_ptr<ScalarArray> s(new BoundedScalarArray(elementType, size));
    Helper::cache(this, s);
    return s;
}

BoundedStringConstPtr epics::pvData::FieldCreate::createBoundedString

(

std::size_t

maxLength

)

const

Create a BoundedString.

Parameters

maxLength

a string maximum length.

Returns

a BoundedString interface for the newly created object.

Exceptions

IllegalArgumentException

if maxLength == 0.

Definition at line 1235 of file FieldCreateFactory.cpp.

{
    std::tr1::shared_ptr<BoundedString> s(new BoundedString(maxLength));
    Helper::cache(this, s);
    return s;
}

FieldBuilderPtr epics::pvData::FieldCreate::createFieldBuilder

(

)

const

Create a new instance of in-line Field builder.

Returns

a new instance of a FieldBuilder.

Definition at line 1213 of file FieldCreateFactory.cpp.

{
    return FieldBuilderPtr(new FieldBuilder());
}

FieldBuilderPtr epics::pvData::FieldCreate::createFieldBuilder

(

StructureConstPtr

S

)

const

Create a new instance of in-line Field builder pre-initialized with and existing Structure

Returns

a new instance of a FieldBuilder.

Definition at line 1218 of file FieldCreateFactory.cpp.

{
    FieldBuilderPtr ret(new FieldBuilder(S.get()));
    return ret;
}

ScalarArrayConstPtr epics::pvData::FieldCreate::createFixedScalarArray	(	ScalarType	elementType,
		std::size_t	size
	)		const

Definition at line 1253 of file FieldCreateFactory.cpp.

{
    if(elementType<0 || elementType>MAX_SCALAR_TYPE) {
        std::ostringstream strm("Can't construct fixed ScalarArray from invalid ScalarType ");
        strm << elementType;
        THROW_EXCEPTION2(std::invalid_argument, strm.str());
    }

    std::tr1::shared_ptr<ScalarArray> s(new FixedScalarArray(elementType, size));
    Helper::cache(this, s);
    return s;
}

ScalarConstPtr epics::pvData::FieldCreate::createScalar

(

ScalarType

scalarType

)

const

Create a ScalarField.

Parameters

scalarType

The scalar type.

Returns

a Scalar interface for the newly created object.

Exceptions

IllegalArgumentException

if an illegal type is specified.

Definition at line 1224 of file FieldCreateFactory.cpp.

{
    if(scalarType<0 || scalarType>MAX_SCALAR_TYPE) {
        std::ostringstream strm("Can't construct Scalar from invalid ScalarType ");
        strm << scalarType;
        THROW_EXCEPTION2(std::invalid_argument, strm.str());
    }

    return scalars[scalarType];
}

ScalarArrayConstPtr epics::pvData::FieldCreate::createScalarArray

(

ScalarType

elementType

)

const

Create an Array field, variable size array.

Parameters

elementType

The ScalarType for array elements

Returns

An Array Interface for the newly created object.

Definition at line 1242 of file FieldCreateFactory.cpp.

{
    if(elementType<0 || elementType>MAX_SCALAR_TYPE) {
        std::ostringstream strm("Can't construct ScalarArray from invalid ScalarType ");
        strm << elementType;
        THROW_EXCEPTION2(std::invalid_argument, strm.str());
    }

    return scalarArrays[elementType];
}

StructureConstPtr epics::pvData::FieldCreate::createStructure

(

)

const

Create a Structure field.

Returns

a Structure interface for the newly created object.

Definition at line 1279 of file FieldCreateFactory.cpp.

{
      StringArray fieldNames;
      FieldConstPtrArray fields;
      return createStructure(fieldNames,fields);
}

StructureConstPtr epics::pvData::FieldCreate::createStructure	(	StringArray const &	fieldNames,
		FieldConstPtrArray const &	fields
	)		const

Create a Structure field.

Parameters

fieldNames	the names of the fields for the structure.
fields	The array of Field objects for the structure.

Returns

a Structure interface for the newly created object.

Definition at line 1329 of file FieldCreateFactory.cpp.

{
      validateFieldNames(fieldNames);
      std::tr1::shared_ptr<Structure> sp(new Structure(fieldNames,fields));
      Helper::cache(this, sp);
      return sp;
}

StructureConstPtr epics::pvData::FieldCreate::createStructure	(	std::string const &	id,
		StringArray const &	fieldNames,
		FieldConstPtrArray const &	fields
	)		const

Create a Structure field with identification string.

Parameters

id	The identification string for the structure.
fieldNames	the names of the fields for the structure.
fields	The array of Field objects for the structure.

Returns

a Structure interface for the newly created object.

StructureArrayConstPtr epics::pvData::FieldCreate::createStructureArray

(

StructureConstPtr const &

structure

)

const

Create an Array field that is has element type Structure

Parameters

structure

The Structure for each array element.

Returns

An Array Interface for the newly created object.

Definition at line 1349 of file FieldCreateFactory.cpp.

{
     std::tr1::shared_ptr<StructureArray> sp(new StructureArray(structure));
     Helper::cache(this, sp);
     return sp;
}

UnionConstPtr epics::pvData::FieldCreate::createUnion	(	StringArray const &	fieldNames,
		FieldConstPtrArray const &	fields
	)		const

Create a Union field.

Parameters

fieldNames	the names of the fields for the union.
fields	The Field for each fields for the union.

Returns

a Union interface for the newly created object.

Definition at line 1357 of file FieldCreateFactory.cpp.

{
      validateFieldNames(fieldNames);
      std::tr1::shared_ptr<Union> sp(new Union(fieldNames,fields));
      Helper::cache(this, sp);
      return sp;
}

UnionConstPtr epics::pvData::FieldCreate::createUnion	(	std::string const &	id,
		StringArray const &	fieldNames,
		FieldConstPtrArray const &	fields
	)		const

Create a Union field with identification string.

Parameters

id	The identification string for the union.
fieldNames	the names of the fields for the union.
fields	The array of Field objects for the union.

Returns

a Union interface for the newly created object.

UnionArrayConstPtr epics::pvData::FieldCreate::createUnionArray

(

UnionConstPtr const &

punion

)

const

Create an Array field that is has element type Union

Parameters

punion

The Union for each array element.

Returns

An Array Interface for the newly created object.

Definition at line 1382 of file FieldCreateFactory.cpp.

{
     std::tr1::shared_ptr<UnionArray> sp(new UnionArray(punion));
     Helper::cache(this, sp);
     return sp;
}

UnionConstPtr epics::pvData::FieldCreate::createVariantUnion

(

)

const

Create a variant Union (aka any type) field.

Returns

a Union interface for the newly created object.

Definition at line 1377 of file FieldCreateFactory.cpp.

{
    return variantUnion;
}

UnionArrayConstPtr epics::pvData::FieldCreate::createVariantUnionArray

(

)

const

Create a variant UnionArray (aka any type) field.

Returns

a UnionArray interface for the newly created object.

Definition at line 1390 of file FieldCreateFactory.cpp.

{
    return variantUnionArray;
}

FieldConstPtr epics::pvData::FieldCreate::deserialize	(	ByteBuffer *	buffer,
		DeserializableControl *	control
	)		const

Deserialize Field instance from given byte buffer.

Parameters

buffer	Buffer containing serialized Field instance.
control	Deserialization control instance.

Returns

a deserialized Field instance.

Definition at line 1474 of file FieldCreateFactory.cpp.

{
    control->ensureData(1);
    int8 code = buffer->getByte();
    if (code == -1)
        return FieldConstPtr();

    int typeCode = code & 0xE7;
    int scalarOrArray = code & 0x18;
    bool notArray = (scalarOrArray == 0);
    if (notArray)
    {
        if (typeCode < 0x80)
        {
            // Type type = Type.scalar;
            int scalarType = decodeScalar(code);
            if (scalarType == -1)
                throw std::invalid_argument("invalid scalar type encoding");
            return scalars[scalarType];
        }
        else if (typeCode == 0x80)
        {
            // Type type = Type.structure;
            return deserializeStructureField(this, buffer, control);
        }
        else if (typeCode == 0x81)
        {
            // Type type = Type.union;
            return deserializeUnionField(this, buffer, control);
        }
        else if (typeCode == 0x82)
        {
            // Type type = Type.union; variant union (aka any type)
            return variantUnion;
        }
        else if (typeCode == 0x83)
        {
            // TODO cache?
            // bounded string

            size_t size = SerializeHelper::readSize(buffer, control);

            std::tr1::shared_ptr<Field> sp(
                        new BoundedString(size));
            Helper::cache(this, sp);
            return sp;
        }
        else
            throw std::invalid_argument("invalid type encoding");
    }
    else // array
    {
        bool isVariable = (scalarOrArray == 0x08);
        // bounded == 0x10;
        bool isFixed = (scalarOrArray == 0x18);

        size_t size = (isVariable ? 0 : SerializeHelper::readSize(buffer, control));

        if (typeCode < 0x80)
        {
            // Type type = Type.scalarArray;
            int scalarType = decodeScalar(code);
            if (scalarType == -1)
                throw std::invalid_argument("invalid scalarArray type encoding");
            if (isVariable)
                return scalarArrays[scalarType];
            else if (isFixed)
            {
                // TODO use std::make_shared
                std::tr1::shared_ptr<Field> sp(
                            new FixedScalarArray(static_cast<epics::pvData::ScalarType>(scalarType), size));
                Helper::cache(this, sp);
                return sp;
            }
            else
            {
                // TODO use std::make_shared
                std::tr1::shared_ptr<Field> sp(
                            new BoundedScalarArray(static_cast<epics::pvData::ScalarType>(scalarType), size));
                Helper::cache(this, sp);
                return sp;
            }
        }
        else if (typeCode == 0x80)
        {
            // TODO fixed and bounded array support
            if (!isVariable)
                throw std::invalid_argument("fixed and bounded structure array not supported");

            // Type type = Type.structureArray;
            StructureConstPtr elementStructure = std::tr1::static_pointer_cast<const Structure>(control->cachedDeserialize(buffer));
            // TODO use std::make_shared
            std::tr1::shared_ptr<Field> sp(new StructureArray(elementStructure));
            Helper::cache(this, sp);
            return sp;
        }
        else if (typeCode == 0x81)
        {
            // TODO fixed and bounded array support
            if (!isVariable)
                throw std::invalid_argument("fixed and bounded structure array not supported");

            // Type type = Type.unionArray;
            UnionConstPtr elementUnion = std::tr1::static_pointer_cast<const Union>(control->cachedDeserialize(buffer));
            // TODO use std::make_shared
            std::tr1::shared_ptr<Field> sp(new UnionArray(elementUnion));
            Helper::cache(this, sp);
            return sp;
        }
        else if (typeCode == 0x82)
        {
            // TODO fixed and bounded array support
            if (!isVariable)
                throw std::invalid_argument("fixed and bounded structure array not supported");

            // Type type = Type.unionArray; variant union (aka any type)
            return variantUnionArray;
        }
        else
            throw std::invalid_argument("invalid type encoding");
    }
}

const FieldCreatePtr & epics::pvData::FieldCreate::getFieldCreate ( )

static

Definition at line 1619 of file FieldCreateFactory.cpp.

{
    epicsThreadOnce(&field_factory_once, &field_factory_init, 0);
    if(!field_factory_s->fieldCreate)
        throw std::logic_error("getFieldCreate() not initialized");
    return field_factory_s->fieldCreate;
}

Friends And Related Function Documentation

friend struct detail::field_factory

friend

Definition at line 1251 of file pvIntrospect.h.

friend class Field

friend

Definition at line 1407 of file pvIntrospect.h.

---

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

• modules/pvData/src/pv/pvIntrospect.h
• modules/pvData/src/factory/FieldCreateFactory.cpp