Uniform Property Definition

Abstract

Uniform Property Definition is what I call defining Properties by macros. I developed this "technique" to reduce coding overhead and to help with the implementation of my Reflection classes.

Motivation

While implementing classes with a lot of properties I getting tired of writing code which felt very repetetive and redundant like the following:

class Person{
private:
    std::string _firstName;
    std::string _lastName;
public:
    std::string getFirstName()const{return _firstName;}
    void setFirstName(const std::string value){_firstName=value;}
    const std::string & firstName()const{return _firstName;}
    std::string & firstName(){return _firstName;}


    std::string getLastName()const{return _lastName;}
    void setLastName(const std::string value){_lastName=value;}

};

Obviously everthing repeats, like the Name of the property's getter and setter methods, the fieldname and the reference access method's name. Also the datatype is used excrutiatingly much. this is especially unnerving for me when the datatypes are long like std::map<std::string, std::map<std::string, std::vector<std::string>>> .

My wish was to only write information once like so:

PROPERTY(std::string, FirstName)

First Iteration

The first Implementation, which is currently used widely in my project, follows a very structured build up of macros.

See Members.h. It is documented which is good, since the macros are nested pretty deeply.

Second Iteration

Motivation

I am not happy with the first Iteration. The type information is still used too much, for every statement like the following:

... .h
PROPERTY(int,NumberVariable);
REFERENCES(int,NumberVariable);

... .cpp
void ClassName::propertyChanging(int, NumberVariable){
}

Also Macros do not take kindly to too many commas when passing argument, macros are after all just part of a "stupid" or I guess "simple" preprocessor language.

This causes problems when passing a type which includes commas; namely templated types with multiple template arguments :

std::map<std::string, std::string>

A statement like the previous would destroy the macros...

Idea

Typedef the type once, and make it so that it is easy to write and read.

What I wanted:

std::map<std::string,std::string> PROPERTY(MyMapVariable);

which will also generate all the getter and setter code and fields. Also I want to be able to specify the storage type:

std::map<std::string,std::string> PROPERTY(MyMapVariable STORAGE(REFERENCE));

std::map<std::string,std::string> PROPERTY(MyMapVariable STORAGE(CALLBACKS(mySetCallback, myGetCallback));

std::map<std::string,std::string> PROPERTY(MyMapVariable STORAGE(POINTER));

std::map<std::string,std::string> PROPERTY(MyMapVariable STORAGE(FIELD));

This was hard to do with the limited preprocessor capabilities.

You can see my first tries in reflection.cpp where I solved the type definition problem by using decltype and a unused static method.

Another simplification I wanted/needed was allowing access to the pointcuts when properties change/are retrieved.

Generally three events are only interesting as illustrated in pseudo code:

void setProperty(PropertyType value){
    // before property is set
    if(onBeforePropertySet(value))return;
    store property
    // after property is set 
    onAfterPropertySet(value);

}
PropertyType getProperty()const{
    onBeforePropertyGet();
    return retrieve property;
    // nothing can happen here
}

This would be relatively easy to write but I want it to be easy to use:

[...]//inside struct/class

int PROPERTY(MyProperty);


beforeGet(MyProperty){
    cout<< _MyProperty << endl;
}
beforeSet(MyProperty){
    cout << "MyProperty changing: "<<_MyProperty<<" -> "<< value<<endl;
}
afterSet(MyProperty){

}

A further constraint is that I want the compiler to optimize away all code that is not needed --> if beforeSet(...) is not defined i want the if() statement to be removed.

Also it has to be fast (optional virtual methods, everything inlineable) .

I found a couple of nice approaches, all of which were not standard compatible because either they rely on __if_exists() (MSVC) which executes code only if a symbol is defined or

non-standard templating: specializing class template methods inside class.

So my solution is based on an almost unspectacular technique: method overloading.

To be continued...