00001 {*********************************************************}
00002 { }
00003 { Zeos Database Objects }
00004 { Variant Processing Classes }
00005 { }
00006 { Originally written by Sergey Seroukhov }
00007 { }
00008 {*********************************************************}
00009
00010 {@********************************************************}
00011 { Copyright (c) 1999-2006 Zeos Development Group }
00012 { }
00013 { License Agreement: }
00014 { }
00015 { This library is distributed in the hope that it will be }
00016 { useful, but WITHOUT ANY WARRANTY; without even the }
00017 { implied warranty of MERCHANTABILITY or FITNESS FOR }
00018 { A PARTICULAR PURPOSE. See the GNU Lesser General }
00019 { Public License for more details. }
00020 { }
00021 { The source code of the ZEOS Libraries and packages are }
00022 { distributed under the Library GNU General Public }
00023 { License (see the file COPYING / COPYING.ZEOS) }
00024 { with the following modification: }
00025 { As a special exception, the copyright holders of this }
00026 { library give you permission to link this library with }
00027 { independent modules to produce an executable, }
00028 { regardless of the license terms of these independent }
00029 { modules, and to copy and distribute the resulting }
00030 { executable under terms of your choice, provided that }
00031 { you also meet, for each linked independent module, }
00032 { the terms and conditions of the license of that module. }
00033 { An independent module is a module which is not derived }
00034 { from or based on this library. If you modify this }
00035 { library, you may extend this exception to your version }
00036 { of the library, but you are not obligated to do so. }
00037 { If you do not wish to do so, delete this exception }
00038 { statement from your version. }
00039 { }
00040 { }
00041 { The project web site is located on: }
00042 { http:
00043 { http:
00044 { svn:
00045 { }
00046 { http:
00047 { http:
00048 { }
00049 { }
00050 { }
00051 { Zeos Development Group. }
00052 {********************************************************@}
00053
00054 unit ZVariant;
00055
00056 interface
00057
00058 {$I ZCore.inc}
00059
00060 uses
00061 {$IFDEF MSWINDOWS}
00062 Windows,
00063 {$ENDIF}
00064 Classes, SysUtils, ZCompatibility, ZClasses, ZSysUtils;
00065
00066 const
00067 {** Precision for float values comparison }
00068 FLOAT_COMPARE_PRECISION = 1.e-5;
00069
00070 type
00071 {** Defines variant types. }
00072 TZVariantType = (vtNull, vtBoolean, vtInteger, vtFloat, vtString,
00073 vtUnicodeString, vtDateTime, vtPointer, vtInterface);
00074
00075 {** Defines a variant structure. }
00076 TZVariant = packed record
00077 VType: TZVariantType;
00078 VBoolean: Boolean;
00079 VInteger: Int64;
00080 VFloat: Extended;
00081 VString: AnsiString;
00082 VUnicodeString: WideString;
00083 VDateTime: TDateTime;
00084 VPointer: Pointer;
00085 VInterface: IZInterface;
00086 end;
00087
00088 {** Defines an array of variants. }
00089 TZVariantDynArray = array of TZVariant;
00090
00091 {** Defines a variant processing exception. }
00092 EZVariantException = class (Exception);
00093
00094 {** Defines an interface for variant data. }
00095 {** Defines a Variant Manager interface. }
00096 IZVariantManager = interface (IZInterface)
00097 ['{DAA373D9-1A98-4AA8-B65E-4C23167EE83F}']
00098
00099 function IsNull(const Value: TZVariant): Boolean;
00100 procedure SetNull(var Value: TZVariant);
00101
00102 function Convert(const Value: TZVariant; NewType: TZVariantType): TZVariant;
00103 procedure Assign(const SrcValue: TZVariant; var DstValue: TZVariant);
00104 function Clone(const Value: TZVariant): TZVariant;
00105 function Compare(const Value1, Value2: TZVariant): Integer;
00106
00107 function GetAsBoolean(const Value: TZVariant): Boolean;
00108 function GetAsInteger(const Value: TZVariant): Int64;
00109 function GetAsFloat(const Value: TZVariant): Extended;
00110 function GetAsString(const Value: TZVariant): AnsiString;
00111 function GetAsUnicodeString(const Value: TZVariant): WideString;
00112 function GetAsDateTime(const Value: TZVariant): TDateTime;
00113 function GetAsPointer(const Value: TZVariant): Pointer;
00114 function GetAsInterface(const Value: TZVariant): IZInterface;
00115
00116 procedure SetAsBoolean(var Value: TZVariant; Data: Boolean);
00117 procedure SetAsInteger(var Value: TZVariant; Data: Int64);
00118 procedure SetAsFloat(var Value: TZVariant; Data: Extended);
00119 procedure SetAsString(var Value: TZVariant; const Data: AnsiString);
00120 procedure SetAsUnicodeString(var Value: TZVariant; const Data: WideString);
00121 procedure SetAsDateTime(var Value: TZVariant; Data: TDateTime);
00122 procedure SetAsPointer(var Value: TZVariant; Data: Pointer);
00123 procedure SetAsInterface(var Value: TZVariant; Data: IZInterface);
00124
00125 function OpAdd(const Value1, Value2: TZVariant): TZVariant;
00126 function OpSub(const Value1, Value2: TZVariant): TZVariant;
00127 function OpMul(const Value1, Value2: TZVariant): TZVariant;
00128 function OpDiv(const Value1, Value2: TZVariant): TZVariant;
00129 function OpMod(const Value1, Value2: TZVariant): TZVariant;
00130 function OpPow(const Value1, Value2: TZVariant): TZVariant;
00131 function OpAnd(const Value1, Value2: TZVariant): TZVariant;
00132 function OpOr(const Value1, Value2: TZVariant): TZVariant;
00133 function OpXor(const Value1, Value2: TZVariant): TZVariant;
00134 function OpNot(const Value: TZVariant): TZVariant;
00135 function OpNegative(const Value: TZVariant): TZVariant;
00136 function OpEqual(const Value1, Value2: TZVariant): TZVariant;
00137 function OpNotEqual(const Value1, Value2: TZVariant): TZVariant;
00138 function OpMore(const Value1, Value2: TZVariant): TZVariant;
00139 function OpLess(const Value1, Value2: TZVariant): TZVariant;
00140 function OpMoreEqual(const Value1, Value2: TZVariant): TZVariant;
00141 function OpLessEqual(const Value1, Value2: TZVariant): TZVariant;
00142 end;
00143
00144 {** Implements a variant manager with strict convertion rules. }
00145 TZDefaultVariantManager = class (TInterfacedObject, IZVariantManager)
00146 protected
00147 procedure RaiseTypeMismatchError;
00148 procedure RaiseUnsupportedOperation;
00149 public
00150 function Convert(const Value: TZVariant; NewType: TZVariantType): TZVariant;
00151 virtual;
00152 procedure Assign(const SrcValue: TZVariant; var DstValue: TZVariant);
00153 function Clone(const Value: TZVariant): TZVariant;
00154 function Compare(const Value1, Value2: TZVariant): Integer;
00155
00156 function IsNull(const Value: TZVariant): Boolean;
00157 procedure SetNull(var Value: TZVariant);
00158
00159 function GetAsBoolean(const Value: TZVariant): Boolean;
00160 function GetAsInteger(const Value: TZVariant): Int64;
00161 function GetAsFloat(const Value: TZVariant): Extended;
00162 function GetAsString(const Value: TZVariant): AnsiString;
00163 function GetAsUnicodeString(const Value: TZVariant): WideString;
00164 function GetAsDateTime(const Value: TZVariant): TDateTime;
00165 function GetAsPointer(const Value: TZVariant): Pointer;
00166 function GetAsInterface(const Value: TZVariant): IZInterface;
00167
00168 procedure SetAsBoolean(var Value: TZVariant; Data: Boolean);
00169 procedure SetAsInteger(var Value: TZVariant; Data: Int64);
00170 procedure SetAsFloat(var Value: TZVariant; Data: Extended);
00171 procedure SetAsString(var Value: TZVariant; const Data: AnsiString);
00172 procedure SetAsUnicodeString(var Value: TZVariant; const Data: WideString);
00173 procedure SetAsDateTime(var Value: TZVariant; Data: TDateTime);
00174 procedure SetAsPointer(var Value: TZVariant; Data: Pointer);
00175 procedure SetAsInterface(var Value: TZVariant; Data: IZInterface);
00176
00177 function OpAdd(const Value1, Value2: TZVariant): TZVariant;
00178 function OpSub(const Value1, Value2: TZVariant): TZVariant;
00179 function OpMul(const Value1, Value2: TZVariant): TZVariant;
00180 function OpDiv(const Value1, Value2: TZVariant): TZVariant;
00181 function OpMod(const Value1, Value2: TZVariant): TZVariant;
00182 function OpPow(const Value1, Value2: TZVariant): TZVariant;
00183 function OpAnd(const Value1, Value2: TZVariant): TZVariant;
00184 function OpOr(const Value1, Value2: TZVariant): TZVariant;
00185 function OpXor(const Value1, Value2: TZVariant): TZVariant;
00186 function OpNot(const Value: TZVariant): TZVariant;
00187 function OpNegative(const Value: TZVariant): TZVariant;
00188 function OpEqual(const Value1, Value2: TZVariant): TZVariant;
00189 function OpNotEqual(const Value1, Value2: TZVariant): TZVariant;
00190 function OpMore(const Value1, Value2: TZVariant): TZVariant;
00191 function OpLess(const Value1, Value2: TZVariant): TZVariant;
00192 function OpMoreEqual(const Value1, Value2: TZVariant): TZVariant;
00193 function OpLessEqual(const Value1, Value2: TZVariant): TZVariant;
00194 end;
00195
00196 {** Implements a variant manager with soft convertion rules. }
00197 TZSoftVariantManager = class (TZDefaultVariantManager)
00198 public
00199 function Convert(const Value: TZVariant; NewType: TZVariantType): TZVariant;
00200 override;
00201 end;
00202
00203 type
00204
00205 {** Represents any value interface. }
00206 IZAnyValue = interface (IZClonnable)
00207 ['{E81988B3-FD0E-4524-B658-B309B02F0B6A}']
00208
00209 function IsNull: Boolean;
00210 function GetValue: TZVariant;
00211
00212 function GetBoolean: Boolean;
00213 function GetInteger: Int64;
00214 function GetFloat: Extended;
00215 function GetString: AnsiString;
00216 function GetUnicodeString: WideString;
00217 function GetDateTime: TDateTime;
00218 end;
00219
00220 {** Implements an any value object. }
00221 TZAnyValue = class(TZAbstractObject, IZAnyValue, IZComparable)
00222 private
00223 FValue: TZVariant;
00224 public
00225 constructor Create(const Value: TZVariant);
00226 constructor CreateWithBoolean(Value: Boolean);
00227 constructor CreateWithInteger(Value: Int64);
00228 constructor CreateWithFloat(Value: Extended);
00229 constructor CreateWithString(const Value: AnsiString);
00230 constructor CreateWithUnicodeString(const Value: WideString);
00231 constructor CreateWithDateTime(Value: TDateTime);
00232
00233 function IsNull: Boolean;
00234 function GetValue: TZVariant;
00235
00236 function GetBoolean: Boolean;
00237 function GetInteger: Int64;
00238 function GetFloat: Extended;
00239 function GetString: AnsiString;
00240 function GetUnicodeString: WideString;
00241 function GetDateTime: TDateTime;
00242
00243 function Equals(const Value: IZInterface): Boolean; override;
00244 function Clone: IZInterface; override;
00245 function ToString: string; override;
00246 end;
00247
00248 {**
00249 Encodes a custom variant value into standard variant.
00250 @param Value a custom variant value to be encoded.
00251 @returns an encoded standard variant.
00252 }
00253 function EncodeVariant(const Value: TZVariant): Variant;
00254
00255 {**
00256 Encodes an array of custom variant values into array of standard variants.
00257 @param Value an array of custom variant values to be encoded.
00258 @returns an encoded array of standard variants.
00259 }
00260 function EncodeVariantArray(const Value: TZVariantDynArray): Variant;
00261
00262 {**
00263 Decodes a standard variant value into custom variant.
00264 @param Value a standard variant value to be decoded.
00265 @returns an decoded custom variant.
00266 }
00267 function DecodeVariant(const Value: Variant): TZVariant;
00268
00269 {**
00270 Decodes an array of standard variant values into array of custom variants.
00271 @param Value an array of standard variant values to be decoded.
00272 @returns an decoded array of custom variants.
00273 }
00274 function DecodeVariantArray(const Value: Variant): TZVariantDynArray;
00275
00276 var
00277 {** Declares a default variant manager with strict convertion rules. }
00278 DefVarManager: IZVariantManager;
00279
00280 {** Declares a variant manager with soft convertion rules. }
00281 SoftVarManager: IZVariantManager;
00282
00283 {** A NULL Variant Value. }
00284 NullVariant: TZVariant;
00285
00286 implementation
00287
00288 uses
00289 {$IFNDEF VER130BELOW}
00290 Variants,
00291 {$ELSE}
00292 {$IFDEF FPC}
00293 Variants,
00294 {$ELSE}
00295 ActiveX,
00296 {$ENDIF}
00297 {$ENDIF}
00298 Math, ZMessages;
00299
00300 { TZDefaultVariantManager }
00301
00302 {**
00303 Assignes one variant value to another one.
00304 @param SrcValue a source variant value.
00305 @param DstValue a destination variant value.
00306 }
00307 procedure TZDefaultVariantManager.Assign(const SrcValue: TZVariant;
00308 var DstValue: TZVariant);
00309 begin
00310 DstValue.VType := SrcValue.VType;
00311 case SrcValue.VType of
00312 vtBoolean: DstValue.VBoolean := SrcValue.VBoolean;
00313 vtInteger: DstValue.VInteger := SrcValue.VInteger;
00314 vtFloat: DstValue.VFloat := SrcValue.VFloat;
00315 vtString: DstValue.VString := SrcValue.VString;
00316 vtUnicodeString: DstValue.VUnicodeString := SrcValue.VUnicodeString;
00317 vtDateTime: DstValue.VDateTime := SrcValue.VDateTime;
00318 vtPointer: DstValue.VPointer := SrcValue.VPointer;
00319 vtInterface: DstValue.VInterface := SrcValue.VInterface;
00320 end;
00321 end;
00322
00323 {**
00324 Clones a variant value.
00325 @param Value a source variant value.
00326 @returns a clonned variant value.
00327 }
00328 function TZDefaultVariantManager.Clone(const Value: TZVariant): TZVariant;
00329 begin
00330 Assign(Value, Result);
00331 end;
00332
00333 {**
00334 Raises a type mismatch exception.
00335 }
00336 procedure TZDefaultVariantManager.RaiseTypeMismatchError;
00337 begin
00338 raise EZVariantException.Create(STypesMismatch);
00339 end;
00340
00341 {**
00342 Raises an unsupported operation exception.
00343 }
00344 procedure TZDefaultVariantManager.RaiseUnsupportedOperation;
00345 begin
00346 raise EZVariantException.Create(SUnsupportedOperation);
00347 end;
00348
00349 {**
00350 Converts a specified variant value to a new type.
00351 @param Value a variant value to be converted.
00352 @param NewType a type of the result variant value.
00353 @returns a converted variant value.
00354 }
00355 function TZDefaultVariantManager.Convert(const Value: TZVariant;
00356 NewType: TZVariantType): TZVariant;
00357 begin
00358 Result.VType := NewType;
00359 case NewType of
00360 vtBoolean:
00361 case Value.VType of
00362 vtNull:
00363 Result.VBoolean := False;
00364 vtBoolean:
00365 Result.VBoolean := Value.VBoolean;
00366 else
00367 RaiseTypeMismatchError;
00368 end;
00369 vtInteger:
00370 case Value.VType of
00371 vtNull:
00372 Result.VInteger := 0;
00373 vtBoolean:
00374 if Value.VBoolean then
00375 Result.VInteger := 1
00376 else Result.VInteger := 0;
00377 vtInteger:
00378 Result.VInteger := Value.VInteger;
00379 else
00380 RaiseTypeMismatchError;
00381 end;
00382 vtFloat:
00383 case Value.VType of
00384 vtNull:
00385 Result.VFloat := 0;
00386 vtBoolean:
00387 if Value.VBoolean then
00388 Result.VFloat := 1
00389 else Result.VFloat := 0;
00390 vtInteger:
00391 Result.VFloat := Value.VInteger;
00392 vtFloat:
00393 Result.VFloat := Value.VFloat;
00394 else
00395 RaiseTypeMismatchError;
00396 end;
00397 vtString:
00398 case Value.VType of
00399 vtNull:
00400 Result.VString := '';
00401 vtString:
00402 Result.VString := Value.VString;
00403 vtUnicodeString:
00404 Result.VString := Value.VUnicodeString;
00405 else
00406 RaiseTypeMismatchError;
00407 end;
00408 vtUnicodeString:
00409 case Value.VType of
00410 vtNull:
00411 Result.VUnicodeString := '';
00412 vtString:
00413 Result.VUnicodeString := Value.VString;
00414 vtUnicodeString:
00415 Result.VUnicodeString := Value.VUnicodeString;
00416 else
00417 RaiseTypeMismatchError;
00418 end;
00419 vtDateTime:
00420 case Value.VType of
00421 vtNull:
00422 Result.VDateTime := 0;
00423 vtDateTime:
00424 Result.VDateTime := Value.VDateTime;
00425 else
00426 RaiseTypeMismatchError;
00427 end;
00428 vtPointer:
00429 case Value.VType of
00430 vtNull:
00431 Result.VPointer := nil;
00432 vtPointer:
00433 Result.VPointer := Value.VPointer;
00434 else
00435 RaiseTypeMismatchError;
00436 end;
00437 vtInterface:
00438 case Value.VType of
00439 vtNull:
00440 Result.VInterface := nil;
00441 vtInterface:
00442 Result.VInterface := Value.VInterface;
00443 else
00444 RaiseTypeMismatchError;
00445 end;
00446 end;
00447 end;
00448
00449 {**
00450 Compares two variant values.
00451 @param Value1 the first variant value.
00452 @param Value2 the second variant value.
00453 @return <0 if Value1 < Value 2, =0 if Value1 = Value2, >0 if Value1 > Value2
00454 }
00455 function TZDefaultVariantManager.Compare(const Value1,
00456 Value2: TZVariant): Integer;
00457 var
00458 TempFloat: Extended;
00459 TempDateTime: TDateTime;
00460 begin
00461 case Value1.VType of
00462 vtNull:
00463 begin
00464 if IsNull(Value2) then
00465 Result := 0
00466 else Result := -1;
00467 end;
00468 vtBoolean:
00469 begin
00470 if GetAsBoolean(Value2) then
00471 begin
00472 if Value1.VBoolean then
00473 Result := 0
00474 else Result := -1;
00475 end
00476 else
00477 begin
00478 if Value1.VBoolean then
00479 Result := 1
00480 else Result := 0;
00481 end;
00482 end;
00483 vtInteger:
00484 Result := Value1.VInteger - GetAsInteger(Value2);
00485 vtFloat:
00486 begin
00487 TempFloat := GetAsFloat(Value2);
00488 if Value1.VFloat - TempFloat < -FLOAT_COMPARE_PRECISION then
00489 Result := -1
00490 else if Value1.VFloat - TempFloat > FLOAT_COMPARE_PRECISION then
00491 Result := 1
00492 else Result := 0;
00493 end;
00494 vtString:
00495 Result := AnsiCompareStr(Value1.VString, GetAsString(Value2));
00496 vtUnicodeString:
00497 {$IFNDEF VER130BELOW}
00498 Result := WideCompareStr(Value1.VUnicodeString, GetAsUnicodeString(Value2));
00499 {$ELSE}
00500 Result := AnsiCompareStr(Value1.VUnicodeString, GetAsString(Value2));
00501 {$ENDIF}
00502 vtDateTime:
00503 begin
00504 TempDateTime := GetAsDateTime(Value2);
00505 if Value1.VDateTime < TempDateTime then
00506 Result := -1
00507 else if Value1.VDateTime > TempDateTime then
00508 Result := 1
00509 else Result := 0;
00510 end;
00511 vtPointer:
00512 Result := LongInt(Value1.VPointer) - GetAsInteger(Value2);
00513 else
00514 Result := 0;
00515 end;
00516 end;
00517
00518 {**
00519 Checks is the specified value NULL.
00520 @param Value a value to be checked.
00521 @returns <code>True</code> if variant has NULL value.
00522 }
00523 function TZDefaultVariantManager.IsNull(const Value: TZVariant): Boolean;
00524 begin
00525 Result := Value.VType = vtNull;
00526 end;
00527
00528 {**
00529 Sets the NULL value to specified variant.
00530 @param Value variant value to be set to NULL.
00531 }
00532 procedure TZDefaultVariantManager.SetNull(var Value: TZVariant);
00533 begin
00534 Value.VType := vtNull;
00535 end;
00536
00537 {**
00538 Gets a variant to boolean value.
00539 @param Value a variant to be converted.
00540 @param a result value.
00541 }
00542 function TZDefaultVariantManager.GetAsBoolean(
00543 const Value: TZVariant): Boolean;
00544 begin
00545 Result := Convert(Value, vtBoolean).VBoolean;
00546 end;
00547
00548 {**
00549 Gets a variant to integer value.
00550 @param Value a variant to be converted.
00551 @param a result value.
00552 }
00553 function TZDefaultVariantManager.GetAsInteger(
00554 const Value: TZVariant): Int64;
00555 begin
00556 Result := Convert(Value, vtInteger).VInteger;
00557 end;
00558
00559 {**
00560 Gets a variant to float value.
00561 @param Value a variant to be converted.
00562 @param a result value.
00563 }
00564 function TZDefaultVariantManager.GetAsFloat(
00565 const Value: TZVariant): Extended;
00566 begin
00567 Result := Convert(Value, vtFloat).VFloat;
00568 end;
00569
00570 {**
00571 Gets a variant to string value.
00572 @param Value a variant to be converted.
00573 @param a result value.
00574 }
00575 function TZDefaultVariantManager.GetAsString(
00576 const Value: TZVariant): AnsiString;
00577 begin
00578 Result := Convert(Value, vtString).VString;
00579 end;
00580
00581 {**
00582 Gets a variant to unicode string value.
00583 @param Value a variant to be converted.
00584 @param a result value.
00585 }
00586 function TZDefaultVariantManager.GetAsUnicodeString(
00587 const Value: TZVariant): WideString;
00588 begin
00589 Result := Convert(Value, vtUnicodeString).VUnicodeString;
00590 end;
00591
00592 {**
00593 Gets a variant to date and time value.
00594 @param Value a variant to be converted.
00595 @param a result value.
00596 }
00597 function TZDefaultVariantManager.GetAsDateTime(
00598 const Value: TZVariant): TDateTime;
00599 begin
00600 Result := Convert(Value, vtDateTime).VDateTime;
00601 end;
00602
00603 {**
00604 Gets a variant to pointer value.
00605 @param Value a variant to be converted.
00606 @param a result value.
00607 }
00608 function TZDefaultVariantManager.GetAsPointer(
00609 const Value: TZVariant): Pointer;
00610 begin
00611 Result := Convert(Value, vtPointer).VPointer;
00612 end;
00613
00614 {**
00615 Gets a variant to interface value.
00616 @param Value a variant to be converted.
00617 @param a result value.
00618 }
00619 function TZDefaultVariantManager.GetAsInterface(
00620 const Value: TZVariant): IZInterface;
00621 begin
00622 Result := Convert(Value, vtInterface).VInterface;
00623 end;
00624
00625 {**
00626 Assignes a boolean value to variant.
00627 @param Value a variant to store the value.
00628 @param Data a value to be assigned.
00629 }
00630 procedure TZDefaultVariantManager.SetAsBoolean(var Value: TZVariant;
00631 Data: Boolean);
00632 begin
00633 Value.VType := vtBoolean;
00634 Value.VBoolean := Data;
00635 end;
00636
00637 {**
00638 Assignes an integer value to variant.
00639 @param Value a variant to store the value.
00640 @param Data a value to be assigned.
00641 }
00642 procedure TZDefaultVariantManager.SetAsInteger(var Value: TZVariant;
00643 Data: Int64);
00644 begin
00645 Value.VType := vtInteger;
00646 Value.VInteger := Data;
00647 end;
00648
00649 {**
00650 Assignes a float value to variant.
00651 @param Value a variant to store the value.
00652 @param Data a value to be assigned.
00653 }
00654 procedure TZDefaultVariantManager.SetAsFloat(var Value: TZVariant;
00655 Data: Extended);
00656 begin
00657 Value.VType := vtFloat;
00658 Value.VFloat := Data;
00659 end;
00660
00661 {**
00662 Assignes a string value to variant.
00663 @param Value a variant to store the value.
00664 @param Data a value to be assigned.
00665 }
00666 procedure TZDefaultVariantManager.SetAsString(var Value: TZVariant;
00667 const Data: AnsiString);
00668 begin
00669 Value.VType := vtString;
00670 Value.VString := Data;
00671 end;
00672
00673 {**
00674 Assignes a unicode string value to variant.
00675 @param Value a variant to store the value.
00676 @param Data a value to be assigned.
00677 }
00678 procedure TZDefaultVariantManager.SetAsUnicodeString(var Value: TZVariant;
00679 const Data: WideString);
00680 begin
00681 Value.VType := vtUnicodeString;
00682 Value.VUnicodeString := Data;
00683 end;
00684
00685 {**
00686 Assignes a datetime value to variant.
00687 @param Value a variant to store the value.
00688 @param Data a value to be assigned.
00689 }
00690 procedure TZDefaultVariantManager.SetAsDateTime(var Value: TZVariant;
00691 Data: TDateTime);
00692 begin
00693 Value.VType := vtDateTime;
00694 Value.VDateTime := Data;
00695 end;
00696
00697 {**
00698 Assignes a pointer value to variant.
00699 @param Value a variant to store the value.
00700 @param Data a value to be assigned.
00701 }
00702 procedure TZDefaultVariantManager.SetAsPointer(var Value: TZVariant;
00703 Data: Pointer);
00704 begin
00705 Value.VType := vtPointer;
00706 Value.VPointer := Data;
00707 end;
00708
00709 {**
00710 Assignes a interface value to variant.
00711 @param Value a variant to store the value.
00712 @param Data a value to be assigned.
00713 }
00714 procedure TZDefaultVariantManager.SetAsInterface(var Value: TZVariant;
00715 Data: IZInterface);
00716 begin
00717 Value.VType := vtInterface;
00718 Value.VInterface := Data;
00719 end;
00720
00721 {**
00722 Performs '+' operation.
00723 @param Value1 the first variant argument.
00724 @param Value2 the second variant argument.
00725 @returns an operation result.
00726 }
00727 function TZDefaultVariantManager.OpAdd(const Value1,
00728 Value2: TZVariant): TZVariant;
00729 begin
00730 case Value1.VType of
00731 vtNull: SetNull(Result);
00732 vtBoolean: RaiseUnsupportedOperation;
00733 vtInteger: SetAsInteger(Result, Value1.VInteger + GetAsInteger(Value2));
00734 vtFloat: SetAsFloat(Result, Value1.VFloat + GetAsFloat(Value2));
00735 vtString: SetAsString(Result, Value1.VString + GetAsString(Value2));
00736 vtUnicodeString: SetAsUnicodeString(Result,
00737 Value1.VUnicodeString + GetAsUnicodeString(Value2));
00738 vtDateTime: SetAsDateTime(Result, Value1.VDateTime + GetAsDateTime(Value2));
00739 vtPointer: RaiseUnsupportedOperation;
00740 vtInterface: RaiseUnsupportedOperation;
00741 end;
00742 end;
00743
00744 {**
00745 Performs '&' operation.
00746 @param Value1 the first variant argument.
00747 @param Value2 the second variant argument.
00748 @returns an operation result.
00749 }
00750 function TZDefaultVariantManager.OpAnd(const Value1,
00751 Value2: TZVariant): TZVariant;
00752 begin
00753 case Value1.VType of
00754 vtNull: SetNull(Result);
00755 vtBoolean: SetAsBoolean(Result, Value1.VBoolean and GetAsBoolean(Value2));
00756 vtInteger: SetAsInteger(Result, Value1.VInteger and GetAsInteger(Value2));
00757 vtFloat: RaiseUnsupportedOperation;
00758 vtString: RaiseUnsupportedOperation;
00759 vtUnicodeString: RaiseUnsupportedOperation;
00760 vtDateTime: RaiseUnsupportedOperation;
00761 vtPointer: RaiseUnsupportedOperation;
00762 vtInterface: RaiseUnsupportedOperation;
00763 end;
00764 end;
00765
00766 {**
00767 Performs '/' operation.
00768 @param Value1 the first variant argument.
00769 @param Value2 the second variant argument.
00770 @returns an operation result.
00771 }
00772 function TZDefaultVariantManager.OpDiv(const Value1,
00773 Value2: TZVariant): TZVariant;
00774 begin
00775 case Value1.VType of
00776 vtNull: SetNull(Result);
00777 vtBoolean: RaiseUnsupportedOperation;
00778 vtInteger: SetAsInteger(Result, Value1.VInteger div GetAsInteger(Value2));
00779 vtFloat: SetAsFloat(Result, Value1.VFloat / GetAsFloat(Value2));
00780 vtString: RaiseUnsupportedOperation;
00781 vtUnicodeString: RaiseUnsupportedOperation;
00782 vtDateTime: RaiseUnsupportedOperation;
00783 vtPointer: RaiseUnsupportedOperation;
00784 vtInterface: RaiseUnsupportedOperation;
00785 end;
00786 end;
00787
00788 {**
00789 Performs '=' operation.
00790 @param Value1 the first variant argument.
00791 @param Value2 the second variant argument.
00792 @returns an operation result.
00793 }
00794 function TZDefaultVariantManager.OpEqual(const Value1,
00795 Value2: TZVariant): TZVariant;
00796 begin
00797 SetAsBoolean(Result, Compare(Value1, Value2) = 0);
00798 end;
00799
00800 {**
00801 Performs '<' operation.
00802 @param Value1 the first variant argument.
00803 @param Value2 the second variant argument.
00804 @returns an operation result.
00805 }
00806 function TZDefaultVariantManager.OpLess(const Value1,
00807 Value2: TZVariant): TZVariant;
00808 begin
00809 SetAsBoolean(Result, Compare(Value1, Value2) < 0);
00810 end;
00811
00812 {**
00813 Performs '<=' operation.
00814 @param Value1 the first variant argument.
00815 @param Value2 the second variant argument.
00816 @returns an operation result.
00817 }
00818 function TZDefaultVariantManager.OpLessEqual(const Value1,
00819 Value2: TZVariant): TZVariant;
00820 begin
00821 SetAsBoolean(Result, Compare(Value1, Value2) <= 0);
00822 end;
00823
00824 {**
00825 Performs '%' operation.
00826 @param Value1 the first variant argument.
00827 @param Value2 the second variant argument.
00828 @returns an operation result.
00829 }
00830 function TZDefaultVariantManager.OpMod(const Value1,
00831 Value2: TZVariant): TZVariant;
00832 begin
00833 case Value1.VType of
00834 vtNull: SetNull(Result);
00835 vtBoolean: RaiseUnsupportedOperation;
00836 vtInteger: SetAsInteger(Result, Value1.VInteger mod GetAsInteger(Value2));
00837 vtFloat: RaiseUnsupportedOperation;
00838 vtString: RaiseUnsupportedOperation;
00839 vtUnicodeString: RaiseUnsupportedOperation;
00840 vtDateTime: RaiseUnsupportedOperation;
00841 vtPointer: RaiseUnsupportedOperation;
00842 vtInterface: RaiseUnsupportedOperation;
00843 end;
00844 end;
00845
00846 {**
00847 Performs '>' operation.
00848 @param Value1 the first variant argument.
00849 @param Value2 the second variant argument.
00850 @returns an operation result.
00851 }
00852 function TZDefaultVariantManager.OpMore(const Value1,
00853 Value2: TZVariant): TZVariant;
00854 begin
00855 SetAsBoolean(Result, Compare(Value1, Value2) > 0);
00856 end;
00857
00858 {**
00859 Performs '>=' operation.
00860 @param Value1 the first variant argument.
00861 @param Value2 the second variant argument.
00862 @returns an operation result.
00863 }
00864 function TZDefaultVariantManager.OpMoreEqual(const Value1,
00865 Value2: TZVariant): TZVariant;
00866 begin
00867 SetAsBoolean(Result, Compare(Value1, Value2) >= 0);
00868 end;
00869
00870 {**
00871 Performs '*' operation.
00872 @param Value1 the first variant argument.
00873 @param Value2 the second variant argument.
00874 @returns an operation result.
00875 }
00876 function TZDefaultVariantManager.OpMul(const Value1,
00877 Value2: TZVariant): TZVariant;
00878 begin
00879 case Value1.VType of
00880 vtNull: SetNull(Result);
00881 vtBoolean: RaiseUnsupportedOperation;
00882 vtInteger: SetAsInteger(Result, Value1.VInteger * GetAsInteger(Value2));
00883 vtFloat: SetAsFloat(Result, Value1.VFloat * GetAsFloat(Value2));
00884 vtString: RaiseUnsupportedOperation;
00885 vtUnicodeString: RaiseUnsupportedOperation;
00886 vtDateTime: RaiseUnsupportedOperation;
00887 vtPointer: RaiseUnsupportedOperation;
00888 vtInterface: RaiseUnsupportedOperation;
00889 end;
00890 end;
00891
00892 {**
00893 Performs unary '-' operation.
00894 @param Value the variant argument.
00895 @returns an operation result.
00896 }
00897 function TZDefaultVariantManager.OpNegative(const Value: TZVariant): TZVariant;
00898 begin
00899 case Value.VType of
00900 vtNull: SetNull(Result);
00901 vtBoolean: RaiseUnsupportedOperation;
00902 vtInteger: SetAsInteger(Result, -Value.VInteger);
00903 vtFloat: SetAsFloat(Result, -Value.VFloat);
00904 vtString: RaiseUnsupportedOperation;
00905 vtUnicodeString: RaiseUnsupportedOperation;
00906 vtDateTime: RaiseUnsupportedOperation;
00907 vtPointer: RaiseUnsupportedOperation;
00908 vtInterface: RaiseUnsupportedOperation;
00909 end;
00910 end;
00911
00912 {**
00913 Performs '~' operation.
00914 @param Value the variant argument.
00915 @returns an operation result.
00916 }
00917 function TZDefaultVariantManager.OpNot(const Value: TZVariant): TZVariant;
00918 begin
00919 case Value.VType of
00920 vtNull: SetNull(Result);
00921 vtBoolean: SetAsBoolean(Result, not Value.VBoolean);
00922 vtInteger: SetAsInteger(Result, not Value.VInteger);
00923 vtFloat: RaiseUnsupportedOperation;
00924 vtString: RaiseUnsupportedOperation;
00925 vtUnicodeString: RaiseUnsupportedOperation;
00926 vtDateTime: RaiseUnsupportedOperation;
00927 vtPointer: RaiseUnsupportedOperation;
00928 vtInterface: RaiseUnsupportedOperation;
00929 end;
00930 end;
00931
00932 {**
00933 Performs '<>' operation.
00934 @param Value1 the first variant argument.
00935 @param Value2 the second variant argument.
00936 @returns an operation result.
00937 }
00938 function TZDefaultVariantManager.OpNotEqual(const Value1,
00939 Value2: TZVariant): TZVariant;
00940 begin
00941 SetAsBoolean(Result, Compare(Value1, Value2) <> 0);
00942 end;
00943
00944 {**
00945 Performs '|' operation.
00946 @param Value1 the first variant argument.
00947 @param Value2 the second variant argument.
00948 @returns an operation result.
00949 }
00950 function TZDefaultVariantManager.OpOr(const Value1,
00951 Value2: TZVariant): TZVariant;
00952 begin
00953 case Value1.VType of
00954 vtNull: SetNull(Result);
00955 vtBoolean: SetAsBoolean(Result, Value1.VBoolean or GetAsBoolean(Value2));
00956 vtInteger: SetAsInteger(Result, Value1.VInteger or GetAsInteger(Value2));
00957 vtFloat: RaiseUnsupportedOperation;
00958 vtString: RaiseUnsupportedOperation;
00959 vtUnicodeString: RaiseUnsupportedOperation;
00960 vtDateTime: RaiseUnsupportedOperation;
00961 vtPointer: RaiseUnsupportedOperation;
00962 vtInterface: RaiseUnsupportedOperation;
00963 end;
00964 end;
00965
00966 {**
00967 Performs '^' operation.
00968 @param Value1 the first variant argument.
00969 @param Value2 the second variant argument.
00970 @returns an operation result.
00971 }
00972 function TZDefaultVariantManager.OpPow(const Value1,
00973 Value2: TZVariant): TZVariant;
00974 begin
00975 case Value1.VType of
00976 vtNull: SetNull(Result);
00977 vtBoolean: RaiseUnsupportedOperation;
00978 vtInteger: SetAsFloat(Result, Power(Value1.VInteger, GetAsInteger(Value2)));
00979 vtFloat: SetAsFloat(Result, Power(Value1.VFloat, GetAsFloat(Value2)));
00980 vtString: RaiseUnsupportedOperation;
00981 vtUnicodeString: RaiseUnsupportedOperation;
00982 vtDateTime: RaiseUnsupportedOperation;
00983 vtPointer: RaiseUnsupportedOperation;
00984 vtInterface: RaiseUnsupportedOperation;
00985 end;
00986 end;
00987
00988 {**
00989 Performs '-' operation.
00990 @param Value1 the first variant argument.
00991 @param Value2 the second variant argument.
00992 @returns an operation result.
00993 }
00994 function TZDefaultVariantManager.OpSub(const Value1,
00995 Value2: TZVariant): TZVariant;
00996 begin
00997 case Value1.VType of
00998 vtNull: SetNull(Result);
00999 vtBoolean: RaiseUnsupportedOperation;
01000 vtInteger: SetAsInteger(Result, Value1.VInteger - GetAsInteger(Value2));
01001 vtFloat: SetAsFloat(Result, Value1.VFloat - GetAsFloat(Value2));
01002 vtString: RaiseUnsupportedOperation;
01003 vtUnicodeString: RaiseUnsupportedOperation;
01004 vtDateTime: RaiseUnsupportedOperation;
01005 vtPointer: RaiseUnsupportedOperation;
01006 vtInterface: RaiseUnsupportedOperation;
01007 end;
01008 end;
01009
01010 {**
01011 Performs '^' operation.
01012 @param Value1 the first variant argument.
01013 @param Value2 the second variant argument.
01014 @returns an operation result.
01015 }
01016 function TZDefaultVariantManager.OpXor(const Value1,
01017 Value2: TZVariant): TZVariant;
01018 var
01019 TempBool1, TempBool2: Boolean;
01020 TempInteger1, TempInteger2: Int64;
01021 begin
01022 case Value1.VType of
01023 vtNull: SetNull(Result);
01024 vtBoolean:
01025 begin
01026 TempBool1 := Value1.VBoolean;
01027 TempBool2 := GetAsBoolean(Value2);
01028 SetAsBoolean(Result, (TempBool1 and not TempBool2)
01029 or (not TempBool1 and TempBool2));
01030 end;
01031 vtInteger:
01032 begin
01033 TempInteger1 := Value1.VInteger;
01034 TempInteger2 := GetAsInteger(Value2);
01035 SetAsInteger(Result, (TempInteger1 and not TempInteger2)
01036 or (not TempInteger1 and TempInteger2));
01037 end;
01038 vtFloat: RaiseUnsupportedOperation;
01039 vtString: RaiseUnsupportedOperation;
01040 vtUnicodeString: RaiseUnsupportedOperation;
01041 vtDateTime: RaiseUnsupportedOperation;
01042 vtPointer: RaiseUnsupportedOperation;
01043 vtInterface: RaiseUnsupportedOperation;
01044 end;
01045 end;
01046
01047 { TZSoftVariantManager }
01048
01049 {**
01050 Converts a specified variant value to a new type.
01051 @param Value a variant value to be converted.
01052 @param NewType a type of the result variant value.
01053 @returns a converted variant value.
01054 }
01055 function TZSoftVariantManager.Convert(const Value: TZVariant;
01056 NewType: TZVariantType): TZVariant;
01057 begin
01058 Result.VType := NewType;
01059 case NewType of
01060 vtBoolean:
01061 case Value.VType of
01062 vtNull:
01063 Result.VBoolean := False;
01064 vtBoolean:
01065 Result.VBoolean := Value.VBoolean;
01066 vtInteger:
01067 Result.VBoolean := Value.VInteger <> 0;
01068 vtFloat:
01069 Result.VBoolean := Value.VFloat <> 0;
01070 vtString:
01071 Result.VBoolean := StrToBoolEx(Value.VString);
01072 vtUnicodeString:
01073 Result.VBoolean := StrToBoolEx(Value.VUnicodeString);
01074 vtDateTime:
01075 Result.VBoolean := Value.VDateTime <> 0;
01076 vtPointer:
01077 RaiseTypeMismatchError;
01078 vtInterface:
01079 RaiseTypeMismatchError;
01080 end;
01081 vtInteger:
01082 case Value.VType of
01083 vtNull:
01084 Result.VInteger := 0;
01085 vtBoolean:
01086 if Value.VBoolean then
01087 Result.VInteger := 1
01088 else Result.VInteger := 0;
01089 vtInteger:
01090 Result.VInteger := Value.VInteger;
01091 vtFloat:
01092 Result.VInteger := Trunc(Value.VFloat);
01093 vtString:
01094 Result.VInteger := StrToIntDef(Value.VString, 0);
01095 vtUnicodeString:
01096 Result.VInteger := StrToIntDef(Value.VUnicodeString, 0);
01097 vtDateTime:
01098 Result.VInteger := Trunc(Value.VDateTime);
01099 vtPointer:
01100 Result.VInteger := Integer(Value.VPointer);
01101 vtInterface:
01102 RaiseTypeMismatchError;
01103 end;
01104 vtFloat:
01105 case Value.VType of
01106 vtNull:
01107 Result.VFloat := 0;
01108 vtBoolean:
01109 if Value.VBoolean then
01110 Result.VFloat := 1
01111 else Result.VFloat := 0;
01112 vtInteger:
01113 Result.VFloat := Value.VInteger;
01114 vtFloat:
01115 Result.VFloat := Value.VFloat;
01116 vtString:
01117 Result.VFloat := SqlStrToFloatDef(Value.VString, 0);
01118 vtUnicodeString:
01119 Result.VFloat := SqlStrToFloatDef(Value.VUnicodeString, 0);
01120 vtDateTime:
01121 Result.VFloat := Value.VDateTime;
01122 vtPointer:
01123 RaiseTypeMismatchError;
01124 vtInterface:
01125 RaiseTypeMismatchError;
01126 end;
01127 vtString:
01128 case Value.VType of
01129 vtNull:
01130 Result.VString := '';
01131 vtBoolean:
01132 if Value.VBoolean then
01133 Result.VString := 'TRUE'
01134 else Result.VString := 'FALSE';
01135 vtInteger:
01136 Result.VString := IntToStr(Value.VInteger);
01137 vtFloat:
01138 Result.VString := FloatToSqlStr(Value.VFloat);
01139 vtString:
01140 Result.VString := Value.VString;
01141 vtUnicodeString:
01142 Result.VString := Value.VUnicodeString;
01143 vtDateTime:
01144 Result.VString := DateTimeToAnsiSQLDate(Value.VDateTime);
01145 vtPointer:
01146 RaiseTypeMismatchError;
01147 vtInterface:
01148 RaiseTypeMismatchError;
01149 end;
01150 vtUnicodeString:
01151 case Value.VType of
01152 vtNull:
01153 Result.VUnicodeString := '';
01154 vtBoolean:
01155 if Value.VBoolean then
01156 Result.VUnicodeString := 'True'
01157 else Result.VUnicodeString := 'False';
01158 vtInteger:
01159 Result.VUnicodeString := IntToStr(Value.VInteger);
01160 vtFloat:
01161 Result.VUnicodeString := FloatToSqlStr(Value.VFloat);
01162 vtString:
01163 Result.VUnicodeString := Value.VString;
01164 vtUnicodeString:
01165 Result.VUnicodeString := Value.VUnicodeString;
01166 vtDateTime:
01167 Result.VUnicodeString := DateTimeToAnsiSQLDate(Value.VDateTime);
01168 vtPointer:
01169 RaiseTypeMismatchError;
01170 vtInterface:
01171 RaiseTypeMismatchError;
01172 end;
01173 vtDateTime:
01174 case Value.VType of
01175 vtNull:
01176 Result.VDateTime := 0;
01177 vtBoolean:
01178 RaiseTypeMismatchError;
01179 vtInteger:
01180 Result.VDateTime := Value.VInteger;
01181 vtFloat:
01182 Result.VDateTime := Value.VFloat;
01183 vtString:
01184 Result.VDateTime := AnsiSQLDateToDateTime(Value.VString);
01185 vtUnicodeString:
01186 Result.VDateTime := AnsiSQLDateToDateTime(Value.VUnicodeString);
01187 vtDateTime:
01188 Result.VDateTime := Value.VDateTime;
01189 vtPointer:
01190 RaiseTypeMismatchError;
01191 vtInterface:
01192 RaiseTypeMismatchError;
01193 end;
01194 vtPointer:
01195 case Value.VType of
01196 vtNull:
01197 Result.VPointer := nil;
01198 vtBoolean:
01199 RaiseTypeMismatchError;
01200 vtInteger:
01201 Result.VPointer := Pointer(Value.VInteger);
01202 vtFloat:
01203 RaiseTypeMismatchError;
01204 vtString:
01205 RaiseTypeMismatchError;
01206 vtUnicodeString:
01207 RaiseTypeMismatchError;
01208 vtDateTime:
01209 RaiseTypeMismatchError;
01210 vtPointer:
01211 Result.VPointer := Value.VPointer;
01212 vtInterface:
01213 RaiseTypeMismatchError;
01214 end;
01215 vtInterface:
01216 case Value.VType of
01217 vtNull:
01218 Result.VInterface := nil;
01219 vtBoolean:
01220 RaiseTypeMismatchError;
01221 vtInteger:
01222 RaiseTypeMismatchError;
01223 vtFloat:
01224 RaiseTypeMismatchError;
01225 vtString:
01226 RaiseTypeMismatchError;
01227 vtUnicodeString:
01228 RaiseTypeMismatchError;
01229 vtDateTime:
01230 RaiseTypeMismatchError;
01231 vtPointer:
01232 RaiseTypeMismatchError;
01233 vtInterface:
01234 Result.VInterface := Value.VInterface;
01235 end;
01236 end;
01237 end;
01238
01239 { TZAnyValue }
01240
01241 {**
01242 Constructs this object and assignes the main properties.
01243 @param Value an any value.
01244 }
01245 constructor TZAnyValue.Create(const Value: TZVariant);
01246 begin
01247 FValue := Value;
01248 end;
01249
01250 {**
01251 Constructs this object and assignes the main properties.
01252 @param Value a boolean value.
01253 }
01254 constructor TZAnyValue.CreateWithBoolean(Value: Boolean);
01255 begin
01256 DefVarManager.SetAsBoolean(FValue, Value);
01257 end;
01258
01259 {**
01260 Constructs this object and assignes the main properties.
01261 @param Value a datetime value.
01262 }
01263 constructor TZAnyValue.CreateWithDateTime(Value: TDateTime);
01264 begin
01265 DefVarManager.SetAsDateTime(FValue, Value);
01266 end;
01267
01268 {**
01269 Constructs this object and assignes the main properties.
01270 @param Value a float value.
01271 }
01272 constructor TZAnyValue.CreateWithFloat(Value: Extended);
01273 begin
01274 DefVarManager.SetAsFloat(FValue, Value);
01275 end;
01276
01277 {**
01278 Constructs this object and assignes the main properties.
01279 @param Value a integer value.
01280 }
01281 constructor TZAnyValue.CreateWithInteger(Value: Int64);
01282 begin
01283 DefVarManager.SetAsInteger(FValue, Value);
01284 end;
01285
01286 {**
01287 Constructs this object and assignes the main properties.
01288 @param Value a string value.
01289 }
01290 constructor TZAnyValue.CreateWithString(const Value: AnsiString);
01291 begin
01292 DefVarManager.SetAsString(FValue, Value);
01293 end;
01294
01295 {**
01296 Constructs this object and assignes the main properties.
01297 @param Value a unicode string value.
01298 }
01299 constructor TZAnyValue.CreateWithUnicodeString(const Value: WideString);
01300 begin
01301 DefVarManager.SetAsUnicodeString(FValue, Value);
01302 end;
01303
01304 {**
01305 Clones an object instance.
01306 @return a clonned object instance.
01307 }
01308 function TZAnyValue.Clone: IZInterface;
01309 begin
01310 Result := TZAnyValue.Create(FValue);
01311 end;
01312
01313 {**
01314 Compares this and another property.
01315 @return <code>True</code> is properties are equal.
01316 }
01317 function TZAnyValue.Equals(const Value: IZInterface): Boolean;
01318 var
01319 Temp: IZAnyValue;
01320 begin
01321 if Value <> nil then
01322 begin
01323 if Value.QueryInterface(IZAnyValue, Temp) = 0 then
01324 begin
01325 Result := SoftVarManager.Compare(FValue, Temp.GetValue) = 0;
01326 Temp := nil;
01327 end else
01328 Result := inherited Equals(Value);
01329 end else
01330 Result := False;
01331 end;
01332
01333 {**
01334 Gets a stored any value.
01335 @return a stored any value.
01336 }
01337 function TZAnyValue.GetValue: TZVariant;
01338 begin
01339 Result := FValue;
01340 end;
01341
01342 {**
01343 Converts this object into the string representation.
01344 @return a string representation for this object.
01345 }
01346 function TZAnyValue.ToString: string;
01347 begin
01348 Result := GetString;
01349 end;
01350
01351 {**
01352 Checks is the stored value contains NULL.
01353 @returns <code>True</code> if NULL is stored.
01354 }
01355 function TZAnyValue.IsNull: Boolean;
01356 begin
01357 Result := SoftVarManager.IsNull(FValue);
01358 end;
01359
01360 {**
01361 Gets a stored value converted to double.
01362 @return a stored value converted to double.
01363 }
01364 function TZAnyValue.GetFloat: Extended;
01365 begin
01366 Result := SoftVarManager.GetAsFloat(FValue);
01367 end;
01368
01369 {**
01370 Gets a stored value converted to integer.
01371 @return a stored value converted to integer.
01372 }
01373 function TZAnyValue.GetInteger: Int64;
01374 begin
01375 Result := SoftVarManager.GetAsInteger(FValue);
01376 end;
01377
01378 {**
01379 Gets a stored value converted to string.
01380 @return a stored value converted to string.
01381 }
01382 function TZAnyValue.GetString: AnsiString;
01383 begin
01384 Result := SoftVarManager.GetAsString(FValue);
01385 end;
01386
01387 {**
01388 Gets a stored value converted to boolean.
01389 @return a stored value converted to boolean.
01390 }
01391 function TZAnyValue.GetBoolean: Boolean;
01392 begin
01393 Result := SoftVarManager.GetAsBoolean(FValue);
01394 end;
01395
01396 {**
01397 Gets a stored value converted to unicode string.
01398 @return a stored value converted to unicode string.
01399 }
01400 function TZAnyValue.GetUnicodeString: WideString;
01401 begin
01402 Result := SoftVarManager.GetAsUnicodeString(FValue);
01403 end;
01404
01405 {**
01406 Gets a stored value converted to datetime.
01407 @return a stored value converted to datetime.
01408 }
01409 function TZAnyValue.GetDateTime: TDateTime;
01410 begin
01411 Result := SoftVarManager.GetAsDateTime(FValue);
01412 end;
01413
01414 {**
01415 Encodes a custom variant value into standard variant.
01416 @param Value a custom variant value to be encoded.
01417 @returns an encoded standard variant.
01418 }
01419 function EncodeVariant(const Value: TZVariant): Variant;
01420 begin
01421 case Value.VType of
01422 vtBoolean: Result := Value.VBoolean;
01423 vtInteger:
01424 if (Value.VInteger > -MaxInt) and (Value.VInteger < MaxInt) then
01425 Result := Integer(Value.VInteger)
01426 else Result := IntToStr(Value.VInteger);
01427 vtFloat: Result := Value.VFloat;
01428 vtString: Result := Value.VString;
01429 vtUnicodeString: Result := Value.VUnicodeString;
01430 vtDateTime: Result := Value.VDateTime;
01431 vtPointer: Result := LongInt(Value.VPointer);
01432 vtInterface: Result := Value.VInterface;
01433 else Result := Null;
01434 end;
01435 end;
01436
01437 {**
01438 Encodes an array of custom variant values into array of standard variants.
01439 @param Value an array of custom variant values to be encoded.
01440 @returns an encoded array of standard variants.
01441 }
01442 function EncodeVariantArray(const Value: TZVariantDynArray): Variant;
01443 var
01444 I, L: Integer;
01445 begin
01446 L := Length(Value);
01447 Result := VarArrayCreate([0, L - 1], varVariant);
01448 for I := 0 to L - 1 do
01449 Result[I] := EncodeVariant(Value[I]);
01450 end;
01451
01452 {**
01453 Decodes a standard variant value into custom variant.
01454 @param Value a standard variant value to be decoded.
01455 @returns an decoded custom variant.
01456 }
01457 function DecodeVariant(const Value: Variant): TZVariant;
01458 begin
01459 case VarType(Value) of
01460 varSmallint, varInteger, varByte:
01461 DefVarManager.SetAsInteger(Result, Integer(Value));
01462 varBoolean: DefVarManager.SetAsBoolean(Result, Value);
01463 varString:
01464 DefVarManager.SetAsString(Result, Value);
01465 varSingle, varDouble, varCurrency:
01466 DefVarManager.SetAsFloat(Result, Value);
01467 varUnknown: DefVarManager.SetAsInterface(Result, Value);
01468 varOleStr:
01469 DefVarManager.SetAsUnicodeString(Result, Value);
01470 varDate: DefVarManager.SetAsDateTime(Result, Value);
01471 {$IFNDEF VER130BELOW}
01472 varShortInt, varWord, varLongWord:
01473 DefVarManager.SetAsInteger(Result, Value);
01474 varInt64: DefVarManager.SetAsInteger(Result, Value);
01475 {$ELSE}
01476 {$IFNDEF FPC}
01477 VT_DECIMAL {varInt64 in Delphi/C++Builder 5}:
01478 DefVarManager.SetAsInteger(Result, Decimal(Value).lo64);
01479 {$ENDIF}
01480 {$ENDIF}
01481 else DefVarManager.SetNull(Result);
01482 end;
01483 end;
01484
01485 {**
01486 Decodes an array of standard variant values into array of custom variants.
01487 @param Value an array of standard variant values to be decoded.
01488 @returns an decoded array of custom variants.
01489 }
01490 function DecodeVariantArray(const Value: Variant): TZVariantDynArray;
01491 var
01492 I, L, H: Integer;
01493 begin
01494 if VarIsArray(Value) then
01495 begin
01496 L := VarArrayLowBound(Value, 1);
01497 H := VarArrayHighBound(Value, 1);
01498 SetLength(Result, H - L + 1);
01499 for I := L to H do
01500 Result[I - L] := DecodeVariant(Value[I]);
01501 end
01502 else
01503 begin
01504 SetLength(Result, 1);
01505 Result[0] := DecodeVariant(Value);
01506 end;
01507 end;
01508
01509 initialization
01510 DefVarManager := TZDefaultVariantManager.Create;
01511 SoftVarManager := TZSoftVariantManager.Create;
01512 DefVarManager.SetNull(NullVariant);
01513 finalization
01514 DefVarManager := nil;
01515 SoftVarManager := nil;
01516 end.
01517
01518