Unustasid parooli?



     
Sisseloginud kasutajatele märgistatakse automaatselt teksti piirkonnad, mis on muutunud alates viimasest lugemisest. Lisandunud osa on roheline, eemaldatud osa punane.
Lisaks märgistatakse sisseloginud kasutajatele menüüs täiendavate värvide abil artiklid, mis on kasutajal loetud (hall), ning artiklid, mis on peale lugemist täienenud (roheline).

   

     

Pealkiri :
Id (lühend aadressiribale) :
Autor ja viimase muudatuse autor :
Loomise aeg ja viimane muudatus :
Teksti pikkus :
Luba ligipääs ainult kasutajanimedele (eralda komadega). Autoril on alati ligipääs. :




An update for Boost.Parameter, short overview in English
 
 
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.
 
 
---
 
 
Boost Parameter libra edasiarendus, lühiülevaade eesti keeles
 
Boost Parameter libra tutvustus on siin: www.boost.org/libs/parameter/index.html
 
Siin: roland.pri.ee/boost/parameter/ on minu poolt muudetud failid.
Kõik muudatused on märgitud kommentaaridega //roland või //roland start ja //roland end.
Alusmaterjaliks kasutasin Boost'i versiooni 1.33.1. Praegu tegelen sellega, et ühendada neid täiendusi Boost'i versioon 1.34.1-ga, milles ka Boost.Parameeter on mõnes muus funktsionaalsuses muutunud.
 
 
Täiendused on järgmised:
  • Parameetrit p (argumentide massiivi) võib väljakutsutud funktsioonis täiendada, muuta ja sellest argumente eemaldada:
    • //  massiivi täiendamine func2-s:
      func1() {
         func2((arg1 = vaartus));
      }
      func2(Params p) {
         func3((p, arg2 = vaartus));
         func4((arg2 = vaartus, p));    //p paigutus nimekirjas pole fikseeritud, kuid tuleks arvestada, et kui p esineb hiljem, siis p-s sisalduvad argumendid kirjutavad üle enne p-d antud samanimelised argumendid, kui neid leidub.
      }
    • //  argumendi muutmine. Uus väärtus võib olla ka uut tüüpi, vana väärtusega seos kaotatakse.
      func2(Params p) {
         func3((p, arg1 = uusvaartus));
      }
    • //  massiivist argumendi eemaldamine:
      func2(Params p) {
         func3((p.unset(arg1)));
         func4((p.unset(arg1), arg2 = vaartus));
      }
         
  • Lisatud mõned macrod. Need täiendused on kõik failis macros.hpp.
    • NO_PARAMS - saab kasutada väljakutsuvas funktsioonis argumentide puudumisel
    • P_ISSET(key) - template metaprogrammeerimise tarbeks
    • UNSET_P(p, key) - sama, mis p.unset(key)
    • P_GET(varname, key) - defineerib muutuja varname, mille tüüp tuletatakse automaatselt p-s sisalduva argumendi tüübist ning salvestab sinna p[key] väärtuse.
    • PARAMETER_TYPE(name) - annab argumendi name typename
    • PARAMETER_TYPE_D(name, default_T) - võimalus määrata vaikimisi väärtuse tüüp
    • PARAMETER_TYPEF(name, T_out) - sisuliselt typedef
    • PARAMETER_TYPEF_D(name, T_out, default_T)
    • PARAMETER_TYPE_NR(name) - sama, mis PARAMETER_TYPE, aga andmetüübilt eemaldatakse reference, kui see esineb
    • PARAMETER_TYPE_D_NR(name, default_T)
    • PARAMETER_TYPEF_NR(name, T_out)
    • PARAMETER_TYPEF_D_NR(name, T_out, default_T)
    • PARAMETER_TYPE_NT(name) - sama, mis PARAMETER_TYPE, aga ilma typename keywordita
    • PARAMETER_TYPE_D_NT(name, default_T)
    • IF_P_ISSET(key) - if(P_ISSET(key)), kuid lülitab välja kompilaatori hoiatuse, et if() lause sees on konstant.
    • IFN_P_ISSET(key) - if(!P_ISSET(key))
    • IF_P_ISSET_S(key) { .... } - Lülitab {  } vahel oleva koodibloki kompileerimisse ainult siis, kui argument key on seatud. Töötab ainult Visual Studio 2005 kompilaatoriga.
    • IFN_P_ISSET_S(key) - kompileerib järgneva bloki, kui argumenti ei ole seatud. Töötab ainult Visual Studio 2005 kompilaatoriga.
    • IF_P_ISSET_S2(key1, key2) - lülitab bloki kompileerimisse, kui vähemalt üks argumentidest on antud
    • IFN_P_ISSET_S2(key1, key2) - lülitab koodi kompileerimisse, kui kumbki argumentidest pole antud
    • P_LAZY(varname, key, lazyfunc) - töötab ainult Visual Studio 2005 kompilaatoriga. Kui argument key pole antud, võetakse muutuja varname väärtus ja tüüp lazyfunc poolt tagastatavast tulemusest.
    • P_GET_(varname, key) - sama, mis P_GET, mõnikord aitab loetavusele kaasa
    • P_GETD(varname, key, default_value) - PARAMETER_TYPE_D(key, default_T) varname = p[key | default_value]; - Tuleks arvestada, et kui default_value on funktsioon, siis paistab minu kogemuse järgi nõnda, et see kutsutakse p[key | default_value] piirkonnas välja ka siis, kui argument on antud.
    • P_GETD2(varname, key, default_T, default_value) - juhul, kui on soov ise vaikimise väärtuse tüüp määrata.
    • BOOST_AUTO_LVALUE(var, expr) - BOOST_LVALUE_TYPEOF(exp) var = expr. Kasutab Boost'i typeof librat.
    • P_MEMFUN2(return_T, name)
    • P_FUN(return_T, name)
    • P_MEMFUN_O_DECL(return_T, name)
    • P_MEMFUN_O(return_T, name)
    • P_MEMFUN_DECL(return_T, name)
    • P_MEMFUN(return_T, name)
    • P_MEMFUN_CO_DECL(return_T, name)
    • P_MEMFUN_CO(return_T, name)
    • P_MEMFUN_C_DECL(return_T, name)
    • P_MEMFUN_C(return_T, name)
    • P_MEMFUN_I(return_T, name)
    • P_MEMFUN_CI(return_T, name)
Tänu neile täiendustele:
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.
 
 
 
--- 
 
 








kommentaarium spämmi tõttu ajutiselt välja lülitatud





Teised tekstid samas jaotuses:  ||  Pipelines and signalling  ||  Boost.Preprocessor suurendatud limiitidega  ||  SSE vektorarvutuse libra  ||  PHP to C++ converter  ||  



  Saada kiri