[Massiv-devel] IDL

[Marek V. <mvo...@ce...>]

Cau,

zamyslel jsem se nad tim, co by mel umet IDL parser.
V zasade jsou dve moznosti:

1) v IDL bude nejak jednoduse popsana kazda trida vsectne presnych typu
vsech atributu + informace
    o kvantovani, presnostech,...;
    nekde v generatoru bude tabulka popisujici serializace: [typ] ->
[serializer]

    vygenerovani factory pro dany typ znamena rozvinout definici typu /
tridy podle zadanych (template) parametru.
    to obnasi nutnost rozumet template parametrum a stanovit si omezeni, co
se za parametry smi pouzivat;
    prakticky asi tezko libovolne C++ template parametry (napr. A<
&tabulka[20] >).

2) v IDL se jen popisou nazvy properties a base classes, ostatni se prenese
na prekladac C++;
    informace o replikacich by byly napsany primo do daneho typu;
    melo by fungovat vsechno, libovolne dedicnosti, template parametry;

    funkce pro serializaci serializovatelnych typu:
        serialize( Int32<parametry> & i );
        serialize( ... );

    ^^ v C++ pro kazdy serializovatelny typ overloadnuta funkce.

    funkce pro serializaci property:

        serialize( PPointer<parametry> & p );
        serialize( PVector<T> & v ) // T je serializable typ a pro jeho
serializaci se pouzije nektera z predchozich funkci
        {
        "for each item" serialize( v[i] );
        }

    vyhodou zde je to, ze je srozumitelne receno, jakym zpusobem se popisuji
replikacni parametry
    (-> jako template parametry serializable typu); to, ze generator
factories vubec nemusi rozumet typum
    a instanciovat ty tridy, staci mu nazvy properties; funguji vsechny
mozne template parametry,
    a je srozumitelne receno, jak jsou pojmenovany class factories.

    priklad:

    // nejaky objekt, ktery chceme spravovat

    template <class T>
    class O
        {
        T property;
        };

    // popis v IDL:
    template <class T>    // okopirovano z C++
    O = property;

    // vygenerovana factory:
    template <class T> // okopirovano z IDL
    class OFactory
        {
        static O * create()
            {
            return new O();
            }

        static void serialize()
            {
            serialize( property );
            // ^^ tady prekladac sam rozpozna typ property a pouzije
spravnou serializaci,
            //      nemusi to zjistovat generator
            }
        }

konstrukce objektu: OFactory<PInteger>::create(

poznamka na zaver:
    ve skutecnosti by od kazde funkce serialize bylo nekolik verzi
serialize,
    ktere bud provedou serializaci na sit, do souboru, nebo jinak.

Osobne jsem pro 2), zejmena proto, ze to neprinasi, zadne omezeni na to, co
si muze programator
ve scriptu napsat, jednoduse se prida novy typ property aniz by se muselo
delat neco s generatorem, ...

-- Markoid