mcs/class/Mono.Data.TdsClient/Mono.Data.TdsTypes/TdsInt16.cs

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