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
 270                         int range = properties.Count - 1;
 271                         if (range < 0)
 272                                 return false;
 273
 274                         Property prop;
 275                         // O(log n + |range|)-time algorithm for 1-d range query
 276                         while (range > 1) {
 277                                 // find middle index
 278                                 int mid = first + (range/2);
 279
 280                                 prop = properties [mid] as Property;
 281                                 // Properties are sorted first by Key, then by Value
 282                                 // We only need to compare the key of the middle element to the key in parameter
 283                                 if (String.Compare (key, prop.Key) > 0) {
 284                                         // minimum item in right subtree is smaller
 285                                         // move right
 286                                         first = mid;
 287                                         range -= (range/2);
 288                                 } else
 289                                         // move left
 290                                         range = (range/2);
 291                         }
 292
 293                         // first points to
 294                         // - either the previous item in the BST
 295                         // - or the next to the previous item in the BST
 296                         prop = (Property) properties [first];
 297                         if (prop.Key != key)
 298                                 first = first + 1;
 299                         if (first >= properties.Count)
 300                                 return false;
 301                         prop = (Property) properties [first];
 302                         if (prop.Key != key)
 303                                 return false;
 304
 305                         top = first + 1;
 306                         // Since range will be small, do a linear scan from here.
 307                         // We could do another BST traversal at the cost of O(log-n),
 308                         // but its not worth it.
 309                         while (top < properties.Count) {
 310                                 prop = properties [top] as Property;
 311                                 if (prop.Key != key)
 312                                         break;
 313                                 ++top;
 314                         }
 315
 316                         return true;
 317                 }
 318
 319                 public string this [string key] {
 320                         get {
 321                                 int first, top;
 322                                 if (! FindProperty (key, out first, out top))
 323                                         return null;
 324
 325                                 if (top - first != 1) {
 326                                         Logger.Log.Warn ("Accessed multi-property key with Hit's indexer.");
 327                                         return null;
 328                                 }
 329
 330                                 Property prop;
 331                                 prop = properties [first] as Property;
 332                                 return prop.Value;
 333                         }
 334
 335                         set {
 336                                 int first = 0, top = 0;
 337
 338                                 // If we've never heard of this property, add it.
 339                                 if (! FindProperty (key, out first, out top)) {
 340                                         AddProperty (Property.New (key, value));
 341                                         return;
 342                                 }
 343
 344                                 // If it has appeared once before, clobber the existing
 345                                 // value.  This emulates the previous (broken) semantics.
 346
 347                                 if (top - first == 1) {
 348                                         properties [first] = Property.New (key, value);
 349                                         return;
 350                                 }
 351
 352                                 // Otherwise throw an exception (which sort of sucks,
 353                                 // but we don't really know what to do there)
 354                                 throw new Exception (String.Format ("Attempt to re-set multi-property '{0}' via the indexer", key));
 355                         }
 356                 }
 357
 358                 public string GetFirstProperty (string key)
 359                 {
 360                         int first, top;
 361                         if (! FindProperty (key, out first, out top))
 362                                 return null;
 363                         Property prop;
 364                         prop = properties [first] as Property;
 365                         return prop.Value;
 366                 }
 367
 368                 public string[] GetProperties (string key)
 369                 {
 370                         int first, top;
 371                         if (! FindProperty (key, out first, out top))
 372                                 return null;
 373
 374                         string[] values = new string [top - first];
 375
 376                         for (int i = 0; first + i < top; i++) {
 377                                 Property prop = properties [first + i] as Property;
 378                                 values [i] = prop.Value;
 379                         }
 380
 381                         return values;
 382                 }
 383
 384                 //////////////////////////
 385
 386                 public override int GetHashCode ()
 387                 {
 388                         return (uri != null ? uri.ToString().GetHashCode () : 0)
 389                                 ^ (type != null ? type.GetHashCode () : 0)
 390                                 ^ (source != null ? source.GetHashCode () : 0);
 391                 }
 392
 393                 //////////////////////////
 394
 395                 public int CompareTo (object obj)
 396                 {
 397                         Hit otherHit = (Hit) obj;
 398                         // Notice that we sort by time from most to least recent
 399                         return DateTime.Compare (otherHit.Timestamp, this.Timestamp);
 400                 }
 401         }
 402 }