class/Npgsql/NpgsqlTypes/NpgsqlTypes.cs

   1 // NpgsqlTypes.NpgsqlTypesHelper.cs
   2 //
   3 // Author:
   4 //    Glen Parker <glenebob@nwlink.com>
   5 //
   6 //    Copyright (C) 2004 The Npgsql Development Team
   7 //    npgsql-general@gborg.postgresql.org
   8 //    http://gborg.postgresql.org/project/npgsql/projdisplay.php
   9 //
  10 // Permission to use, copy, modify, and distribute this software and its
  11 // documentation for any purpose, without fee, and without a written
  12 // agreement is hereby granted, provided that the above copyright notice
  13 // and this paragraph and the following two paragraphs appear in all copies.
  14 //
  15 // IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY
  16 // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
  17 // INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  18 // DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF
  19 // THE POSSIBILITY OF SUCH DAMAGE.
  20 //
  21 // THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  22 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  23 // AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
  24 // ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS
  25 // TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  26
  27 // This file provides implementations of PostgreSQL specific data types that cannot
  28 // be mapped to standard .NET classes.
  29
  30 using System;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33 using System.Net;
  34 using Npgsql;
  35
  36 namespace NpgsqlTypes
  37 {
  38     /// <summary>
  39     /// Represents a PostgreSQL Point type
  40     /// </summary>
  41     public struct NpgsqlPoint : IEquatable<NpgsqlPoint>
  42     {
  43         private Single _x;
  44         private Single _y;
  45
  46         public NpgsqlPoint(Single x, Single y)
  47         {
  48             _x = x;
  49             _y = y;
  50         }
  51
  52         public Single X
  53         {
  54             get
  55             {
  56                 return _x;
  57             }
  58
  59             set
  60             {
  61                 _x = value;
  62             }
  63         }
  64
  65         public Single Y
  66         {
  67             get
  68             {
  69                 return _y;
  70             }
  71
  72             set
  73             {
  74                 _y = value;
  75             }
  76         }
  77
  78
  79         public bool Equals(NpgsqlPoint other)
  80         {
  81             return X == other.X && Y == other.Y;
  82         }
  83
  84         public override bool Equals(object obj)
  85         {
  86             return obj != null && obj is NpgsqlPoint && Equals((NpgsqlPoint) obj);
  87         }
  88
  89         public static bool operator ==(NpgsqlPoint x, NpgsqlPoint y)
  90         {
  91             return x.Equals(y);
  92         }
  93
  94         public static bool operator !=(NpgsqlPoint x, NpgsqlPoint y)
  95         {
  96             return !(x == y);
  97         }
  98
  99         public override int GetHashCode()
 100         {
 101             return X.GetHashCode() ^ PGUtil.RotateShift(Y.GetHashCode(), sizeof (int)/2);
 102         }
 103     }
 104
 105     public struct NpgsqlBox : IEquatable<NpgsqlBox>
 106     {
 107
 108         private NpgsqlPoint _upperRight;
 109         private NpgsqlPoint _lowerLeft;
 110
 111         public NpgsqlBox(NpgsqlPoint upperRight, NpgsqlPoint lowerLeft)
 112         {
 113             _upperRight = upperRight;
 114             _lowerLeft = lowerLeft;
 115         }
 116
 117         public NpgsqlBox(float Top, float Right, float Bottom, float Left)
 118             : this(new NpgsqlPoint(Right, Top), new NpgsqlPoint(Left, Bottom))
 119         {
 120         }
 121
 122         public NpgsqlPoint UpperRight
 123         {
 124             get
 125             {
 126                 return _upperRight;
 127             }
 128
 129             set
 130             {
 131                 _upperRight = value;
 132             }
 133
 134         }
 135
 136         public NpgsqlPoint LowerLeft
 137         {
 138             get
 139             {
 140                 return _lowerLeft;
 141             }
 142
 143             set
 144             {
 145                 _lowerLeft = value;
 146             }
 147
 148         }
 149
 150         public float Left
 151         {
 152             get { return LowerLeft.X; }
 153         }
 154
 155         public float Right
 156         {
 157             get { return UpperRight.X; }
 158         }
 159
 160         public float Bottom
 161         {
 162             get { return LowerLeft.Y; }
 163         }
 164
 165         public float Top
 166         {
 167             get { return UpperRight.Y; }
 168         }
 169
 170         public float Width
 171         {
 172             get { return Right - Left; }
 173         }
 174
 175         public float Height
 176         {
 177             get { return Top - Bottom; }
 178         }
 179
 180         public bool IsEmpty
 181         {
 182             get { return Width == 0 || Height == 0; }
 183         }
 184
 185         public bool Equals(NpgsqlBox other)
 186         {
 187             return UpperRight == other.UpperRight && LowerLeft == other.LowerLeft;
 188         }
 189
 190         public override bool Equals(object obj)
 191         {
 192             return obj != null && obj is NpgsqlBox && Equals((NpgsqlBox) obj);
 193         }
 194
 195         public static bool operator ==(NpgsqlBox x, NpgsqlBox y)
 196         {
 197             return x.Equals(y);
 198         }
 199
 200         public static bool operator !=(NpgsqlBox x, NpgsqlBox y)
 201         {
 202             return !(x == y);
 203         }
 204
 205         public override int GetHashCode()
 206         {
 207             return
 208                 Top.GetHashCode() ^ PGUtil.RotateShift(Right.GetHashCode(), sizeof (int)/4) ^
 209                 PGUtil.RotateShift(Bottom.GetHashCode(), sizeof (int)/2) ^
 210                 PGUtil.RotateShift(LowerLeft.GetHashCode(), sizeof (int)*3/4);
 211         }
 212     }
 213
 214
 215     /// <summary>
 216     /// Represents a PostgreSQL Line Segment type.
 217     /// </summary>
 218     public struct NpgsqlLSeg : IEquatable<NpgsqlLSeg>
 219     {
 220         public NpgsqlPoint Start;
 221         public NpgsqlPoint End;
 222
 223         public NpgsqlLSeg(NpgsqlPoint start, NpgsqlPoint end)
 224         {
 225             Start = start;
 226             End = end;
 227         }
 228
 229         public override String ToString()
 230         {
 231             return String.Format("({0}, {1})", Start, End);
 232         }
 233
 234         public override int GetHashCode()
 235         {
 236             return
 237                 Start.X.GetHashCode() ^ PGUtil.RotateShift(Start.Y.GetHashCode(), sizeof (int)/4) ^
 238                 PGUtil.RotateShift(End.X.GetHashCode(), sizeof (int)/2) ^ PGUtil.RotateShift(End.Y.GetHashCode(), sizeof (int)*3/4);
 239         }
 240
 241         public bool Equals(NpgsqlLSeg other)
 242         {
 243             return Start == other.Start && End == other.End;
 244         }
 245
 246         public override bool Equals(object obj)
 247         {
 248             return obj != null && obj is NpgsqlLSeg && Equals((NpgsqlLSeg) obj);
 249         }
 250
 251         public static bool operator ==(NpgsqlLSeg x, NpgsqlLSeg y)
 252         {
 253             return x.Equals(y);
 254         }
 255
 256         public static bool operator !=(NpgsqlLSeg x, NpgsqlLSeg y)
 257         {
 258             return !(x == y);
 259         }
 260     }
 261
 262     /// <summary>
 263     /// Represents a PostgreSQL Path type.
 264     /// </summary>
 265     public struct NpgsqlPath : IList<NpgsqlPoint>, IEquatable<NpgsqlPath>
 266     {
 267         private bool _open;
 268         private readonly List<NpgsqlPoint> _points;
 269
 270         public NpgsqlPath(IEnumerable<NpgsqlPoint> points, bool open)
 271         {
 272             _points = new List<NpgsqlPoint>(points);
 273             _open = open;
 274         }
 275
 276         public NpgsqlPath(IEnumerable<NpgsqlPoint> points)
 277             : this(points, false)
 278         {
 279         }
 280
 281         public NpgsqlPath(NpgsqlPoint[] points) : this((IEnumerable<NpgsqlPoint>)points, false)
 282         {
 283         }
 284
 285         public NpgsqlPath(bool open)
 286         {
 287             _points = new List<NpgsqlPoint>();
 288             _open = open;
 289         }
 290
 291         public NpgsqlPath(int capacity, bool open)
 292         {
 293             _points = new List<NpgsqlPoint>(capacity);
 294             _open = open;
 295         }
 296
 297         public NpgsqlPath(int capacity)
 298             : this(capacity, false)
 299         {
 300         }
 301
 302         public bool Open
 303         {
 304             get
 305             {
 306                 return _open;
 307             }
 308
 309             set
 310             {
 311                 _open = value;
 312             }
 313         }
 314
 315         public NpgsqlPoint this[int index]
 316         {
 317             get { return _points[index]; }
 318             set { _points[index] = value; }
 319         }
 320
 321         public int Count
 322         {
 323             get { return _points.Count; }
 324         }
 325
 326         public bool IsReadOnly
 327         {
 328             get { return false; }
 329         }
 330
 331         public int IndexOf(NpgsqlPoint item)
 332         {
 333             return _points.IndexOf(item);
 334         }
 335
 336         public void Insert(int index, NpgsqlPoint item)
 337         {
 338             _points.Insert(index, item);
 339         }
 340
 341         public void RemoveAt(int index)
 342         {
 343             _points.RemoveAt(index);
 344         }
 345
 346         public void Add(NpgsqlPoint item)
 347         {
 348             _points.Add(item);
 349         }
 350
 351         public void Clear()
 352         {
 353             _points.Clear();
 354         }
 355
 356         public bool Contains(NpgsqlPoint item)
 357         {
 358             return _points.Contains(item);
 359         }
 360
 361         public void CopyTo(NpgsqlPoint[] array, int arrayIndex)
 362         {
 363             _points.CopyTo(array, arrayIndex);
 364         }
 365
 366         public bool Remove(NpgsqlPoint item)
 367         {
 368             return _points.Remove(item);
 369         }
 370
 371         public IEnumerator<NpgsqlPoint> GetEnumerator()
 372         {
 373             return _points.GetEnumerator();
 374         }
 375
 376         IEnumerator IEnumerable.GetEnumerator()
 377         {
 378             return GetEnumerator();
 379         }
 380
 381         public bool Equals(NpgsqlPath other)
 382         {
 383             if (Open != other.Open || Count != other.Count)
 384             {
 385                 return false;
 386             }
 387             for (int i = 0; i != Count; ++i)
 388             {
 389                 if (this[i] != other[i])
 390                 {
 391                     return false;
 392                 }
 393             }
 394             return true;
 395         }
 396
 397         public override bool Equals(object obj)
 398         {
 399             return obj != null && obj is NpgsqlPath && Equals((NpgsqlPath) obj);
 400         }
 401
 402         public static bool operator ==(NpgsqlPath x, NpgsqlPath y)
 403         {
 404             return x.Equals(y);
 405         }
 406
 407         public static bool operator !=(NpgsqlPath x, NpgsqlPath y)
 408         {
 409             return !(x == y);
 410         }
 411
 412         public override int GetHashCode()
 413         {
 414             int ret = 0;
 415             foreach (NpgsqlPoint point in this)
 416             {
 417                 //The ideal amount to shift each value is one that would evenly spread it throughout
 418                 //the resultant bytes. Using the current result % 32 is essentially using a random value
 419                 //but one that will be the same on subsequent calls.
 420                 ret ^= PGUtil.RotateShift(point.GetHashCode(), ret%sizeof (int));
 421             }
 422             return Open ? ret : -ret;
 423         }
 424     }
 425
 426     /// <summary>
 427     /// Represents a PostgreSQL Polygon type.
 428     /// </summary>
 429     public struct NpgsqlPolygon : IList<NpgsqlPoint>, IEquatable<NpgsqlPolygon>
 430     {
 431         private readonly List<NpgsqlPoint> _points;
 432
 433         public NpgsqlPolygon(IEnumerable<NpgsqlPoint> points)
 434         {
 435             _points = new List<NpgsqlPoint>(points);
 436         }
 437
 438         public NpgsqlPolygon(NpgsqlPoint[] points) : this ((IEnumerable<NpgsqlPoint>) points)
 439         {
 440         }
 441
 442         public NpgsqlPoint this[int index]
 443         {
 444             get { return _points[index]; }
 445             set { _points[index] = value; }
 446         }
 447
 448         public int Count
 449         {
 450             get { return _points.Count; }
 451         }
 452
 453         public bool IsReadOnly
 454         {
 455             get { return false; }
 456         }
 457
 458         public int IndexOf(NpgsqlPoint item)
 459         {
 460             return _points.IndexOf(item);
 461         }
 462
 463         public void Insert(int index, NpgsqlPoint item)
 464         {
 465             _points.Insert(index, item);
 466         }
 467
 468         public void RemoveAt(int index)
 469         {
 470             _points.RemoveAt(index);
 471         }
 472
 473         public void Add(NpgsqlPoint item)
 474         {
 475             _points.Add(item);
 476         }
 477
 478         public void Clear()
 479         {
 480             _points.Clear();
 481         }
 482
 483         public bool Contains(NpgsqlPoint item)
 484         {
 485             return _points.Contains(item);
 486         }
 487
 488         public void CopyTo(NpgsqlPoint[] array, int arrayIndex)
 489         {
 490             _points.CopyTo(array, arrayIndex);
 491         }
 492
 493         public bool Remove(NpgsqlPoint item)
 494         {
 495             return _points.Remove(item);
 496         }
 497
 498         public IEnumerator<NpgsqlPoint> GetEnumerator()
 499         {
 500             return _points.GetEnumerator();
 501         }
 502
 503         IEnumerator IEnumerable.GetEnumerator()
 504         {
 505             return GetEnumerator();
 506         }
 507
 508         public bool Equals(NpgsqlPolygon other)
 509         {
 510             if (Count != other.Count)
 511             {
 512                 return false;
 513             }
 514             for (int i = 0; i != Count; ++i)
 515             {
 516                 if (this[i] != other[i])
 517                 {
 518                     return false;
 519                 }
 520             }
 521             return true;
 522         }
 523
 524         public override bool Equals(object obj)
 525         {
 526             return obj != null && obj is NpgsqlPolygon && Equals((NpgsqlPolygon) obj);
 527         }
 528
 529         public static bool operator ==(NpgsqlPolygon x, NpgsqlPolygon y)
 530         {
 531             return x.Equals(y);
 532         }
 533
 534         public static bool operator !=(NpgsqlPolygon x, NpgsqlPolygon y)
 535         {
 536             return !(x == y);
 537         }
 538
 539         public override int GetHashCode()
 540         {
 541             int ret = 0;
 542             foreach (NpgsqlPoint point in this)
 543             {
 544                 //The ideal amount to shift each value is one that would evenly spread it throughout
 545                 //the resultant bytes. Using the current result % 32 is essentially using a random value
 546                 //but one that will be the same on subsequent calls.
 547                 ret ^= PGUtil.RotateShift(point.GetHashCode(), ret%sizeof (int));
 548             }
 549             return ret;
 550         }
 551     }
 552
 553     /// <summary>
 554     /// Represents a PostgreSQL Circle type.
 555     /// </summary>
 556     public struct NpgsqlCircle : IEquatable<NpgsqlCircle>
 557     {
 558         public NpgsqlPoint Center;
 559         public Double Radius;
 560
 561         public NpgsqlCircle(NpgsqlPoint center, Double radius)
 562         {
 563             Center = center;
 564             Radius = radius;
 565         }
 566
 567         public bool Equals(NpgsqlCircle other)
 568         {
 569             return Center == other.Center && Radius == other.Radius;
 570         }
 571
 572         public override bool Equals(object obj)
 573         {
 574             return obj != null && obj is NpgsqlCircle && Equals((NpgsqlCircle) obj);
 575         }
 576
 577         public override String ToString()
 578         {
 579             return string.Format("({0}), {1}", Center, Radius);
 580         }
 581
 582         public static bool operator ==(NpgsqlCircle x, NpgsqlCircle y)
 583         {
 584             return x.Equals(y);
 585         }
 586
 587         public static bool operator !=(NpgsqlCircle x, NpgsqlCircle y)
 588         {
 589             return !(x == y);
 590         }
 591
 592         public override int GetHashCode()
 593         {
 594             return
 595                 Center.X.GetHashCode() ^ PGUtil.RotateShift(Center.Y.GetHashCode(), sizeof (int)/4) ^
 596                 PGUtil.RotateShift(Radius.GetHashCode(), sizeof (int)/2);
 597         }
 598     }
 599
 600
 601     /// <summary>
 602     /// Represents a PostgreSQL inet type.
 603     /// </summary>
 604     public struct NpgsqlInet : IEquatable<NpgsqlInet>
 605     {
 606         public IPAddress addr;
 607         public int mask;
 608
 609         public NpgsqlInet(IPAddress addr, int mask)
 610         {
 611             this.addr = addr;
 612             this.mask = mask;
 613         }
 614
 615         public NpgsqlInet(IPAddress addr)
 616         {
 617             this.addr = addr;
 618             this.mask = 32;
 619         }
 620
 621         public NpgsqlInet(string addr)
 622         {
 623             if (addr.IndexOf('/') > 0)
 624             {
 625                 string[] addrbits = addr.Split('/');
 626                 if (addrbits.GetUpperBound(0) != 1)
 627                 {
 628                     throw new FormatException("Invalid number of parts in CIDR specification");
 629                 }
 630                 this.addr = IPAddress.Parse(addrbits[0]);
 631                 this.mask = int.Parse(addrbits[1]);
 632             }
 633             else
 634             {
 635                 this.addr = IPAddress.Parse(addr);
 636                 this.mask = 32;
 637             }
 638         }
 639
 640         public override String ToString()
 641         {
 642             if (mask != 32)
 643             {
 644                 return string.Format("{0}/{1}", addr, mask);
 645             }
 646                 return addr.ToString();
 647
 648         }
 649
 650         public static implicit operator IPAddress(NpgsqlInet x)
 651         {
 652             if (x.mask != 32)
 653             {
 654                 throw new InvalidCastException("Cannot cast CIDR network to address");
 655             }
 656                 return x.addr;
 657
 658         }
 659
 660         public bool Equals(NpgsqlInet other)
 661         {
 662             return addr.Equals(other.addr) && mask == other.mask;
 663         }
 664
 665         public override bool Equals(object obj)
 666         {
 667             return obj != null && obj is NpgsqlInet && Equals((NpgsqlInet) obj);
 668         }
 669
 670         public override int GetHashCode()
 671         {
 672             return PGUtil.RotateShift(addr.GetHashCode(), mask%32);
 673         }
 674
 675         public static bool operator ==(NpgsqlInet x, NpgsqlInet y)
 676         {
 677             return x.Equals(y);
 678         }
 679
 680         public static bool operator !=(NpgsqlInet x, NpgsqlInet y)
 681         {
 682             return !(x == y);
 683         }
 684     }
 685 }