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