Re: [Boost-users] Generic indexing by "const char *"

From: Joseph Fradley (joe.fradley_at_[hidden])
Date: 2008-01-29 11:46:37

Ovanes,

That's pretty neat, I never knew you could do that. But I don't think
it gets me there. If I'm coming in with an unknown const char *, I can
get the extern equivalent via looping through a global registry doing
strcmp()s. But once I get my index into the registry I can't place it
into the template specification ( such as "TypeId<typeid_registry[i]>
v;").

Also I was hoping to create all the required stuff via a single MACRO
per class member, for example I was hoping to create something like
this:

class Point
{
   getMemberValue()
   {
      INDEX_MACRO(x)
      INDEX_MACRO(y)
   }

   int x;
   int y;
}

Using the templated TypeId struct I have to define a whole lot of
extern's out of the class and function declarations inside the class
for each member.

And probably the toughest problem with this, how to create a simple
way to "expand the tree" of all possible access() functions. For
example, if I'm coming in with an index of "corner:x" into Rectangle
object,  I don't want to know about a Point just an int. So, I would
need a special type just for "corner:x" and a access() function that
takes this type and return a int.

In case you're interested below is what I came up with (minus the
MACROs and minus it being able to compile). Thanks for you help, I
probably have to think of a different solution.

template<const char*>
struct TypeId
{};

///header
// for Point
extern const char    x[] = "x";
extern const char    y[] = "y";
typedef TypeId<x>          x_Accessor;
typedef TypeId<y>          y_Accessor;

// for Rectangle
extern const char  corner[] = "corner";
extern const char  width[]  = "width";
extern const char  height[] = "height";
typedef TypeId<corner>          corner_Accessor;
typedef TypeId<width>            width_Accessor;
typedef TypeId<height>          height_Accessor;

extern const char  corner_x[] = "corner:x";
extern const char  corner_y[] = "corner:y";
typedef TypeId<corner_x>		corner_x_Accessor;
typedef TypeId<corner_y>		corner_y_Accessor;

extern const char *typeid_registry[] =
{
                x,
                y,
                corner,
                width,
                height,
                corner_x,
                corner_y,
                NULL
};

struct PointClass
{
        // get
        int access(x_Accessor)
        {
                return x;
        }
        int access(y_Accessor)
        {
                return y;
        }
        // set
        void set(x_Accessor, int value)
        {
                x = value;
        }
        void set(y_Accessor, int value)
        {
                y = value;
        }
        
        int x;
        int y;
};

struct RectangleClass
{
        // get
        int access(width_Accessor)
        {
                return width;
        }
        int access(height_Accessor)
        {
                return height;
        }
        PointClass access(corner_Accessor)
        {
                return corner;
        }
        int access(corner_x_Accessor)
        {
                return corner.x;
        }
        int access(corner_y_Accessor)
        {
                return corner.y;
        }

        // set
        void set(width_Accessor, int value)
        {
                width = value;
        }
        void set(height_Accessor, int value)
        {
                height = value;
        }
        void set(corner_Accessor, PointClass value)
        {
                corner = value;
        }
        void set(corner_x_Accessor, int value)
        {
                corner.x = value;
        }
        void set(corner_y_Accessor, int value)
        {
                corner.y = value;
        }

        
        int width;
        int height;
        PointClass corner;
};

struct BlobClass
{
        // a whole lot of access()/set() functions
        
        RectangleClass	boundingBox;
        int				centroid;
        float			mass;
};

int main(void)
{
    RectangleClass rc;

    rc.corner.x = 55;
    rc.corner.y = 66;
    rc.width = 77;
    rc.height = 88;

    std::string simpleSrcKey = "width";
    std::string simpleDestKey = "corner:x";

    for(int srci = 0; typeid_registry[srci] != NULL; ++srci)
    {
            if(!strcmp(typeid_registry[srci], simpleSrcKey.c_str() ))
            {
                    for(int dsti = 0; typeid_registry[dsti] != NULL; ++dsti)
                    {
                            if(!strcmp(typeid_registry[dsti], simpleDestKey.c_str() ))
                            {
                                TypeId<typeid_registry[0]> dst;
                                TypeId<typeid_registry[0]> src;
                                rc.set(dst, rc.access(src));
                            }    			
                    }
            }
    }

    return 0;
}

On 1/29/08, Ovanes Markarian <om_boost_at_[hidden]> wrote:
> Yes, you can define your types based on const char* and overload template
> functions on them.
>
>
> //using structs to skip explicit public access specifiers
>
> ///header
> extern const char  SomeName[];
>
> template<const char*>
>  struct TypeId
> {};
>
>
> typedef TypeId<SomeName>          MemberX_Accessor;
>
>
>
> struct ClassWithMembers
> {
>     void access(MemberX_Accessor)
>     {
>       ...
>     }
>
>     template<class T>
>      void access(T)
>     {
>         /// issue error here, no accessor specified!!!
>     }
>
>    private:
>       MemberX        x;
> };
>
>
> ///cpp
> extern const char SomeName[] ="memberX";
>
>
> I hope that example brings you to some useful ideas.
>
>
>
> Regards,
> Ovanes
>
>
>
>
> On Jan 29, 2008 3:34 PM, Joseph Fradley <joe.fradley_at_[hidden]> wrote:
>
> >
> >
> > I have a problem that I would like to solve in the most generic
> non-intrusive way possible (such as boost serialization). What I want is to
> access class members both via it's initially designed accessors but also via
> a "const char *"  key. In addition, I want to pass list of key's (via a
> vector of const char * or a single delimited multikey char *) to get nested
> member access.
> >
> > For example:
> > ...
> > // these should be equivalent
> > Point p;
> > int val;
> > val = p.x;
> > val = p.getX();
> > p.getMemberValue("x", val);
> >
> > // there also
> > Rectangle r;
> > int val;
> > Point pVal;
> > r.getMemberValue("corner:x", val);
> > r.getMemberValue("corner", pVal);
> >
> >
> > I thought about having a templated function similar to the serialize()
> function called 'getMemberValue()', where each 'if' block below could be
> wrapped into a MACRO taking just the member name.
> >
> > template< class T >
> > bool getMemberValue(const char *key, T & value)
> > {
> >         if(!strcmp(key, "member"))
> >         {
> >             value = this->member;
> >             return true;
> >         }
> >         return false;
> > }
> >
> > This appears to work fine for one level deep but if I want the behavior
> such as the above rectangle example, I run into trouble. I end up with a
> function implementation like this for the 'Rectangle' class
> >
> > template< Point >
> > bool getMemberValue(const char *key, Point & value)
> > {
> >         if(!strcmp(key, "corner"))
> >         {
> >             value = this->corner;  // Point
> >             return true;
> >         }
> >         if(!strcmp(key, "width"))
> >         {
> >             value = this->width;  // int
> >             return true;
> >         }
> >         if(!strcmp(key, "height"))
> >         {
> >             value = this->height; // int
> >             return true;
> >         }
> >         return false;
> > }
> >
> > This fails because it ends up trying to set an integer value to a Point
> variable.
> >
> > Anybody have any suggestions?
> >
> >
> > Joe
> >
> >
> >
> >
> > _______________________________________________
> > Boost-users mailing list
> > Boost-users_at_[hidden]
> > http://lists.boost.org/mailman/listinfo.cgi/boost-users
> >
>
>
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users
>