mcs/class/System.Data/System.Data.SqlTypes/SqlInt16.cs

   1 //
   2 // System.Data.SqlTypes.SqlInt16
   3 //
   4 // Author:
   5 //   Tim Coleman <tim@timcoleman.com>
   6 //   Ville Palo <vi64pa@koti.soon.fi>
   7 //
   8 // (C) Copyright 2002 Tim Coleman
   9 //
  10
  11 //
  12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System;
  35 using System.Globalization;
  36
  37 namespace System.Data.SqlTypes
  38 {
  39         public struct SqlInt16 : INullable, IComparable
  40         {
  41                 #region Fields
  42
  43                 short value;
  44                 private bool notNull;
  45
  46                 public static readonly SqlInt16 MaxValue = new SqlInt16 (32767);
  47                 public static readonly SqlInt16 MinValue = new SqlInt16 (-32768);
  48                 public static readonly SqlInt16 Null;
  49                 public static readonly SqlInt16 Zero = new SqlInt16 (0);
  50
  51                 #endregion
  52
  53                 #region Constructors
  54
  55                 public SqlInt16 (short value)
  56                 {
  57                         this.value = value;
  58                         notNull = true;;
  59                 }
  60
  61                 #endregion
  62
  63                 #region Properties
  64
  65                 public bool IsNull {
  66                         get { return !notNull; }
  67                 }
  68
  69                 public short Value {
  70                         get {
  71                                 if (this.IsNull)
  72                                         throw new SqlNullValueException ();
  73                                 else
  74                                         return value;
  75                         }
  76                 }
  77
  78                 #endregion
  79
  80                 #region Methods
  81
  82                 public static SqlInt16 Add (SqlInt16 x, SqlInt16 y)
  83                 {
  84                         return (x + y);
  85                 }
  86
  87                 public static SqlInt16 BitwiseAnd (SqlInt16 x, SqlInt16 y)
  88                 {
  89                         return (x & y);
  90                 }
  91
  92                 public static SqlInt16 BitwiseOr (SqlInt16 x, SqlInt16 y)
  93                 {
  94                         return (x | y);
  95                 }
  96
  97                 public int CompareTo (object value)
  98                 {
  99                         if (value == null)
 100                                 return 1;
 101                         else if (!(value is SqlInt16))
 102                                 throw new ArgumentException (Locale.GetText ("Value is not a System.Data.SqlTypes.SqlInt16"));
 103                         return CompareSqlInt16 ((SqlInt16) value);
 104                 }
 105
 106                 #if NET_2_0
 107                 public int CompareTo (SqlInt16 value)
 108                 {
 109                         return CompareSqlInt16 (value);
 110                 }
 111                 #endif
 112
 113                 private int CompareSqlInt16 (SqlInt16 value)
 114                 {
 115                          if (((SqlInt16)value).IsNull)
 116                                 return 1;
 117                         else
 118                                 return this.value.CompareTo (value.Value);
 119                 }
 120
 121                 public static SqlInt16 Divide (SqlInt16 x, SqlInt16 y)
 122                 {
 123                         return (x / y);
 124                 }
 125
 126                 public override bool Equals (object value)
 127                 {
 128                         if (!(value is SqlInt16))
 129                                 return false;
 130                         else if (this.IsNull && ((SqlInt16)value).IsNull)
 131                                 return true;
 132                         else if (((SqlInt16)value).IsNull)
 133                                 return false;
 134                         else
 135                                 return (bool)(this == (SqlInt16)value);
 136                 }
 137
 138                 public static SqlBoolean Equals (SqlInt16 x, SqlInt16 y)
 139                 {
 140                         return (x == y);
 141                 }
 142
 143                 public override int GetHashCode ()
 144                 {
 145                         return (int)value;
 146                 }
 147
 148                 public static SqlBoolean GreaterThan (SqlInt16 x, SqlInt16 y)
 149                 {
 150                         return (x > y);
 151                 }
 152
 153                 public static SqlBoolean GreaterThanOrEqual (SqlInt16 x, SqlInt16 y)
 154                 {
 155                         return (x >= y);
 156                 }
 157
 158                 public static SqlBoolean LessThan (SqlInt16 x, SqlInt16 y)
 159                 {
 160                         return (x < y);
 161                 }
 162
 163                 public static SqlBoolean LessThanOrEqual (SqlInt16 x, SqlInt16 y)
 164                 {
 165                         return (x <= y);
 166                 }
 167
 168                 public static SqlInt16 Mod (SqlInt16 x, SqlInt16 y)
 169                 {
 170                         return (x % y);
 171                 }
 172
 173                 #if NET_2_0
 174                 public static SqlInt16 Modulus (SqlInt16 x, SqlInt16 y)
 175                 {
 176                         return (x % y);
 177                 }
 178                 #endif
 179
 180
 181                 public static SqlInt16 Multiply (SqlInt16 x, SqlInt16 y)
 182                 {
 183                         return (x * y);
 184                 }
 185
 186                 public static SqlBoolean NotEquals (SqlInt16 x, SqlInt16 y)
 187                 {
 188                         return (x != y);
 189                 }
 190
 191                 public static SqlInt16 OnesComplement (SqlInt16 x)
 192                 {
 193                         if (x.IsNull)
 194                                 return Null;
 195
 196                         return ~x;
 197                 }
 198
 199                 public static SqlInt16 Parse (string s)
 200                 {
 201                         checked {
 202                                 return new SqlInt16 (Int16.Parse (s));
 203                         }
 204                 }
 205
 206                 public static SqlInt16 Subtract (SqlInt16 x, SqlInt16 y)
 207                 {
 208                         return (x - y);
 209                 }
 210
 211                 public SqlBoolean ToSqlBoolean ()
 212                 {
 213                         return ((SqlBoolean)this);
 214                 }
 215
 216                 public SqlByte ToSqlByte ()
 217                 {
 218                         return ((SqlByte)this);
 219                 }
 220
 221                 public SqlDecimal ToSqlDecimal ()
 222                 {
 223                         return ((SqlDecimal)this);
 224                 }
 225
 226                 public SqlDouble ToSqlDouble ()
 227                 {
 228                         return ((SqlDouble)this);
 229                 }
 230
 231                 public SqlInt32 ToSqlInt32 ()
 232                 {
 233                         return ((SqlInt32)this);
 234                 }
 235
 236                 public SqlInt64 ToSqlInt64 ()
 237                 {
 238                         return ((SqlInt64)this);
 239                 }
 240
 241                 public SqlMoney ToSqlMoney ()
 242                 {
 243                         return ((SqlMoney)this);
 244                 }
 245
 246                 public SqlSingle ToSqlSingle ()
 247                 {
 248                         return ((SqlSingle)this);
 249                 }
 250
 251                 public SqlString ToSqlString ()
 252                 {
 253                         return ((SqlString)this);
 254                 }
 255
 256                 public override string ToString ()
 257                 {
 258                         if (this.IsNull)
 259                                 return "Null";
 260                         else
 261                                 return value.ToString ();
 262                 }
 263
 264                 public static SqlInt16 Xor (SqlInt16 x, SqlInt16 y)
 265                 {
 266                         return (x ^ y);
 267                 }
 268
 269                 public static SqlInt16 operator + (SqlInt16 x, SqlInt16 y)
 270                 {
 271                         checked {
 272                                 return new SqlInt16 ((short) (x.Value + y.Value));
 273                         }
 274                 }
 275
 276                 public static SqlInt16 operator & (SqlInt16 x, SqlInt16 y)
 277                 {
 278                         return new SqlInt16 ((short) (x.value & y.Value));
 279                 }
 280
 281                 public static SqlInt16 operator | (SqlInt16 x, SqlInt16 y)
 282                 {
 283                         return new SqlInt16 ((short) ( x.Value | y.Value));
 284                 }
 285
 286                 public static SqlInt16 operator / (SqlInt16 x, SqlInt16 y)
 287                 {
 288                         checked {
 289                                 return new SqlInt16 ((short) (x.Value / y.Value));
 290                         }
 291                 }
 292
 293                 public static SqlBoolean operator == (SqlInt16 x, SqlInt16 y)
 294                 {
 295                         if (x.IsNull || y.IsNull)
 296                                 return SqlBoolean.Null;
 297                         else
 298                                 return new SqlBoolean (x.Value == y.Value);
 299                 }
 300
 301                 public static SqlInt16 operator ^ (SqlInt16 x, SqlInt16 y)
 302                 {
 303                         return new SqlInt16 ((short) (x.Value ^ y.Value));
 304                 }
 305
 306                 public static SqlBoolean operator > (SqlInt16 x, SqlInt16 y)
 307                 {
 308                         if (x.IsNull || y.IsNull)
 309                                 return SqlBoolean.Null;
 310                         else
 311                                 return new SqlBoolean (x.Value > y.Value);
 312                 }
 313
 314                 public static SqlBoolean operator >= (SqlInt16 x, SqlInt16 y)
 315                 {
 316                         if (x.IsNull || y.IsNull)
 317                                 return SqlBoolean.Null;
 318                         else
 319                                 return new SqlBoolean (x.Value >= y.Value);
 320                 }
 321
 322                 public static SqlBoolean operator != (SqlInt16 x, SqlInt16 y)
 323                 {
 324                         if (x.IsNull || y.IsNull)
 325                                 return SqlBoolean.Null;
 326                         else
 327                                 return new SqlBoolean (!(x.Value == y.Value));
 328                 }
 329
 330                 public static SqlBoolean operator < (SqlInt16 x, SqlInt16 y)
 331                 {
 332                         if (x.IsNull || y.IsNull)
 333                                 return SqlBoolean.Null;
 334                         else
 335                                 return new SqlBoolean (x.Value < y.Value);
 336                 }
 337
 338                 public static SqlBoolean operator <= (SqlInt16 x, SqlInt16 y)
 339                 {
 340                         if (x.IsNull || y.IsNull)
 341                                 return SqlBoolean.Null;
 342                         else
 343                                 return new SqlBoolean (x.Value <= y.Value);
 344                 }
 345
 346                 public static SqlInt16 operator % (SqlInt16 x, SqlInt16 y)
 347                 {
 348                         return new SqlInt16 ((short) (x.Value % y.Value));
 349                 }
 350
 351                 public static SqlInt16 operator * (SqlInt16 x, SqlInt16 y)
 352                 {
 353                         checked {
 354                                 return new SqlInt16 ((short) (x.Value * y.Value));
 355                         }
 356                 }
 357
 358                 public static SqlInt16 operator ~ (SqlInt16 x)
 359                 {
 360                         if (x.IsNull)
 361                                 return Null;
 362
 363                         return new SqlInt16 ((short) (~x.Value));
 364                 }
 365
 366                 public static SqlInt16 operator - (SqlInt16 x, SqlInt16 y)
 367                 {
 368                         checked {
 369                                 return new SqlInt16 ((short) (x.Value - y.Value));
 370                         }
 371                 }
 372
 373                 public static SqlInt16 operator - (SqlInt16 n)
 374                 {
 375                         checked {
 376                                 return new SqlInt16 ((short) (-n.Value));
 377                         }
 378                 }
 379
 380                 public static explicit operator SqlInt16 (SqlBoolean x)
 381                 {
 382                         if (x.IsNull)
 383                                 return Null;
 384                         else
 385                                 return new SqlInt16 ((short)x.ByteValue);
 386                 }
 387
 388                 public static explicit operator SqlInt16 (SqlDecimal x)
 389                 {
 390                         checked {
 391                                 if (x.IsNull)
 392                                         return Null;
 393                                 else
 394                                         return new SqlInt16 ((short)x.Value);
 395                         }
 396                 }
 397
 398                 public static explicit operator SqlInt16 (SqlDouble x)
 399                 {
 400                         if (x.IsNull)
 401                                 return Null;
 402                         else
 403                                 return new SqlInt16 (checked ((short)x.Value));
 404                 }
 405
 406                 public static explicit operator short (SqlInt16 x)
 407                 {
 408                         return x.Value;
 409                 }
 410
 411                 public static explicit operator SqlInt16 (SqlInt32 x)
 412                 {
 413                         checked {
 414                                 if (x.IsNull)
 415                                         return Null;
 416                                 else
 417                                         return new SqlInt16 ((short)x.Value);
 418                         }
 419                 }
 420
 421                 public static explicit operator SqlInt16 (SqlInt64 x)
 422                 {
 423                         if (x.IsNull)
 424                                 return Null;
 425                         else {
 426                                 checked {
 427                                         return new SqlInt16 ((short)x.Value);
 428                                 }
 429                         }
 430                 }
 431
 432                 public static explicit operator SqlInt16 (SqlMoney x)
 433                 {
 434                         checked {
 435                                 if (x.IsNull)
 436                                         return Null;
 437                                 else
 438                                         return new SqlInt16 ((short) Math.Round (x.Value));
 439                         }
 440                 }
 441
 442
 443                 public static explicit operator SqlInt16 (SqlSingle x)
 444                 {
 445                         if (x.IsNull)
 446                                 return Null;
 447                         else {
 448                                 checked {
 449                                         return new SqlInt16 ((short)x.Value);
 450                                 }
 451                         }
 452                 }
 453
 454                 public static explicit operator SqlInt16 (SqlString x)
 455                 {
 456                         if (x.IsNull)
 457                                 return Null;
 458
 459                         return SqlInt16.Parse (x.Value);
 460                 }
 461
 462                 public static implicit operator SqlInt16 (short x)
 463                 {
 464                         return new SqlInt16 (x);
 465                 }
 466
 467                 public static implicit operator SqlInt16 (SqlByte x)
 468                 {
 469                         return new SqlInt16 ((short)x.Value);
 470                 }
 471
 472                 #endregion
 473         }
 474 }
 475