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