BeagleClient/Hit.cs

   1 //
   2 // Hit.cs
   3 //
   4 // Copyright (C) 2004 Novell, Inc.
   5 //
   6
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a
   9 // copy of this software and associated documentation files (the "Software"),
  10 // to deal in the Software without restriction, including without limitation
  11 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12 // and/or sell copies of the Software, and to permit persons to whom the
  13 // Software is furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24 // DEALINGS IN THE SOFTWARE.
  25 //
  26
  27
  28 using System;
  29 using System.Collections;
  30 using System.Diagnostics;
  31 using System.IO;
  32 using System.Xml;
  33 using System.Xml.Serialization;
  34
  35 using Beagle.Util;
  36
  37 namespace Beagle {
  38
  39         public class Hit: Versioned, IComparable {
  40
  41                 // A URI we can use to locate the source of this match.
  42                 private Uri uri = null;
  43
  44                 // A URI of this Hit's container element
  45                 private Uri parent_uri = null;
  46
  47                 // File, Web, MailMessage, IMLog, etc.
  48                 private string type = null;
  49
  50                 // If applicable, otherwise set to null.
  51                 private string mimeType = null;
  52
  53                 // IndexUser, IndexSystem, Google, Addressbook, iFolder, etc.
  54                 private string source = null;
  55
  56                 // This is used to hold a copy of the Queryable in the
  57                 // server-side copy of the Hit.  It is always null
  58                 // on the client-side.
  59                 private object sourceObject = null;
  60
  61                 // High scores imply greater relevance.
  62                 private double score = 0.0;
  63
  64                 private ArrayList properties = new ArrayList ();
  65
  66                 private enum SpecialType {
  67                         Unknown,
  68                         None,
  69                         Invalid,
  70                         File,
  71                         Directory
  72                 }
  73
  74                 SpecialType special = SpecialType.Unknown;
  75
  76                 private string path;
  77                 private FileInfo fileInfo = null;
  78                 private DirectoryInfo directoryInfo = null;
  79
  80                 //////////////////////////
  81
  82                 [XmlIgnore]
  83                 public Uri Uri {
  84                         get { return uri; }
  85                         set { uri = value; }
  86                 }
  87
  88                 [XmlAttribute ("Uri")]
  89                 public string EscapedUri {
  90                         get {
  91                                 return UriFu.UriToEscapedString (uri);
  92                         }
  93
  94                         set {
  95                                 uri = UriFu.EscapedStringToUri (value);
  96                         }
  97                 }
  98
  99                 [XmlIgnore]
 100                 public Uri ParentUri {
 101                         get { return parent_uri; }
 102                         set { parent_uri = value; }
 103                 }
 104
 105                 [XmlAttribute ("ParentUri")]
 106                 public string EscapedParentUri {
 107                         get {
 108                                 if (parent_uri == null)
 109                                         return null;
 110
 111                                 return UriFu.UriToEscapedString (parent_uri);
 112                         }
 113
 114                         set {
 115                                 if (value == null)
 116                                         parent_uri = null;
 117                                 else
 118                                         parent_uri = UriFu.EscapedStringToUri (value);
 119                         }
 120                 }
 121
 122                 // DEPRECATED: This is now stored as a property.
 123                 [XmlAttribute]
 124                 public string Type {
 125                         get { return type; }
 126                         set { type = value; }
 127                 }
 128
 129                 // DEPRECATED: This is now stored as a property.
 130                 [XmlAttribute]
 131                 public string MimeType {
 132                         get { return mimeType; }
 133                         set { mimeType = value; }
 134                 }
 135
 136                 [XmlAttribute]
 137                 public string Source {
 138                         get { return source; }
 139                         set { source = value; }
 140                 }
 141
 142                 [XmlIgnore]
 143                 public object SourceObject {
 144                         get { return sourceObject; }
 145                         set { sourceObject = value; }
 146                 }
 147
 148                 [XmlAttribute]
 149                 public double Score {
 150                         get { return score; }
 151                         set { score = value; }
 152                 }
 153
 154                 //////////////////////////
 155
 156                 private void SpecialHandling ()
 157                 {
 158                         if (special != SpecialType.Unknown)
 159                                 return;
 160
 161                         if (uri.IsFile) {
 162                                 path = uri.LocalPath;
 163                                 if (File.Exists (path))
 164                                         special = SpecialType.File;
 165                                 else if (Directory.Exists (path))
 166                                         special = SpecialType.Directory;
 167                                 else
 168                                         special = SpecialType.Invalid;
 169                         }
 170
 171                         if (special == SpecialType.Unknown)
 172                                 special = SpecialType.None;
 173                 }
 174
 175                 public bool IsValid {
 176                         get { SpecialHandling (); return special != SpecialType.Invalid; }
 177                 }
 178
 179                 public bool IsFile {
 180                         get { SpecialHandling (); return special == SpecialType.File; }
 181                 }
 182
 183                 public bool IsDirectory {
 184                         get { SpecialHandling (); return special == SpecialType.Directory; }
 185                 }
 186
 187                 public bool IsFileSystem {
 188                         get { return IsFile || IsDirectory; }
 189                 }
 190
 191                 public string Path {
 192                         get { SpecialHandling (); return path; }
 193                 }
 194
 195                 public string PathQuoted {
 196                         get { return Path.Replace (" ", "\\ "); }
 197                 }
 198
 199                 public string FileName {
 200                         get { return Path != null ? System.IO.Path.GetFileName (Path) : null; }
 201                 }
 202
 203                 public string DirectoryName {
 204                         get { return Path != null ? System.IO.Path.GetDirectoryName (Path) : null; }
 205                 }
 206
 207                 [XmlIgnore]
 208                 public FileSystemInfo FileSystemInfo {
 209                         get {
 210                                 if (IsFile)
 211                                         return (FileSystemInfo) FileInfo;
 212                                 else if (IsDirectory)
 213                                         return (FileSystemInfo) DirectoryInfo;
 214                                 else
 215                                         return null;
 216                         }
 217                 }
 218
 219                 [XmlIgnore]
 220                 public FileInfo FileInfo {
 221                         get {
 222                                 if (fileInfo == null && IsFile)
 223                                         fileInfo = new FileInfo (Path);
 224                                 return fileInfo;
 225                         }
 226                 }
 227
 228                 [XmlIgnore]
 229                 public DirectoryInfo DirectoryInfo {
 230                         get {
 231                                 if (directoryInfo == null && IsDirectory)
 232                                         directoryInfo = new DirectoryInfo (Path);
 233                                 return directoryInfo;
 234                         }
 235                 }
 236
 237                 //////////////////////////
 238
 239                 [XmlArray]
 240                 [XmlArrayItem (ElementName="Property", Type=typeof (Property))]
 241                 public ArrayList Properties {
 242                         get {  return properties; }
 243                 }
 244
 245                 public void AddProperty (Property prop)
 246                 {
 247                         int loc = properties.BinarySearch (prop);
 248
 249                         // If the value is not in the array we get its position
 250                         // by taking bitwise complement.
 251                         if (loc < 0)
 252                                 loc = ~loc;
 253
 254                         properties.Insert (loc, prop);
 255                 }
 256
 257                 public void AddProperty (ICollection props)
 258                 {
 259                         properties.AddRange (props);
 260                         properties.Sort ();
 261                 }
 262
 263
 264                 private bool FindProperty (string key, out int first, out int top)
 265                 {
 266
 267                         first = 0;
 268                         top = 0;
 269                         int range = properties.Count - 1;
 270                         Property prop;
 271
 272                         // O(log n + |range|)-time algorithm for 1-d range query
 273                         while (range > 1) {
 274                                 // find middle index
 275                                 int mid = first + (range/2);
 276
 277                                 prop = properties [mid] as Property;
 278                                 // Properties are sorted first by Key, then by Value
 279                                 // We only need to compare the key of the middle element to the key in parameter
 280                                 if (String.Compare (key, prop.Key) > 0) {
 281                                         // minimum item in right subtree is smaller
 282                                         // move right
 283                                         first = mid;
 284                                         range -= (range/2);
 285                                 } else
 286                                         // move left
 287                                         range = (range/2);
 288                         }
 289
 290                         // first points to
 291                         // - either the previous item in the BST
 292                         // - or the next to the previous item in the BST
 293                         prop = (Property) properties [first];
 294                         if (prop.Key != key)
 295                                 first = first + 1;
 296                         if (first >= properties.Count)
 297                                 return false;
 298                         prop = (Property) properties [first];
 299                         if (prop.Key != key)
 300                                 return false;
 301
 302                         top = first + 1;
 303                         // Since range will be small, do a linear scan from here.
 304                         // We could do another BST traversal at the cost of O(log-n),
 305                         // but its not worth it.
 306                         while (top < properties.Count) {
 307                                 prop = properties [top] as Property;
 308                                 if (prop.Key != key)
 309                                         break;
 310                                 ++top;
 311                         }
 312
 313                         return true;
 314                 }
 315
 316                 public string this [string key] {
 317                         get {
 318                                 int first, top;
 319                                 if (! FindProperty (key, out first, out top))
 320                                         return null;
 321
 322                                 if (top - first != 1) {
 323                                         Logger.Log.Warn ("Accessed multi-property key with Hit's indexer.");
 324                                         return null;
 325                                 }
 326
 327                                 Property prop;
 328                                 prop = properties [first] as Property;
 329                                 return prop.Value;
 330                         }
 331
 332                         set {
 333                                 int first = 0, top = 0;
 334
 335                                 // If we've never heard of this property, add it.
 336                                 if (! FindProperty (key, out first, out top)) {
 337                                         AddProperty (Property.New (key, value));
 338                                         return;
 339                                 }
 340
 341                                 // If it has appeared once before, clobber the existing
 342                                 // value.  This emulates the previous (broken) semantics.
 343
 344                                 if (top - first == 1) {
 345                                         properties [first] = Property.New (key, value);
 346                                         return;
 347                                 }
 348
 349                                 // Otherwise throw an exception (which sort of sucks,
 350                                 // but we don't really know what to do there)
 351                                 throw new Exception (String.Format ("Attempt to re-set multi-property '{0}' via the indexer", key));
 352                         }
 353                 }
 354
 355                 public string GetFirstProperty (string key)
 356                 {
 357                         int first, top;
 358                         if (! FindProperty (key, out first, out top))
 359                                 return null;
 360                         Property prop;
 361                         prop = properties [first] as Property;
 362                         return prop.Value;
 363                 }
 364
 365                 public string[] GetProperties (string key)
 366                 {
 367                         int first, top;
 368                         if (! FindProperty (key, out first, out top))
 369                                 return null;
 370
 371                         string[] values = new string [top - first];
 372
 373                         for (int i = 0; first + i < top; i++) {
 374                                 Property prop = properties [first + i] as Property;
 375                                 values [i] = prop.Value;
 376                         }
 377
 378                         return values;
 379                 }
 380
 381                 //////////////////////////
 382
 383                 public override int GetHashCode ()
 384                 {
 385                         return (uri != null ? uri.ToString().GetHashCode () : 0)
 386                                 ^ (type != null ? type.GetHashCode () : 0)
 387                                 ^ (source != null ? source.GetHashCode () : 0);
 388                 }
 389
 390                 //////////////////////////
 391
 392                 public int CompareTo (object obj)
 393                 {
 394                         Hit otherHit = (Hit) obj;
 395                         // Notice that we sort by time from most to least recent
 396                         return DateTime.Compare (otherHit.Timestamp, this.Timestamp);
 397                 }
 398         }
 399 }