Marco van de Voort wrote:
I found a png, but can't seem to find the original file (it is in .dia
format), will have to search for it.
http://www.stack.nl/~marcov/decalhier.png
If you can't find the eps - or never had any - I can create one on my own
(using xfig).
Anyway, here is a patch for the tex file which fixes
- unwanted extra } at the end of code line
- some small errors in the text
- unwanted spaces in \emph and \textbf
- removed tabs in code
- fixed new paragraphs starting in the middle of a sentence
Still remaining problems are:
- the lstlisting environment doesn't highlight Pascal properly
- some lines of code are too long
and I probably have overlooked some remaning errors of course.
Perhaps the lstlisting should be replaced by some command from fpc.sty?
The use of TVarRec has it's disadvantages when it comes to speed and memory
usage, but definitely makes things easier for the programmer. I think only
Generics can beat that! I don't know whether the internals of Decal are bulky,
but that doesn't result simply from using TVarRec.
Btw TVarRec is only 8 bytes in size, where variants require 16, so it isn't
/that/ bad :)
Anyway, for high perfomance it is better to store only a pointer. In that case
the programmer has to inform the container about the type it actually stores
(or pass a custom comparator) so the container knows how to compare items.
Besides containers, there is also the SuperStream library, which seems to be
very nice too. For this library, the use of TVarRec makes life easier too.
Though maybe using RTTI and published properties can be easier, the scheme of
SuperStream is very powerful.
Note for people searching for .pas sources: the original sources from Soletta
are on http://cvs.sourceforge.net/viewcvs.py/decal/ and are also (modified) on
fpc cvs/contrib
(http://www.freepascal.org/cgi-bin/viewcvs.cgi/contrib/decal/?root=projects).
Regards,
Bram
304c304,306
< Guide section of this manual fairly
---
> Guide
> section of this manual fairly
>
376,378c378
< \item As an archive, downloaded from the internet. The original sources from
< Soletta are on the following CVS repository on SourceForge:
< \url{http://cvs.sourceforge.net/viewcvs.py/decal/}
---
> \item As an archive, downloaded from the internet
737c737
< For I := 0 to list.count - 1 do
---
> For I := 0 to list.count -- 1 do
742c742
< For I := 0 to list.count - 1 do
---
> For I := 0 to list.count -- 1 do
826c826
< Function GenMix(ptr : Pointer) : DObject;
---
> Procedure GenMix;
839c839
< case obj.vtype of
---
> case obj.vtype of}
932c932
< the objects (it is a \emph{shallow} copy of the arr container).
---
> the objects (it is a \`{\i}shallow\^{\i} copy of a the arr container).
1062c1062
< \section{Lesson 5 -- Using Maps (Key-Value Pairs)}
---
> \section{Lesson 5 -- Using Maps (Key-Value Pairs}
1163c1163
< Writeln(`Found Ted Jones, whose id is `, emp.id);
---
> Writeln(`Found Ted Jones, whose id is `, emp.id;
1202c1202
< For I := 1 to 50 do
---
> For I := 1 to 50 do}
1280c1280
< Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee(
getObject(obj2)).name);
---
> Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee(
> getObject(obj2)).name));
1348c1348
< For I := 1 to 10 do
---
> For I := 1 to 10 do}
1402c1402
< Since we really want remove to run fast, we change our data structure
---
> Since we really want that remove to run fast, we change our data structure
1481c1481
< Result := TEmployee(getObject(obj)).salary >= 50000;
---
> Result := TEmployee(getObject(obj)).salary $>$= 50000;
1487c1487
< Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee(
getObject(obj2)).name);
---
> Result := CompareText(TEmployee( getObject(obj1)).name, TEmployee(
> getObject(obj2)).name));
1639c1639
< Figure 1 shows the SDL container class hierarchy.
---
> Figure 1 shows the SDL container class hierarchy:
1734c1734,1736
< When you retrieve an iterator from one of these containers, the iterator will
---
> When
>
> you retrieve an iterator from one of these containers, the iterator will
1877,1878c1879,1880
< \textbf{zero} if obj1 equals obj2, and
< \textbf{greater than zero} if obj1 is greater than obj2.
---
> \textbf{zero} if obj2 equals obj2, and
> \textbf{greater than zero} if obj2 is greater than obj1.
1885c1887
< ACar := asObject(obj1) as TCar
---
> ACar := asObject(obj1) as TCar}
1893c1895
< Result := TCar(obj1.VObject).FValue - TCar(obj2.VObject).FValue;
---
> Result := TCar(obj2.VObject)^.FValue - TCar(obj1.VObject)^.FValue;
2044c2046
< PushFront(item)
---
> PushFront(item)}
2059c2061
< PopBack
---
> PopBack}
2138,2139c2140,2141
< use the correct form with assertions. Note that it doesn't make any sense to
< try to add elements directly to a map (because you haven't supplied the
---
> use the correct form with assertions. Note that is doesn't make any sense to
> try to add elements directly to a map (because you haven't) supplied the
2141c2143
< to a set (because there isn't any value).
---
> to a set(because there isn't any value).
2164c2166
< them don't need to be overridden -- there are default implementations. Those
---
> them don't need to overridden -- there are default implementations. Those
2182c2184
< \lstinline|Container.add([value]);|
---
> \lstinline$Container.add([value]);$
2216c2218
< // no advancement necessary - but don't reuse the iterator once
---
> // no advancement necessary -- but don't reuse the iterator once
2238,2239c2240,2242
< \subsection{Why does SDL use functions instead of class members for its
algorithms
< (and for iterator operations?)}
---
> \subsection{Why does SDL use functions instead of class members for its
> algorithms}
>
> (and for iterator operations?)
2326c2329
< \lstinline|procedure uniqueInWithTo(_start, _end, dest : DIterator; compare :
DBinaryTest);|
---
> \lstinline|procedure uniqueInWithTo(\_start, \_end, dest : DIterator; compare
> : DBinaryTest);|
2338c2341
< procedure forEachIn(_start, _end : DIterator; unary : DApply);
---
> procedure forEachIn(\_start, \_end : DIterator; unary : DApply);
2340c2343
< procedure forEachInIf(_start, _end : DIterator; unary : DApply; test : DTest);
---
> procedure forEachInIf(\_start, \_end : DIterator; unary : DApply; test :
> DTest);
2354c2357
< given (not including the item at the \_end position).
---
> given (not including the item at the \_end position).
2366,2367c2369,2370
< function _inject(container : DContainer; const obj : DObject; binary :
DBinary) : DObject;
< function _injectIn(_start, _end : DIterator; const obj : DObject; binary :
DBinary) : DObject;
---
> function \_inject(container : DContainer; const obj : DObject; binary :
> DBinary) : DObject;
> function \_injectIn(\_start, \_end : DIterator; const obj : DObject; binary :
> DBinary) : DObject;
2369c2372
< function injectIn(_start, _end : DIterator; obj : array of const; binary :
DBinary) : DObject;
---
> function injectIn(\_start, \_end : DIterator; obj : array of const; binary :
> DBinary) : DObject;
2413c2416
< function _median(const obj1, obj2, obj3 : DObject; compare : DComparator) :
DObject;
---
> function \_median(const obj1, obj2, obj3 : DObject; compare : DComparator) :
> DObject;
2454,2455c2457,2458
< function copyInTo(_start, _end, output : DIterator) : DIterator;
< function copyBackward(_start, _end, output : DIterator) : DIterator;
---
> function copyInTo(\_start, \_end, output : DIterator) : DIterator;
> function copyBackward(\_start, \_end, output : DIterator) : DIterator;
2461c2464
< \textbf{CopyTo} copies the contents of con1 to the iterator given. The
---
> \textbf{ CopyTo} copies the contents of con1 to the iterator given. The
2476c2479
< function countIn(_start, _end : DIterator; objs : array of const) : Integer;
---
> function countIn(\_start, \_end : DIterator; objs : array of const) : Integer;
2478c2481
< function countIfIn(_start, _end : DIterator; test : DTest) : Integer;
---
> function countIfIn(\_start, \_end : DIterator; test : DTest) : Integer;
2489c2492
< \textbf{CountIf}
---
> \textbf{ CountIf}
2493c2496
< \textbf{CountIfIn } determines the number of items in the range \_start to
---
> \textbf{ CountIfIn } determines the number of items in the range \_start to
2502c2505
< procedure fillIn(_start, _end : DIterator; obj : array of const);
---
> procedure fillIn(\_start, \_end : DIterator; obj : array of const);
2519c2522
< procedure generateIn(_start, _end : DIterator; gen : DGenerator);
---
> procedure generateIn(\_start, \_end : DIterator; gen : DGenerator);
2533c2536
< Function uniqueIn(_start, _end : DIterator) : DIterator;
---
> Function uniqueIn(\_start, \_end : DIterator) : DIterator;
2535c2538
< Function uniqueInWith(_start, _end : DIterator; compare : DBinaryTest) :
DIterator;
---
> Function uniqueInWith(\_start, \_end : DIterator; compare : DBinaryTest) :
> DIterator;
2537,2538c2540,2541
< Function uniqueInTo(_start, _end, dest : DIterator) : DIterator;
< Function uniqueInWithTo(_start, _end, dest : DIterator; compare :
DBinaryTest) :DIterator;
---
> Function uniqueInTo(\_start, \_end, dest : DIterator) : DIterator;
> Function uniqueInWithTo(\_start, \_end, dest : DIterator; compare :
> DBinaryTest) :DIterator;
2551c2554
< function FilterInTo(_start, _end, dest : DIterator; test : DTest) : DIterator;
---
> function FilterInTo(\_start, \_end, dest : DIterator; test : DTest) :
> DIterator;
2566,2567c2569,2570
< function adjacentFindIn(_start, _end : DIterator) : DIterator;
< function adjacentFindInWith(_start, _end : DIterator; compare : DBinaryTest)
: DIterator;
---
> function adjacentFindIn(\_start, \_end : DIterator) : DIterator;
> function adjacentFindInWith(\_start, \_end : DIterator; compare :
> DBinaryTest) : DIterator;
2579c2582
< function binarySearchIn(_start, _end : DIterator; obj : array of const) :
DIterator;
---
> function binarySearchIn(\_start, \_end : DIterator; obj : array of const) :
> DIterator;
2581c2584
< function binarySearchInWith(_start, _end : DIterator; compare : DComparator;
obj : array of const) : DIterator;
---
> function binarySearchInWith(\_start, \_end : DIterator; compare :
> DComparator; obj : array of const) : DIterator;
2592c2595
< function detectInWith(_start, _end : DIterator; compare : DTest) : DIterator;
---
> function detectInWith(\_start, \_end : DIterator; compare : DTest) :
> DIterator;
2603c2606
< function everyIn(_start, _end : DIterator; test : DTest) : Boolean;
---
> function everyIn(\_start, \_end : DIterator; test : DTest) : Boolean;
2614c2617
< function findIn(_start, _end : DIterator; obj : array of const) : DIterator;
---
> function findIn(\_start, \_end : DIterator; obj : array of const) : DIterator;
2616c2619
< function findIfIn(_start, _end : DIterator; test : DTest) : DIterator;
---
> function findIfIn(\_start, \_end : DIterator; test : DTest) : DIterator;
2627c2630
< function someIn(_start, _end : DIterator; test : DTest) : Boolean;
---
> function someIn(\_start, \_end : DIterator; test : DTest) : Boolean;
2640c2643
< procedure objFreeIn(_start, _end : DIterator);
---
> procedure objFreeIn(\_start, \_end : DIterator);
2650c2653
< procedure objDisposeIn(_start, _end : DIterator);
---
> procedure objDisposeIn(\_start, \_end : DIterator);
2673c2676
< function orderedHashIn(_start, _end : DIterator) : Integer;
---
> function orderedHashIn(\_start, \_end : DIterator) : Integer;
2690c2693
< function unorderedHashIn(_start, _end : DIterator) : Integer;
---
> function unorderedHashIn(\_start, \_end : DIterator) : Integer;
2704c2707
< function removeIn(_start, _end : DIterator; objs : array of const) :
DIterator;
---
> function removeIn(\_start, \_end : DIterator; objs : array of const) :
> DIterator;
2706c2709
< function removeInTo(_start, _end, output : DIterator; objs : array of const)
: DIterator;
---
> function removeInTo(\_start, \_end, output : DIterator; objs : array of
> const) : DIterator;
2718c2721
< function removeCopyIn(_start, _end, output : DIterator; objs : array of
const) :DIterator;
---
> function removeCopyIn(\_start, \_end, output : DIterator; objs : array of
> const) :DIterator;
2721c2724
< function removeCopyIfIn(_start, _end, output : DIterator; test : DTest) :
DIterator;
---
> function removeCopyIfIn(\_start, \_end, output : DIterator; test : DTest) :
> DIterator;
2731c2734
< function removeIfIn(_start, _end : DIterator; test : DTest) : DIterator;
---
> function removeIfIn(\_start, \_end : DIterator; test : DTest) : DIterator;
2733c2736
< function removeIfInTo(_start, _end, output : DIterator; test : DTest) :
DIterator;
---
> function removeIfInTo(\_start, \_end, output : DIterator; test : DTest) :
> DIterator;
2746c2749
< function replaceIn(_start, _end : DIterator; objs1, objs2 : array of const)
:Integer;
---
> function replaceIn(\_start, \_end : DIterator; objs1, objs2 : array of const)
> :Integer;
2758c2761
< function replaceCopyInTo(_start, _end, output : DIterator; objs1, objs2 :
array of const) : Integer;
---
> function replaceCopyInTo(\_start, \_end, output : DIterator; objs1, objs2 :
> array of const) : Integer;
2761c2764
< function replaceCopyIfInTo(_start, _end, output : DIterator; test : DTest;
objs :array of const) : Integer;
---
> function replaceCopyIfInTo(\_start, \_end, output : DIterator; test : DTest;
> objs :array of const) : Integer;
2765c2768
< item that matches obj1 with obj2 as it copies. The If variants use test to
---
> item that matches obj1 with obj2 as it copies. The IF variants use test to
2772c2775
< function replaceIfIn(_start, _end : DIterator; test : DTest; objs : array of
const) :Integer;
---
> function replaceIfIn(\_start, \_end : DIterator; test : DTest; objs : array
> of const) :Integer;
2784c2787
< procedure reverseIn(_start, _end : DIterator);
---
> procedure reverseIn(\_start, \_end : DIterator);
2795c2798
< procedure reverseCopyInTo(_start, _end, output : DIterator);
---
> procedure reverseCopyInTo(\_start, \_end, output : DIterator);
2848a2852
>
2850a2855
>
2900c2905
< procedure randomShuffleIn(_start, _end : DIterator);
---
> procedure randomShuffleIn(\_start, \_end : DIterator);
2912c2917
< procedure sortIn(_start, _end : DIterator);
---
> procedure sortIn(\_start, \_end : DIterator);
2914c2919
< procedure sortInWith(_start, _end : DIterator; comparator : DComparator);
---
> procedure sortInWith(\_start, \_end : DIterator; comparator : DComparator);
2926c2931
< procedure stablesortIn(_start, _end : DIterator);
---
> procedure stablesortIn(\_start, \_end : DIterator);
2928c2933
< procedure stablesortInWith(_start, _end : DIterator; comparator :
DComparator);
---
> procedure stablesortInWith(\_start, \_end : DIterator; comparator :
> DComparator);
2931c2936
< StableSort sorts the items in the container or range, and maintains (without
---
> StableSort sorts the items in the container or range, an maintains (without
2962c2967
< function collectIn(_start, _end : DIterator; unary : DUnary) : DContainer;
---
> function collectIn(\_start, \_end : DIterator; unary : DUnary) : DContainer;
2987c2992
< function transformunaryInTo(_start, _finish, output : DIterator; unary :
DUnary) :DIterator;
---
> function transformunaryInTo(\_start, \_finish, output : DIterator; unary :
> DUnary) :DIterator;
2991c2996,2998
< in a container or range, and stores the results in an output area.
---
> in a container or range, and stored
>
> the results in an output area.
3007c3014,3016
< Object, Class, WideChar, PWideChar, String, Currency, WideString
---
> Object, Class, WideChar,
>
> PWideChar, String, Currency, WideString
3057c3066,3068
< \lstinline|function JenkinsHashBuffer(const buffer; length : Integer; initVal
: Integer) :Integer;|
---
> \begin{lstlisting}
> function JenkinsHashBuffer(const buffer; length : Integer; initVal : Integer)
> :Integer;
> \end{lstlisting}
3061,3062c3072
< pointer to some variable, and you want to hash the variable, use the \verb|^|
< notation to dereference the pointer.
---
> pointer to some variable, and you want to hash the variable, use the \^
> notation.
3070c3080
< Return the hash value for a \textbf{single} value.
---
> Return the hash value for a \textbf{ single} value.
3074c3084
< Return the hash value for a \textbf{double} value.
---
> Return the hash value for a \textbf{ double} value.
3146a3157
>
3158c3169
< (the first one), Delphi passes an \emph{invisible parameter}, self, as the
---
> (the first one), Delphi passes an \_invisible parameter\_, self, as the
3195c3206
< a_pointer_i_want_to_pass));
---
> a\_pointer\_i\_want\_to\_pass));
3281c3292
< each item. This is nice when you're printing objects.
---
> each item. This is nice when you're print objects.
3287c3298
< SDL contains numerous assertions throughout its code. In the binary release
---
> SDL contains numerous assertions throughout its code. In the binary release
3294,3295c3305,3306
< normal activity; for this reason, you never need to turn off \emph{break on
< exception} while working with SDL. Most SDL exceptions will contain a
---
> normal activity; for this reason, you never need to turn off \`{\i}break on
> exception\^{\i} while working with SDL. Most SDL exceptions will contain a
3360,3362c3371,3373
< public
< s,t : String;
< end;
---
> public
> s,t : String;
> end;
3364a3376
>
3367c3379
< end;
---
> end;}
3422,3426c3434,3438
< public
< s,t : String;
< yipe : Integer;
< constructor Create;
< end;
---
> public
> s,t : String;
> yipe : Integer;
> constructor Create;
> end;
3428c3440
< constructor TTest.Create;
---
> constructor TTest.Create;}
3430c3442
< s := `zonk';
---
> s := `zonk';}
3435a3448
>
3442,3443c3455,3456
< var
< test : TTest;
---
>
> var test : TTest;
3454a3468
>
3468c3482
< Your transfer function will always receive a pointer \emph{obj} to the
---
> Your transfer function will always receive a pointer (\emph{obj} to the
3480c3494
< know whether a read or write is in progress. \emph{Version} indicates the
---
> know whether a read or write is in progress. \emph{Version } indicates the
3484c3498
< object to the latest version. \emph{CallSuper} is an advanced variable --
---
> object to the latest version. \emph{CallSuper } is an advanced variable --
3498c3512
< function. The third is the \emph{tip version} of the object. When reading
---
> function. The third is the \emph{tip version } of the object. When reading
3520c3534
< WriteObjectToFile and ReadObjectInFile are both \emph{class methods}
---
> WriteObjectToFile and ReadObjectInFile are both \emph{class methods }
3548,3551c3562,3565
< TExtra = class(TTest)
< public
< d : Integer;
< end;
---
> TExtra = class(TTest)
> public
> d : Integer;
> end;
3555c3569
< \textbf{d}, to TTest's definition.
---
> \textbf{ d}, to TTest's definition.
3573c3587
< Now let's create a routine that puts a TTest, a TExtra, and another TTest
---
> Now let's create a routine that puts a TTest, a TExtra, and another TText
3615c3629
< whether it \emph{owns} the stream it is wrapping. If the object stream owns
---
> whether it \emph{owns } the stream it is wrapping. If the object stream owns
3621,3622c3635,3636
< Note that we created the object stream with a \emph{true} value for the
< \emph{owned} parameter. When we free this object stream, it will
---
> Note that we created the object stream with a \emph{true } value for the
> \emph{owned } parameter. When we free this object stream, it will
3644a3659
>
3646,3649c3661,3664
< Int1, int2 : Integer;
< T : TTest;
< Constructor Create;
< End;
---
> Int1, int2 : Integer;
> T : TTest;
> Constructor Create;
> End;
3651a3667
>
3659a3676
>
3661,3664c3678,3681
< with obj as TEmbed do
< stream.TransferItems([int1, int2, t],
< [EMAIL PROTECTED], @int2, @t],
< direction, version);
---
> with obj as TEmbed do
> stream.TransferItems([int1, int2, t],
> [EMAIL PROTECTED], @int2, @t],
> direction, version);
3668,3669c3685,3686
< var
< e : TEmbed;
---
>
> var e : TEmbed;
3696,3699d3712
< Type
< TBase = class
< I1, i2 : Integer;
< End;
3701,3703c3714
< TDerived = class(TBase)
< S : String;
< End;
---
> Type
3705,3707c3716,3726
< TAnother = class(TDerived)
< Toast : String;
< End;
---
> TBase = class
> I1, i2 : Integer;
> End;
>
> TDerived = class(TBase)
> S : String;
> End;
>
> TAnother = class(TDerived)
> Toast : String;
> End;
3710a3730
>
3717a3738
>
3724a3746
>
3747c3769
< d.i2 := 201;
---
> d.i2 := 201;}
3764d3785
< \end{lstlisting}
3769d3789
< \begin{verbatim}
3770a3791
>
3771a3793
>
3773c3795
< \end{verbatim}
---
>
3778c3800
< object, preventing the superclass from doing anything.
---
> object, preventing the subclass from doing anything.
3843c3865
< The two transferItems calls are identical, except for an additional open array
---
> The two transferItems calls are identical, except for an addition open array
3897d3918
< \end{lstlisting}
3900,3901d3920
<
< \begin{lstlisting}
3923,3928c3942,3947
< TSpecial = class
< Int1, int2 : Integer;
< St : String;
< When : TDateTime;
< R : Single;
< End;
---
> TSpecial = class
> Int1, int2 : Integer;
> St : String;
> When : TDateTime;
> R : Single;
> End;
3931a3951
>
3935,3937c3955,3957
< [EMAIL PROTECTED], @r, @int1, @int2, @st],
< [ssvtDateTime, ssvtSingle],
< direction, version);
---
> [EMAIL PROTECTED], @r, @int1, @int2, @st],
> [ssvtDateTime, ssvtSingle],
> direction, version);
3941,3942c3961,3962
< var
< s : TSpecial;
---
>
> var s : TSpecial;
3951c3971
< s.when := Now;
---
> s.when := Now;}
3978,3985c3998,4005
< TRaw = class
< FNames : Integer;
< FName : array[1..25] of String;
< FAddresses : array[1..25] of String;
< FEmployees : array[1..25] of TEmployee;
< FBitmapSize : Integer;
< FBitmapData : Pointer;
< End;
---
> TRaw = class
> FNames : Integer;
> FName : array[1..25] of String;
> FAddresses : array[1..25] of String;
> FEmployees : array[1..25] of TEmployee;
> FBitmapSize : Integer;
> FBitmapData : Pointer;
> End;
3988a4009
>
3993c4014
< direction,version);
---
> direction,version);
3995,3996c4016,4017
< [EMAIL PROTECTED], @FAddresses[1],
@FEmployees[1]],
< [25, 25, 25],direction);
---
> [EMAIL PROTECTED], @FAddresses[1], @FEmployees[1]],
> [25, 25, 25],direction);
4004,4005c4025,4026
< var
< r : TRaw;
---
>
> var r : TRaw;
4027c4048
< parameters: the \textbf{first} item in each array (which is used to get
---
> parameters: the \textbf{ first} item in each array (which is used to get
4029c4050
< (which is used to figure out where everything is), the \textbf{number} of
---
> (which is used to figure out where everything is), the \textbf{ number } of
4039c4060
< The only wrinkle in this example is that during a \textbf{read}, we need to
---
> The only wrinkle in this example is that during a (\textbf{read}, we need to
4050c4071
< You may have a \emph{complex object graph} -- which is a bunch of objects
---
> You may have a \emph{complex object graph } -- which is a bunch of objects
4063,4065c4084,4086
< FHello : String;
< Inside : TTwo;
< End;
---
> FHello : String;
> Inside : TTwo;
> End;
4068,4070c4089,4091
< Inside : TOne;
< Ouch : String;
< End;
---
> Inside : TOne;
> Ouch : String;
> End;
4073a4095
>
4081a4104
>
4085c4108
< version);
---
> version);
4088a4112
>
4090a4115
>
4096,4097c4121,4122
< o.FHello := `hello';
< o.inside := t;
---
> o.FHello := `hello';}
> o.inside := t;}
4122,4124c4147,4149
< Name, address : String;
< Salary : Integer;
< End;
---
> Name, address : String;
> Salary : Integer;
> End;
4127a4153
>
4131c4157
< direction, version);
---
> direction, version);
4135,4136c4161,4162
< var
< a : TAppObject;
---
>
> var a : TAppObject;
4155,4158c4181,4184
< TAppObject = class
< Name, Address : STring;
< SalaryHigh : Boolean;
< End;
---
> TAppObject = class
> Name, Address : STring;
> SalaryHigh : Boolean;
> End;
4162,4163c4188,4189
< var
< oldSalary : Integer;
---
>
> var oldSalary : Integer;
4168,4174c4194,4200
< stream.transferItems([name, address, oldSalary],
< [EMAIL PROTECTED], @address,@oldSalary],
direction, version);
< SalaryHigh := oldSalary > HighSalaryValue;
< end;
< 2: with obj as TAppObject do
< stream.transferItems([name, address, salaryHigh],
< [EMAIL PROTECTED], @address,@salaryHigh],
direction, version);
---
> stream.transferItems([name, address, oldSalary], [EMAIL PROTECTED],
> @address,
> @oldSalary], direction, version);
>
> SalaryHigh := oldSalary $>$ HighSalaryValue;
> end;
> 2: with obj as TAppObject do
> stream.transferItems([name, address, salaryHigh], [EMAIL PROTECTED],
> @address,@salaryHigh], direction, version);
4179,4180c4205,4207
< var
< a : TAppObject;
---
>
> var a : TAppObject;
>
4193c4220
< we just perform conventional IO. If we're reading an old object (which is
---
> we just perform convention IO. If we're reading an old object (which is
4284c4311
< objects. It is a subclass of Delphi's TList class, with an additional property
---
> objects. It is a subclass of Delphi's TList class, with an addition property
_______________________________________________
fpc-devel maillist - fpc-devel@lists.freepascal.org
http://lists.freepascal.org/mailman/listinfo/fpc-devel
