Talk:V4 CA Interfaces

Some comments from Andrew Johnson:

In your presentation about CA V4, you included the method channel::createAllPropertiesReadRequest(). I agree that we need a way to be able to read all of the properties available from the server for a particular PV name, but I want more flexibility than just being able to put that wild-card at the top of my request.

I think we need the ability to be able to subscribe with a property catalog having a specific set of properties at one level but to wild-card a sub-property catalog at some level below. Is this currently possible? If not, please consider this a request to add that capability, which might then remove the need for the seperate createAllPropertiesReadRequest() method. I'm only looking for you to support "*", no pattern matching or regex stuff.

Some comments from Jeff Hill:

During our meeting I raised a question; do we may need a Data Access interface allowing traversal of the structure of the property hierarchy, learning the native type of the properties, but not require instances of the properties?

There may be legitimate situations where the property catalog egg must come before the property catalog chicken. Furthermore, it might be quite inconvenient from a memory management perspective to require an instance of an array before it is really used. I think that this negative could be perhaps minimized if we state in the CA manual that the array bounds alone will be examined, and the array elements will not be traversed, when scanning a property catalog to learn its structure.

Probably the only negative associated with adding a property catalog structure traverse capability to the interface would be that the application would need to provide one additional function. They are already providing an immutable traverse, a mutable traverse function, and an immutable find function. What is vexing is that all three of the traverse functions are nearly identical. Personally, I don’t like to see common code managed with cut and paste. I am even less fond of that eventuality should it be repeated for many, many data structures in a proliferation of applications.

So I had a look at what level of Data Access library support might be provided so that they need write the guts of the traverse function once. The following is an example of how they might structure their application. There are still three traverse functions because cross library binding requires the virtual base class interfaced technique, but now they can use a template to implement the traversing only once.

This level of complication appears to be reasonable for end user applications.

PropertyId propertyX;
PropertyId propertyY;
PropertyId propertyZ;
PropertyId propertyI;

class MyContainer : private PropertyCatalog {
public:

private:
    int x;
    float y;
    double z;
    char i;
    static void traverse ( 
        PropertyDescriptionViewer & );
    void traverse ( 
        PropertyManipulator & );
    void traverse ( 
        PropertyViewer & ) const;
    bool find ( 
        const PropertyId & id, PropertyViewer & ) const;
    template < class REFERENCE, class MANIPULATOR >
    static void traverseTempl ( 
        const REFERENCE &, MANIPULATOR & );
};

template < class REFERENCE, class MANIPULATOR >
inline void MyContainer::traverseTempl ( 
    const REFERENCE & ref, MANIPULATOR & manipulator )
{
    ref.reveal ( 
        manipulator, propertyX, & MyContainer::x );
    ref.reveal ( 
        manipulator, propertyY, & MyContainer::y );
    ref.reveal ( 
        manipulator, propertyZ, & MyContainer::x );
    ref.reveal ( 
        manipulator, propertyI, & MyContainer::i );
}

void MyContainer::traverse ( 
    PropertyManipulator & manipulator ) 
{
    MyContainer::traverseTempl ( 
        reference < MyContainer > ( *this ), manipulator );
}

void MyContainer::traverse ( 
    PropertyViewer & viewer ) const 
{
    MyContainer::traverseTempl ( 
        reference < const MyContainer > ( *this ), viewer );
}

void MyContainer::traverse ( 
    PropertyDescriptionViewer & viewer )
{
    MyContainer::traverseTempl ( reference < void > (), viewer );
}
    
bool MyContainer::find ( 
    const PropertyId & id, 
    PropertyManipulator < Property > & manipulator ) const 
{
    bool status = false;
    if ( id == propertyX ) {
    	manipulator.reveal ( 
    	    Property < const int > ( propertyX, this->x ) );
        status = true;
    }
    else ( id == propertyY ) {
    	manipulator.reveal ( 
    	    Property < const int > ( propertyY, this->y ) );
        status = true;
    }
    return status;
}

Here are the interface details.

class PropertyId;
class ArraySegment;
class StringSegment;
class EnumStateSet;
class PropertyCatalog;
class PropertyCatalog;
class Time;

class PropertyId {
};

extern class PropertyCatalog & voidCatalog;

class PropertyViewer {
public:
    virtual void reveal ( const PropertyId &, 
        const double &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const int &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const unsigned int &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const long &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const unsigned long &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const Time &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const StringSegment &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const EnumStateSet & )  = 0;
    virtual void reveal ( const PropertyId &, 
        const ArraySegment &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        const PropertyCatalog & )  = 0;
};

template < class T >
class TypedVoid {
};

class PropertyDescriptionViewer {
public:
    virtual void reveal ( const PropertyId &, 
        TypedVoid < float > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < double > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < char > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < signed char > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < unsigned char > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < short > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < unsigned short > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < int > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < unsigned int > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < long > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < unsigned long > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < Time > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < StringSegment > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < EnumStateSet > & )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < ArraySegment > &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        TypedVoid < PropertyCatalog > & )  = 0;
};

class PropertyManipulator {
public:
    virtual void reveal ( const PropertyId &, 
        float &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        double &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        char &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        signed char &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        unsigned char &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        short &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        unsigned short &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        int &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        unsigned int &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        long &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        unsigned long &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        Time &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        StringSegment &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        EnumStateSet & )  = 0;
    virtual void reveal ( const PropertyId &, 
        ArraySegment &, const PropertyCatalog & = voidCatalog )  = 0;
    virtual void reveal ( const PropertyId &, 
        PropertyCatalog & )  = 0;
};

class PropertyCatalog {
public:
    virtual void traverse ( 
        PropertyManipulator & ) = 0;
    virtual void traverse ( 
        PropertyViewer & ) const = 0;
    // false returned when the property does not exist, otherwise true
    virtual bool find ( 
        const PropertyId & id, PropertyViewer & ) const = 0;
};

// ----------------- void property catalog implementation ---------------------------

class VoidContainer : public PropertyCatalog {
    void traverse ( 
        PropertyManipulator & ) {}
    void traverse ( 
        PropertyViewer & ) const {}
    // false returned when the property does not exist, otherwise true
    bool find ( 
        const PropertyId & id, PropertyViewer & ) const 
    {
        return false;
    }
};

VoidContainer aVoidContainer;
class PropertyCatalog & voidCatalog = aVoidContainer;

// --------------------------- begin reference implemenation --------------------------

template < class T >
class reference
{
public:
    reference ( T & ref ) : 
      _ref ( ref ) 
    {
    }
    template < class M >
    void reveal ( 
        PropertyManipulator & manipulator,
        const PropertyId & id, M ( T :: * p ), 
        PropertyCatalog & subordinates = voidCatalog ) const
    {
        manipulator.reveal (
            id, _ref.*p, subordinates );
    }
private:
    T & _ref;
};

template < class T >
class reference < const T >
{
public:
    reference ( const T & ref ) : 
      _ref ( ref ) 
    {
    }
    template < class M >
    void reveal ( 
        PropertyViewer & viewer,
        const PropertyId & id, M ( T :: * p ), 
        const PropertyCatalog & subordinates = voidCatalog ) const
    {
        viewer.reveal (
            id, _ref.*p, subordinates );
    }
private:
    const T & _ref;
};

template <>
class reference < void >
{
public:
    template < class T, class M >
    void reveal ( 
        PropertyDescriptionViewer & viewer,
        const PropertyId & id, M ( T :: * p ), 
        const PropertyCatalog & subordinates = voidCatalog ) const
    {
        viewer.reveal (
            id, TypedVoid < M > (), subordinates );
    }
};