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                 private string source_object_name = null;
  61
  62                 // High scores imply greater relevance.
  63                 private double score = 0.0;
  64
  65                 private ArrayList properties = new ArrayList ();
  66                 private bool sorted = true;
  67
  68                 private enum SpecialType {
  69                         Unknown,
  70                         None,
  71                         Invalid,
  72                         File,
  73                         Directory
  74                 }
  75
  76                 SpecialType special = SpecialType.Unknown;
  77
  78                 private string path;
  79                 private FileInfo fileInfo = null;
  80                 private DirectoryInfo directoryInfo = null;
  81
  82                 //////////////////////////
  83
  84                 [XmlIgnore]
  85                 public Uri Uri {
  86                         get { return uri; }
  87                         set { uri = value; }
  88                 }
  89
  90                 [XmlAttribute ("Uri")]
  91                 public string UriAsString {
  92                         get {
  93                                 return UriFu.UriToSerializableString (uri);
  94                         }
  95
  96                         set {
  97                                 uri = UriFu.UriStringToUri (value);
  98                         }
  99                 }
 100
 101                 [XmlIgnore]
 102                 public Uri ParentUri {
 103                         get { return parent_uri; }
 104                         set { parent_uri = value; }
 105                 }
 106
 107                 [XmlAttribute ("ParentUri")]
 108                 public string ParentUriAsString {
 109                         get {
 110                                 if (parent_uri == null)
 111                                         return null;
 112
 113                                 return UriFu.UriToSerializableString (parent_uri);
 114                         }
 115
 116                         set {
 117                                 if (value == null)
 118                                         parent_uri = null;
 119                                 else
 120                                         parent_uri = UriFu.UriStringToUri (value);
 121                         }
 122                 }
 123
 124                 // DEPRECATED: This is now stored as a property.
 125                 [XmlAttribute]
 126                 public string Type {
 127                         get { return type; }
 128                         set { type = value; }
 129                 }
 130
 131                 // DEPRECATED: This is now stored as a property.
 132                 [XmlAttribute]
 133                 public string MimeType {
 134                         get { return mimeType; }
 135                         set { mimeType = value; }
 136                 }
 137
 138                 [XmlAttribute]
 139                 public string Source {
 140                         get { return source; }
 141                         set { source = value; }
 142                 }
 143
 144                 [XmlIgnore]
 145                 public object SourceObject {
 146                         get { return sourceObject; }
 147                         set { sourceObject = value; }
 148                 }
 149
 150                 [XmlAttribute]
 151                 public string SourceObjectName {
 152                         get { return source_object_name; }
 153                         set { source_object_name = value; }
 154                 }
 155
 156                 [XmlAttribute]
 157                 public double Score {
 158                         get { return score; }
 159                         set { score = value; }
 160                 }
 161
 162                 //////////////////////////
 163
 164                 private void SpecialHandling ()
 165                 {
 166                         if (special != SpecialType.Unknown)
 167                                 return;
 168
 169                         if (uri.IsFile) {
 170                                 path = uri.LocalPath;
 171                                 if (File.Exists (path))
 172                                         special = SpecialType.File;
 173                                 else if (Directory.Exists (path))
 174                                         special = SpecialType.Directory;
 175                                 else
 176                                         special = SpecialType.Invalid;
 177                         }
 178
 179                         if (special == SpecialType.Unknown)
 180                                 special = SpecialType.None;
 181                 }
 182
 183                 public bool IsValid {
 184                         get { SpecialHandling (); return special != SpecialType.Invalid; }
 185                 }
 186
 187                 public bool IsFile {
 188                         get { SpecialHandling (); return special == SpecialType.File; }
 189                 }
 190
 191                 public bool IsDirectory {
 192                         get { SpecialHandling (); return special == SpecialType.Directory; }
 193                 }
 194
 195                 public bool IsFileSystem {
 196                         get { return IsFile || IsDirectory; }
 197                 }
 198
 199                 public string Path {
 200                         get { SpecialHandling (); return path; }
 201                 }
 202
 203                 public string PathQuoted {
 204                         get { return Path.Replace (" ", "\\ "); }
 205                 }
 206
 207                 public string FileName {
 208                         get { return Path != null ? System.IO.Path.GetFileName (Path) : null; }
 209                 }
 210
 211                 public string DirectoryName {
 212                         get { return Path != null ? System.IO.Path.GetDirectoryName (Path) : null; }
 213                 }
 214
 215                 [XmlIgnore]
 216                 public FileSystemInfo FileSystemInfo {
 217                         get {
 218                                 if (IsFile)
 219                                         return (FileSystemInfo) FileInfo;
 220                                 else if (IsDirectory)
 221                                         return (FileSystemInfo) DirectoryInfo;
 222                                 else
 223                                         return null;
 224                         }
 225                 }
 226
 227                 [XmlIgnore]
 228                 public FileInfo FileInfo {
 229                         get {
 230                                 if (fileInfo == null && IsFile)
 231                                         fileInfo = new FileInfo (Path);
 232                                 return fileInfo;
 233                         }
 234                 }
 235
 236                 [XmlIgnore]
 237                 public DirectoryInfo DirectoryInfo {
 238                         get {
 239                                 if (directoryInfo == null && IsDirectory)
 240                                         directoryInfo = new DirectoryInfo (Path);
 241                                 return directoryInfo;
 242                         }
 243                 }
 244
 245                 //////////////////////////
 246
 247                 [XmlArray]
 248                 [XmlArrayItem (ElementName="Property", Type=typeof (Property))]
 249                 public ArrayList Properties {
 250                         get {  return properties; }
 251                 }
 252
 253                 public void AddProperty (Property prop)
 254                 {
 255                         if (sorted && properties.Count > 0) {
 256                                 Property last_prop;
 257                                 last_prop = properties [properties.Count - 1] as Property;
 258                                 if (last_prop.CompareTo (prop) > 0) // i.e. last_prop > prop
 259                                         sorted = false;
 260                         }
 261
 262                         properties.Add (prop);
 263                 }
 264
 265                 private bool FindProperty (string key, out int first, out int top)
 266                 {
 267                         // FIXME: Should use binary search on sorted property list
 268                         if (! sorted) {
 269                                 properties.Sort ();
 270                                 sorted = true;
 271                         }
 272
 273                         first = 0;
 274                         top = 0;
 275
 276                         while  (first < properties.Count) {
 277                                 Property prop;
 278                                 prop = properties [first] as Property;
 279                                 if (prop.Key == key)
 280                                         break;
 281                                 ++first;
 282                         }
 283
 284                         if (first >= properties.Count)
 285                                 return false;
 286
 287                         top = first + 1;
 288                         while (top < properties.Count) {
 289                                 Property prop;
 290                                 prop = properties [top] as Property;
 291                                 if (prop.Key != key)
 292                                         break;
 293                                 ++top;
 294                         }
 295
 296                         return true;
 297                 }
 298
 299                 public string this [string key] {
 300                         get {
 301                                 int first, top;
 302                                 if (! FindProperty (key, out first, out top))
 303                                         return null;
 304
 305                                 if (top - first != 1) {
 306                                         Logger.Log.Debug ("Accessed multi-property key with Hit's indexer.");
 307                                         return null;
 308                                 }
 309
 310                                 Property prop;
 311                                 prop = properties [first] as Property;
 312                                 return prop.Value;
 313                         }
 314
 315                         set {
 316                                 int first = 0, top = 0;
 317
 318                                 // If we've never heard of this property, add it.
 319                                 if (! FindProperty (key, out first, out top)) {
 320                                         AddProperty (Property.New (key, value));
 321                                         return;
 322                                 }
 323
 324                                 // If it has appeared once before, clobber the existing
 325                                 // value.  This emulates the previous (broken) semantics.
 326
 327                                 if (top - first == 1) {
 328                                         properties [first] = Property.New (key, value);
 329                                         return;
 330                                 }
 331
 332                                 // Otherwise throw an exception (which sort of sucks,
 333                                 // but we don't really know what to do there)
 334                                 throw new Exception (String.Format ("Attempt to re-set multi-property '{0}' via the indexer", key));
 335                         }
 336                 }
 337
 338                 public string GetFirstProperty (string key)
 339                 {
 340                         int first, top;
 341                         if (! FindProperty (key, out first, out top))
 342                                 return null;
 343                         Property prop;
 344                         prop = properties [first] as Property;
 345                         return prop.Value;
 346                 }
 347
 348                 public string[] GetProperties (string key)
 349                 {
 350                         int first, top;
 351                         if (! FindProperty (key, out first, out top))
 352                                 return null;
 353
 354                         string[] values = new string [top - first];
 355
 356                         for (int i = 0; first + i < top; i++) {
 357                                 Property prop = properties [first + i] as Property;
 358                                 values [i] = prop.Value;
 359                         }
 360
 361                         return values;
 362                 }
 363
 364                 //////////////////////////
 365
 366                 public override int GetHashCode ()
 367                 {
 368                         return (uri != null ? uri.ToString().GetHashCode () : 0)
 369                                 ^ (type != null ? type.GetHashCode () : 0)
 370                                 ^ (source != null ? source.GetHashCode () : 0);
 371                 }
 372
 373                 //////////////////////////
 374
 375                 public int CompareTo (object obj)
 376                 {
 377                         Hit otherHit = (Hit) obj;
 378                         // Notice that we sort by time from most to least recent
 379                         return DateTime.Compare (otherHit.Timestamp, this.Timestamp);
 380                 }
 381         }
 382 }