mcs/class/referencesource/System.Data/System/Data/DataKey.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="DataKey.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 // <owner current="true" primary="false">Microsoft</owner>
   7 // <owner current="false" primary="false">Microsoft</owner>
   8 //------------------------------------------------------------------------------
   9
  10 namespace System.Data {
  11     using System;
  12     using System.Diagnostics;
  13     using System.ComponentModel;
  14
  15     internal struct DataKey {
  16         private const int maxColumns = 32;
  17
  18         private readonly DataColumn[] columns;
  19
  20         /// <devdoc>
  21         ///    <para>[To be supplied.]</para>
  22         /// </devdoc>
  23         internal DataKey(DataColumn[] columns, bool copyColumns) {
  24             if (columns == null)
  25                 throw ExceptionBuilder.ArgumentNull("columns");
  26
  27             if (columns.Length == 0)
  28                 throw ExceptionBuilder.KeyNoColumns();
  29
  30             if (columns.Length > maxColumns)
  31                 throw ExceptionBuilder.KeyTooManyColumns(maxColumns);
  32
  33             for (int i = 0; i < columns.Length; i++) {
  34                 if (columns[i] == null)
  35                     throw ExceptionBuilder.ArgumentNull("column");
  36             }
  37
  38             for (int i = 0; i < columns.Length; i++) {
  39                 for (int j = 0; j < i; j++) {
  40                     if (columns[i] == columns[j]) {
  41                         throw ExceptionBuilder.KeyDuplicateColumns(columns[i].ColumnName);
  42                     }
  43                 }
  44             }
  45
  46             if (copyColumns) {
  47                 // Need to make a copy of all columns
  48                 this.columns = new DataColumn [columns.Length];
  49                 for (int i = 0; i < columns.Length; i++)
  50                     this.columns[i] = columns[i];
  51             }
  52             else {
  53                 // take ownership of the array passed in
  54                 this.columns = columns;
  55             }
  56             CheckState();
  57         }
  58
  59         internal DataColumn[] ColumnsReference {
  60             get {
  61                 return columns;
  62             }
  63         }
  64
  65         internal bool HasValue {
  66             get {
  67                 return (null != columns);
  68             }
  69         }
  70
  71         internal DataTable Table {
  72             get {
  73                 return columns[0].Table;
  74             }
  75         }
  76
  77         internal void CheckState() {
  78             DataTable table = columns[0].Table;
  79
  80             if (table == null) {
  81                 throw ExceptionBuilder.ColumnNotInAnyTable();
  82             }
  83
  84             for (int i = 1; i < columns.Length; i++) {
  85                 if (columns[i].Table == null) {
  86                     throw ExceptionBuilder.ColumnNotInAnyTable();
  87                 }
  88                 if (columns[i].Table != table) {
  89                     throw ExceptionBuilder.KeyTableMismatch();
  90                 }
  91             }
  92         }
  93
  94         //check to see if this.columns && key2's columns are equal regardless of order
  95         internal bool ColumnsEqual(DataKey key) {
  96             return ColumnsEqual(this.columns, ((DataKey)key).columns);
  97         }
  98
  99         //check to see if columns1 && columns2 are equal regardless of order
 100         internal static bool ColumnsEqual(DataColumn[] column1, DataColumn[] column2) {
 101
 102             if (column1 == column2) {
 103                 return true;
 104             } else if (column1 == null || column2 == null) {
 105                 return false;
 106             } else if (column1.Length != column2.Length) {
 107                 return false;
 108             } else {
 109                 int i, j;
 110                 for (i=0; i<column1.Length; i++) {
 111                     bool check = false;
 112                     for (j=0; j<column2.Length; j++) {
 113                         if (column1[i].Equals(column2[j])) {
 114                             check = true;
 115                             break;
 116                         }
 117                     }
 118                     if (!check) {
 119                         return false;
 120                     }
 121                 }
 122             }
 123             return true;
 124         }
 125
 126         internal bool ContainsColumn(DataColumn column) {
 127             for (int i = 0; i < columns.Length; i++) {
 128                 if (column == columns[i]) {
 129                     return true;
 130                 }
 131             }
 132             return false;
 133         }
 134
 135         public override int GetHashCode() {
 136             Debug.Assert(false, "don't put DataKey into a Hashtable");
 137             return base.GetHashCode();
 138         }
 139
 140         public static bool operator==(DataKey x, DataKey y) {
 141             return x.Equals((object)y);
 142         }
 143
 144         public static bool operator!=(DataKey x, DataKey y) {
 145             return !x.Equals((object)y);
 146         }
 147
 148         public override bool Equals(object value) {
 149             Debug.Assert(false, "need to directly call Equals(DataKey)");
 150             return Equals((DataKey)value);
 151         }
 152
 153         internal bool Equals(DataKey value) {
 154             //check to see if this.columns && key2's columns are equal...
 155             DataColumn[] column1=this.columns;
 156             DataColumn[] column2=value.columns;
 157
 158             if (column1 == column2) {
 159                 return true;
 160             }
 161             else if (column1 == null || column2 == null) {
 162                 return false;
 163             }
 164             else if (column1.Length != column2.Length) {
 165                 return false;
 166             }
 167             else {
 168                 for (int i = 0; i <column1.Length; i++) {
 169                     if (!column1[i].Equals(column2[i])) {
 170                         return false;
 171                     }
 172                 }
 173                 return true;
 174             }
 175         }
 176
 177         internal string[] GetColumnNames() {
 178             string[] values = new string[columns.Length];
 179             for(int i = 0; i < columns.Length; ++i) {
 180                 values[i] = columns[i].ColumnName;
 181             }
 182             return values;
 183         }
 184
 185         internal IndexField[] GetIndexDesc() {
 186             IndexField[] indexDesc = new IndexField[columns.Length];
 187             for (int i = 0; i < columns.Length; i++) {
 188                 indexDesc[i] = new IndexField(columns[i], false);
 189             }
 190             return indexDesc;
 191         }
 192
 193         internal object[] GetKeyValues(int record) {
 194             object[] values = new object[columns.Length];
 195             for (int i = 0; i < columns.Length; i++) {
 196                 values[i] = columns[i][record];
 197             }
 198             return values;
 199         }
 200
 201         internal Index GetSortIndex() {
 202             return GetSortIndex(DataViewRowState.CurrentRows);
 203         }
 204
 205         internal Index GetSortIndex(DataViewRowState recordStates) {
 206             IndexField[] indexDesc = GetIndexDesc();
 207             return columns[0].Table.GetIndex(indexDesc, recordStates, (IFilter)null);
 208         }
 209
 210         internal bool RecordsEqual(int record1, int record2) {
 211             for (int i = 0; i < columns.Length; i++) {
 212                 if (columns[i].Compare(record1, record2) != 0) {
 213                     return false;
 214                 }
 215             }
 216             return true;
 217         }
 218
 219         internal DataColumn[] ToArray() {
 220             DataColumn[] values = new DataColumn[columns.Length];
 221             for(int i = 0; i < columns.Length; ++i) {
 222                 values[i] = columns[i];
 223             }
 224             return values;
 225         }
 226     }
 227 }