mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseTypes/SybaseInt64.cs

   1 //
   2 // Mono.Data.SybaseTypes.SybaseInt64
   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.SybaseClient;
  32 using System;
  33 using System.Data.SqlTypes;
  34 using System.Globalization;
  35
  36 namespace Mono.Data.SybaseTypes {
  37         public struct SybaseInt64 : INullable, IComparable
  38         {
  39                 #region Fields
  40
  41                 long value;
  42
  43                 private bool notNull;
  44
  45                 public static readonly SybaseInt64 MaxValue = new SybaseInt64 (9223372036854775807);
  46                 public static readonly SybaseInt64 MinValue = new SybaseInt64 (-9223372036854775808);
  47
  48                 public static readonly SybaseInt64 Null;
  49                 public static readonly SybaseInt64 Zero = new SybaseInt64 (0);
  50
  51                 #endregion
  52
  53                 #region Constructors
  54
  55                 public SybaseInt64 (long 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 long Value {
  70                         get {
  71                                 if (this.IsNull)
  72                                         throw new SybaseNullValueException ();
  73                                 else
  74                                         return value;
  75                         }
  76                 }
  77
  78                 #endregion
  79
  80                 #region Methods
  81
  82                 public static SybaseInt64 Add (SybaseInt64 x, SybaseInt64 y)
  83                 {
  84                         return (x + y);
  85                 }
  86
  87                 public static SybaseInt64 BitwiseAnd (SybaseInt64 x, SybaseInt64 y)
  88                 {
  89                         return (x & y);
  90                 }
  91
  92                 public static SybaseInt64 BitwiseOr (SybaseInt64 x, SybaseInt64 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 SybaseInt64))
 102                                 throw new ArgumentException (Locale.GetText ("Value is not a System.Data.SybaseTypes.SybaseInt64"));
 103                         else if (((SybaseInt64)value).IsNull)
 104                                 return 1;
 105                         else
 106                                 return this.value.CompareTo (((SybaseInt64)value).Value);
 107                 }
 108
 109                 public static SybaseInt64 Divide (SybaseInt64 x, SybaseInt64 y)
 110                 {
 111                         return (x / y);
 112                 }
 113
 114                 public override bool Equals (object value)
 115                 {
 116                         if (!(value is SybaseInt64))
 117                                 return false;
 118                         else
 119                                 return (bool) (this == (SybaseInt64)value);
 120                 }
 121
 122                 public static SybaseBoolean Equals (SybaseInt64 x, SybaseInt64 y)
 123                 {
 124                         return (x == y);
 125                 }
 126
 127                 public override int GetHashCode ()
 128                 {
 129                         return (int)(value & 0xffffffff) ^ (int)(value >> 32);
 130                 }
 131
 132                 public static SybaseBoolean GreaterThan (SybaseInt64 x, SybaseInt64 y)
 133                 {
 134                         return (x > y);
 135                 }
 136
 137                 public static SybaseBoolean GreaterThanOrEqual (SybaseInt64 x, SybaseInt64 y)
 138                 {
 139                         return (x >= y);
 140                 }
 141
 142                 public static SybaseBoolean LessThan (SybaseInt64 x, SybaseInt64 y)
 143                 {
 144                         return (x < y);
 145                 }
 146
 147                 public static SybaseBoolean LessThanOrEqual (SybaseInt64 x, SybaseInt64 y)
 148                 {
 149                         return (x <= y);
 150                 }
 151
 152                 public static SybaseInt64 Mod (SybaseInt64 x, SybaseInt64 y)
 153                 {
 154                         return (x % y);
 155                 }
 156
 157                 public static SybaseInt64 Multiply (SybaseInt64 x, SybaseInt64 y)
 158                 {
 159                         return (x * y);
 160                 }
 161
 162                 public static SybaseBoolean NotEquals (SybaseInt64 x, SybaseInt64 y)
 163                 {
 164                         return (x != y);
 165                 }
 166
 167                 public static SybaseInt64 OnesComplement (SybaseInt64 x)
 168                 {
 169                         return ~x;
 170                 }
 171
 172
 173                 public static SybaseInt64 Parse (string s)
 174                 {
 175                         return new SybaseInt64 (Int64.Parse (s));
 176                 }
 177
 178                 public static SybaseInt64 Subtract (SybaseInt64 x, SybaseInt64 y)
 179                 {
 180                         return (x - y);
 181                 }
 182
 183                 public SybaseBoolean ToSybaseBoolean ()
 184                 {
 185                         return ((SybaseBoolean)this);
 186                 }
 187
 188                 public SybaseByte ToSybaseByte ()
 189                 {
 190                         return ((SybaseByte)this);
 191                 }
 192
 193                 public SybaseDecimal ToSybaseDecimal ()
 194                 {
 195                         return ((SybaseDecimal)this);
 196                 }
 197
 198                 public SybaseDouble ToSybaseDouble ()
 199                 {
 200                         return ((SybaseDouble)this);
 201                 }
 202
 203                 public SybaseInt16 ToSybaseInt16 ()
 204                 {
 205                         return ((SybaseInt16)this);
 206                 }
 207
 208                 public SybaseInt32 ToSybaseInt32 ()
 209                 {
 210                         return ((SybaseInt32)this);
 211                 }
 212
 213                 public SybaseMoney ToSybaseMoney ()
 214                 {
 215                         return ((SybaseMoney)this);
 216                 }
 217
 218                 public SybaseSingle ToSybaseSingle ()
 219                 {
 220                         return ((SybaseSingle)this);
 221                 }
 222
 223                 public SybaseString ToSybaseString ()
 224                 {
 225                         return ((SybaseString)this);
 226                 }
 227
 228                 public override string ToString ()
 229                 {
 230                         if (this.IsNull)
 231                                 return "Null";
 232
 233                         return value.ToString ();
 234                 }
 235
 236                 public static SybaseInt64 Xor (SybaseInt64 x, SybaseInt64 y)
 237                 {
 238                         return (x ^ y);
 239                 }
 240
 241                 public static SybaseInt64 operator + (SybaseInt64 x, SybaseInt64 y)
 242                 {
 243                         return new SybaseInt64 (x.Value + y.Value);
 244                 }
 245
 246                 public static SybaseInt64 operator & (SybaseInt64 x, SybaseInt64 y)
 247                 {
 248                         return new SybaseInt64 (x.value & y.Value);
 249                 }
 250
 251                 public static SybaseInt64 operator | (SybaseInt64 x, SybaseInt64 y)
 252                 {
 253                         return new SybaseInt64 (x.value | y.Value);
 254                 }
 255
 256                 public static SybaseInt64 operator / (SybaseInt64 x, SybaseInt64 y)
 257                 {
 258                         return new SybaseInt64 (x.Value / y.Value);
 259                 }
 260
 261                 public static SybaseBoolean operator == (SybaseInt64 x, SybaseInt64 y)
 262                 {
 263                         if (x.IsNull || y.IsNull)
 264                                 return SybaseBoolean.Null;
 265                         else
 266                                 return new SybaseBoolean (x.Value == y.Value);
 267                 }
 268
 269                 public static SybaseInt64 operator ^ (SybaseInt64 x, SybaseInt64 y)
 270                 {
 271                         return new SybaseInt64 (x.Value ^ y.Value);
 272                 }
 273
 274                 public static SybaseBoolean operator > (SybaseInt64 x, SybaseInt64 y)
 275                 {
 276                         if (x.IsNull || y.IsNull)
 277                                 return SybaseBoolean.Null;
 278                         else
 279                                 return new SybaseBoolean (x.Value > y.Value);
 280                 }
 281
 282                 public static SybaseBoolean operator >= (SybaseInt64 x, SybaseInt64 y)
 283                 {
 284                         if (x.IsNull || y.IsNull)
 285                                 return SybaseBoolean.Null;
 286                         else
 287                                 return new SybaseBoolean (x.Value >= y.Value);
 288                 }
 289
 290                 public static SybaseBoolean operator != (SybaseInt64 x, SybaseInt64 y)
 291                 {
 292                         if (x.IsNull || y.IsNull)
 293                                 return SybaseBoolean.Null;
 294                         else
 295                                 return new SybaseBoolean (!(x.Value == y.Value));
 296                 }
 297
 298                 public static SybaseBoolean operator < (SybaseInt64 x, SybaseInt64 y)
 299                 {
 300                         if (x.IsNull || y.IsNull)
 301                                 return SybaseBoolean.Null;
 302                         else
 303                                 return new SybaseBoolean (x.Value < y.Value);
 304                 }
 305
 306                 public static SybaseBoolean operator <= (SybaseInt64 x, SybaseInt64 y)
 307                 {
 308                         if (x.IsNull || y.IsNull)
 309                                 return SybaseBoolean.Null;
 310                         else
 311                                 return new SybaseBoolean (x.Value <= y.Value);
 312                 }
 313
 314                 public static SybaseInt64 operator % (SybaseInt64 x, SybaseInt64 y)
 315                 {
 316                         return new SybaseInt64(x.Value % y.Value);
 317                 }
 318
 319                 public static SybaseInt64 operator * (SybaseInt64 x, SybaseInt64 y)
 320                 {
 321                         return new SybaseInt64 (x.Value * y.Value);
 322                 }
 323
 324                 public static SybaseInt64 operator ~ (SybaseInt64 x)
 325                 {
 326                         return new SybaseInt64 (~(x.Value));
 327                 }
 328
 329                 public static SybaseInt64 operator - (SybaseInt64 x, SybaseInt64 y)
 330                 {
 331                         return new SybaseInt64 (x.Value - y.Value);
 332                 }
 333
 334                 public static SybaseInt64 operator - (SybaseInt64 n)
 335                 {
 336                         return new SybaseInt64 (-(n.Value));
 337                 }
 338
 339                 public static explicit operator SybaseInt64 (SybaseBoolean x)
 340                 {
 341                         if (x.IsNull)
 342                                 return SybaseInt64.Null;
 343                         else
 344                                 return new SybaseInt64 ((long)x.ByteValue);
 345                 }
 346
 347                 public static explicit operator SybaseInt64 (SybaseDecimal x)
 348                 {
 349                         if (x.IsNull)
 350                                 return SybaseInt64.Null;
 351                         else
 352                                 return new SybaseInt64 ((long)x.Value);
 353                 }
 354
 355                 public static explicit operator SybaseInt64 (SybaseDouble x)
 356                 {
 357                         if (x.IsNull)
 358                                 return SybaseInt64.Null;
 359                         else
 360                                 return new SybaseInt64 ((long)x.Value);
 361                 }
 362
 363                 public static explicit operator long (SybaseInt64 x)
 364                 {
 365                         return x.Value;
 366                 }
 367
 368                 public static explicit operator SybaseInt64 (SybaseMoney x)
 369                 {
 370                         if (x.IsNull)
 371                                 return SybaseInt64.Null;
 372                         else
 373                                 return new SybaseInt64 ((long)x.Value);
 374                 }
 375
 376                 public static explicit operator SybaseInt64 (SybaseSingle x)
 377                 {
 378                         if (x.IsNull)
 379                                 return SybaseInt64.Null;
 380                         else
 381                                 return new SybaseInt64 ((long)x.Value);
 382                 }
 383
 384                 public static explicit operator SybaseInt64 (SybaseString x)
 385                 {
 386                         return SybaseInt64.Parse (x.Value);
 387                 }
 388
 389                 public static implicit operator SybaseInt64 (long x)
 390                 {
 391                         return new SybaseInt64 (x);
 392                 }
 393
 394                 public static implicit operator SybaseInt64 (SybaseByte x)
 395                 {
 396                         if (x.IsNull)
 397                                 return SybaseInt64.Null;
 398                         else
 399                                 return new SybaseInt64 ((long)x.Value);
 400                 }
 401
 402                 public static implicit operator SybaseInt64 (SybaseInt16 x)
 403                 {
 404                         if (x.IsNull)
 405                                 return SybaseInt64.Null;
 406                         else
 407                                 return new SybaseInt64 ((long)x.Value);
 408                 }
 409
 410                 public static implicit operator SybaseInt64 (SybaseInt32 x)
 411                 {
 412                         if (x.IsNull)
 413                                 return SybaseInt64.Null;
 414                         else
 415                                 return new SybaseInt64 ((long)x.Value);
 416                 }
 417
 418                 #endregion
 419         }
 420 }
 421