mcs/class/System.Data.OracleClient/System.Data.OracleClient/OracleNumber.cs

   1 //
   2 // OracleNumber.cs
   3 //
   4 // Part of the Mono class libraries at
   5 // mcs/class/System.Data.OracleClient/System.Data.OracleClient
   6 //
   7 // Assembly: System.Data.OracleClient.dll
   8 // Namespace: System.Data.OracleClient
   9 //
  10 // Author: Tim Coleman <tim@timcoleman.com>
  11 //
  12 // Copyright (C) Tim Coleman, 2003
  13 //
  14 // Licensed under the MIT/X11 License.
  15 //
  16
  17 using System;
  18 using System.Data.SqlTypes;
  19
  20 namespace System.Data.OracleClient {
  21         public struct OracleNumber : IComparable, INullable
  22         {
  23                 #region Fields
  24
  25                 public static readonly OracleNumber E = new OracleNumber (Math.E);
  26                 public static readonly int MaxPrecision = 38;
  27                 public static readonly int MaxScale = 127;
  28                 public static readonly OracleNumber MaxValue; // FIXME
  29                 public static readonly int MinScale = -84;
  30                 public static readonly OracleNumber MinusOne = new OracleNumber (-1);
  31                 public static readonly OracleNumber MinValue; // FIXME
  32                 public static readonly OracleNumber Null = new OracleNumber ();
  33                 public static readonly OracleNumber One = new OracleNumber (1);
  34                 public static readonly OracleNumber PI = new OracleNumber (Math.PI);
  35                 public static readonly OracleNumber Zero = new OracleNumber (0);
  36
  37                 decimal value;
  38                 bool notNull;
  39
  40                 #endregion // Fields
  41
  42                 #region Constructors
  43
  44                 public OracleNumber (decimal decValue)
  45                 {
  46                         this.value = decValue;
  47                         notNull = true;
  48                 }
  49
  50                 public OracleNumber (double dblValue)
  51                         : this ((decimal) dblValue)
  52                 {
  53                 }
  54
  55                 public OracleNumber (int intValue)
  56                         : this ((decimal) intValue)
  57                 {
  58                 }
  59
  60                 public OracleNumber (long longValue)
  61                         : this ((decimal) longValue)
  62                 {
  63                 }
  64
  65                 public OracleNumber (OracleNumber from)
  66                         : this (from.Value)
  67                 {
  68                 }
  69
  70                 #endregion // Constructors
  71
  72                 #region Properties
  73
  74                 public bool IsNull {
  75                         get { return !notNull; }
  76                 }
  77
  78                 public decimal Value {
  79                         get {
  80                                 if (IsNull)
  81                                         throw new InvalidOperationException ("The value is Null.");
  82                                 return value;
  83                         }
  84                 }
  85
  86                 #endregion // Properties
  87
  88                 #region Methods
  89
  90                 public static OracleNumber Abs (OracleNumber n)
  91                 {
  92                         if (n.IsNull)
  93                                 return OracleNumber.Null;
  94                         return new OracleNumber (Math.Abs (n.Value));
  95                 }
  96
  97                 public static OracleNumber Acos (OracleNumber n)
  98                 {
  99                         if (n.IsNull)
 100                                 return OracleNumber.Null;
 101                         return new OracleNumber (Math.Acos ((double) n));
 102                 }
 103
 104                 public static OracleNumber Add (OracleNumber x, OracleNumber y)
 105                 {
 106                         if (x.IsNull || y.IsNull)
 107                                 return OracleNumber.Null;
 108                         return new OracleNumber (x.Value + y.Value);
 109                 }
 110
 111                 public static OracleNumber Asin (OracleNumber n)
 112                 {
 113                         if (n.IsNull)
 114                                 return OracleNumber.Null;
 115                         return new OracleNumber (Math.Asin ((double) n));
 116                 }
 117
 118                 public static OracleNumber Atan (OracleNumber n)
 119                 {
 120                         if (n.IsNull)
 121                                 return OracleNumber.Null;
 122                         return new OracleNumber (Math.Atan ((double) n));
 123                 }
 124
 125                 public static OracleNumber Atan2 (OracleNumber y, OracleNumber x)
 126                 {
 127                         if (x.IsNull || y.IsNull)
 128                                 return OracleNumber.Null;
 129                         return new OracleNumber (Math.Atan2 ((double) y, (double) x));
 130                 }
 131
 132                 public static OracleNumber Ceiling (OracleNumber n)
 133                 {
 134                         if (n.IsNull)
 135                                 return OracleNumber.Null;
 136                         return new OracleNumber (Math.Ceiling ((double) n));
 137                 }
 138
 139                 [MonoTODO]
 140                 public int CompareTo (object obj)
 141                 {
 142                         throw new NotImplementedException ();
 143                 }
 144
 145                 public static OracleNumber Cos (OracleNumber n)
 146                 {
 147                         if (n.IsNull)
 148                                 return OracleNumber.Null;
 149                         return new OracleNumber (Math.Cos ((double) n));
 150                 }
 151
 152                 public static OracleNumber Cosh (OracleNumber n)
 153                 {
 154                         if (n.IsNull)
 155                                 return OracleNumber.Null;
 156                         return new OracleNumber (Math.Cosh ((double) n));
 157                 }
 158
 159                 public static OracleNumber Divide (OracleNumber x, OracleNumber y)
 160                 {
 161                         if (x.IsNull || y.IsNull)
 162                                 return OracleNumber.Null;
 163                         return new OracleNumber (x.Value / y.Value);
 164                 }
 165
 166                 [MonoTODO]
 167                 public override bool Equals (object value)
 168                 {
 169                         throw new NotImplementedException ();
 170                 }
 171
 172                 public static OracleBoolean Equals (OracleNumber x, OracleNumber y)
 173                 {
 174                         if (x.IsNull || y.IsNull)
 175                                 return OracleBoolean.Null;
 176                         return new OracleBoolean (x.Value == y.Value);
 177                 }
 178
 179                 public static OracleNumber Exp (OracleNumber p)
 180                 {
 181                         if (p.IsNull)
 182                                 return OracleNumber.Null;
 183                         return new OracleNumber (Math.Exp ((double) p));
 184                 }
 185
 186                 public static OracleNumber Floor (OracleNumber n)
 187                 {
 188                         if (n.IsNull)
 189                                 return OracleNumber.Null;
 190                         return new OracleNumber (Decimal.Floor (n.Value));
 191                 }
 192
 193                 [MonoTODO]
 194                 public override int GetHashCode ()
 195                 {
 196                         throw new NotImplementedException ();
 197                 }
 198
 199                 public static OracleBoolean GreaterThan (OracleNumber x, OracleNumber y)
 200                 {
 201                         if (x.IsNull || y.IsNull)
 202                                 return OracleBoolean.Null;
 203                         return new OracleBoolean (x.Value > y.Value);
 204                 }
 205
 206                 public static OracleBoolean GreaterThanOrEqual (OracleNumber x, OracleNumber y)
 207                 {
 208                         if (x.IsNull || y.IsNull)
 209                                 return OracleBoolean.Null;
 210                         return new OracleBoolean (x.Value >= y.Value);
 211                 }
 212
 213                 public static OracleBoolean LessThan (OracleNumber x, OracleNumber y)
 214                 {
 215                         if (x.IsNull || y.IsNull)
 216                                 return OracleBoolean.Null;
 217                         return new OracleBoolean (x.Value < y.Value);
 218                 }
 219
 220                 public static OracleBoolean LessThanOrEqual (OracleNumber x, OracleNumber y)
 221                 {
 222                         if (x.IsNull || y.IsNull)
 223                                 return OracleBoolean.Null;
 224                         return new OracleBoolean (x.Value <= y.Value);
 225                 }
 226
 227                 public static OracleNumber Log (OracleNumber n)
 228                 {
 229                         if (n.IsNull)
 230                                 return OracleNumber.Null;
 231                         return new OracleNumber (Math.Log ((double) n));
 232                 }
 233
 234                 public static OracleNumber Log (OracleNumber n, int newBase)
 235                 {
 236                         if (n.IsNull)
 237                                 return OracleNumber.Null;
 238                         return new OracleNumber (Math.Log ((double) n, (double) newBase));
 239                 }
 240
 241                 public static OracleNumber Log (OracleNumber n, OracleNumber newBase)
 242                 {
 243                         if (n.IsNull || newBase.IsNull)
 244                                 return OracleNumber.Null;
 245                         return new OracleNumber (Math.Log ((double) n, (double) newBase));
 246                 }
 247
 248                 public static OracleNumber Log10 (OracleNumber n)
 249                 {
 250                         if (n.IsNull)
 251                                 return OracleNumber.Null;
 252                         return new OracleNumber (Math.Log10 ((double) n));
 253                 }
 254
 255                 public static OracleNumber Max (OracleNumber x, OracleNumber y)
 256                 {
 257                         if (x.IsNull || y.IsNull)
 258                                 return OracleNumber.Null;
 259                         return new OracleNumber (Math.Max (x.Value, y.Value));
 260                 }
 261
 262                 public static OracleNumber Min (OracleNumber x, OracleNumber y)
 263                 {
 264                         if (x.IsNull || y.IsNull)
 265                                 return OracleNumber.Null;
 266                         return new OracleNumber (Math.Min (x.Value, y.Value));
 267                 }
 268
 269                 public static OracleNumber Modulo (OracleNumber x, OracleNumber y)
 270                 {
 271                         if (x.IsNull || y.IsNull)
 272                                 return OracleNumber.Null;
 273                         return new OracleNumber (x.Value % y.Value);
 274                 }
 275
 276                 public static OracleNumber Multiply (OracleNumber x, OracleNumber y)
 277                 {
 278                         if (x.IsNull || y.IsNull)
 279                                 return OracleNumber.Null;
 280                         return new OracleNumber (x.Value * y.Value);
 281                 }
 282
 283                 public static OracleNumber Negate (OracleNumber x)
 284                 {
 285                         if (x.IsNull)
 286                                 return OracleNumber.Null;
 287                         return new OracleNumber (-x.Value);
 288                 }
 289
 290                 public static OracleBoolean NotEquals (OracleNumber x, OracleNumber y)
 291                 {
 292                         if (x.IsNull || y.IsNull)
 293                                 return OracleBoolean.Null;
 294                         return new OracleBoolean (x.Value != y.Value);
 295                 }
 296
 297                 public static OracleNumber Parse (string s)
 298                 {
 299                         return new OracleNumber (Decimal.Parse (s));
 300                 }
 301
 302                 public static OracleNumber Pow (OracleNumber x, int y)
 303                 {
 304                         if (x.IsNull)
 305                                 return OracleNumber.Null;
 306                         return new OracleNumber (Math.Pow ((double) x, (double) y));
 307                 }
 308
 309                 public static OracleNumber Pow (OracleNumber x, OracleNumber y)
 310                 {
 311                         if (x.IsNull || y.IsNull)
 312                                 return OracleNumber.Null;
 313                         return new OracleNumber (Math.Pow ((double) x, (double) y));
 314                 }
 315
 316                 public static OracleNumber Round (OracleNumber n, int position)
 317                 {
 318                         if (n.IsNull)
 319                                 return OracleNumber.Null;
 320                         return new OracleNumber (Math.Round (n.Value, position));
 321                 }
 322
 323                 public static OracleNumber Shift (OracleNumber n, int digits)
 324                 {
 325                         if (n.IsNull)
 326                                 return OracleNumber.Null;
 327                         return new OracleNumber (n * (OracleNumber) (Math.Pow (10, digits)));
 328                 }
 329
 330                 public static OracleNumber Sign (OracleNumber n)
 331                 {
 332                         if (n.IsNull)
 333                                 return OracleNumber.Null;
 334                         return new OracleNumber (Math.Sign (n.Value));
 335                 }
 336
 337                 public static OracleNumber Sin (OracleNumber n)
 338                 {
 339                         if (n.IsNull)
 340                                 return OracleNumber.Null;
 341                         return new OracleNumber (Math.Sin ((double) n));
 342                 }
 343
 344                 public static OracleNumber Sinh (OracleNumber n)
 345                 {
 346                         if (n.IsNull)
 347                                 return OracleNumber.Null;
 348                         return new OracleNumber (Math.Sinh ((double) n));
 349                 }
 350
 351                 public static OracleNumber Sqrt (OracleNumber n)
 352                 {
 353                         if (n.IsNull)
 354                                 return OracleNumber.Null;
 355                         return new OracleNumber (Math.Sqrt ((double) n));
 356                 }
 357
 358                 public static OracleNumber Subtract (OracleNumber x, OracleNumber y)
 359                 {
 360                         if (x.IsNull || y.IsNull)
 361                                 return OracleNumber.Null;
 362                         return new OracleNumber (x.Value - y.Value);
 363                 }
 364
 365                 public static OracleNumber Tan (OracleNumber n)
 366                 {
 367                         if (n.IsNull)
 368                                 return OracleNumber.Null;
 369                         return new OracleNumber (Math.Tan ((double) n));
 370                 }
 371
 372                 public static OracleNumber Tanh (OracleNumber n)
 373                 {
 374                         if (n.IsNull)
 375                                 return OracleNumber.Null;
 376                         return new OracleNumber (Math.Tanh ((double) n));
 377                 }
 378
 379                 public override string ToString ()
 380                 {
 381                         if (IsNull)
 382                                 return "Null";
 383                         return Value.ToString ();
 384                 }
 385
 386                 [MonoTODO]
 387                 public static OracleNumber Truncate (OracleNumber n, int position)
 388                 {
 389                         throw new NotImplementedException ();
 390                 }
 391
 392                 #endregion // Methods
 393
 394                 #region Operators and Type Conversions
 395
 396                 public static OracleNumber operator + (OracleNumber x, OracleNumber y)
 397                 {
 398                         return Add (x, y);
 399                 }
 400
 401                 public static OracleNumber operator / (OracleNumber x, OracleNumber y)
 402                 {
 403                         return Divide (x, y);
 404                 }
 405
 406                 public static OracleBoolean operator == (OracleNumber x, OracleNumber y)
 407                 {
 408                         return Equals (x, y);
 409                 }
 410
 411                 public static OracleBoolean operator > (OracleNumber x, OracleNumber y)
 412                 {
 413                         return GreaterThan (x, y);
 414                 }
 415
 416                 public static OracleBoolean operator >= (OracleNumber x, OracleNumber y)
 417                 {
 418                         return GreaterThanOrEqual (x, y);
 419                 }
 420
 421                 public static OracleBoolean operator != (OracleNumber x, OracleNumber y)
 422                 {
 423                         return NotEquals (x, y);
 424                 }
 425
 426                 public static OracleBoolean operator < (OracleNumber x, OracleNumber y)
 427                 {
 428                         return LessThan (x, y);
 429                 }
 430
 431                 public static OracleBoolean operator <= (OracleNumber x, OracleNumber y)
 432                 {
 433                         return LessThanOrEqual (x, y);
 434                 }
 435
 436                 public static OracleNumber operator % (OracleNumber x, OracleNumber y)
 437                 {
 438                         return Modulo (x, y);
 439                 }
 440
 441                 public static OracleNumber operator * (OracleNumber x, OracleNumber y)
 442                 {
 443                         return Multiply (x, y);
 444                 }
 445
 446                 public static OracleNumber operator - (OracleNumber x, OracleNumber y)
 447                 {
 448                         return Subtract (x, y);
 449                 }
 450
 451                 public static OracleNumber operator - (OracleNumber x)
 452                 {
 453                         return Negate (x);
 454                 }
 455
 456                 public static explicit operator OracleNumber (decimal x)
 457                 {
 458                         return new OracleNumber (x);
 459                 }
 460
 461                 public static explicit operator OracleNumber (double x)
 462                 {
 463                         return new OracleNumber (x);
 464                 }
 465
 466                 public static explicit operator OracleNumber (int x)
 467                 {
 468                         return new OracleNumber (x);
 469                 }
 470
 471                 public static explicit operator OracleNumber (long x)
 472                 {
 473                         return new OracleNumber (x);
 474                 }
 475
 476                 public static explicit operator double (OracleNumber x)
 477                 {
 478                         if (x.IsNull)
 479                                 throw new NullReferenceException ();
 480                         return (double) x.Value;
 481                 }
 482
 483                 public static explicit operator decimal (OracleNumber x)
 484                 {
 485                         if (x.IsNull)
 486                                 throw new NullReferenceException ();
 487                         return x.Value;
 488                 }
 489
 490                 public static explicit operator int (OracleNumber x)
 491                 {
 492                         if (x.IsNull)
 493                                 throw new NullReferenceException ();
 494                         return (int) x.Value;
 495                 }
 496
 497                 public static explicit operator long (OracleNumber x)
 498                 {
 499                         if (x.IsNull)
 500                                 throw new NullReferenceException ();
 501                         return (long) x.Value;
 502                 }
 503
 504                 public static explicit operator OracleNumber (string x)
 505                 {
 506                         return OracleNumber.Parse (x);
 507                 }
 508
 509                 #endregion // Operators and Type Conversions
 510         }
 511 }