You can find the tutorial of Boost Parameter library here: www.boost.org/libs/parameter/index.html

 

Here: roland.pri.ee/boost/parameter/ are the files that I have changed.

All changes are marked with comments //roland or //roland start and //roland end.

The update is written for Boost version 1.33.1. Right now I'm merging it with Boost 1.34.1, where also Boost.Parameter library has changed, in some other aspects.

 

 

The update for Boost.Parameter enables one to write code like this:

 

//  updating the parameter array in func2:
func1() {
   func2((arg1 = value1, arg3 = value3));
}
func2(Params p) {
   func3((p, arg2 = value2, arg3 = value3));    //this replace of "arg3" does not change the original variable that were assigned to "p[arg3]" in previous caller, so that for example the variable "value3" in func1() remains unchanged.
   func4((arg2 = value2, p));    //ordering of "p" is not fixed in 

parameter list
   func5((arg1 = value1, p));    //but the following rule applies: if "p" appears later than the explicit call arguments (arg1), then the members of p, that overlap the the explicit call arguments, will replace the the explicit call arguments, so in this case the assignment arg1 = value1 has no effect on the parameter list of the func5, unless the "p" sometimes also may be without arg1.

} 

 

//  changing the value of some argument in "p". New value may have different type, association with old value is lost.
func1() {
   func2((arg1 = value));
}
func2(Params p) {
   func3((p, arg1 = new_value));
} 

 

//  one can also remove arguments from "p" :
func1() {
   func2((arg1 = value));
}
func2(Params p) {
   func3((p.unset(arg1)));
   func4((p.unset(arg1), arg2 = value));
}
    

This update gives one possibility to use functions which "forward" their parameter arrays to next functions. These functions may act as some kind of "filters", for example. When one has some kind of data processing pipeline, then it essentially has entire row of such "filters" calling each other. Intermediate filters do not have to know all arguments that are set by previous callers for reading in some later processing stages.

 

I have also added a lot of optional macros, which I will not list here all right now.
I mention some of them:

 

NO_PARAMS - one can use it if the func1() does not have arguments for func2(), but wants to call it.
P_ISSET(key) - available for template metaprogramming 

UNSET_P(p, key) - same, as p.unset(key)
P_GET(varname, key) - defines variable varname, which has type selected according to the type of p[key], and assigns the value of p[key] to that variable.
P_MEMFUN(return_T, name) - for member function definition. If one wants to have "standard" interface to one's member functions, then the code is easier to read without seeing the details, as they never change.
P_FUN(return_T, name) - same for functions.

1) On võimalik tekitada funktsioone, mis forwardivad oma argumente massiivis p järgmistele funktsioonidele, võibolla töötlevad mõnda argumenti või lisavad, kuid ei pea olema teadlikud kogu massiivi sisust. Seega saavad need funktsioonid olla kui "filtrid", mis võivad asuda andmetöötlusvoo erinevates piirkondades ning on kergesti ringitõstetavad-lisatavad.

2) Kirjutada lakoonilisemat koodi.

3) Minu "Pipelines and Signalling" libra sõltub sellest Boost.Parameter täiendusest suuresti.