mcs/class/System.Data/System.Data.Common/DataContainer.cs

   1 \r
   2 //\r
   3 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)\r
   4 //\r
   5 // Permission is hereby granted, free of charge, to any person obtaining\r
   6 // a copy of this software and associated documentation files (the\r
   7 // "Software"), to deal in the Software without restriction, including\r
   8 // without limitation the rights to use, copy, modify, merge, publish,\r
   9 // distribute, sublicense, and/or sell copies of the Software, and to\r
  10 // permit persons to whom the Software is furnished to do so, subject to\r
  11 // the following conditions:\r
  12 // \r
  13 // The above copyright notice and this permission notice shall be\r
  14 // included in all copies or substantial portions of the Software.\r
  15 // \r
  16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  18 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  23 //\r
  24 using System;\r
  25 using System.Collections;\r
  26 \r
  27 namespace System.Data.Common\r
  28 {\r
  29         internal abstract class AbstractDataContainer\r
  30         {\r
  31                 #region Fields\r
  32 \r
  33                 BitArray _nullValues;\r
  34                 System.Type _type;\r
  35                 DataColumn _column;\r
  36 \r
  37                 #endregion //Fields\r
  38 \r
  39                 #region Properties\r
  40 \r
  41                 internal abstract object this[int index] {\r
  42                         get;\r
  43                         set;\r
  44                 }\r
  45 \r
  46                 internal virtual int Capacity {\r
  47                         get { \r
  48                                 return (_nullValues != null) ? _nullValues.Count : 0; \r
  49                         }\r
  50                         set { \r
  51                                 if (_nullValues == null) {\r
  52                                         _nullValues = new BitArray(value);\r
  53                                 }\r
  54                                 else {\r
  55                                         _nullValues.Length = value;\r
  56                                 }\r
  57                         }\r
  58                 }\r
  59 \r
  60                 internal Type Type {\r
  61                         get {\r
  62                                 return _type;\r
  63                         }\r
  64                 }\r
  65 \r
  66                 protected DataColumn Column {\r
  67                         get {\r
  68                                 return _column;\r
  69                         }\r
  70                 }\r
  71 \r
  72                 #endregion //Properties\r
  73 \r
  74                 #region Methods\r
  75 \r
  76                 internal static AbstractDataContainer CreateInstance(Type type, DataColumn column)\r
  77                 {\r
  78                         AbstractDataContainer container;\r
  79                         switch (Type.GetTypeCode(type)) {\r
  80                                 case TypeCode.Int16 :\r
  81                                         container = new Int16DataContainer();\r
  82                                         break;\r
  83                                 case TypeCode.Int32 : \r
  84                                         container = new Int32DataContainer();\r
  85                                         break;\r
  86                                 case TypeCode.Int64 :\r
  87                                         container = new Int64DataContainer();\r
  88                                         break;\r
  89                                 case TypeCode.String :\r
  90                                         container = new StringDataContainer();\r
  91                                         break;\r
  92                                 case TypeCode.Boolean:\r
  93                                         container = new BitDataContainer();\r
  94                                         break;\r
  95                                 case TypeCode.Byte :\r
  96                                         container = new ByteDataContainer();\r
  97                                         break;\r
  98                                 case TypeCode.Char :\r
  99                                         container = new CharDataContainer();\r
 100                                         break;\r
 101                                 case TypeCode.Double :\r
 102                                         container = new DoubleDataContainer();\r
 103                                         break;\r
 104                                 case TypeCode.SByte :\r
 105                                         container = new SByteDataContainer();\r
 106                                         break;\r
 107                                 case TypeCode.Single :\r
 108                                         container = new SingleDataContainer();\r
 109                                         break;\r
 110                                 case TypeCode.UInt16 :\r
 111                                         container = new UInt16DataContainer();\r
 112                                         break;\r
 113                                 case TypeCode.UInt32 :\r
 114                                         container = new UInt32DataContainer();\r
 115                                         break;\r
 116                                 case TypeCode.UInt64 :\r
 117                                         container = new UInt64DataContainer();\r
 118                                         break;\r
 119                                 case TypeCode.DateTime :\r
 120                                         container = new DateTimeDataContainer();\r
 121                                         break;\r
 122                                 case TypeCode.Decimal :\r
 123                                         container = new DecimalDataContainer();\r
 124                                         break;\r
 125                                 default :\r
 126                                         container = new ObjectDataContainer();\r
 127                                         break;\r
 128                         }\r
 129                         container._type = type;\r
 130                         container._column = column;\r
 131                         return container;\r
 132                 }\r
 133 \r
 134                 internal bool IsNull(int index)\r
 135                 {\r
 136                         return (_nullValues != null) ? _nullValues[index] : true;\r
 137                 }\r
 138 \r
 139                 internal void SetNullBit(int index,bool isNull)\r
 140                 {\r
 141                         _nullValues[index] = isNull;\r
 142                 }\r
 143 \r
 144                 protected void SetNull(int index,bool isNull,bool isDbNull)\r
 145                 {\r
 146                         SetNullBit(index,isDbNull);\r
 147                         // this method must be called after setting the value into value array\r
 148                         // otherwise the dafault value will be overriden\r
 149                         if ( isNull ) {\r
 150                                 // set the value to default\r
 151                                 CopyValue(Column.Table.DefaultValuesRowIndex,index);\r
 152                         }\r
 153                 }\r
 154 \r
 155                 internal void FillValues(int fromIndex)\r
 156                 {\r
 157                         for(int i=0; i < Capacity; i++) {\r
 158                                 CopyValue(fromIndex,i);\r
 159                                 _nullValues[i] = _nullValues[fromIndex];\r
 160                         }\r
 161                 }\r
 162 \r
 163                 internal virtual void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 164                 {\r
 165                         _nullValues[toIndex] = fromContainer._nullValues[fromIndex];\r
 166                 }\r
 167 \r
 168                 internal virtual void CopyValue(int fromIndex, int toIndex)\r
 169                 {\r
 170                         _nullValues[toIndex] = _nullValues[fromIndex];\r
 171                 }\r
 172 \r
 173                 internal virtual void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 174                 {\r
 175                         bool isDbNull = record.IsDBNull(field);\r
 176                         SetNull(index,false,isDbNull);\r
 177                 }\r
 178 \r
 179                 protected int CompareNulls(int index1, int index2)\r
 180                 {\r
 181                         bool null1 = IsNull(index1);\r
 182                         bool null2 = IsNull(index2);\r
 183 \r
 184                         if ( null1 ^ null2 ) {\r
 185                                 return null1 ? -1 : 1;\r
 186                         }\r
 187                         else {\r
 188                                 return 0;\r
 189                         }\r
 190                 }\r
 191 \r
 192                 internal abstract int CompareValues(int index1, int index2);\r
 193 \r
 194                 internal abstract long GetInt64(int index);\r
 195 \r
 196                 #endregion //Methods\r
 197 \r
 198                 sealed class Int16DataContainer : AbstractDataContainer\r
 199                 {\r
 200                         #region Fields\r
 201                 \r
 202                         short[] _values;\r
 203 \r
 204                         #endregion //Fields\r
 205 \r
 206                         #region Properties\r
 207 \r
 208                         internal override object this[int index] {\r
 209                                 get {\r
 210                                         if (IsNull(index)) {\r
 211                                                 return DBNull.Value;\r
 212                                         }\r
 213                                         else {\r
 214                                                 return _values[index];\r
 215                                         }\r
 216                                 }\r
 217                                 set {\r
 218                                         bool isDbNull = (value ==  DBNull.Value);\r
 219                                         if (value == null || isDbNull) {\r
 220                                                 SetValue(index,0);\r
 221                                         }\r
 222                                         else if( value is short ) {\r
 223                                                 SetValue(index,(short)value);\r
 224                                         }\r
 225                                         else {\r
 226                                                 SetValue(index,Convert.ToInt16(value));\r
 227                                         }\r
 228                                         SetNull(index,value == null,isDbNull);\r
 229                                 }\r
 230                         }\r
 231 \r
 232                         internal override int Capacity {\r
 233                                 set {\r
 234                                         base.Capacity = value;\r
 235                                         if (_values == null) {\r
 236                                                 _values = new short[value];\r
 237                                         }\r
 238                                         else {\r
 239                                                 short[] tmp = new short[value];\r
 240                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 241                                                 _values = tmp;\r
 242                                         }\r
 243                                 }\r
 244                         }\r
 245 \r
 246                         #endregion //Properties\r
 247 \r
 248                         #region Methods\r
 249                         \r
 250                         private void SetValue(int index, short value)\r
 251                         {\r
 252                                 _values[index] = value;\r
 253                         }\r
 254 \r
 255                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 256                         {\r
 257                                 // if exception thrown, it should be caught in the  caller method\r
 258                                 if (record is ISafeDataRecord) {\r
 259                                         SetValue(index,((ISafeDataRecord)record).GetInt16Safe(field));\r
 260                                 }\r
 261                                 else {\r
 262                                         this[index] = record.GetValue(field);\r
 263                                 }\r
 264                                 base.SetItemFromDataRecord(index,record,field);\r
 265                         }\r
 266 \r
 267                         internal override void CopyValue(int fromIndex, int toIndex)\r
 268                         {\r
 269                                 base.CopyValue(fromIndex, toIndex);\r
 270                                 _values[toIndex] = _values[fromIndex];\r
 271                         }\r
 272 \r
 273                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 274                         {\r
 275                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 276                                 _values[toIndex] = ((Int16DataContainer)fromContainer)._values[fromIndex];\r
 277                         }\r
 278 \r
 279                         internal override int CompareValues(int index1, int index2)\r
 280                         {\r
 281                                 short s1 = _values[index1];\r
 282                                 short s2 = _values[index2];\r
 283 \r
 284                                 if ( s1 == 0 || s2 == 0 ) {\r
 285                                         int cn = CompareNulls(index1, index2);\r
 286                                         if (cn != 0)\r
 287                                                 return cn;\r
 288                                 }\r
 289 \r
 290                                 return s1 - s2;\r
 291                         }\r
 292 \r
 293                         internal override long GetInt64(int index)\r
 294                         {\r
 295                                 return (long) _values[index];\r
 296                         }\r
 297 \r
 298                         #endregion //Methods\r
 299                 }\r
 300 \r
 301                 sealed class Int32DataContainer : AbstractDataContainer\r
 302                 {\r
 303                         #region Fields\r
 304                 \r
 305                         int[] _values;\r
 306 \r
 307                         #endregion //Fields\r
 308 \r
 309                         #region Properties\r
 310 \r
 311                         internal override object this[int index] {\r
 312                                 get {\r
 313                                         if (IsNull(index)) {\r
 314                                                 return DBNull.Value;\r
 315                                         }\r
 316                                         else {\r
 317                                                 return _values[index];\r
 318                                         }\r
 319                                 }\r
 320                                 set {\r
 321                                         bool isDbNull = (value ==  DBNull.Value);\r
 322                                         if (value == null || isDbNull) {\r
 323                                                 SetValue(index,0);\r
 324                                         }\r
 325                                         else if( value is int ) {\r
 326                                                 SetValue(index,(int)value);\r
 327                                         }\r
 328                                         else {\r
 329                                                 SetValue(index,Convert.ToInt32(value));\r
 330                                         }\r
 331                                         SetNull(index,value == null,isDbNull);\r
 332                                 }\r
 333                         }\r
 334 \r
 335                         internal override int Capacity {\r
 336                                 set {\r
 337                                         base.Capacity = value;\r
 338                                         if (_values == null) {\r
 339                                                 _values = new int[value];\r
 340                                         }\r
 341                                         else {\r
 342                                                 int[] tmp = new int[value];\r
 343                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 344                                                 _values = tmp;\r
 345                                         }\r
 346                                 }\r
 347                         }\r
 348 \r
 349                         #endregion //Properties\r
 350 \r
 351                         #region Methods\r
 352                         \r
 353                         private void SetValue(int index, int value)\r
 354                         {\r
 355                                 _values[index] = value;\r
 356                         }\r
 357 \r
 358                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 359                         {\r
 360                                 // if exception thrown, it should be caught in the  caller method\r
 361                                 if (record is ISafeDataRecord) {\r
 362                                         SetValue(index,((ISafeDataRecord)record).GetInt32Safe(field));\r
 363                                 }\r
 364                                 else {\r
 365                                         this[index] = record.GetValue(field);\r
 366                                 }\r
 367                                 base.SetItemFromDataRecord(index,record,field);\r
 368                         }\r
 369 \r
 370                         internal override void CopyValue(int fromIndex, int toIndex)\r
 371                         {\r
 372                                 base.CopyValue(fromIndex, toIndex);\r
 373                                 _values[toIndex] = _values[fromIndex];\r
 374                         }\r
 375 \r
 376                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 377                         {\r
 378                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 379                                 _values[toIndex] = ((Int32DataContainer)fromContainer)._values[fromIndex];\r
 380                         }\r
 381 \r
 382                         internal override int CompareValues(int index1, int index2)\r
 383                         {\r
 384                                 int i1 = _values[index1];\r
 385                                 int i2 = _values[index2];\r
 386                                 \r
 387                                 if (i1 == 0 || i2 == 0) {\r
 388                                         int cn = CompareNulls(index1, index2);\r
 389                                         if (cn != 0)\r
 390                                                 return cn;\r
 391                                 }\r
 392 \r
 393                                 if ( i1 <= i2 ) {\r
 394                                         return ( i1 == i2 ) ? 0 : -1;\r
 395                                 }\r
 396                                 return 1;\r
 397                         }\r
 398 \r
 399                         internal override long GetInt64(int index)\r
 400                         {\r
 401                                 return (long) _values[index];\r
 402                         }\r
 403 \r
 404                         #endregion //Methods\r
 405                 }\r
 406 \r
 407                 sealed class Int64DataContainer : AbstractDataContainer\r
 408                 {\r
 409                         #region Fields\r
 410                 \r
 411                         long[] _values;\r
 412 \r
 413                         #endregion //Fields\r
 414 \r
 415                         #region Properties\r
 416 \r
 417                         internal override object this[int index] {\r
 418                                 get {\r
 419                                         if (IsNull(index)) {\r
 420                                                 return DBNull.Value;\r
 421                                         }\r
 422                                         else {\r
 423                                                 return _values[index];\r
 424                                         }\r
 425                                 }\r
 426                                 set {\r
 427                                         bool isDbNull = (value ==  DBNull.Value);\r
 428                                         if (value == null || isDbNull) {\r
 429                                                 SetValue(index,0);\r
 430                                         }\r
 431                                         else if( value is long ) {\r
 432                                                 SetValue(index,(long)value);\r
 433                                         }\r
 434                                         else {\r
 435                                                 SetValue(index,Convert.ToInt64(value));\r
 436                                         }\r
 437                                         SetNull(index,value == null,isDbNull);\r
 438                                 }\r
 439                         }\r
 440 \r
 441                         internal override int Capacity {\r
 442                                 set {\r
 443                                         base.Capacity = value;\r
 444                                         if (_values == null) {\r
 445                                                 _values = new long[value];\r
 446                                         }\r
 447                                         else {\r
 448                                                 long[] tmp = new long[value];\r
 449                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 450                                                 _values = tmp;\r
 451                                         }\r
 452                                 }\r
 453                         }\r
 454 \r
 455                         #endregion //Properties\r
 456 \r
 457                         #region Methods\r
 458                         \r
 459                         private void SetValue(int index, long value)\r
 460                         {\r
 461                                 _values[index] = value;\r
 462                         }\r
 463 \r
 464                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 465                         {\r
 466                                 // if exception thrown, it should be caught in the  caller method\r
 467                                 if (record is ISafeDataRecord) {\r
 468                                         SetValue(index,((ISafeDataRecord)record).GetInt64Safe(field));\r
 469                                 }\r
 470                                 else {\r
 471                                         this[index] = record.GetValue(field);\r
 472                                 }\r
 473                                 base.SetItemFromDataRecord(index,record,field);\r
 474                         }\r
 475 \r
 476                         internal override void CopyValue(int fromIndex, int toIndex)\r
 477                         {\r
 478                                 base.CopyValue(fromIndex, toIndex);\r
 479                                 _values[toIndex] = _values[fromIndex];\r
 480                         }\r
 481 \r
 482                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 483                         {\r
 484                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 485                                 _values[toIndex] = ((Int64DataContainer)fromContainer)._values[fromIndex];\r
 486                         }\r
 487 \r
 488                         internal override int CompareValues(int index1, int index2)\r
 489                         {\r
 490                                 long l1 = _values[index1];\r
 491                                 long l2 = _values[index2];\r
 492 \r
 493                                 if ( l1 == 0 || l2 == 0 ) {\r
 494                                         int cn = CompareNulls(index1, index2);\r
 495                                         if (cn != 0) {\r
 496                                                 return cn;\r
 497                                         }\r
 498                                 }\r
 499 \r
 500                                 if ( l1 <= l2 ) {\r
 501                                         return ( l1 != l2 ) ? -1 : 0;\r
 502                                 }\r
 503                                 return 1;\r
 504                         }\r
 505 \r
 506                         internal override long GetInt64(int index)\r
 507                         {\r
 508                                 return _values[index];\r
 509                         }\r
 510 \r
 511                         #endregion //Methods\r
 512                 }\r
 513 \r
 514                 sealed class SingleDataContainer : AbstractDataContainer\r
 515                 {\r
 516                         #region Fields\r
 517                 \r
 518                         float[] _values;\r
 519 \r
 520                         #endregion //Fields\r
 521 \r
 522                         #region Properties\r
 523 \r
 524                         internal override object this[int index] {\r
 525                                 get {\r
 526                                         if (IsNull(index)) {\r
 527                                                 return DBNull.Value;\r
 528                                         }\r
 529                                         else {\r
 530                                                 return _values[index];\r
 531                                         }\r
 532                                 }\r
 533                                 set {\r
 534                                         bool isDbNull = (value ==  DBNull.Value);\r
 535                                         if (value == null || isDbNull) {\r
 536                                                 SetValue(index,0);\r
 537                                         }\r
 538                                         else if( value is float ) {\r
 539                                                 SetValue(index,(float)value);\r
 540                                         }\r
 541                                         else {\r
 542                                                 SetValue(index,Convert.ToSingle(value));\r
 543                                         }\r
 544                                         SetNull(index,value == null,isDbNull);\r
 545                                 }\r
 546                         }\r
 547 \r
 548                         internal override int Capacity {\r
 549                                 set {\r
 550                                         base.Capacity = value;\r
 551                                         if (_values == null) {\r
 552                                                 _values = new float[value];\r
 553                                         }\r
 554                                         else {\r
 555                                                 float[] tmp = new float[value];\r
 556                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 557                                                 _values = tmp;\r
 558                                         }\r
 559                                 }\r
 560                         }\r
 561 \r
 562                         #endregion //Properties\r
 563 \r
 564                         #region Methods\r
 565                         \r
 566                         private void SetValue(int index, float value)\r
 567                         {\r
 568                                 _values[index] = value;\r
 569                         }\r
 570 \r
 571                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 572                         {\r
 573                                 // if exception thrown, it should be caught in the  caller method\r
 574                                 if (record is ISafeDataRecord) {\r
 575                                         SetValue(index,((ISafeDataRecord)record).GetFloatSafe(field));\r
 576                                 }\r
 577                                 else {\r
 578                                         this[index] = record.GetValue(field);\r
 579                                 }\r
 580                                 base.SetItemFromDataRecord(index,record,field);\r
 581                         }\r
 582 \r
 583                         internal override void CopyValue(int fromIndex, int toIndex)\r
 584                         {\r
 585                                 base.CopyValue(fromIndex, toIndex);\r
 586                                 _values[toIndex] = _values[fromIndex];\r
 587                         }\r
 588 \r
 589                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 590                         {\r
 591                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 592                                 _values[toIndex] = ((SingleDataContainer)fromContainer)._values[fromIndex];\r
 593                         }\r
 594 \r
 595                         internal override int CompareValues(int index1, int index2)\r
 596                         {\r
 597                                 float f1 = _values[index1];\r
 598                                 float f2 = _values[index2];\r
 599 \r
 600                                 if ( f1 == 0 || f2 == 0 ) {\r
 601                                         int cn = CompareNulls(index1, index2);\r
 602                                         if (cn != 0) {\r
 603                                                 return cn;\r
 604                                         }\r
 605                                 }\r
 606 \r
 607                                 if ( f1 <= f2 ) {\r
 608                                         return ( f1 != f2 ) ? -1 : 0;\r
 609                                 }\r
 610                                 return 1;\r
 611                         }\r
 612 \r
 613                         internal override long GetInt64(int index)\r
 614                         {\r
 615                                 return Convert.ToInt64(_values[index]);\r
 616                         }\r
 617 \r
 618                         #endregion //Methods\r
 619                 }\r
 620 \r
 621                 sealed class DoubleDataContainer : AbstractDataContainer\r
 622                 {\r
 623                         #region Fields\r
 624                 \r
 625                         double[] _values;\r
 626 \r
 627                         #endregion //Fields\r
 628 \r
 629                         #region Properties\r
 630 \r
 631                         internal override object this[int index] {\r
 632                                 get {\r
 633                                         if (IsNull(index)) {\r
 634                                                 return DBNull.Value;\r
 635                                         }\r
 636                                         else {\r
 637                                                 return _values[index];\r
 638                                         }\r
 639                                 }\r
 640                                 set {\r
 641                                         bool isDbNull = (value ==  DBNull.Value);\r
 642                                         if (value == null || isDbNull) {\r
 643                                                 SetValue(index,0);\r
 644                                         }\r
 645                                         else if( value is double ) {\r
 646                                                 SetValue(index,(double)value);\r
 647                                         }\r
 648                                         else {\r
 649                                                 SetValue(index,Convert.ToDouble(value));\r
 650                                         }\r
 651                                         SetNull(index,value == null,isDbNull);\r
 652                                 }\r
 653                         }\r
 654 \r
 655                         internal override int Capacity {\r
 656                                 set {\r
 657                                         base.Capacity = value;\r
 658                                         if (_values == null) {\r
 659                                                 _values = new double[value];\r
 660                                         }\r
 661                                         else {\r
 662                                                 double[] tmp = new double[value];\r
 663                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 664                                                 _values = tmp;\r
 665                                         }\r
 666                                 }\r
 667                         }\r
 668 \r
 669                         #endregion //Properties\r
 670 \r
 671                         #region Methods\r
 672                         \r
 673                         private void SetValue(int index, double value)\r
 674                         {\r
 675                                 _values[index] = value;\r
 676                         }\r
 677 \r
 678                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 679                         {\r
 680                                 // if exception thrown, it should be caught in the  caller method\r
 681                                 if (record is ISafeDataRecord) {\r
 682                                         SetValue(index,((ISafeDataRecord)record).GetDoubleSafe(field));\r
 683                                 }\r
 684                                 else {\r
 685                                         this[index] = record.GetValue(field);\r
 686                                 }\r
 687                                 base.SetItemFromDataRecord(index,record,field);\r
 688                         }\r
 689 \r
 690                         internal override void CopyValue(int fromIndex, int toIndex)\r
 691                         {\r
 692                                 base.CopyValue(fromIndex, toIndex);\r
 693                                 _values[toIndex] = _values[fromIndex];\r
 694                         }\r
 695 \r
 696                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 697                         {\r
 698                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 699                                 _values[toIndex] = ((DoubleDataContainer)fromContainer)._values[fromIndex];\r
 700                         }\r
 701 \r
 702                         internal override int CompareValues(int index1, int index2)\r
 703                         {\r
 704                                 double d1 = _values[index1];\r
 705                                 double d2 = _values[index2];\r
 706 \r
 707                                 if ( d1 == 0 || d2 == 0 ) {\r
 708                                         int cn = CompareNulls(index1, index2);\r
 709                                         if (cn != 0) {\r
 710                                                 return cn;\r
 711                                         }\r
 712                                 }\r
 713 \r
 714                                 if ( d1 <= d2 ) {\r
 715                                         return ( d1 != d2 ) ? -1 : 0;\r
 716                                 }\r
 717                                 return 1;\r
 718                         }\r
 719 \r
 720                         internal override long GetInt64(int index)\r
 721                         {\r
 722                                 return Convert.ToInt64(_values[index]);\r
 723                         }\r
 724 \r
 725                         #endregion //Methods\r
 726                 }\r
 727 \r
 728                 sealed class ByteDataContainer : AbstractDataContainer\r
 729                 {\r
 730                         #region Fields\r
 731                 \r
 732                         byte[] _values;\r
 733 \r
 734                         #endregion //Fields\r
 735 \r
 736                         #region Properties\r
 737 \r
 738                         internal override object this[int index] {\r
 739                                 get {\r
 740                                         if (IsNull(index)) {\r
 741                                                 return DBNull.Value;\r
 742                                         }\r
 743                                         else {\r
 744                                                 return _values[index];\r
 745                                         }\r
 746                                 }\r
 747                                 set {\r
 748                                         bool isDbNull = (value ==  DBNull.Value);\r
 749                                         if (value == null || isDbNull) {\r
 750                                                 SetValue(index,0);\r
 751                                         }\r
 752                                         else if( value is byte ) {\r
 753                                                 SetValue(index,(byte)value);\r
 754                                         }\r
 755                                         else {\r
 756                                                 SetValue(index,Convert.ToByte(value));\r
 757                                         }\r
 758                                         SetNull(index,value == null,isDbNull);\r
 759                                 }\r
 760                         }\r
 761 \r
 762                         internal override int Capacity {\r
 763                                 set {\r
 764                                         base.Capacity = value;\r
 765                                         if (_values == null) {\r
 766                                                 _values = new byte[value];\r
 767                                         }\r
 768                                         else {\r
 769                                                 byte[] tmp = new byte[value];\r
 770                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 771                                                 _values = tmp;\r
 772                                         }\r
 773                                 }\r
 774                         }\r
 775 \r
 776                         #endregion //Properties\r
 777 \r
 778                         #region Methods\r
 779                         \r
 780                         private void SetValue(int index, byte value)\r
 781                         {\r
 782                                 _values[index] = value;\r
 783                         }\r
 784 \r
 785                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 786                         {\r
 787                                 // if exception thrown, it should be caught in the  caller method\r
 788                                 if (record is ISafeDataRecord) {\r
 789                                         SetValue(index,((ISafeDataRecord)record).GetByteSafe(field));\r
 790                                 }\r
 791                                 else {\r
 792                                         this[index] = record.GetValue(field);\r
 793                                 }\r
 794                                 base.SetItemFromDataRecord(index,record,field);\r
 795                         }\r
 796 \r
 797                         internal override void CopyValue(int fromIndex, int toIndex)\r
 798                         {\r
 799                                 base.CopyValue(fromIndex, toIndex);\r
 800                                 _values[toIndex] = _values[fromIndex];\r
 801                         }\r
 802 \r
 803                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 804                         {\r
 805                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 806                                 _values[toIndex] = ((ByteDataContainer)fromContainer)._values[fromIndex];\r
 807                         }\r
 808 \r
 809                         internal override int CompareValues(int index1, int index2)\r
 810                         {\r
 811                                 byte b1 = _values[index1];\r
 812                                 byte b2 = _values[index2];\r
 813 \r
 814                                 if ( b1 == 0 || b2 == 0 ) {\r
 815                                         int cn = CompareNulls(index1, index2);\r
 816                                         if (cn != 0) {\r
 817                                                 return cn;\r
 818                                         }\r
 819                                 }\r
 820 \r
 821                                 return b1 - b2;\r
 822                         }\r
 823 \r
 824                         internal override long GetInt64(int index)\r
 825                         {\r
 826                                 return (long) _values[index];\r
 827                         }\r
 828 \r
 829                         #endregion //Methods\r
 830                 }\r
 831 \r
 832                 sealed class BitDataContainer : AbstractDataContainer\r
 833                 {\r
 834                         #region Fields\r
 835                 \r
 836                         bool[] _values;\r
 837 \r
 838                         #endregion //Fields\r
 839 \r
 840                         #region Properties\r
 841 \r
 842                         internal override object this[int index] {\r
 843                                 get {\r
 844                                         bool isNull = IsNull(index);\r
 845                                         if (isNull) {\r
 846                                                 return DBNull.Value;\r
 847                                         }\r
 848                                         else {\r
 849                                                 return _values[index];\r
 850                                         }\r
 851                                 }\r
 852                                 set {\r
 853                                         bool isDbNull = (value ==  DBNull.Value);\r
 854                                         if (value == null || isDbNull) {\r
 855                                                 SetValue(index,false);\r
 856                                         }\r
 857                                         else if( value is bool ) {\r
 858                                                 SetValue(index,(bool)value);\r
 859                                         }\r
 860                                         else {\r
 861                                                 SetValue(index,Convert.ToBoolean(value));\r
 862                                         }\r
 863                                         SetNull(index,value == null,isDbNull);\r
 864                                 }\r
 865                         }\r
 866 \r
 867                         internal override int Capacity {\r
 868                                 set {\r
 869                                         base.Capacity = value;\r
 870                                         if (_values == null) {\r
 871                                                 _values = new bool[value];\r
 872                                         }\r
 873                                         else {\r
 874                                                 bool[] tmp = new bool[value];\r
 875                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 876                                                 _values = tmp;\r
 877                                         }\r
 878                                 }\r
 879                         }\r
 880 \r
 881                         #endregion //Properties\r
 882 \r
 883                         #region Methods\r
 884                         \r
 885                         private void SetValue(int index, bool value)\r
 886                         {\r
 887                                 _values[index] = value;\r
 888                         }\r
 889 \r
 890                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
 891                         {\r
 892                                 // if exception thrown, it should be caught in the  caller method\r
 893                                 if (record is ISafeDataRecord) {\r
 894                                         SetValue(index,((ISafeDataRecord)record).GetBooleanSafe(field));\r
 895                                 }\r
 896                                 else {\r
 897                                         this[index] = record.GetValue(field);\r
 898                                 }\r
 899                         }\r
 900 \r
 901                         internal override void CopyValue(int fromIndex, int toIndex)\r
 902                         {\r
 903                                 base.CopyValue(fromIndex, toIndex);\r
 904                                 _values[toIndex] = _values[fromIndex];\r
 905                         }\r
 906 \r
 907                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 908                         {\r
 909                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 910                                 _values[toIndex] = ((BitDataContainer)fromContainer)._values[fromIndex];\r
 911                         }\r
 912 \r
 913                         internal override int CompareValues(int index1, int index2)\r
 914                         {\r
 915                                 bool b1 = _values[index1];\r
 916                                 bool b2 = _values[index2];\r
 917 \r
 918                                 if ( b1 ^ b2 ) {\r
 919                                         return b1 ? 1 : -1;\r
 920                                 }\r
 921                                 \r
 922                                 if ( b1 ) {\r
 923                                         return 0;\r
 924                                 }\r
 925 \r
 926                                 return CompareNulls(index1, index2);    \r
 927                         }\r
 928 \r
 929                         internal override long GetInt64(int index)\r
 930                         {\r
 931                                 return Convert.ToInt64(_values[index]);\r
 932                         }\r
 933 \r
 934                         #endregion //Methods\r
 935                 }\r
 936 \r
 937                 abstract class AbstractObjectDataContainer : AbstractDataContainer\r
 938                 {\r
 939                         #region Fields\r
 940                 \r
 941                         object[] _values;\r
 942 \r
 943                         #endregion //Fields\r
 944 \r
 945                         #region Properties\r
 946 \r
 947                         internal override object this[int index] {\r
 948                                 get {\r
 949                                         if (IsNull(index)) \r
 950                                                 return DBNull.Value;\r
 951 \r
 952                                         return _values[index];\r
 953                                 }\r
 954                                 set {\r
 955                                         SetValue(index,value);\r
 956                                         SetNull(index,value == null,value == DBNull.Value);\r
 957                                 }\r
 958                         }\r
 959 \r
 960                         internal override int Capacity {\r
 961                                 set {\r
 962                                         base.Capacity = value;\r
 963                                         if (_values == null) {\r
 964                                                 _values = new object[value];\r
 965                                         }\r
 966                                         else {\r
 967                                                 object[] tmp = new object[value];\r
 968                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
 969                                                 _values = tmp;\r
 970                                         }\r
 971                                 }\r
 972                         }\r
 973 \r
 974                         #endregion //Properties\r
 975 \r
 976                         #region Methods\r
 977                         \r
 978                         protected virtual void SetValue(int index, object value)\r
 979                         {\r
 980                                 if(value == null) {\r
 981                                         value = Column.DefaultValue;\r
 982                                 }\r
 983                                 _values[index] = value;\r
 984                         }\r
 985 \r
 986                         internal override void CopyValue(int fromIndex, int toIndex)\r
 987                         {\r
 988                                 base.CopyValue(fromIndex, toIndex);\r
 989                                 _values[toIndex] = _values[fromIndex];\r
 990                         }\r
 991 \r
 992                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
 993                         {\r
 994                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
 995                                 _values[toIndex] = ((AbstractObjectDataContainer)fromContainer)._values[fromIndex];\r
 996                         }\r
 997 \r
 998                         internal override int CompareValues(int index1, int index2)\r
 999                         {\r
1000                                 object obj1 = _values[index1];\r
1001                                 object obj2 = _values[index2];\r
1002                                 if(obj1 == obj2) \r
1003                                 {\r
1004                                         return 0;\r
1005                                 }\r
1006                                 else\r
1007                                 {\r
1008                                         int cn = CompareNulls(index1, index2);\r
1009                                         if (cn != 0) \r
1010                                                 return cn;\r
1011 \r
1012                                         if (obj1 is IComparable) \r
1013                                         {\r
1014                                                 try \r
1015                                                 {\r
1016                                                         return ((IComparable)obj1).CompareTo(obj2);\r
1017                                                 }\r
1018                                                 catch \r
1019                                                 {\r
1020                                                         //just suppress\r
1021                                                 }\r
1022 \r
1023                                                 if (obj2 is IComparable) \r
1024                                                 {\r
1025                                                         obj2 = Convert.ChangeType(obj2, Type.GetTypeCode(obj1.GetType()));\r
1026                                                         return ((IComparable)obj1).CompareTo(obj2);\r
1027                                                 }\r
1028                                         }\r
1029                                 }\r
1030 \r
1031                                 return String.Compare(obj1.ToString(), obj2.ToString());\r
1032                         }\r
1033 \r
1034                         internal override long GetInt64(int index)\r
1035                         {\r
1036                                 return Convert.ToInt64(_values[index]);\r
1037                         }\r
1038 \r
1039                         #endregion //Methods\r
1040          \r
1041                 }\r
1042 \r
1043                 sealed class ObjectDataContainer : AbstractObjectDataContainer\r
1044                 {\r
1045                         #region Methods\r
1046                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1047                         {\r
1048                                 // if exception thrown, it should be caught \r
1049                                 // in the  caller method\r
1050                                 SetValue(index,record.GetValue(field));\r
1051                                 base.SetItemFromDataRecord(index,record,field);\r
1052                         }\r
1053 \r
1054                         protected override void SetValue(int index, object value)\r
1055                         {\r
1056                                 if(value != null && value != DBNull.Value && !Type.IsAssignableFrom(value.GetType()))\r
1057                                         value = Convert.ChangeType(value, Type);\r
1058 \r
1059                                 base.SetValue(index, value);\r
1060                         }\r
1061                         #endregion //Methods\r
1062          \r
1063                 }\r
1064 \r
1065                 sealed class DateTimeDataContainer : AbstractObjectDataContainer\r
1066                 {\r
1067                         #region Methods\r
1068                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1069                         {\r
1070                                 // if exception thrown, it should be caught \r
1071                                 // in the  caller method\r
1072                                 base.SetValue(index,record.GetDateTime(field));\r
1073                                 base.SetItemFromDataRecord(index,record,field);\r
1074                         }\r
1075 \r
1076                         protected override void SetValue(int index, object value)\r
1077                         {\r
1078                                 if (value != null && value != DBNull.Value)\r
1079                                         value = Convert.ToDateTime(value);\r
1080                                 base.SetValue(index, value);\r
1081                         }\r
1082                         #endregion //Methods\r
1083          \r
1084                 }\r
1085 \r
1086                 sealed class DecimalDataContainer : AbstractObjectDataContainer\r
1087                 {\r
1088                         #region Methods\r
1089                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1090                         {\r
1091                                 // if exception thrown, it should be caught in the  caller method\r
1092                                 if (record is ISafeDataRecord) {\r
1093                                         SetValue(index,((ISafeDataRecord)record).GetDecimalSafe(field));\r
1094                                 }\r
1095                                 else {\r
1096                                         this[index] = record.GetValue(field);\r
1097                                 }\r
1098                                 base.SetItemFromDataRecord(index,record,field);\r
1099                         }\r
1100 \r
1101                         protected override void SetValue(int index, object value)\r
1102                         {\r
1103                                 if (value != null && value != DBNull.Value)\r
1104                                         value = Convert.ToDecimal(value);\r
1105                                 base.SetValue(index, value);\r
1106                         }\r
1107                         #endregion //Methods\r
1108          \r
1109                 }\r
1110 \r
1111                 sealed class StringDataContainer : AbstractObjectDataContainer\r
1112                 {\r
1113                         #region Methods\r
1114 \r
1115                         private void SetValue(int index, string value)\r
1116                         {\r
1117                                 if (value != null && Column.MaxLength >= 0 && Column.MaxLength < value.Length ) {\r
1118                                         throw new ArgumentException("Cannot set column '" + Column.ColumnName + "' to '" + value + "'. The value violates the MaxLength limit of this column.");\r
1119                                 }\r
1120                                 base.SetValue(index,value);\r
1121                         }\r
1122                         \r
1123                         protected override void SetValue(int index, object value)\r
1124                         {\r
1125                                 if ( value != null && value != DBNull.Value ) {\r
1126                                         if ( value is string ) {\r
1127                                                 SetValue(index, (string) value);\r
1128                                         }\r
1129                                         else {\r
1130                                                 SetValue(index, Convert.ToString(value));\r
1131                                         }\r
1132                                         return;\r
1133                                 }\r
1134 \r
1135                                 base.SetValue(index, value);\r
1136                         }\r
1137 \r
1138                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1139                         {\r
1140                                 // if exception thrown, it should be caught \r
1141                                 // in the  caller method\r
1142                                 if (record is ISafeDataRecord) {\r
1143                                         SetValue(index,((ISafeDataRecord)record).GetStringSafe(field));\r
1144                                 }\r
1145                                 else {\r
1146                                         this[index] = record.GetValue(field);\r
1147                                 }\r
1148                                 base.SetItemFromDataRecord(index,record,field);\r
1149                         }\r
1150 \r
1151                         internal override int CompareValues(int index1, int index2)\r
1152                         {\r
1153                                 bool isNull1 = IsNull(index1);\r
1154                                 bool isNull2 = IsNull(index2);\r
1155 \r
1156                                 if (isNull1) {\r
1157                                         return isNull2 ? 0 : -1;\r
1158                                 }\r
1159                                 else {\r
1160                                         if (isNull2) {\r
1161                                                 return 1;\r
1162                                         }\r
1163                                 }\r
1164                                 return String.Compare((string)this[index1], (string)this[index2], !Column.Table.CaseSensitive);\r
1165                         }\r
1166 \r
1167                         #endregion //Methods \r
1168                 }\r
1169 \r
1170                 sealed class CharDataContainer : AbstractDataContainer\r
1171                 {\r
1172                         #region Fields\r
1173                 \r
1174                         char[] _values;\r
1175 \r
1176                         #endregion //Fields\r
1177 \r
1178                         #region Properties\r
1179 \r
1180                         internal override object this[int index] {\r
1181                                 get {\r
1182                                         if (IsNull(index)) {\r
1183                                                 return DBNull.Value;\r
1184                                         }\r
1185                                         else {\r
1186                                                 return _values[index];\r
1187                                         }\r
1188                                 }\r
1189                                 set {\r
1190                                         bool isDbNull = (value ==  DBNull.Value);\r
1191                                         if (value == null || isDbNull) {\r
1192                                                 SetValue(index,'\0');\r
1193                                         }\r
1194                                         else if( value is char ) {\r
1195                                                 SetValue(index,(char)value);\r
1196                                         }\r
1197                                         else {\r
1198                                                 SetValue(index,Convert.ToChar(value));\r
1199                                         }\r
1200                                         SetNull(index,value == null,isDbNull);\r
1201                                 }\r
1202                         }\r
1203 \r
1204                         internal override int Capacity {\r
1205                                 set {\r
1206                                         base.Capacity = value;\r
1207                                         if (_values == null) {\r
1208                                                 _values = new char[value];\r
1209                                         }\r
1210                                         else {\r
1211                                                 char[] tmp = new char[value];\r
1212                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
1213                                                 _values = tmp;\r
1214                                         }\r
1215                                 }\r
1216                         }\r
1217 \r
1218                         #endregion //Properties\r
1219 \r
1220                         #region Methods\r
1221                         \r
1222                         private void SetValue(int index, char value)\r
1223                         {\r
1224                                 _values[index] = value;\r
1225                         }\r
1226 \r
1227                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1228                         {\r
1229                                 // if exception thrown, it should be caught in the  caller method\r
1230                                 if (record is ISafeDataRecord) {\r
1231                                         SetValue(index,((ISafeDataRecord)record).GetCharSafe(field));\r
1232                                 }\r
1233                                 else {\r
1234                                         this[index] = record.GetValue(field);\r
1235                                 }\r
1236                                 base.SetItemFromDataRecord(index,record,field);\r
1237                         }\r
1238 \r
1239                         internal override void CopyValue(int fromIndex, int toIndex)\r
1240                         {\r
1241                                 base.CopyValue(fromIndex, toIndex);\r
1242                                 _values[toIndex] = _values[fromIndex];\r
1243                         }\r
1244 \r
1245                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
1246                         {\r
1247                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
1248                                 _values[toIndex] = ((CharDataContainer)fromContainer)._values[fromIndex];\r
1249                         }\r
1250 \r
1251                         internal override int CompareValues(int index1, int index2)\r
1252                         {\r
1253                                 char c1 = _values[index1];\r
1254                                 char c2 = _values[index2];\r
1255 \r
1256                                 if ( c1 == '\0' || c2 == '\0' ) \r
1257                                 {\r
1258                                         int cn = CompareNulls(index1, index2);\r
1259                                         if (cn != 0) \r
1260                                                 return cn;\r
1261                                 }\r
1262 \r
1263                                 return c1 - c2;\r
1264                         }\r
1265 \r
1266                         internal override long GetInt64(int index)\r
1267                         {\r
1268                                 return Convert.ToInt64(_values[index]);\r
1269                         }\r
1270 \r
1271                         #endregion //Methods\r
1272                 }\r
1273 \r
1274                 sealed class UInt16DataContainer : AbstractDataContainer\r
1275                 {\r
1276                         #region Fields\r
1277                 \r
1278                         ushort[] _values;\r
1279 \r
1280                         #endregion //Fields\r
1281 \r
1282                         #region Properties\r
1283 \r
1284                         internal override object this[int index] {\r
1285                                 get {\r
1286                                         if (IsNull(index)) {\r
1287                                                 return DBNull.Value;\r
1288                                         }\r
1289                                         else {\r
1290                                                 return _values[index];\r
1291                                         }\r
1292                                 }\r
1293                                 set {\r
1294                                         bool isDbNull = (value ==  DBNull.Value);\r
1295                                         if (value == null || isDbNull) {\r
1296                                                 SetValue(index,0);\r
1297                                         }\r
1298                                         else if( value is ushort ) {\r
1299                                                 SetValue(index,(ushort)value);\r
1300                                         }\r
1301                                         else {\r
1302                                                 SetValue(index,Convert.ToUInt16(value));\r
1303                                         }\r
1304                                         SetNull(index,value == null,isDbNull);\r
1305                                 }\r
1306                         }\r
1307 \r
1308                         internal override int Capacity {\r
1309                                 set {\r
1310                                         base.Capacity = value;\r
1311                                         if (_values == null) {\r
1312                                                 _values = new ushort[value];\r
1313                                         }\r
1314                                         else {\r
1315                                                 ushort[] tmp = new ushort[value];\r
1316                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
1317                                                 _values = tmp;\r
1318                                         }\r
1319                                 }\r
1320                         }\r
1321 \r
1322                         #endregion //Properties\r
1323 \r
1324                         #region Methods\r
1325                         \r
1326                         private void SetValue(int index, ushort value)\r
1327                         {\r
1328                                 _values[index] = value;\r
1329                         }\r
1330 \r
1331                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1332                         {\r
1333                                 // if exception thrown, it should be caught in the  caller method\r
1334                                 if (record is ISafeDataRecord) {\r
1335                                         SetValue(index,(ushort)((ISafeDataRecord)record).GetInt16Safe(field));\r
1336                                 }\r
1337                                 else {\r
1338                                         this[index] = record.GetValue(field);\r
1339                                 }\r
1340                                 base.SetItemFromDataRecord(index,record,field);\r
1341                         }\r
1342 \r
1343                         internal override void CopyValue(int fromIndex, int toIndex)\r
1344                         {\r
1345                                 base.CopyValue(fromIndex, toIndex);\r
1346                                 _values[toIndex] = _values[fromIndex];\r
1347                         }\r
1348 \r
1349                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
1350                         {\r
1351                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
1352                                 _values[toIndex] = ((UInt16DataContainer)fromContainer)._values[fromIndex];\r
1353                         }\r
1354 \r
1355                         internal override int CompareValues(int index1, int index2)\r
1356                         {\r
1357                                 ushort s1 = _values[index1];\r
1358                                 ushort s2 = _values[index2];\r
1359 \r
1360                                 if ( s1 == 0 || s2 == 0 ) {\r
1361                                         int cn = CompareNulls(index1, index2);\r
1362                                         if (cn != 0)\r
1363                                                 return cn;\r
1364                                 }\r
1365 \r
1366                                 return s1 - s2;\r
1367                         }\r
1368 \r
1369                         internal override long GetInt64(int index)\r
1370                         {\r
1371                                 return Convert.ToInt64(_values[index]);\r
1372                         }\r
1373 \r
1374                         #endregion //Methods\r
1375                 }\r
1376 \r
1377                 sealed class UInt32DataContainer : AbstractDataContainer\r
1378                 {\r
1379                         #region Fields\r
1380                 \r
1381                         uint[] _values;\r
1382 \r
1383                         #endregion //Fields\r
1384 \r
1385                         #region Properties\r
1386 \r
1387                         internal override object this[int index] {\r
1388                                 get {\r
1389                                         if (IsNull(index)) {\r
1390                                                 return DBNull.Value;\r
1391                                         }\r
1392                                         else {\r
1393                                                 return _values[index];\r
1394                                         }\r
1395                                 }\r
1396                                 set {\r
1397                                         bool isDbNull = (value ==  DBNull.Value);\r
1398                                         if (value == null || isDbNull) {\r
1399                                                 SetValue(index,0);\r
1400                                         }\r
1401                                         else if( value is uint ) {\r
1402                                                 SetValue(index,(uint)value);\r
1403                                         }\r
1404                                         else {\r
1405                                                 SetValue(index,Convert.ToUInt32(value));\r
1406                                         }\r
1407                                         SetNull(index,value == null,isDbNull);\r
1408                                 }\r
1409                         }\r
1410 \r
1411                         internal override int Capacity {\r
1412                                 set {\r
1413                                         base.Capacity = value;\r
1414                                         if (_values == null) {\r
1415                                                 _values = new uint[value];\r
1416                                         }\r
1417                                         else {\r
1418                                                 uint[] tmp = new uint[value];\r
1419                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
1420                                                 _values = tmp;\r
1421                                         }\r
1422                                 }\r
1423                         }\r
1424 \r
1425                         #endregion //Properties\r
1426 \r
1427                         #region Methods\r
1428                         \r
1429                         private void SetValue(int index, uint value)\r
1430                         {\r
1431                                 _values[index] = value;\r
1432                         }\r
1433 \r
1434                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1435                         {\r
1436                                 // if exception thrown, it should be caught in the  caller method\r
1437                                 if (record is ISafeDataRecord) {\r
1438                                         SetValue(index,(uint)((ISafeDataRecord)record).GetInt32Safe(field));\r
1439                                 }\r
1440                                 else {\r
1441                                         this[index] = record.GetValue(field);\r
1442                                 }\r
1443                                 base.SetItemFromDataRecord(index,record,field);\r
1444                         }\r
1445 \r
1446                         internal override void CopyValue(int fromIndex, int toIndex)\r
1447                         {\r
1448                                 base.CopyValue(fromIndex, toIndex);\r
1449                                 _values[toIndex] = _values[fromIndex];\r
1450                         }\r
1451 \r
1452                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
1453                         {\r
1454                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
1455                                 _values[toIndex] = ((UInt32DataContainer)fromContainer)._values[fromIndex];\r
1456                         }\r
1457 \r
1458                         internal override int CompareValues(int index1, int index2)\r
1459                         {\r
1460                                 uint i1 = _values[index1];\r
1461                                 uint i2 = _values[index2];\r
1462 \r
1463                                 if ( i1 == 0 || i2 == 0 ) {\r
1464                                         int cn = CompareNulls(index1, index2);\r
1465                                         if (cn != 0)\r
1466                                                 return cn;\r
1467                                 }\r
1468 \r
1469                                 if ( i1 <= i2 ) {\r
1470                                         return ( i1 != i2 ) ? -1 : 0;\r
1471                                 }\r
1472                                 return 1;\r
1473                         }\r
1474 \r
1475                         internal override long GetInt64(int index)\r
1476                         {\r
1477                                 return Convert.ToInt64(_values[index]);\r
1478                         }\r
1479 \r
1480                         #endregion //Methods\r
1481                 }\r
1482 \r
1483                 sealed class UInt64DataContainer : AbstractDataContainer\r
1484                 {\r
1485                         #region Fields\r
1486                 \r
1487                         ulong[] _values;\r
1488 \r
1489                         #endregion //Fields\r
1490 \r
1491                         #region Properties\r
1492 \r
1493                         internal override object this[int index] {\r
1494                                 get {\r
1495                                         if (IsNull(index)) {\r
1496                                                 return DBNull.Value;\r
1497                                         }\r
1498                                         else {\r
1499                                                 return _values[index];\r
1500                                         }\r
1501                                 }\r
1502                                 set {\r
1503                                         bool isDbNull = (value ==  DBNull.Value);\r
1504                                         if (value == null || isDbNull) {\r
1505                                                 SetValue(index,0);\r
1506                                         }\r
1507                                         else if( value is ulong ) {\r
1508                                                 SetValue(index,(ulong)value);\r
1509                                         }\r
1510                                         else {\r
1511                                                 SetValue(index,Convert.ToUInt64(value));\r
1512                                         }\r
1513                                         SetNull(index,value == null,isDbNull);\r
1514                                 }\r
1515                         }\r
1516 \r
1517                         internal override int Capacity {\r
1518                                 set {\r
1519                                         base.Capacity = value;\r
1520                                         if (_values == null) {\r
1521                                                 _values = new ulong[value];\r
1522                                         }\r
1523                                         else {\r
1524                                                 ulong[] tmp = new ulong[value];\r
1525                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
1526                                                 _values = tmp;\r
1527                                         }\r
1528                                 }\r
1529                         }\r
1530 \r
1531                         #endregion //Properties\r
1532 \r
1533                         #region Methods\r
1534                         \r
1535                         private void SetValue(int index, ulong value)\r
1536                         {\r
1537                                 _values[index] = value;\r
1538                         }\r
1539 \r
1540                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1541                         {\r
1542                                 // if exception thrown, it should be caught in the  caller method\r
1543                                 if (record is ISafeDataRecord) {\r
1544                                         SetValue(index,(ulong)((ISafeDataRecord)record).GetInt64Safe(field));\r
1545                                 }\r
1546                                 else {\r
1547                                         this[index] = record.GetValue(field);\r
1548                                 }\r
1549                                 base.SetItemFromDataRecord(index,record,field);\r
1550                         }\r
1551 \r
1552                         internal override void CopyValue(int fromIndex, int toIndex)\r
1553                         {\r
1554                                 base.CopyValue(fromIndex, toIndex);\r
1555                                 _values[toIndex] = _values[fromIndex];\r
1556                         }\r
1557 \r
1558                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
1559                         {\r
1560                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
1561                                 _values[toIndex] = ((UInt64DataContainer)fromContainer)._values[fromIndex];\r
1562                         }\r
1563 \r
1564                         internal override int CompareValues(int index1, int index2)\r
1565                         {\r
1566                                 ulong l1 = _values[index1];\r
1567                                 ulong l2 = _values[index2];\r
1568 \r
1569                                 if ( l1 == 0 || l2 == 0 ) {\r
1570                                         int cn = CompareNulls(index1, index2);\r
1571                                         if (cn != 0) {\r
1572                                                 return cn;\r
1573                                         }\r
1574                                 }\r
1575 \r
1576                                 if ( l1 <= l2 ) {\r
1577                                         return ( l1 != l2 ) ? -1 : 0;\r
1578                                 }\r
1579                                 return 1;\r
1580                         }\r
1581 \r
1582                         internal override long GetInt64(int index)\r
1583                         {\r
1584                                 return Convert.ToInt64(_values[index]);\r
1585                         }\r
1586 \r
1587                         #endregion //Methods\r
1588                 }\r
1589 \r
1590 \r
1591                 sealed class SByteDataContainer : AbstractDataContainer\r
1592                 {\r
1593                         #region Fields\r
1594                 \r
1595                         sbyte[] _values;\r
1596 \r
1597                         #endregion //Fields\r
1598 \r
1599                         #region Properties\r
1600 \r
1601                         internal override object this[int index] {\r
1602                                 get {\r
1603                                         if (IsNull(index)) {\r
1604                                                 return DBNull.Value;\r
1605                                         }\r
1606                                         else {\r
1607                                                 return _values[index];\r
1608                                         }\r
1609                                 }\r
1610                                 set {\r
1611                                         bool isDbNull = (value ==  DBNull.Value);\r
1612                                         if (value == null || isDbNull) {\r
1613                                                 SetValue(index,0);\r
1614                                         }\r
1615                                         else if( value is sbyte ) {\r
1616                                                 SetValue(index,(sbyte)value);\r
1617                                         }\r
1618                                         else {\r
1619                                                 SetValue(index,Convert.ToSByte(value));\r
1620                                         }\r
1621                                         SetNull(index,value == null,isDbNull);\r
1622                                 }\r
1623                         }\r
1624 \r
1625                         internal override int Capacity {\r
1626                                 set {\r
1627                                         base.Capacity = value;\r
1628                                         if (_values == null) {\r
1629                                                 _values = new sbyte[value];\r
1630                                         }\r
1631                                         else {\r
1632                                                 sbyte[] tmp = new sbyte[value];\r
1633                                                 Array.Copy(_values,0,tmp,0,_values.Length);\r
1634                                                 _values = tmp;\r
1635                                         }\r
1636                                 }\r
1637                         }\r
1638 \r
1639                         #endregion //Properties\r
1640 \r
1641                         #region Methods\r
1642                         \r
1643                         private void SetValue(int index, sbyte value)\r
1644                         {\r
1645                                 _values[index] = value;\r
1646                         }\r
1647 \r
1648                         internal override void SetItemFromDataRecord(int index, IDataRecord record, int field)\r
1649                         {\r
1650                                 // if exception thrown, it should be caught in the  caller method\r
1651                                 if (record is ISafeDataRecord) {\r
1652                                         SetValue(index,(sbyte)((ISafeDataRecord)record).GetByteSafe(field));\r
1653                                 }\r
1654                                 else {\r
1655                                         this[index] = record.GetValue(field);\r
1656                                 }\r
1657                                 base.SetItemFromDataRecord(index,record,field);\r
1658                         }\r
1659 \r
1660                         internal override void CopyValue(int fromIndex, int toIndex)\r
1661                         {\r
1662                                 base.CopyValue(fromIndex, toIndex);\r
1663                                 _values[toIndex] = _values[fromIndex];\r
1664                         }\r
1665 \r
1666                         internal override void CopyValue(AbstractDataContainer fromContainer, int fromIndex, int toIndex)\r
1667                         {\r
1668                                 base.CopyValue(fromContainer, fromIndex, toIndex);\r
1669                                 _values[toIndex] = ((SByteDataContainer)fromContainer)._values[fromIndex];\r
1670                         }\r
1671 \r
1672                         internal override int CompareValues(int index1, int index2)\r
1673                         {\r
1674                                 sbyte b1 = _values[index1];\r
1675                                 sbyte b2 = _values[index2];\r
1676 \r
1677                                 if ( b1 == 0 || b2 == 0 ) {\r
1678                                         int cn = CompareNulls(index1, index2);\r
1679                                         if (cn != 0) {\r
1680                                                 return cn;\r
1681                                         }\r
1682                                 }\r
1683 \r
1684                                 return b1 - b2;\r
1685                         }\r
1686 \r
1687                         internal override long GetInt64(int index)\r
1688                         {\r
1689                                 return Convert.ToSByte(_values[index]);\r
1690                         }\r
1691 \r
1692                         #endregion //Methods\r
1693                 }\r
1694 \r
1695         }\r
1696 }\r