/packages/fcl-sdo/src/base/sdo_dataobject.pas

https://github.com/slibre/freepascal · Pascal · 4199 lines · 3467 code · 408 blank · 324 comment · 324 complexity · 2b95a80fc937a285b144f14dee5a4de0 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. {
    2. 

  2.     This file is part of the Free Pascal Class Library SDO Implementation
    3. 

  3.     Copyright (c) 2012 by Inoussa OUEDRAOGO
    4. 

  4.     Free Pascal development team
    5. 

  5. 

  6.     This unit implements the basic SDO objects
    7. 

  7. 

  8.     See the file COPYING.FPC, included in this distribution,
    9. 

  9.     for details about the copyright.
    10. 

  10. 

  11.     This program is distributed in the hope that it will be useful,
    12. 

  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    14. 

  14. 

  15.  **********************************************************************}
    16. 

  16. {$INCLUDE sdo_global.inc}
    17. 

  17. unit sdo_dataobject;
    18. 

  18. 

  19. interface
    20. 

  20. uses
    21. 

  21.   SysUtils, Classes, Contnrs,
    22. 

  22.   sdo_types, sdo, sdo_type, sdo_changesummary, sdo_xpath_helper, sdo_linked_list,
    23. 

  23.   sdo_field_imp;
    24. 

  24. 

  25. type
    26. 

  26. 

  27.   IDataObjectObserver = interface
    28. 

  28.     ['{EF23F339-EF10-4312-B202-43AA5C743841}']
    29. 

  29.     procedure NotifyDeletion(
    30. 

  30.       const ADataObject : ISDODataObject;
    31. 

  31.       const AProperty : ISDOProperty
    32. 

  32.     );
    33. 

  33.   end;
    34. 

  34. 

  35.   ISDODataObjectEx = interface(ISDODataObject)
    36. 

  36.     ['{2EA33304-D190-425F-A952-685619896AB2}']
    37. 

  37.     //Return TRUE if this instance is an instance or a derived class
    38. 

  38.     function IsInstanceOf(const AType : ISDOType) : Boolean;
    39. 

  39. 

  40.     function IsAncestorOf(const AObject : ISDODataObject) : Boolean;
    41. 

  41.     procedure setContainer(
    42. 

  42.       const AContainer : ISDODataObject;
    43. 

  43.       const AContainerProperty : ISDOProperty
    44. 

  44.     );
    45. 

  45.     procedure AddReference(
    46. 

  46.       const AReferencer : ISDODataObject;
    47. 

  47.       const AReferenceProperty : ISDOProperty
    48. 

  48.     );
    49. 

  49.     procedure RemoveReference(
    50. 

  50.       const AReferencer : ISDODataObject;
    51. 

  51.       const AReferenceProperty : ISDOProperty
    52. 

  52.     );
    53. 

  53.     procedure NotifyContainedObjectsForDeletion(const ACallFromParent : Boolean);// logical deletion
    54. 

  54. 

  55.     // for open Type support
    56. 

  56.     procedure addProperty(
    57. 

  57.       const APropName : string;
    58. 

  58.       const APropType : ISDOType;
    59. 

  59.       const AFlags : TPropertyFlags
    60. 

  60.     );
    61. 

  61.   end;
    62. 

  62. 

  63.   TObserverInfo = class
    64. 

  64.   private
    65. 

  65.     FDataObject  : Pointer;
    66. 

  66.     FRefProperty : Pointer;
    67. 

  67.   public
    68. 

  68.     constructor Create(const ADataObject : ISDODataObject; const ARefProperty : ISDOProperty);
    69. 

  69.     function GetDataObject() : ISDODataObject;{$IFDEF USE_INLINE}inline;{$ENDIF}
    70. 

  70.     function GetRefProperty() : ISDOProperty;{$IFDEF USE_INLINE}inline;{$ENDIF}
    71. 

  71.   end;
    72. 

  72. 

  73.   TDataObjectObserverList = class
    74. 

  74.   private
    75. 

  75.     FList : TObjectList;
    76. 

  76.   public
    77. 

  77.     constructor Create();
    78. 

  78.     destructor Destroy();override;
    79. 

  79.     procedure Add(const ADataObject : ISDODataObject; const ARefProperty : ISDOProperty);{$IFDEF USE_INLINE}inline;{$ENDIF}
    80. 

  80.     function IndexOf(const ADataObject : ISDODataObject; const ARefProperty : ISDOProperty) : PtrInt;
    81. 

  81.     function Find(const ADataObject : ISDODataObject; const ARefProperty : ISDOProperty) : TObserverInfo;{$IFDEF USE_INLINE}inline;{$ENDIF}
    82. 

  82.     function GetCount() : PtrInt;{$IFDEF USE_INLINE}inline;{$ENDIF}
    83. 

  83.     function GetItem(const AIndex : PtrInt) : TObserverInfo;{$IFDEF USE_INLINE}inline;{$ENDIF}
    84. 

  84.     function Extract(const AIndex : PtrInt) : TObserverInfo;{$IFDEF USE_INLINE}inline;{$ENDIF}
    85. 

  85.     procedure Delete(const AIndex : PtrInt);{$IFDEF USE_INLINE}inline;{$ENDIF}
    86. 

  86.   end;
    87. 

  87. 

  88.   TSDOBaseDataObjectClass = class of TSDOBaseDataObject;
    89. 

  89.   TSDOBaseDataObject = class(
    90. 

  90.     TInterfacedObject,
    91. 

  91.     IInterface,
    92. 

  92.     ISDODataObject,
    93. 

  93.     ISDODataObjectEx,
    94. 

  94.     IDataObjectObserver
    95. 

  95.   )
    96. 

  96.   private
    97. 

  97.     FDestroying : Boolean;
    98. 

  98.     FType : ISDOObjectType;
    99. 

  99.     FContainer : Pointer;
    100. 

  100.     FContainerProperty : Pointer;
    101. 

  101.     FBuffer : TSDOFieldBuffer;
    102. 

  102.     FBufferLength : PtrUInt;
    103. 

  103.     FChangeSummary : Pointer;//ISDOChangeSummaryEx;
    104. 

  104.     FReferenceLinkList : TDataObjectObserverList;
    105. 

  105.   private
    106. 

  106.     FXPathExpression : TXPathExpression;
    107. 

  107.     FXPathProcessor : TXPathProcessor;
    108. 

  108.   protected
    109. 

  109.     function _Release: LongInt; {$IFNDEF WINDOWS}cdecl{$ELSE}stdcall{$ENDIF};
    110. 

  110.     procedure PrepareDataBuffer();
    111. 

  111.     procedure FreeBuffer();
    112. 

  112.     function parsePropertyPath(const APath : string) : TXPathExecContext;
    113. 

  113.     function IsOwnerOf(const AProp : ISDOProperty) : Boolean;virtual;//{$IFDEF USE_INLINE}inline;{$ENDIF}
    114. 

  114.     function CreateList(const AProperty : ISDOProperty) : ISDODataObjectList;{$IFDEF USE_INLINE}inline;{$ENDIF}
    115. 

  115.     procedure InitializeDefaultValues();
    116. 

  116.   protected
    117. 

  117.     procedure RecordChange(const AProperty : ISDOProperty);{$IFDEF USE_INLINE}inline;{$ENDIF}
    118. 

  118.     procedure NotifyReferencersForDeletion();
    119. 

  119.   protected
    120. 

  120.     // ISDODataObjectEx
    121. 

  121.     function IsInstanceOf(const AType : ISDOType) : Boolean;
    122. 

  122.     function IsAncestorOf(const AObject : ISDODataObject) : Boolean;
    123. 

  123.     procedure setContainer(
    124. 

  124.       const AContainer : ISDODataObject;
    125. 

  125.       const AContainerProperty : ISDOProperty
    126. 

  126.     );
    127. 

  127. 

  128.     //ISDODataObject
    129. 

  129.     function getPropertyIndex(const AProperty : ISDOProperty) : PtrInt;
    130. 

  130.     function getInstanceProperties() : ISDOPropertyList;virtual;
    131. 

  131. 

  132.     function getProperty(const AIndex : PtrUInt) : ISDOProperty;overload;
    133. 

  133.     function getProperty(const AProp : string) : ISDOProperty;overload;
    134. 

  134. 

  135.     function getContainer() : ISDODataObject;
    136. 

  136.     function getContainmentProperty() : ISDOProperty;
    137. 

  137.     function getType() : ISDOType;
    138. 

  138.     function getTypeEnum() : TSDOTypeKind;
    139. 

  139. 

  140.     function getList(const APath : string) : ISDODataObjectList; overload;
    141. 

  141.     function getList(const APropertyIndex : PtrUInt) : ISDODataObjectList; overload;
    142. 

  142.     function getList(const AProperty : ISDOProperty) : ISDODataObjectList; overload;
    143. 

  143. 

  144.     function getDataObject(const APath : string) : ISDODataObject; overload;
    145. 

  145.     function getDataObject(const APropertyIndex : PtrUInt) : ISDODataObject; overload;
    146. 

  146.     function getDataObject(const AProperty : ISDOProperty) : ISDODataObject; overload;
    147. 

  147. 

  148.     procedure setDataObject(const APath : string; AValue : ISDODataObject); overload; virtual;
    149. 

  149.     procedure setDataObject(const APropertyIndex : PtrUInt; AValue : ISDODataObject); overload;
    150. 

  150.     procedure setDataObject(const AProperty : ISDOProperty; AValue : ISDODataObject); overload;
    151. 

  151. 

  152.     function getBoolean(const APath : string) : TSDOBoolean; overload;
    153. 

  153.     function getBoolean(const APropertyIndex : PtrUInt) : TSDOBoolean; overload;
    154. 

  154.     function getBoolean(const AProperty : ISDOProperty) : TSDOBoolean; overload;
    155. 

  155. 

  156.     procedure setBoolean(const APath : string; const AValue : TSDOBoolean); overload; virtual;
    157. 

  157.     procedure setBoolean(const APropertyIndex : PtrUInt; const AValue : TSDOBoolean); overload;
    158. 

  158.     procedure setBoolean(const AProperty : ISDOProperty; const AValue : TSDOBoolean); overload;
    159. 

  159. 

  160.     function getByte(const APath : string) : TSDOByte;overload;
    161. 

  161.     function getByte(const APropertyIndex : PtrUInt) : TSDOByte;overload;
    162. 

  162.     function getByte(const AProperty : ISDOProperty) : TSDOByte;overload;
    163. 

  163. 

  164.     procedure setByte(const APath : string; const AValue : TSDOByte);overload; virtual;
    165. 

  165.     procedure setByte(const APropertyIndex : PtrUInt; const AValue : TSDOByte);overload;
    166. 

  166.     procedure setByte(const AProperty : ISDOProperty; const AValue : TSDOByte);overload;
    167. 

  167. 

  168. {$IFDEF HAS_SDO_CHAR}
    169. 

  169.     function getCharacter(const APath : string) : TSDOChar;overload;
    170. 

  170.     function getCharacter(const APropertyIndex : PtrUInt) : TSDOChar;overload;
    171. 

  171.     function getCharacter(const AProperty : ISDOProperty) : TSDOChar;overload;
    172. 

  172. 

  173.     procedure setCharacter(const APath : string; const AValue : TSDOChar);overload; virtual;
    174. 

  174.     procedure setCharacter(const APropertyIndex : PtrUInt; const AValue : TSDOChar);overload;
    175. 

  175.     procedure setCharacter(const AProperty : ISDOProperty; const AValue : TSDOChar);overload;
    176. 

  176. {$ENDIF HAS_SDO_CHAR}
    177. 

  177. 

  178. {$IFDEF HAS_SDO_BYTES}
    179. 

  179.     function getBytes(const APath : string) : TSDOBytes;overload;
    180. 

  180.     function getBytes(const APropertyIndex : PtrUInt) : TSDOBytes;overload;
    181. 

  181.     function getBytes(const AProperty : ISDOProperty) : TSDOBytes;overload;
    182. 

  182. 

  183.     procedure setBytes(const APath : string; AValue : TSDOBytes);overload; virtual;
    184. 

  184.     procedure setBytes(const APropertyIndex : PtrUInt; AValue : TSDOBytes);overload;
    185. 

  185.     procedure setBytes(const AProperty : ISDOProperty; AValue : TSDOBytes);overload;
    186. 

  186. {$ENDIF HAS_SDO_BYTES}
    187. 

  187. 

  188. {$IFDEF HAS_SDO_CURRENCY}
    189. 

  189.     function getCurrency(const APath : string) : TSDOCurrency;overload;
    190. 

  190.     function getCurrency(const APropertyIndex : PtrUInt) : TSDOCurrency;overload;
    191. 

  191.     function getCurrency(const AProperty : ISDOProperty) : TSDOCurrency;overload;
    192. 

  192. 

  193.     procedure setCurrency(const APath : string; const AValue : TSDOCurrency);overload;  virtual;
    194. 

  194.     procedure setCurrency(const APropertyIndex : PtrUInt; const AValue : TSDOCurrency);overload;
    195. 

  195.     procedure setCurrency(const AProperty : ISDOProperty; const AValue : TSDOCurrency);overload;
    196. 

  196. {$ENDIF HAS_SDO_CURRENCY}
    197. 

  197. 

  198.     function getString(const APath : string) : TSDOString;overload;
    199. 

  199.     function getString(const APropertyIndex : PtrUInt) : TSDOString;overload;
    200. 

  200.     function getString(const AProperty : ISDOProperty) : TSDOString;overload;
    201. 

  201. 

  202.     procedure setString(const APath : string; const AValue : TSDOString);overload;virtual;
    203. 

  203.     procedure setString(const APropertyIndex : PtrUInt; const AValue : TSDOString);overload;
    204. 

  204.     procedure setString(const AProperty : ISDOProperty; const AValue : TSDOString);overload;
    205. 

  205. 

  206.     function getDate(const APath : string) : TSDODate;overload;
    207. 

  207.     function getDate(const APropertyIndex : PtrUInt) : TSDODate;overload;
    208. 

  208.     function getDate(const AProperty : ISDOProperty) : TSDODate;overload;
    209. 

  209. 

  210.     procedure setDate(const APath : string; const AValue : TSDODate);overload;virtual;
    211. 

  211.     procedure setDate(const APropertyIndex : PtrUInt; const AValue : TSDODate);overload;
    212. 

  212.     procedure setDate(const AProperty : ISDOProperty; const AValue : TSDODate);overload;
    213. 

  213. 

  214. {$IFDEF HAS_SDO_DOUBLE}
    215. 

  215.     function getDouble(const APath : string) : TSDODouble;overload;
    216. 

  216.     function getDouble(const APropertyIndex : PtrUInt) : TSDODouble;overload;
    217. 

  217.     function getDouble(const AProperty : ISDOProperty) : TSDODouble;overload;
    218. 

  218. 

  219.     procedure setDouble(const APath : string; const AValue : TSDODouble);overload; virtual;
    220. 

  220.     procedure setDouble(const APropertyIndex : PtrUInt; const AValue : TSDODouble);overload;
    221. 

  221.     procedure setDouble(const AProperty : ISDOProperty; const AValue : TSDODouble);overload; 
    222. 

  222. {$ENDIF HAS_SDO_DOUBLE}
    223. 

  223. 

  224. {$IFDEF HAS_SDO_FLOAT}
    225. 

  225.     function getFloat(const APath : string) : TSDOFloat;overload;
    226. 

  226.     function getFloat(const APropertyIndex : PtrUInt) : TSDOFloat;overload;
    227. 

  227.     function getFloat(const AProperty : ISDOProperty) : TSDOFloat;overload;
    228. 

  228. 

  229.     procedure setFloat(const APath : string; const AValue : TSDOFloat);overload; virtual;
    230. 

  230.     procedure setFloat(const APropertyIndex : PtrUInt; const AValue : TSDOFloat);overload;
    231. 

  231.     procedure setFloat(const AProperty : ISDOProperty; const AValue : TSDOFloat);overload;
    232. 

  232. {$ENDIF HAS_SDO_FLOAT}
    233. 

  233. 

  234.     function getInteger(const APath : string) : TSDOInteger;overload;
    235. 

  235.     function getInteger(const APropertyIndex : PtrUInt) : TSDOInteger;overload;
    236. 

  236.     function getInteger(const AProperty : ISDOProperty) : TSDOInteger;overload;
    237. 

  237. 

  238.     procedure setInteger(const APath : string; const AValue : TSDOInteger);overload;virtual;
    239. 

  239.     procedure setInteger(const APropertyIndex : PtrUInt; const AValue : TSDOInteger);overload;
    240. 

  240.     procedure setInteger(const AProperty : ISDOProperty; const AValue : TSDOInteger);overload;
    241. 

  241. 

  242. {$IFDEF HAS_SDO_LONG}
    243. 

  243.     function getLong(const APath : string) : TSDOLong;overload;
    244. 

  244.     function getLong(const APropertyIndex : PtrUInt) : TSDOLong;overload;
    245. 

  245.     function getLong(const AProperty : ISDOProperty) : TSDOLong;overload;
    246. 

  246. 

  247.     procedure setLong(const APath : string; const AValue : TSDOLong);overload; virtual;
    248. 

  248.     procedure setLong(const APropertyIndex : PtrUInt; const AValue : TSDOLong);overload;
    249. 

  249.     procedure setLong(const AProperty : ISDOProperty; const AValue : TSDOLong);overload; 
    250. 

  250. {$ENDIF HAS_SDO_LONG}
    251. 

  251. 

  252. {$IFDEF HAS_SDO_SHORT}
    253. 

  253.     function getShort(const APath : string) : TSDOShort;overload;
    254. 

  254.     function getShort(const APropertyIndex : PtrUInt) : TSDOShort;overload;
    255. 

  255.     function getShort(const AProperty : ISDOProperty) : TSDOShort;overload;
    256. 

  256. 

  257.     procedure setShort(const APath : string; const AValue : TSDOShort);overload; virtual;
    258. 

  258.     procedure setShort(const APropertyIndex : PtrUInt; const AValue : TSDOShort);overload;
    259. 

  259.     procedure setShort(const AProperty : ISDOProperty; const AValue : TSDOShort);overload; 
    260. 

  260. {$ENDIF HAS_SDO_SHORT}
    261. 

  261. 

  262.     function getVariant(const APath : string) : TSDOVariant;overload;
    263. 

  263.     function getVariant(const APropertyIndex : PtrUInt) : TSDOVariant;overload;
    264. 

  264.     function getVariant(const AProperty : ISDOProperty) : TSDOVariant;overload;
    265. 

  265. 

  266.     procedure setVariant(const APath : string; const AValue : TSDOVariant);overload;
    267. 

  267.     procedure setVariant(const APropertyIndex : PtrUInt; const AValue : TSDOVariant);overload;
    268. 

  268.     procedure setVariant(const AProperty : ISDOProperty; const AValue : TSDOVariant);overload;
    269. 

  269. 

  270.     procedure setNull(const APath : string);overload;
    271. 

  271.     procedure setNull(const APropertyIndex : PtrUInt);overload;
    272. 

  272.     procedure setNull(const AProperty : ISDOProperty);overload;
    273. 

  273. 

  274.     function isNull(const APath : string) : Boolean;overload;
    275. 

  275.     function isNull(const APropertyIndex : PtrUInt) : Boolean;overload;
    276. 

  276.     function isNull(const AProperty : ISDOProperty) : Boolean;overload;
    277. 

  277. 

  278.     function isSet(const APath : string) : Boolean;overload;
    279. 

  279.     function isSet(const APropertyIndex : PtrUInt) : Boolean;overload;
    280. 

  280.     function isSet(const AProperty : ISDOProperty) : Boolean;overload;
    281. 

  281. 

  282.     procedure unset(const APath : string);overload;
    283. 

  283.     procedure unset(const APropertyIndex : PtrUInt);overload;
    284. 

  284.     procedure unset(const AProperty : ISDOProperty);overload;
    285. 

  285. 

  286.     function createDataObject(const APath : string) : ISDODataObject; overload;
    287. 

  287.     function createDataObject(const APropertyIndex : PtrUInt) : ISDODataObject; overload;
    288. 

  288.     function createDataObject(const AProperty : ISDOProperty) : ISDODataObject; overload;
    289. 

  289. 

  290.     function getChangeSummary() : ISDOChangeSummary;overload;
    291. 

  291.     {function getChangeSummary(const APath : string) : ISDOChangeSummary;overload;
    292. 

  292.     function getChangeSummary(const APropIndex : PtrUInt) : ISDOChangeSummary;overload;
    293. 

  293.     function getChangeSummary(const AProp : ISDOProperty ) : ISDOChangeSummary;overload;
    294. 

  294.     }
    295. 

  295.     procedure clear();
    296. 

  296. 

  297.     // IDataObjectObserver implementation
    298. 

  298.     procedure NotifyDeletion(
    299. 

  299.       const ADataObject : ISDODataObject;
    300. 

  300.       const AProperty : ISDOProperty
    301. 

  301.     );
    302. 

  302.     procedure AddReference(
    303. 

  303.       const AReferencer : ISDODataObject;
    304. 

  304.       const AReferenceProperty : ISDOProperty
    305. 

  305.     );
    306. 

  306.     procedure RemoveReference(
    307. 

  307.       const AReferencer : ISDODataObject;
    308. 

  308.       const AReferenceProperty : ISDOProperty
    309. 

  309.     );
    310. 

  310.     procedure NotifyContainedObjectsForDeletion(const ACallFromParent : Boolean);// logical deletion
    311. 

  311.     // for open Type support
    312. 

  312.     procedure addProperty(
    313. 

  313.       const APropName : string;
    314. 

  314.       const APropType : ISDOType;
    315. 

  315.       const AFlags : TPropertyFlags
    316. 

  316.     );
    317. 

  317.   public
    318. 

  318.     constructor Create(
    319. 

  319.       const AType : ISDOTypeEx;
    320. 

  320.       const AContainer : ISDODataObject;
    321. 

  321.       const AContainerProperty : ISDOProperty
    322. 

  322.     );virtual;
    323. 

  323.     destructor Destroy();override;
    324. 

  324.   end;
    325. 

  325. 

  326.   TSDODataObject = class(TSDOBaseDataObject, IInterface, ISDODataObject)
    327. 

  327.   end;
    328. 

  328. 

  329.   TSDOOpenedDataObject = class(
    330. 

  330.     TSDOBaseDataObject,
    331. 

  331.     IInterface,
    332. 

  332.     ISDODataObject,
    333. 

  333.     ISDODataObjectEx
    334. 

  334.   )
    335. 

  335.   private
    336. 

  336.     FInstanceProperties : ISDOPropertyListEx;
    337. 

  337.   protected
    338. 

  338.     function IsOwnerOf(const AProp : ISDOProperty) : Boolean; override;
    339. 

  339.     function getInstanceProperties() : ISDOPropertyList;override;
    340. 

  340.     procedure setBoolean(const APath : string; const AValue : TSDOBoolean); overload; override;
    341. 

  341.     procedure setByte(const APath : string; const AValue : TSDOByte); overload; override;
    342. 

  342. {$IFDEF HAS_SDO_BYTES}
    343. 

  343.     procedure setBytes(const APath : string; AValue : TSDOBytes); overload; override;
    344. 

  344. {$ENDIF HAS_SDO_BYTES}
    345. 

  345. {$IFDEF HAS_SDO_CHAR}
    346. 

  346.     procedure setCharacter(const APath : string; const AValue : TSDOChar); overload; override;
    347. 

  347. {$ENDIF HAS_SDO_CHAR}
    348. 

  348. {$IFDEF HAS_SDO_CURRENCY}
    349. 

  349.     procedure setCurrency(const APath : string; const AValue : Currency); overload; override;
    350. 

  350. {$ENDIF HAS_SDO_CURRENCY}
    351. 

  351.     procedure setDate(const APath : string; const AValue : TSDODate);overload;override;
    352. 

  352. {$IFDEF HAS_SDO_DOUBLE}
    353. 

  353.     procedure setDouble(const APath : string; const AValue : TSDODouble); overload; override;
    354. 

  354. {$ENDIF HAS_SDO_DOUBLE}
    355. 

  355. {$IFDEF HAS_SDO_FLOAT}
    356. 

  356.     procedure setFloat(const APath : string; const AValue : TSDOFloat); overload; override;
    357. 

  357. {$ENDIF HAS_SDO_FLOAT}
    358. 

  358.     procedure setInteger(const APath : string; const AValue : TSDOInteger);overload;override;
    359. 

  359. {$IFDEF HAS_SDO_LONG}
    360. 

  360.     procedure setLong(const APath : string; const AValue : TSDOLong); overload; override;
    361. 

  361. {$ENDIF HAS_SDO_LONG}
    362. 

  362. {$IFDEF HAS_SDO_SHORT}
    363. 

  363.     procedure setShort(const APath : string; const AValue : TSDOShort); overload; override;
    364. 

  364. {$ENDIF HAS_SDO_SHORT}
    365. 

  365.     procedure setString(const APath : string; const AValue : TSDOString);overload;override;
    366. 

  366.     procedure setDataObject(const APath : string; AValue : ISDODataObject); overload; override;
    367. 

  367. 

  368.     // for open Type support
    369. 

  369.     procedure addProperty(
    370. 

  370.       const APropName : string;
    371. 

  371.       const APropType : ISDOType;
    372. 

  372.       const AFlags : TPropertyFlags
    373. 

  373.     );
    374. 

  374.   public
    375. 

  375.     constructor Create(
    376. 

  376.       const AType : ISDOTypeEx;
    377. 

  377.       const AContainer : ISDODataObject;
    378. 

  378.       const AContainerProperty : ISDOProperty
    379. 

  379.     );override;
    380. 

  380.   end;
    381. 

  381. 

  382.   TSDODataObjectList = class(TInterfacedObject,IInterface,ISDODataObjectList)
    383. 

  383.   private
    384. 

  384.     FItemType : ISDOType;
    385. 

  385.     FData : TDoubleLinkedList;
    386. 

  386.     FCursor : ILinkedListCursor;
    387. 

  387.     FField : ISDOField;
    388. 

  388.   private
    389. 

  389.     procedure Clear();
    390. 

  390.     procedure InternalDelete(const AData : PLinkedNode);{$IFDEF USE_INLINE}inline;{$ENDIF}
    391. 

  391.     function InternalAppend() : PLinkedNode;{$IFDEF USE_INLINE}inline;{$ENDIF}
    392. 

  392.     procedure CheckCursorPosition();{$IFDEF USE_INLINE}inline;{$ENDIF}
    393. 

  393.     procedure MoveTo(const AIndex : PtrInt);{$IFDEF USE_INLINE}inline;{$ENDIF}
    394. 

  394.   protected
    395. 

  395.     function getItemType() : ISDOType;{$IFDEF USE_INLINE}inline;{$ENDIF}
    396. 

  396.     function size() : PtrInt;
    397. 

  397.     function getCursor() : ILinkedListCursor;
    398. 

  398. 

  399.     {These operations use the cursor location}
    400. 

  400.     function getBoolean() : TSDOBoolean;overload;
    401. 

  401.     function getByte() : TSDOByte;overload;
    402. 

  402. {$IFDEF HAS_SDO_BYTES}
    403. 

  403.     function getBytes() : TSDOBytes;overload;
    404. 

  404. {$ENDIF HAS_SDO_BYTES}
    405. 

  405. {$IFDEF HAS_SDO_CHAR}
    406. 

  406.     function getCharacter() : TSDOChar;overload;
    407. 

  407. {$ENDIF HAS_SDO_CHAR}
    408. 

  408. {$IFDEF HAS_SDO_CURRENCY}
    409. 

  409.     function getCurrency() : TSDOCurrency;overload;
    410. 

  410. {$ENDIF HAS_SDO_CURRENCY}
    411. 

  411.     function getDate() : TSDODate;overload;
    412. 

  412. {$IFDEF HAS_SDO_DOUBLE}
    413. 

  413.     function getDouble() : TSDODouble;overload;
    414. 

  414. {$ENDIF HAS_SDO_DOUBLE}
    415. 

  415. {$IFDEF HAS_SDO_FLOAT}
    416. 

  416.     function getFloat() : TSDOFloat;overload;
    417. 

  417. {$ENDIF HAS_SDO_FLOAT}
    418. 

  418.     function getInteger() : TSDOInteger;overload;
    419. 

  419. {$IFDEF HAS_SDO_LONG}
    420. 

  420.     function getLong() : TSDOLong;overload;
    421. 

  421. {$ENDIF HAS_SDO_LONG}
    422. 

  422. {$IFDEF HAS_SDO_SHORT}
    423. 

  423.     function getShort() : TSDOShort;overload;
    424. 

  424. {$ENDIF HAS_SDO_SHORT}
    425. 

  425.     function getString() : TSDOString;overload;
    426. 

  426.     function getDataObject() : ISDODataObject;overload;
    427. 

  427.     function getVariant() : TSDOVariant;overload;
    428. 

  428. 

  429. 

  430.     procedure setBoolean(const AValue : TSDOBoolean);overload;
    431. 

  431.     procedure setByte(const AValue : TSDOByte);overload;
    432. 

  432. {$IFDEF HAS_SDO_BYTES}
    433. 

  433.    procedure setBytes(AValue : TSDOBytes);overload;
    434. 

  434. {$ENDIF HAS_SDO_BYTES}
    435. 

  435. {$IFDEF HAS_SDO_CHAR}
    436. 

  436.     procedure setCharacter(const AValue : TSDOChar);overload;
    437. 

  437. {$ENDIF HAS_SDO_CHAR}
    438. 

  438. {$IFDEF HAS_SDO_CURRENCY}
    439. 

  439.     procedure setCurrency(const AValue : TSDOCurrency);overload;
    440. 

  440. {$ENDIF HAS_SDO_CURRENCY}
    441. 

  441.     procedure setDate(const AValue : TSDODate);overload;
    442. 

  442. {$IFDEF HAS_SDO_DOUBLE}
    443. 

  443.     procedure setDouble(const AValue : TSDODouble);overload;
    444. 

  444. {$ENDIF HAS_SDO_DOUBLE}
    445. 

  445. {$IFDEF HAS_SDO_FLOAT}
    446. 

  446.     procedure setFloat(const AValue : TSDOFloat);overload;
    447. 

  447. {$ENDIF HAS_SDO_FLOAT}
    448. 

  448.     procedure setInteger(const AValue : TSDOInteger);overload;
    449. 

  449. {$IFDEF HAS_SDO_LONG}
    450. 

  450.     procedure setLong(const AValue : TSDOLong);overload;
    451. 

  451. {$ENDIF HAS_SDO_LONG}
    452. 

  452. {$IFDEF HAS_SDO_SHORT}
    453. 

  453.     procedure setShort(const AValue : TSDOShort);overload;
    454. 

  454. {$ENDIF HAS_SDO_SHORT}
    455. 

  455.     procedure setString(const AValue : TSDOString);overload;
    456. 

  456.     procedure setDataObject(AValue : ISDODataObject);overload;
    457. 

  457.     procedure setVariant(const AValue : TSDOVariant);overload;
    458. 

  458. 

  459. 

  460.     function getBoolean(const AIndex : PtrInt) : TSDOBoolean;overload;
    461. 

  461.     function getByte(const AIndex : PtrInt) : TSDOByte;overload;
    462. 

  462. {$IFDEF HAS_SDO_BYTES}
    463. 

  463.     function getBytes(const AIndex : PtrInt) : TSDOBytes;overload;
    464. 

  464. {$ENDIF HAS_SDO_BYTES}
    465. 

  465. {$IFDEF HAS_SDO_CHAR}
    466. 

  466.     function getCharacter(const AIndex : PtrInt) : TSDOChar;overload;
    467. 

  467. {$ENDIF HAS_SDO_CHAR}
    468. 

  468. {$IFDEF HAS_SDO_CURRENCY}
    469. 

  469.     function getCurrency(const AIndex : PtrInt) : TSDOCurrency;overload;
    470. 

  470. {$ENDIF HAS_SDO_CURRENCY}
    471. 

  471.     function getDate(const AIndex : PtrInt) : TSDODate;overload;
    472. 

  472. {$IFDEF HAS_SDO_DOUBLE}
    473. 

  473.     function getDouble(const AIndex : PtrInt) : TSDODouble;overload;
    474. 

  474. {$ENDIF HAS_SDO_DOUBLE}
    475. 

  475. {$IFDEF HAS_SDO_FLOAT}
    476. 

  476.     function getFloat(const AIndex : PtrInt) : TSDOFloat;overload;
    477. 

  477. {$ENDIF HAS_SDO_FLOAT}
    478. 

  478.     function getInteger(const AIndex : PtrInt) : TSDOInteger;overload;
    479. 

  479. {$IFDEF HAS_SDO_LONG}
    480. 

  480.     function getLong(const AIndex : PtrInt) : TSDOLong;overload;
    481. 

  481. {$ENDIF HAS_SDO_LONG}
    482. 

  482. {$IFDEF HAS_SDO_SHORT}
    483. 

  483.     function getShort(const AIndex : PtrInt) : TSDOShort;overload;
    484. 

  484. {$ENDIF HAS_SDO_SHORT}
    485. 

  485.     function getString(const AIndex : PtrInt) : TSDOString;overload;
    486. 

  486.     function getDataObject(const AIndex : PtrInt) : ISDODataObject;overload;
    487. 

  487.     function getVariant(const AIndex : PtrInt) : TSDOVariant;overload;
    488. 

  488. 

  489. 

  490.     procedure setBoolean(const AIndex : PtrInt; const AValue : TSDOBoolean);overload;
    491. 

  491.     procedure setByte(const AIndex : PtrInt; const AValue : TSDOByte);overload;
    492. 

  492. {$IFDEF HAS_SDO_BYTES}
    493. 

  493.     procedure setBytes(const AIndex : PtrInt; AValue : TSDOBytes);overload;
    494. 

  494. {$ENDIF HAS_SDO_BYTES}
    495. 

  495. {$IFDEF HAS_SDO_CHAR}
    496. 

  496.     procedure setCharacter(const AIndex : PtrInt; const AValue : TSDOChar);overload;
    497. 

  497. {$ENDIF HAS_SDO_CHAR}
    498. 

  498. {$IFDEF HAS_SDO_CURRENCY}
    499. 

  499.     procedure setCurrency(const AIndex : PtrInt; const AValue : TSDOCurrency);overload;
    500. 

  500. {$ENDIF HAS_SDO_CURRENCY}
    501. 

  501.     procedure setDate(const AIndex : PtrInt; const AValue : TSDODate);overload;
    502. 

  502. {$IFDEF HAS_SDO_DOUBLE}
    503. 

  503.     procedure setDouble(const AIndex : PtrInt; const AValue : TSDODouble);overload;
    504. 

  504. {$ENDIF HAS_SDO_DOUBLE}
    505. 

  505. {$IFDEF HAS_SDO_FLOAT}
    506. 

  506.     procedure setFloat(const AIndex : PtrInt; const AValue : TSDOFloat);overload;
    507. 

  507. {$ENDIF HAS_SDO_FLOAT}
    508. 

  508.     procedure setInteger(const AIndex : PtrInt; const AValue : TSDOInteger);overload;
    509. 

  509. {$IFDEF HAS_SDO_LONG}
    510. 

  510.     procedure setLong(const AIndex : PtrInt; const AValue : TSDOLong);overload;
    511. 

  511. {$ENDIF HAS_SDO_LONG}
    512. 

  512. {$IFDEF HAS_SDO_SHORT}
    513. 

  513.     procedure setShort(const AIndex : PtrInt; const AValue : TSDOShort);overload;
    514. 

  514. {$ENDIF HAS_SDO_SHORT}
    515. 

  515.     procedure setString(const AIndex : PtrInt; const AValue : TSDOString);overload;
    516. 

  516.     procedure setVariant(const AIndex : PtrInt; const AValue : TSDOVariant);overload;
    517. 

  517.     procedure setDataObject(const AIndex : PtrInt; AValue : ISDODataObject);overload;
    518. 

  518. 

  519. 

  520.     procedure insert(const AIndex : PtrInt; const AValue : TSDOBoolean);overload;
    521. 

  521.     procedure insert(const AIndex : PtrInt; const AValue : TSDOByte);overload;
    522. 

  522. {$IFDEF HAS_SDO_BYTES}
    523. 

  523.     procedure insertBytes(const AIndex : PtrInt; AValue : TSDOBytes);overload;
    524. 

  524. {$ENDIF HAS_SDO_BYTES}
    525. 

  525. {$IFDEF HAS_SDO_CHAR}
    526. 

  526.     procedure insert(const AIndex : PtrInt; const AValue : TSDOChar);overload;
    527. 

  527. {$ENDIF HAS_SDO_CHAR}
    528. 

  528. {$IFDEF HAS_SDO_CURRENCY}
    529. 

  529.     procedure insertCurrency(const AIndex : PtrInt; const AValue : TSDOCurrency);
    530. 

  530. {$ENDIF HAS_SDO_CURRENCY}
    531. 

  531.     procedure insert(const AIndex : PtrInt; const AValue : TSDODate);overload;
    532. 

  532. {$IFDEF HAS_SDO_DOUBLE}
    533. 

  533.     procedure insert(const AIndex : PtrInt; const AValue : TSDODouble);overload;
    534. 

  534. {$ENDIF HAS_SDO_DOUBLE}
    535. 

  535. {$IFDEF HAS_SDO_FLOAT}
    536. 

  536.     procedure insert(const AIndex : PtrInt; const AValue : TSDOFloat);overload;
    537. 

  537. {$ENDIF HAS_SDO_FLOAT}
    538. 

  538.     procedure insert(const AIndex : PtrInt; const AValue : TSDOInteger);overload;
    539. 

  539. {$IFDEF HAS_SDO_LONG}
    540. 

  540.     procedure insert(const AIndex : PtrInt; const AValue : TSDOLong);overload;
    541. 

  541. {$ENDIF HAS_SDO_LONG}
    542. 

  542. {$IFDEF HAS_SDO_SHORT}
    543. 

  543.     procedure insert(const AIndex : PtrInt; const AValue : TSDOShort);overload;
    544. 

  544. {$ENDIF HAS_SDO_SHORT}
    545. 

  545.     procedure insert(const AIndex : PtrInt; const AValue : TSDOString);overload;
    546. 

  546.     procedure insert(const AIndex : PtrInt; AValue : ISDODataObject);overload;
    547. 

  547. 

  548. 

  549.     procedure append(const AValue : TSDOBoolean);overload;
    550. 

  550.     procedure append(const AValue : TSDOByte);overload;
    551. 

  551. {$IFDEF HAS_SDO_BYTES}
    552. 

  552.     procedure appendBytes(AValue : TSDOBytes);overload;
    553. 

  553. {$ENDIF HAS_SDO_BYTES}
    554. 

  554. {$IFDEF HAS_SDO_CHAR}
    555. 

  555.     procedure append(const AValue : TSDOChar);overload;
    556. 

  556. {$ENDIF HAS_SDO_CHAR}
    557. 

  557. {$IFDEF HAS_SDO_CURRENCY}
    558. 

  558.     procedure appendCurrency(const AValue : TSDOCurrency);
    559. 

  559. {$ENDIF HAS_SDO_CURRENCY}
    560. 

  560.     procedure append(const AValue : TSDODate);overload;
    561. 

  561. {$IFDEF HAS_SDO_DOUBLE}
    562. 

  562.     procedure append(const AValue : TSDODouble);overload;
    563. 

  563. {$ENDIF HAS_SDO_DOUBLE}
    564. 

  564. {$IFDEF HAS_SDO_FLOAT}
    565. 

  565.     procedure append(const AValue : TSDOFloat);overload;
    566. 

  566. {$ENDIF HAS_SDO_FLOAT}
    567. 

  567.     procedure append(const AValue : TSDOInteger);overload;
    568. 

  568. {$IFDEF HAS_SDO_LONG}
    569. 

  569.     procedure append(const AValue : TSDOLong);overload;
    570. 

  570. {$ENDIF HAS_SDO_LONG}
    571. 

  571. {$IFDEF HAS_SDO_SHORT}
    572. 

  572.     procedure append(const AValue : TSDOShort);overload;
    573. 

  573. {$ENDIF HAS_SDO_SHORT}
    574. 

  574.     procedure append(const AValue : TSDOString);overload;
    575. 

  575.     procedure append(AValue : ISDODataObject);overload;
    576. 

  576. 

  577. 

  578.     procedure delete(const AIndex : PtrInt);overload;
    579. 

  579.     procedure delete();overload;
    580. 

  580.   public
    581. 

  581.     constructor Create(const AItemType : ISDOType);
    582. 

  582.     destructor Destroy();override;
    583. 

  583.   end;
    584. 

  584. 

  585.   TSDOOwnedDataObjectList = class(TSDODataObjectList,IInterface,ISDODataObjectList)
    586. 

  586.   private
    587. 

  587.     FOwner : Pointer; // do not add a reference count!
    588. 

  588.     FOwnerProperty : ISDOProperty;
    589. 

  589.   protected
    590. 

  590.     procedure RecordChange(const AChange : TManyValuePropAction);overload;{$IFDEF USE_INLINE}inline;{$ENDIF}
    591. 

  591.     function getOwner() : ISDODataObject;{$IFDEF USE_INLINE}inline;{$ENDIF}
    592. 

  592.     procedure InternalSetDataObject(const AValue : ISDODataObject; const ADoRecordChange : Boolean);
    593. 

  593.   protected
    594. 

  594.     procedure setBoolean(const AValue : TSDOBoolean);overload;
    595. 

  595.     procedure setByte(const AValue : TSDOByte);overload;
    596. 

  596. {$IFDEF HAS_SDO_BYTES}
    597. 

  597.     procedure setBytes(AValue : TSDOBytes);overload;
    598. 

  598. {$ENDIF HAS_SDO_BYTES}
    599. 

  599. {$IFDEF HAS_SDO_CHAR}
    600. 

  600.     procedure setCharacter(const AValue : TSDOChar);overload;
    601. 

  601. {$ENDIF HAS_SDO_CHAR}
    602. 

  602. {$IFDEF HAS_SDO_CURRENCY}
    603. 

  603.     procedure setCurrency(const AValue : TSDOCurrency);overload;
    604. 

  604. {$ENDIF HAS_SDO_CURRENCY}
    605. 

  605.     procedure setDate(const AValue : TSDODate);overload;
    606. 

  606. {$IFDEF HAS_SDO_DOUBLE}
    607. 

  607.     procedure setDouble(const AValue : TSDODouble);overload;
    608. 

  608. {$ENDIF HAS_SDO_DOUBLE}
    609. 

  609. {$IFDEF HAS_SDO_FLOAT}
    610. 

  610.     procedure setFloat(const AValue : TSDOFloat);overload;
    611. 

  611. {$ENDIF HAS_SDO_FLOAT}
    612. 

  612.     procedure setInteger(const AValue : TSDOInteger);overload;
    613. 

  613. {$IFDEF HAS_SDO_LONG}
    614. 

  614.     procedure setLong(const AValue : TSDOLong);overload;
    615. 

  615. {$ENDIF HAS_SDO_LONG}
    616. 

  616. {$IFDEF HAS_SDO_SHORT}
    617. 

  617.     procedure setShort(const AValue : TSDOShort);overload;
    618. 

  618. {$ENDIF HAS_SDO_SHORT}
    619. 

  619.     procedure setString(const AValue : TSDOString);overload;
    620. 

  620.     procedure setDataObject(AValue : ISDODataObject);overload;
    621. 

  621.     procedure setVariant(const AValue : TSDOVariant);overload;
    622. 

  622. 

  623.     procedure setBoolean(const AIndex : PtrInt; const AValue : TSDOBoolean);overload;
    624. 

  624.     procedure setByte(const AIndex : PtrInt; const AValue : TSDOByte);overload;
    625. 

  625. {$IFDEF HAS_SDO_BYTES}
    626. 

  626.     procedure setBytes(const AIndex : PtrInt; AValue : TSDOBytes);overload;
    627. 

  627. {$ENDIF HAS_SDO_BYTES}
    628. 

  628. {$IFDEF HAS_SDO_CHAR}
    629. 

  629.     procedure setCharacter(const AIndex : PtrInt; const AValue : TSDOChar);overload;
    630. 

  630. {$ENDIF HAS_SDO_CHAR}
    631. 

  631. {$IFDEF HAS_SDO_CURRENCY}
    632. 

  632.     procedure setCurrency(const AIndex : PtrInt; const AValue : TSDOCurrency);overload;
    633. 

  633. {$ENDIF HAS_SDO_CURRENCY}
    634. 

  634.     procedure setDate(const AIndex : PtrInt; const AValue : TSDODate);overload;
    635. 

  635. {$IFDEF HAS_SDO_DOUBLE}
    636. 

  636.     procedure setDouble(const AIndex : PtrInt; const AValue : TSDODouble);overload;
    637. 

  637. {$ENDIF HAS_SDO_DOUBLE}
    638. 

  638. {$IFDEF HAS_SDO_FLOAT}
    639. 

  639.     procedure setFloat(const AIndex : PtrInt; const AValue : TSDOFloat);overload;
    640. 

  640. {$ENDIF HAS_SDO_FLOAT}
    641. 

  641.     procedure setInteger(const AIndex : PtrInt; const AValue : TSDOInteger);overload;
    642. 

  642. {$IFDEF HAS_SDO_LONG}
    643. 

  643.     procedure setLong(const AIndex : PtrInt; const AValue : TSDOLong);overload;
    644. 

  644. {$ENDIF HAS_SDO_LONG}
    645. 

  645. {$IFDEF HAS_SDO_SHORT}
    646. 

  646.     procedure setShort(const AIndex : PtrInt; const AValue : TSDOShort);overload;
    647. 

  647. {$ENDIF HAS_SDO_SHORT}
    648. 

  648.     procedure setString(const AIndex : PtrInt; const AValue : TSDOString);overload;
    649. 

  649.     procedure setDataObject(const AIndex : PtrInt; AValue : ISDODataObject);overload;
    650. 

  650.     procedure setVariant(const AIndex : PtrInt; const AValue : TSDOVariant);overload;
    651. 

  651. 

  652.     procedure insert(const AIndex : PtrInt; const AValue : TSDOBoolean);overload;
    653. 

  653.     procedure insert(const AIndex : PtrInt; const AValue : TSDOByte);overload;
    654. 

  654. {$IFDEF HAS_SDO_BYTES}
    655. 

  655.     procedure insertBytes(const AIndex : PtrInt; AValue : TSDOBytes);overload;
    656. 

  656. {$ENDIF HAS_SDO_BYTES}
    657. 

  657. {$IFDEF HAS_SDO_CHAR}
    658. 

  658.     procedure insert(const AIndex : PtrInt; const AValue : TSDOChar);overload;
    659. 

  659. {$ENDIF HAS_SDO_CHAR}
    660. 

  660. {$IFDEF HAS_SDO_CURRENCY}
    661. 

  661.     procedure insertCurrency(const AIndex : PtrInt; const AValue : TSDOCurrency);
    662. 

  662. {$ENDIF HAS_SDO_CURRENCY}
    663. 

  663.     procedure insert(const AIndex : PtrInt; const AValue : TSDODate);overload;
    664. 

  664. {$IFDEF HAS_SDO_DOUBLE}
    665. 

  665.     procedure insert(const AIndex : PtrInt; const AValue : TSDODouble);overload;
    666. 

  666. {$ENDIF HAS_SDO_DOUBLE}
    667. 

  667. {$IFDEF HAS_SDO_FLOAT}
    668. 

  668.     procedure insert(const AIndex : PtrInt; const AValue : TSDOFloat);overload;
    669. 

  669. {$ENDIF HAS_SDO_FLOAT}
    670. 

  670.     procedure insert(const AIndex : PtrInt; const AValue : TSDOInteger);overload;
    671. 

  671. {$IFDEF HAS_SDO_LONG}
    672. 

  672.     procedure insert(const AIndex : PtrInt; const AValue : TSDOLong);overload;
    673. 

  673. {$ENDIF HAS_SDO_LONG}
    674. 

  674. {$IFDEF HAS_SDO_SHORT}
    675. 

  675.     procedure insert(const AIndex : PtrInt; const AValue : TSDOShort);overload;
    676. 

  676. {$ENDIF HAS_SDO_SHORT}
    677. 

  677.     procedure insert(const AIndex : PtrInt; const AValue : TSDOString);overload;
    678. 

  678.     procedure insert(const AIndex : PtrInt; AValue : ISDODataObject);overload;
    679. 

  679. 

  680.     procedure append(const AValue : TSDOBoolean);overload;
    681. 

  681.     procedure append(const AValue : TSDOByte);overload;
    682. 

  682. {$IFDEF HAS_SDO_BYTES}
    683. 

  683.     procedure appendBytes(AValue : TSDOBytes);overload;
    684. 

  684. {$ENDIF HAS_SDO_BYTES}
    685. 

  685. {$IFDEF HAS_SDO_CHAR}
    686. 

  686.     procedure append(const AValue : TSDOChar);overload;
    687. 

  687. {$ENDIF HAS_SDO_CHAR}
    688. 

  688. {$IFDEF HAS_SDO_CURRENCY}
    689. 

  689.     procedure appendCurrency(const AValue : TSDOCurrency);
    690. 

  690. {$ENDIF HAS_SDO_CURRENCY}
    691. 

  691.     procedure append(const AValue : TSDODate);overload;
    692. 

  692. {$IFDEF HAS_SDO_DOUBLE}
    693. 

  693.     procedure append(const AValue : TSDODouble);overload;
    694. 

  694. {$ENDIF HAS_SDO_DOUBLE}
    695. 

  695. {$IFDEF HAS_SDO_FLOAT}
    696. 

  696.     procedure append(const AValue : TSDOFloat);overload;
    697. 

  697. {$ENDIF HAS_SDO_FLOAT}
    698. 

  698.     procedure append(const AValue : TSDOInteger);overload;
    699. 

  699. {$IFDEF HAS_SDO_LONG}
    700. 

  700.     procedure append(const AValue : TSDOLong);overload;
    701. 

  701. {$ENDIF HAS_SDO_LONG}
    702. 

  702. {$IFDEF HAS_SDO_SHORT}
    703. 

  703.     procedure append(const AValue : TSDOShort);overload;
    704. 

  704. {$ENDIF HAS_SDO_SHORT}
    705. 

  705.     procedure append(AValue : ISDODataObject);overload;
    706. 

  706.     procedure append(const AValue : TSDOString);overload;
    707. 

  707. 

  708.     procedure delete(const AIndex : PtrInt);overload;
    709. 

  709.     procedure delete();overload;
    710. 

  710.   public
    711. 

  711.     constructor Create(
    712. 

  712.       const AOwner : ISDODataObject;
    713. 

  713.       const AProperty : ISDOProperty
    714. 

  714.     );
    715. 

  715.   end;
    716. 

  716. 

  717. implementation
    718. 

  718. 

  719. uses
    720. 

  720.   sdo_imp_utils, sdo_utils;
    721. 

  721. 

  722. { TSDOBaseDataObject }
    723. 

  723. 

  724. procedure TSDOBaseDataObject.clear;
    725. 

  725. begin
    726. 

  726. 

  727. end;
    728. 

  728. 

  729. constructor TSDOBaseDataObject.Create(
    730. 

  730.   const AType: ISDOTypeEx;
    731. 

  731.   const AContainer : ISDODataObject;
    732. 

  732.   const AContainerProperty : ISDOProperty
    733. 

  733. );
    734. 

  734. begin
    735. 

  735.   if ( AType = nil ) then
    736. 

  736.     raise ESDOIllegalArgumentException.Create('AType');
    737. 

  737.   if ( AContainer <> nil ) and ( AContainerProperty = nil ) then
    738. 

  738.     raise ESDOIllegalArgumentException.Create('AContainerProperty');
    739. 

  739.   FType := AType as ISDOObjectType;
    740. 

  740.   FContainer := Pointer(AContainer);
    741. 

  741.   FContainerProperty := Pointer(AContainerProperty);
    742. 

  742.   FXPathExpression := TXPathExpression.Create();
    743. 

  743.   FXPathProcessor := TXPathProcessor.Create();
    744. 

  744.   PrepareDataBuffer();
    745. 

  745.   InitializeDefaultValues();
    746. 

  746.   FType.setUsedFlag(True);
    747. 

  747. end;
    748. 

  748. 

  749. function TSDOBaseDataObject.createDataObject(const APath: string): ISDODataObject;
    750. 

  750. var
    751. 

  751.   locCtx : TXPathExecContext;
    752. 

  752. begin
    753. 

  753.   locCtx := parsePropertyPath(APath);
    754. 

  754.   if ( locCtx.PropertyOwner = nil ) then
    755. 

  755.     raise ESDOInvalidPathException.Create(APath);
    756. 

  756.   Result := locCtx.PropertyOwner.createDataObject(locCtx.CurrentProperty);
    757. 

  757. end;
    758. 

  758. 

  759. function TSDOBaseDataObject.createDataObject(const AProperty: ISDOProperty) : ISDODataObject;
    760. 

  760. var
    761. 

  761.   prp : ISDOPropertyEx;
    762. 

  762. begin
    763. 

  763.   if ( AProperty = nil ) or ( not Self.IsOwnerOf(AProperty) ) then
    764. 

  764.     raise ESDOIllegalArgumentException.Create('AProperty');
    765. 

  765.   prp := AProperty as ISDOPropertyEx;
    766. 

  766.   Result := TSDOBaseDataObjectClass(Self.ClassType).Create(
    767. 

  767.               prp.getType() as ISDOTypeEx,
    768. 

  768.               nil, //Self as ISDODataObject,
    769. 

  769.               prp
    770. 

  770.             ) as ISDODataObject;
    771. 

  771.   if not AProperty.isMany() then
    772. 

  772.     setDataObject(prp,Result);
    773. 

  773. end;
    774. 

  774. 

  775. function TSDOBaseDataObject.createDataObject(const APropertyIndex: PtrUInt): ISDODataObject;
    776. 

  776. begin
    777. 

  777.   Result := createDataObject(getProperty(APropertyIndex));
    778. 

  778. end;
    779. 

  779. 

  780. destructor TSDOBaseDataObject.Destroy();
    781. 

  781. begin
    782. 

  782.   FDestroying := True;
    783. 

  783.   FreeBuffer();
    784. 

  784.   FType := nil;
    785. 

  785.   FContainer := nil;
    786. 

  786.   FContainerProperty := nil;
    787. 

  787.   FChangeSummary := nil;
    788. 

  788.   FreeAndNil(FReferenceLinkList);
    789. 

  789.   FreeAndNil(FXPathExpression);
    790. 

  790.   FreeAndNil(FXPathProcessor);
    791. 

  791.   inherited;
    792. 

  792. end;
    793. 

  793. 

  794. function TSDOBaseDataObject.getBoolean(const APath: string): TSDOBoolean;
    795. 

  795. var
    796. 

  796.   locCtx : TXPathExecContext;
    797. 

  797. begin
    798. 

  798.   locCtx := parsePropertyPath(APath);
    799. 

  799.   if ( locCtx.PropertyOwner = nil ) then
    800. 

  800.     raise ESDOInvalidPathException.Create(APath);
    801. 

  801.   if ( locCtx.ContentKind = xckList ) then
    802. 

  802.     Result := locCtx.ListItem.getBoolean()
    803. 

  803.   else
    804. 

  804.     Result := locCtx.PropertyOwner.getBoolean(locCtx.CurrentProperty);
    805. 

  805. end;
    806. 

  806. 

  807. function TSDOBaseDataObject.getBoolean(const APropertyIndex: PtrUInt): TSDOBoolean;
    808. 

  808. begin
    809. 

  809.   Result := getBoolean(getProperty(APropertyIndex));
    810. 

  810. end;
    811. 

  811. 

  812. function TSDOBaseDataObject.getBoolean(const AProperty: ISDOProperty): TSDOBoolean;
    813. 

  813. var
    814. 

  814.   prp : ISDOPropertyEx;
    815. 

  815. begin
    816. 

  816.   if ( AProperty = nil ) or
    817. 

  817.      ( not Self.IsOwnerOf(AProperty) ) or
    818. 

  818.      ( AProperty.isMany() )
    819. 

  819.   then begin
    820. 

  820.     raise ESDOIllegalArgumentException.Create('AProperty');
    821. 

  821.   end;
    822. 

  822.   prp := AProperty as ISDOPropertyEx;
    823. 

  823.   Result := getField(prp.getTypeEnum()).getBoolean(FBuffer,prp.getBufferOffset());
    824. 

  824. end;
    825. 

  825. 

  826. function TSDOBaseDataObject.getByte(const APath: string): TSDOByte;
    827. 

  827. var
    828. 

  828.   locCtx : TXPathExecContext;
    829. 

  829. begin
    830. 

  830.   locCtx := parsePropertyPath(APath);
    831. 

  831.   if ( locCtx.PropertyOwner = nil ) then
    832. 

  832.     raise ESDOInvalidPathException.Create(APath);
    833. 

  833.   if ( locCtx.ContentKind = xckList ) then
    834. 

  834.     Result := locCtx.ListItem.getByte()
    835. 

  835.   else
    836. 

  836.     Result := locCtx.PropertyOwner.getByte(locCtx.CurrentProperty);
    837. 

  837. end;
    838. 

  838. 

  839. function TSDOBaseDataObject.getByte(const APropertyIndex: PtrUInt): TSDOByte;
    840. 

  840. begin
    841. 

  841.   Result := getByte(getProperty(APropertyIndex));
    842. 

  842. end;
    843. 

  843. 

  844. function TSDOBaseDataObject.getByte(const AProperty: ISDOProperty): TSDOByte;
    845. 

  845. var
    846. 

  846.   prp : ISDOPropertyEx;
    847. 

  847. begin
    848. 

  848.   if ( AProperty = nil ) or
    849. 

  849.      ( not Self.IsOwnerOf(AProperty) ) or
    850. 

  850.      ( AProperty.isMany() )
    851. 

  851.   then begin
    852. 

  852.     raise ESDOIllegalArgumentException.Create('AProperty');
    853. 

  853.   end;
    854. 

  854.   prp := AProperty as ISDOPropertyEx;
    855. 

  855.   Result := getField(prp.getTypeEnum()).getByte(FBuffer,prp.getBufferOffset());
    856. 

  856. end;
    857. 

  857. 

  858. {$IFDEF HAS_SDO_BYTES}
    859. 

  859. function TSDOBaseDataObject.getBytes(const AProperty: ISDOProperty): TSDOBytes;
    860. 

  860. var
    861. 

  861.   prp : ISDOPropertyEx;
    862. 

  862. begin
    863. 

  863.   if ( AProperty = nil ) or
    864. 

  864.      ( not Self.IsOwnerOf(AProperty) ) or
    865. 

  865.      ( AProperty.isMany() )
    866. 

  866.   then begin
    867. 

  867.     raise ESDOIllegalArgumentException.Create('AProperty');
    868. 

  868.   end;
    869. 

  869.   prp := AProperty as ISDOPropertyEx;
    870. 

  870.   Result := getField(prp.getTypeEnum()).getBytes(FBuffer,prp.getBufferOffset());
    871. 

  871. end;
    872. 

  872. 

  873. function TSDOBaseDataObject.getBytes(const APath: string): TSDOBytes;
    874. 

  874. var
    875. 

  875.   locCtx : TXPathExecContext;
    876. 

  876. begin
    877. 

  877.   locCtx := parsePropertyPath(APath);
    878. 

  878.   if ( locCtx.PropertyOwner = nil ) then
    879. 

  879.     raise ESDOInvalidPathException.Create(APath);
    880. 

  880.   if ( locCtx.ContentKind = xckList ) then
    881. 

  881.     Result := locCtx.ListItem.getBytes()
    882. 

  882.   else
    883. 

  883.     Result := locCtx.PropertyOwner.getBytes(locCtx.CurrentProperty);
    884. 

  884. end;
    885. 

  885. 

  886. function TSDOBaseDataObject.getBytes(const APropertyIndex: PtrUInt): TSDOBytes;
    887. 

  887. begin
    888. 

  888.   Result := getBytes(getProperty(APropertyIndex));
    889. 

  889. end;
    890. 

  890. {$ENDIF HAS_SDO_BYTES}
    891. 

  891. 

  892. function TSDOBaseDataObject.getCharacter(const AProperty: ISDOProperty): TSDOChar;
    893. 

  893. var
    894. 

  894.   prp : ISDOPropertyEx;
    895. 

  895. begin
    896. 

  896.   if ( AProperty = nil ) or
    897. 

  897.      ( not Self.IsOwnerOf(AProperty) ) or
    898. 

  898.      ( AProperty.isMany() )
    899. 

  899.   then begin
    900. 

  900.     raise ESDOIllegalArgumentException.Create('AProperty');
    901. 

  901.   end;
    902. 

  902.   prp := AProperty as ISDOPropertyEx;
    903. 

  903.   Result := getField(prp.getTypeEnum()).getCharacter(FBuffer,prp.getBufferOffset());
    904. 

  904. end;
    905. 

  905. 

  906. function TSDOBaseDataObject.getCharacter(const APropertyIndex: PtrUInt): TSDOChar;
    907. 

  907. begin
    908. 

  908.   Result := getCharacter(getProperty(APropertyIndex));
    909. 

  909. end;
    910. 

  910. 

  911. function TSDOBaseDataObject.getCharacter(const APath: string): TSDOChar;
    912. 

  912. var
    913. 

  913.   locCtx : TXPathExecContext;
    914. 

  914. begin
    915. 

  915.   locCtx := parsePropertyPath(APath);
    916. 

  916.   if ( locCtx.PropertyOwner = nil ) then
    917. 

  917.     raise ESDOInvalidPathException.Create(APath);
    918. 

  918.   if ( locCtx.ContentKind = xckList ) then
    919. 

  919.     Result := locCtx.ListItem.getCharacter()
    920. 

  920.   else
    921. 

  921.     Result := locCtx.PropertyOwner.getCharacter(locCtx.CurrentProperty);
    922. 

  922. end;
    923. 

  923. 

  924. function TSDOBaseDataObject.getContainer() : ISDODataObject;
    925. 

  925. begin
    926. 

  926.   Result := ISDODataObject(FContainer);
    927. 

  927. end;
    928. 

  928. 

  929. function TSDOBaseDataObject.getContainmentProperty() : ISDOProperty;
    930. 

  930. begin
    931. 

  931.   if not Assigned(FContainerProperty) then
    932. 

  932.     raise ESDOPropertyNotFoundException.Create('ContainmentProperty');
    933. 

  933.   Result := ISDOProperty(FContainerProperty);
    934. 

  934. end;
    935. 

  935. 

  936. {$IFDEF HAS_SDO_CURRENCY }
    937. 

  937. function TSDOBaseDataObject.getCurrency(const AProperty: ISDOProperty): TSDOCurrency;
    938. 

  938. var
    939. 

  939.   prp : ISDOPropertyEx;
    940. 

  940. begin
    941. 

  941.   if ( AProperty = nil ) or
    942. 

  942.      ( not Self.IsOwnerOf(AProperty) ) or
    943. 

  943.      ( AProperty.isMany() )
    944. 

  944.   then begin
    945. 

  945.     raise ESDOIllegalArgumentException.Create('AProperty');
    946. 

  946.   end;
    947. 

  947.   prp := AProperty as ISDOPropertyEx;
    948. 

  948.   Result := getField(prp.getTypeEnum()).getCurrency(FBuffer,prp.getBufferOffset());
    949. 

  949. end;
    950. 

  950. 

  951. function TSDOBaseDataObject.getCurrency(const APropertyIndex: PtrUInt): TSDOCurrency;
    952. 

  952. begin
    953. 

  953.   Result := getCurrency(getProperty(APropertyIndex));
    954. 

  954. end;
    955. 

  955. 

  956. function TSDOBaseDataObject.getCurrency(const APath: string): TSDOCurrency;
    957. 

  957. var
    958. 

  958.   locCtx : TXPathExecContext;
    959. 

  959. begin
    960. 

  960.   locCtx := parsePropertyPath(APath);
    961. 

  961.   if ( locCtx.PropertyOwner = nil ) then
    962. 

  962.     raise ESDOInvalidPathException.Create(APath);
    963. 

  963.   if ( locCtx.ContentKind = xckList ) then
    964. 

  964.     Result := locCtx.ListItem.getCurrency()
    965. 

  965.   else
    966. 

  966.     Result := locCtx.PropertyOwner.getCurrency(locCtx.CurrentProperty);
    967. 

  967. end;
    968. 

  968. {$ENDIF HAS_SDO_CURRENCY }
    969. 

  969. 

  970. function TSDOBaseDataObject.getDataObject(const APath: string): ISDODataObject;
    971. 

  971. var
    972. 

  972.   locCtx : TXPathExecContext;
    973. 

  973. begin
    974. 

  974.   locCtx := parsePropertyPath(APath);
    975. 

  975.   if ( locCtx.PropertyOwner = nil ) then
    976. 

  976.     raise ESDOInvalidPathException.Create(APath);
    977. 

  977.   Result := locCtx.ObjectItem;
    978. 

  978.   {if ( locCtx.ContentKind = xckList ) then
    979. 

  979.     Result := locCtx.ListItem.getDataObject()
    980. 

  980.   else
    981. 

  981.     Result := locCtx.PropertyOwner.getDataObject(locCtx.CurrentProperty);}
    982. 

  982. end;
    983. 

  983. 

  984. function TSDOBaseDataObject.getDataObject(const APropertyIndex: PtrUInt): ISDODataObject;
    985. 

  985. begin
    986. 

  986.   Result := getDataObject(getProperty(APropertyIndex));
    987. 

  987. end;
    988. 

  988. 

  989. function TSDOBaseDataObject.getDataObject(const AProperty: ISDOProperty): ISDODataObject;
    990. 

  990. var
    991. 

  991.   prp : ISDOPropertyEx;
    992. 

  992. begin
    993. 

  993.   if ( AProperty = nil ) or ( not Self.IsOwnerOf(AProperty) ) then
    994. 

  994.     raise ESDOIllegalArgumentException.Create('AProperty');
    995. 

  995.   if AProperty.isMany() then begin
    996. 

  996.     Result := getList(AProperty).getDataObject();
    997. 

  997.   end else begin
    998. 

  998.     prp := AProperty as ISDOPropertyEx;
    999. 

  999.     Result := getField(prp.getTypeEnum()).getDataObject(FBuffer,prp.getBufferOffset());
    1000. 

  1000.   end;
    1001. 

  1001. end;
    1002. 

  1002. 

  1003. function TSDOBaseDataObject.getDate(const APropertyIndex: PtrUInt): TSDODate;
    1004. 

  1004. begin
    1005. 

  1005.   Result := getDate(getProperty(APropertyIndex));
    1006. 

  1006. end;
    1007. 

  1007. 

  1008. function TSDOBaseDataObject.getDate(const APath: string): TSDODate;
    1009. 

  1009. var
    1010. 

  1010.   locCtx : TXPathExecContext;
    1011. 

  1011. begin
    1012. 

  1012.   locCtx := parsePropertyPath(APath);
    1013. 

  1013.   if ( locCtx.PropertyOwner = nil ) then
    1014. 

  1014.     raise ESDOInvalidPathException.Create(APath);
    1015. 

  1015.   if ( locCtx.ContentKind = xckList ) then
    1016. 

  1016.     Result := locCtx.ListItem.getDate()
    1017. 

  1017.   else
    1018. 

  1018.     Result := locCtx.PropertyOwner.getDate(locCtx.CurrentProperty);
    1019. 

  1019. end;
    1020. 

  1020. 

  1021. function TSDOBaseDataObject.getDate(const AProperty: ISDOProperty): TSDODate;
    1022. 

  1022. var
    1023. 

  1023.   prp : ISDOPropertyEx;
    1024. 

  1024. begin
    1025. 

  1025.   if ( AProperty = nil ) or
    1026. 

  1026.      ( not Self.IsOwnerOf(AProperty) ) or
    1027. 

  1027.      ( AProperty.isMany() )
    1028. 

  1028.   then begin
    1029. 

  1029.     raise ESDOIllegalArgumentException.Create('AProperty');
    1030. 

  1030.   end;
    1031. 

  1031.   prp := AProperty as ISDOPropertyEx;
    1032. 

  1032.   Result := getField(prp.getTypeEnum()).getDate(FBuffer,prp.getBufferOffset());
    1033. 

  1033. end;
    1034. 

  1034. 

  1035. {$IFDEF HAS_SDO_DOUBLE }
    1036. 

  1036. function TSDOBaseDataObject.getDouble(const AProperty: ISDOProperty): TSDODouble;
    1037. 

  1037. var
    1038. 

  1038.   prp : ISDOPropertyEx;
    1039. 

  1039. begin
    1040. 

  1040.   if ( AProperty = nil ) or
    1041. 

  1041.      ( not Self.IsOwnerOf(AProperty) ) or
    1042. 

  1042.      ( AProperty.isMany() )
    1043. 

  1043.   then begin
    1044. 

  1044.     raise ESDOIllegalArgumentException.Create('AProperty');
    1045. 

  1045.   end;
    1046. 

  1046.   prp := AProperty as ISDOPropertyEx;
    1047. 

  1047.   Result := getField(prp.getTypeEnum()).getDouble(FBuffer,prp.getBufferOffset());
    1048. 

  1048. end;
    1049. 

  1049. 

  1050. function TSDOBaseDataObject.getDouble(const APropertyIndex: PtrUInt): TSDODouble;
    1051. 

  1051. begin
    1052. 

  1052.   Result := getDouble(getProperty(APropertyIndex));
    1053. 

  1053. end;
    1054. 

  1054. 

  1055. function TSDOBaseDataObject.getDouble(const APath: string): TSDODouble;
    1056. 

  1056. var
    1057. 

  1057.   locCtx : TXPathExecContext;
    1058. 

  1058. begin
    1059. 

  1059.   locCtx := parsePropertyPath(APath);
    1060. 

  1060.   if ( locCtx.PropertyOwner = nil ) then
    1061. 

  1061.     raise ESDOInvalidPathException.Create(APath);
    1062. 

  1062.   if ( locCtx.ContentKind = xckList ) then
    1063. 

  1063.     Result := locCtx.ListItem.getDouble()
    1064. 

  1064.   else
    1065. 

  1065.     Result := locCtx.PropertyOwner.getDouble(locCtx.CurrentProperty);
    1066. 

  1066. end;
    1067. 

  1067. {$ENDIF HAS_SDO_DOUBLE }
    1068. 

  1068. 

  1069. {$IFDEF HAS_SDO_FLOAT }
    1070. 

  1070. function TSDOBaseDataObject.getFloat(const AProperty: ISDOProperty): TSDOFloat;
    1071. 

  1071. var
    1072. 

  1072.   prp : ISDOPropertyEx;
    1073. 

  1073. begin
    1074. 

  1074.   if ( AProperty = nil ) or
    1075. 

  1075.      ( not Self.IsOwnerOf(AProperty) ) or
    1076. 

  1076.      ( AProperty.isMany() )
    1077. 

  1077.   then begin
    1078. 

  1078.     raise ESDOIllegalArgumentException.Create('AProperty');
    1079. 

  1079.   end;
    1080. 

  1080.   prp := AProperty as ISDOPropertyEx;
    1081. 

  1081.   Result := getField(prp.getTypeEnum()).getFloat(FBuffer,prp.getBufferOffset());
    1082. 

  1082. end;
    1083. 

  1083. 

  1084. function TSDOBaseDataObject.getFloat(const APropertyIndex: PtrUInt): TSDOFloat;
    1085. 

  1085. begin
    1086. 

  1086.   Result := getFloat(getProperty(APropertyIndex));
    1087. 

  1087. end;
    1088. 

  1088. 

  1089. function TSDOBaseDataObject.getFloat(const APath: string): TSDOFloat;
    1090. 

  1090. var
    1091. 

  1091.   locCtx : TXPathExecContext;
    1092. 

  1092. begin
    1093. 

  1093.   locCtx := parsePropertyPath(APath);
    1094. 

  1094.   if ( locCtx.PropertyOwner = nil ) then
    1095. 

  1095.     raise ESDOInvalidPathException.Create(APath);
    1096. 

  1096.   if ( locCtx.ContentKind = xckList ) then
    1097. 

  1097.     Result := locCtx.ListItem.getFloat()
    1098. 

  1098.   else
    1099. 

  1099.     Result := locCtx.PropertyOwner.getFloat(locCtx.CurrentProperty);
    1100. 

  1100. end;
    1101. 

  1101. {$ENDIF HAS_SDO_FLOAT }
    1102. 

  1102. 

  1103. function TSDOBaseDataObject.getInstanceProperties() : ISDOPropertyList;
    1104. 

  1104. begin
    1105. 

  1105.   Result := FType.getProperties();
    1106. 

  1106. end;
    1107. 

  1107. 

  1108. function TSDOBaseDataObject.getInteger(const AProperty: ISDOProperty): TSDOInteger;
    1109. 

  1109. var
    1110. 

  1110.   prp : ISDOPropertyEx;
    1111. 

  1111. begin
    1112. 

  1112.   if ( AProperty = nil ) or
    1113. 

  1113.      ( not Self.IsOwnerOf(AProperty) ) or
    1114. 

  1114.      ( AProperty.isMany() )
    1115. 

  1115.   then begin
    1116. 

  1116.     raise ESDOIllegalArgumentException.Create('AProperty');
    1117. 

  1117.   end;
    1118. 

  1118.   prp := AProperty as ISDOPropertyEx;
    1119. 

  1119.   Result := getField(prp.getTypeEnum()).getInteger(FBuffer,prp.getBufferOffset());
    1120. 

  1120. end;
    1121. 

  1121. 

  1122. function TSDOBaseDataObject.getInteger(const APropertyIndex: PtrUInt): TSDOInteger;
    1123. 

  1123. begin
    1124. 

  1124.   Result := getInteger(getProperty(APropertyIndex));
    1125. 

  1125. end;
    1126. 

  1126. 

  1127. function TSDOBaseDataObject.getInteger(const APath: string): TSDOInteger;
    1128. 

  1128. var
    1129. 

  1129.   locCtx : TXPathExecContext;
    1130. 

  1130. begin
    1131. 

  1131.   locCtx := parsePropertyPath(APath);
    1132. 

  1132.   if ( locCtx.PropertyOwner = nil ) then
    1133. 

  1133.     raise ESDOInvalidPathException.Create(APath);
    1134. 

  1134.   if ( locCtx.ContentKind = xckList ) then
    1135. 

  1135.     Result := locCtx.ListItem.getInteger()
    1136. 

  1136.   else
    1137. 

  1137.     Result := locCtx.PropertyOwner.getInteger(locCtx.CurrentProperty);
    1138. 

  1138. end;
    1139. 

  1139. 

  1140. function TSDOBaseDataObject.getLong(const AProperty: ISDOProperty): TSDOLong;
    1141. 

  1141. var
    1142. 

  1142.   prp : ISDOPropertyEx;
    1143. 

  1143. begin
    1144. 

  1144.   if ( AProperty = nil ) or
    1145. 

  1145.      ( not Self.IsOwnerOf(AProperty) ) or
    1146. 

  1146.      ( AProperty.isMany() )
    1147. 

  1147.   then begin
    1148. 

  1148.     raise ESDOIllegalArgumentException.Create('AProperty');
    1149. 

  1149.   end;
    1150. 

  1150.   prp := AProperty as ISDOPropertyEx;
    1151. 

  1151.   Result := getField(prp.getTypeEnum()).getLong(FBuffer,prp.getBufferOffset());
    1152. 

  1152. end;
    1153. 

  1153. 

  1154. function TSDOBaseDataObject.getLong(const APropertyIndex: PtrUInt): TSDOLong;
    1155. 

  1155. begin
    1156. 

  1156.    Result := getLong(getProperty(APropertyIndex));
    1157. 

  1157. end;
    1158. 

  1158. 

  1159. function TSDOBaseDataObject.getLong(const APath: string): TSDOLong;
    1160. 

  1160. var
    1161. 

  1161.   locCtx : TXPathExecContext;
    1162. 

  1162. begin
    1163. 

  1163.   locCtx := parsePropertyPath(APath);
    1164. 

  1164.   if ( locCtx.PropertyOwner = nil ) then
    1165. 

  1165.     raise ESDOInvalidPathException.Create(APath);
    1166. 

  1166.   if ( locCtx.ContentKind = xckList ) then
    1167. 

  1167.     Result := locCtx.ListItem.getLong()
    1168. 

  1168.   else
    1169. 

  1169.     Result := locCtx.PropertyOwner.getLong(locCtx.CurrentProperty);
    1170. 

  1170. end;
    1171. 

  1171. 

  1172. function TSDOBaseDataObject.getProperty(const AIndex: PtrUInt): ISDOProperty;
    1173. 

  1173. begin
    1174. 

  1174.   Result := getInstanceProperties().getItem(AIndex);//FType.getProperty(AIndex);
    1175. 

  1175. end;
    1176. 

  1176. 

  1177. function TSDOBaseDataObject.getProperty(const AProp: string): ISDOProperty;
    1178. 

  1178. begin
    1179. 

  1179.   Result := getInstanceProperties().find(AProp);
    1180. 

  1180.   if ( Result = nil ) then
    1181. 

  1181.     raise ESDOPropertyNotFoundException.Create(AProp);
    1182. 

  1182. end;
    1183. 

  1183. 

  1184. function TSDOBaseDataObject.getPropertyIndex(const AProperty: ISDOProperty): PtrInt;
    1185. 

  1185. begin
    1186. 

  1186.   Result := FType.getPropertyIndex(AProperty.getName());
    1187. 

  1187. end;
    1188. 

  1188. 

  1189. function TSDOBaseDataObject.getShort(const APropertyIndex: PtrUInt): TSDOShort;
    1190. 

  1190. begin
    1191. 

  1191.   Result := getShort(getProperty(APropertyIndex));
    1192. 

  1192. end;
    1193. 

  1193. 

  1194. function TSDOBaseDataObject.getShort(const APath: string): TSDOShort;
    1195. 

  1195. var
    1196. 

  1196.   locCtx : TXPathExecContext;
    1197. 

  1197. begin
    1198. 

  1198.   locCtx := parsePropertyPath(APath);
    1199. 

  1199.   if ( locCtx.PropertyOwner = nil ) then
    1200. 

  1200.     raise ESDOInvalidPathException.Create(APath);
    1201. 

  1201.   if ( locCtx.ContentKind = xckList ) then
    1202. 

  1202.     Result := locCtx.ListItem.getShort()
    1203. 

  1203.   else
    1204. 

  1204.     Result := locCtx.PropertyOwner.getShort(locCtx.CurrentProperty);
    1205. 

  1205. end;
    1206. 

  1206. 

  1207. function TSDOBaseDataObject.getShort(const AProperty: ISDOProperty): TSDOShort;
    1208. 

  1208. var
    1209. 

  1209.   prp : ISDOPropertyEx;
    1210. 

  1210. begin
    1211. 

  1211.   if ( AProperty = nil ) or
    1212. 

  1212.      ( not Self.IsOwnerOf(AProperty) ) or
    1213. 

  1213.      ( AProperty.isMany() )
    1214. 

  1214.   then begin
    1215. 

  1215.     raise ESDOIllegalArgumentException.Create('AProperty');
    1216. 

  1216.   end;
    1217. 

  1217.   prp := AProperty as ISDOPropertyEx;
    1218. 

  1218.   Result := getField(prp.getTypeEnum()).getShort(FBuffer,prp.getBufferOffset());
    1219. 

  1219. end;
    1220. 

  1220. 

  1221. function TSDOBaseDataObject.getString(const AProperty: ISDOProperty): TSDOString;
    1222. 

  1222. var
    1223. 

  1223.   prp : ISDOPropertyEx;
    1224. 

  1224. begin
    1225. 

  1225.   if ( AProperty = nil ) or
    1226. 

  1226.      ( not Self.IsOwnerOf(AProperty) ) or
    1227. 

  1227.      ( AProperty.isMany() )
    1228. 

  1228.   then begin
    1229. 

  1229.     raise ESDOIllegalArgumentException.Create('AProperty');
    1230. 

  1230.   end;
    1231. 

  1231.   prp := AProperty as ISDOPropertyEx;
    1232. 

  1232.   Result := getField(prp.getTypeEnum()).getString(FBuffer,prp.getBufferOffset());
    1233. 

  1233. end;
    1234. 

  1234. 

  1235. function TSDOBaseDataObject.getString(const APropertyIndex: PtrUInt): TSDOString;
    1236. 

  1236. begin
    1237. 

  1237.   Result := getString(getProperty(APropertyIndex));
    1238. 

  1238. end;
    1239. 

  1239. 

  1240. function TSDOBaseDataObject.getString(const APath: string): TSDOString;
    1241. 

  1241. var
    1242. 

  1242.   locCtx : TXPathExecContext;
    1243. 

  1243. begin
    1244. 

  1244.   locCtx := parsePropertyPath(APath);
    1245. 

  1245.   if ( locCtx.PropertyOwner = nil ) then
    1246. 

  1246.     raise ESDOInvalidPathException.Create(APath);
    1247. 

  1247.   if ( locCtx.ContentKind = xckList ) then
    1248. 

  1248.     Result := locCtx.ListItem.getString()
    1249. 

  1249.   else
    1250. 

  1250.     Result := locCtx.PropertyOwner.getString(locCtx.CurrentProperty);
    1251. 

  1251. end;
    1252. 

  1252. 

  1253. function TSDOBaseDataObject.getType() : ISDOType;
    1254. 

  1254. begin
    1255. 

  1255.   Result := FType as ISDOType;
    1256. 

  1256. end;
    1257. 

  1257. 

  1258. function TSDOBaseDataObject.getTypeEnum() : TSDOTypeKind;
    1259. 

  1259. begin
    1260. 

  1260.   Result := FType.getTypeEnum();
    1261. 

  1261. end;
    1262. 

  1262. 

  1263. function TSDOBaseDataObject.isNull(const APath: string): Boolean;
    1264. 

  1264. var
    1265. 

  1265.   locCtx : TXPathExecContext;
    1266. 

  1266. begin
    1267. 

  1267.   locCtx := parsePropertyPath(APath);
    1268. 

  1268.   if ( locCtx.PropertyOwner = nil ) then
    1269. 

  1269.     raise ESDOInvalidPathException.Create(APath);
    1270. 

  1270.   case locCtx.ContentKind of
    1271. 

  1271.     xckNull    : Result := True;
    1272. 

  1272.     xckObject  : Result := False;
    1273. 

  1273.     xckList    :
    1274. 

  1274.       begin
    1275. 

  1275.         Result := locCtx.CurrentProperty.getType().isDataObjectType and ( locCtx.ListItem.getDataObject() = nil );
    1276. 

  1276.       end;
    1277. 

  1277.     xckValue : Result := locCtx.ObjectItem.isNull(locCtx.CurrentProperty);
    1278. 

  1278.     else
    1279. 

  1279.       Result := False;
    1280. 

  1280.   end;
    1281. 

  1281. end;
    1282. 

  1282. 

  1283. function TSDOBaseDataObject.isNull(const AProperty: ISDOProperty): Boolean;
    1284. 

  1284. var
    1285. 

  1285.   prp : ISDOPropertyEx;
    1286. 

  1286. begin
    1287. 

  1287.   if ( AProperty = nil ) or ( not Self.IsOwnerOf(AProperty) ) then
    1288. 

  1288.     raise ESDOIllegalArgumentException.Create('AProperty');
    1289. 

  1289.   if AProperty.isMany() then begin
    1290. 

  1290.     Result := ( getList(AProperty).size > 0 );
    1291. 

  1291.   end else begin
    1292. 

  1292.     prp := AProperty as ISDOPropertyEx;
    1293. 

  1293.     Result := getField(prp.getTypeEnum()).isNull(FBuffer,prp.getBufferOffset());
    1294. 

  1294.   end;
    1295. 

  1295. end;
    1296. 

  1296. 

  1297. function TSDOBaseDataObject.isNull(const APropertyIndex: PtrUInt): Boolean;
    1298. 

  1298. begin
    1299. 

  1299.   Result := isNull(getProperty(APropertyIndex));
    1300. 

  1300. end;
    1301. 

  1301. 

  1302. function TSDOBaseDataObject.isSet(const APropertyIndex: PtrUInt): Boolean;
    1303. 

  1303. begin
    1304. 

  1304.   Result := isSet(getProperty(APropertyIndex));
    1305. 

  1305. end;
    1306. 

  1306. 

  1307. function TSDOBaseDataObject.isSet(const APath: string): Boolean;
    1308. 

  1308. var
    1309. 

  1309.   locCtx : TXPathExecContext;
    1310. 

  1310. begin
    1311. 

  1311.   locCtx := parsePropertyPath(APath);
    1312. 

  1312.   if ( locCtx.PropertyOwner = nil ) then
    1313. 

  1313.     raise ESDOInvalidPathException.Create(APath);
    1314. 

  1314.   case locCtx.ContentKind of
    1315. 

  1315.     xckNull    : Result := not locCtx.PropertyOwner.getType().isDataObjectType();
    1316. 

  1316.     xckObject  : Result := locCtx.PropertyOwner.isSet(locCtx.CurrentProperty);
    1317. 

  1317.     xckList    : Result := ( locCtx.ListItem.size() > 0 );
    1318. 

  1318.     xckValue   : Result := locCtx.ObjectItem.isSet(locCtx.CurrentProperty);
    1319. 

  1319.     else
    1320. 

  1320.       Result := False;    
    1321. 

  1321.   end;
    1322. 

  1322. end;
    1323. 

  1323. 

  1324. function TSDOBaseDataObject.isSet(const AProperty: ISDOProperty): Boolean;
    1325. 

  1325. var
    1326. 

  1326.   prp : ISDOPropertyEx;
    1327. 

  1327. begin
    1328. 

  1328.   if ( AProperty = nil ) or ( not Self.IsOwnerOf(AProperty) ) then
    1329. 

  1329.     raise ESDOIllegalArgumentException.Create('AProperty');
    1330. 

  1330.   if AProperty.isMany() then begin
    1331. 

  1331.     Result := ( getList(AP…
    1332.