bludgeon/FileModel.cs

   1
   2 using System;
   3 using System.Collections;
   4 using System.IO;
   5
   6 using Beagle.Util;
   7 using Beagle;
   8
   9 namespace Bludgeon {
  10
  11         public class FileModel {
  12
  13                 static Random random = new Random ();
  14                 static private ArrayList roots = new ArrayList ();
  15
  16                 static public ICollection Roots { get { return roots; } }
  17
  18                 static public void AddRoot (FileModel root)
  19                 {
  20                         if (! root.IsRoot)
  21                                 throw new Exception ("Attempted to add non-root as root");
  22
  23                         roots.Add (root);
  24                 }
  25
  26                 static public FileModel PickRoot ()
  27                 {
  28                         if (roots.Count == 0)
  29                                 return null;
  30                         else if (roots.Count == 1)
  31                                 return roots [0] as FileModel;
  32
  33                         return roots [random.Next (roots.Count)] as FileModel;
  34                 }
  35
  36                 //
  37                 // Note that the probability of a FileModel being picked
  38                 // by any of these "picker" methods is not uniform.
  39                 // The two-step process where we first pick a root messes
  40                 // that up.
  41                 //
  42
  43
  44                 // Can be either a file or directory
  45                 static public FileModel PickNonRoot ()
  46                 {
  47                         FileModel root;
  48                         root = PickRoot ();
  49                         return root.PickDescendant ();
  50                 }
  51
  52                 static public FileModel PickFile ()
  53                 {
  54                         FileModel root;
  55                         root = PickRoot ();
  56                         return root.PickFileDescendant ();
  57                 }
  58
  59                 static public FileModel PickAnyDirectory ()
  60                 {
  61                         FileModel root;
  62                         root = PickRoot ();
  63                         return root.PickDirectory ();
  64                 }
  65
  66                 static public FileModel PickNonRootDirectory ()
  67                 {
  68                         FileModel root;
  69                         root = PickRoot ();
  70                         return root.PickDirectoryDescendant ();
  71                 }
  72
  73                 //////////////////////////////////////////////////////////////
  74
  75                 // Properties of the root directory:
  76                 // name contains full path of BEAGLE_HOME
  77                 // parent is null
  78                 // body is null
  79                 // children is non-null
  80
  81                 // Properties of a non-root directory:
  82                 // name is a token
  83                 // parent is non-null
  84                 // body is null
  85                 // children is non-null
  86
  87                 // Properties of a file:
  88                 // name is a token
  89                 // parent is non-null, and is a directory
  90                 // body is non-null
  91                 // children is null
  92
  93                 private string name = null;
  94                 private DateTime mtime;
  95                 private FileModel parent = null;
  96                 private string [] body = null;
  97                 private Hashtable children = null;
  98
  99                 //////////////////////////////////////////////////////////////
 100
 101                 public bool IsRoot {
 102                         get { return parent == null; }
 103                 }
 104
 105                 public bool IsDirectory {
 106                         get { return body == null; }
 107                 }
 108
 109                 public bool IsFile {
 110                         get { return body != null; }
 111                 }
 112
 113                 public string Type {
 114                         get { return IsDirectory ? "directory" : "file"; }
 115                 }
 116
 117                 public string Name {
 118                         get { return name; }
 119                 }
 120
 121                 public DateTime Mtime {
 122                         get { return mtime; }
 123                 }
 124
 125                 public string FullName {
 126                         get { return IsRoot ? Name : Path.Combine (parent.FullName, name); }
 127                 }
 128
 129                 public string ShortName {
 130                         get { return  IsRoot ? Path.GetFileName (Name) : Path.Combine (parent.ShortName, name); }
 131                 }
 132
 133                 public Uri Uri {
 134                         get { return UriFu.PathToFileUri (FullName); }
 135                 }
 136
 137                 public string [] Body {
 138                         get { return body; }
 139                 }
 140
 141                 public FileModel Parent {
 142                         get { return parent; }
 143                 }
 144
 145                 public ICollection Children {
 146                         get { return children.Values; }
 147                 }
 148
 149                 public int Size {
 150                         get {
 151                                 if (IsFile)
 152                                         return 1;
 153                                 int sum = 0;
 154                                 if (IsDirectory)
 155                                         sum = 1; // count ourselves
 156                                 foreach (FileModel child in children.Values)
 157                                         sum += child.Size;
 158                                 return sum;
 159                         }
 160                 }
 161
 162                 // IsAbove is easier to think about than IsAncestorOf
 163                 public bool IsAbove (FileModel other)
 164                 {
 165                         return this == other.parent
 166                                 || (other.parent != null && IsAbove (other.parent));
 167                 }
 168
 169                 // IsBelow is easier to thik about than IsDescendantOf
 170                 public bool IsBelow (FileModel other)
 171                 {
 172                         return other.IsAbove (this);
 173                 }
 174
 175                 //////////////////////////////////////////////////////////////
 176
 177                 private void RecursiveListAdd (ArrayList list,
 178                                                bool add_self,
 179                                                bool add_dirs,
 180                                                bool add_files)
 181                 {
 182                         if (add_self && ((add_dirs && IsDirectory) || (add_files && IsFile)))
 183                                 list.Add (this);
 184
 185                         if (children != null)
 186                                 foreach (FileModel file in children.Values)
 187                                         file.RecursiveListAdd (list, true, add_dirs, add_files);
 188                 }
 189
 190                 public ArrayList GetDescendants ()
 191                 {
 192                         ArrayList list = new ArrayList ();
 193                         RecursiveListAdd (list, false, true, true);
 194                         return list;
 195                 }
 196
 197                 public ArrayList GetFileDescendants ()
 198                 {
 199                         ArrayList list = new ArrayList ();
 200                         RecursiveListAdd (list, false, false, true);
 201                         return list;
 202                 }
 203
 204                 // Includes ourself
 205                 public ArrayList GetDirectories ()
 206                 {
 207                         ArrayList list = new ArrayList ();
 208                         RecursiveListAdd (list, true, true, false);
 209                         return list;
 210                 }
 211
 212                 // Never includes ourself
 213                 public ArrayList GetDirectoryDescendants ()
 214                 {
 215                         ArrayList list = new ArrayList ();
 216                         RecursiveListAdd (list, false, true, false);
 217                         return list;
 218                 }
 219
 220                 //////////////////////////////////////////////////////////////
 221
 222                 public FileModel PickDescendant ()
 223                 {
 224                         ArrayList all;
 225                         all = GetDescendants ();
 226                         if (all.Count == 0)
 227                                 return null;
 228                         return all [random.Next (all.Count)] as FileModel;
 229                 }
 230
 231                 public FileModel PickFileDescendant ()
 232                 {
 233                         ArrayList all;
 234                         all = GetFileDescendants ();
 235                         if (all.Count == 0)
 236                                 return null;
 237                         return all [random.Next (all.Count)] as FileModel;
 238                 }
 239
 240                 public FileModel PickDirectoryDescendant ()
 241                 {
 242                         ArrayList all;
 243                         all = GetDirectoryDescendants ();
 244                         if (all.Count == 0)
 245                                 return null;
 246                         return all [random.Next (all.Count)] as FileModel;
 247                 }
 248
 249                 // This can return the root
 250                 public FileModel PickDirectory ()
 251                 {
 252                         ArrayList all;
 253                         all = GetDirectories ();
 254                         return all [random.Next (all.Count)] as FileModel;
 255                 }
 256
 257                 //////////////////////////////////////////////////////////////
 258
 259                 public bool BodyContains (string token)
 260                 {
 261                         if (body == null)
 262                                 return false;
 263
 264                         // FIXME: Do a binary search (or something smarter)
 265                         // instead
 266                         for (int i = 0; i < body.Length; ++i)
 267                                 if (body [i] == token)
 268                                         return true;
 269                         return false;
 270                 }
 271
 272                 public bool Contains (string token)
 273                 {
 274                         return name == token || BodyContains (token);
 275                 }
 276
 277                 //////////////////////////////////////////////////////////////
 278
 279                 static DateTime base_time;
 280                 const int seconds_per_year = 60 * 60 * 24 * 365;
 281
 282                 // Picks a random time in the last year
 283                 static public DateTime PickDateTime ()
 284                 {
 285                         return base_time.AddSeconds (- random.Next (seconds_per_year));
 286                 }
 287
 288                 //////////////////////////////////////////////////////////////
 289
 290                 static FileModel ()
 291                 {
 292                         base_time = DateTime.Now;
 293                 }
 294
 295                 private FileModel ()
 296                 {
 297                         // Pick a random timestamp for every file.
 298                         mtime = PickDateTime ();
 299                 }
 300
 301                 public static FileModel NewRoot ()
 302                 {
 303                         FileModel root = new FileModel ();
 304                         root.name = PathFinder.HomeDir;
 305                         root.children = new Hashtable ();
 306                         root.mtime = Directory.GetLastWriteTimeUtc (root.FullName);
 307                         return root;
 308                 }
 309
 310                 // Creates a randomly-named new directory.
 311                 // Avoid name collisions with existing files.
 312                 public FileModel NewDirectory ()
 313                 {
 314                         if (! IsDirectory)
 315                                 throw new ArgumentException ("parent must be a directory");
 316
 317                         // no more names left
 318                         if (children.Count == Token.Count)
 319                                 return null;
 320
 321                         FileModel child;
 322                         child = new FileModel ();
 323                         child.name = PickName (this);
 324                         child.children = new Hashtable ();
 325
 326                         child.parent = this;
 327                         children [child.name] = child;
 328
 329                         // Actually create the directory
 330                         Directory.CreateDirectory (child.FullName);
 331                         child.mtime = Directory.GetLastWriteTimeUtc (child.FullName);
 332
 333                         return child;
 334                 }
 335
 336                 public FileModel NewFile ()
 337                 {
 338                         if (! IsDirectory)
 339                                 throw new ArgumentException ("parent must be a directory");
 340
 341                         // no more names left
 342                         if (children.Count == Token.Count)
 343                                 return null;
 344
 345                         FileModel child;
 346                         child = new FileModel ();
 347                         child.name = PickName (this);
 348                         child.body = NewBody (10);
 349
 350                         child.parent = this;
 351                         children [child.name] = child;
 352
 353                         // Create the file
 354                         child.Write ();
 355
 356                         return child;
 357                 }
 358
 359                 //////////////////////////////////////////////////////////////
 360
 361                 // Mutate the tree
 362
 363                 public void Grow (int depth)
 364                 {
 365                         const int num_dirs = 2;
 366                         const int num_files = 5;
 367
 368                         if (depth > 0) {
 369                                 for (int i = 0; i < num_dirs; ++i) {
 370                                         FileModel file;
 371                                         file = NewDirectory ();
 372                                         if (file != null)
 373                                                 file.Grow (depth - 1);
 374                                 }
 375                         }
 376
 377                         for (int i = 0; i < num_files; ++i)
 378                                 NewFile ();
 379                 }
 380
 381                 //////////////////////////////////////////////////////////////
 382
 383                 // Basic file system operations
 384
 385                 public void Touch ()
 386                 {
 387                         if (IsFile) {
 388                                 body = NewBody (10);
 389                                 Write ();
 390                         }
 391                 }
 392
 393                 public void Delete ()
 394                 {
 395                         if (IsRoot)
 396                                 throw new Exception ("Can't delete the root!");
 397
 398                         if (IsDirectory)
 399                                 Directory.Delete (FullName, true); // recursive
 400                         else
 401                                 File.Delete (FullName);
 402
 403                         parent.children.Remove (name);
 404                         parent = null;
 405                 }
 406
 407                 // If the move would cause a filename collision or is
 408                 // otherwise impossible, return false.  Return true if the
 409                 // move actually happens.
 410                 public bool MoveTo (FileModel new_parent, // or null, to just rename
 411                                     string    new_name)   // or null, to just move
 412                 {
 413                         if (! new_parent.IsDirectory)
 414                                 throw new ArgumentException ("Parent must be a directory");
 415
 416                         if (this.IsRoot)
 417                                 throw new ArgumentException ("Can't move a root");
 418
 419                         // Impossible
 420                         if (this == new_parent || this.IsAbove (new_parent))
 421                                 return false;
 422
 423                         string old_path;
 424                         old_path = this.FullName;
 425
 426                         if (new_parent == null)
 427                                 new_parent = this.parent;
 428                         if (new_name == null)
 429                                 new_name = this.name;
 430
 431                         // check for a filename collision
 432                         if (new_parent.children.Contains (new_name))
 433                                 return false;
 434
 435                         // modify the data structure
 436                         this.parent.children.Remove (this.name);
 437                         this.parent = new_parent;
 438                         this.name = new_name;
 439                         this.parent.children [this.name] = this;
 440
 441                         string new_path;
 442                         new_path = Path.Combine (new_parent.FullName, new_name);
 443
 444                         if (this.IsDirectory)
 445                                 Directory.Move (old_path, new_path);
 446                         else
 447                                 File.Move (old_path, new_path);
 448
 449                         return true;
 450                 }
 451
 452
 453                 //////////////////////////////////////////////////////////////
 454
 455                 // Useful utility functions
 456
 457                 static private string PickName (FileModel p)
 458                 {
 459                         string pick;
 460                         do {
 461                                 pick = Token.GetRandom ();
 462                         } while (p.children.Contains (pick));
 463                         return pick;
 464                 }
 465
 466                 static private string [] NewBody (int size)
 467                 {
 468                         string [] body;
 469                         body = new string [size];
 470                         for (int i = 0; i < size; ++i)
 471                                 body [i] = Token.GetRandom ();
 472                         Array.Sort (body);
 473                         return body;
 474                 }
 475
 476                 private void Write ()
 477                 {
 478                         TextWriter writer;
 479                         writer = new StreamWriter (FullName);
 480                         for (int i = 0; i < body.Length; ++i)
 481                                 writer.WriteLine (body [i]);
 482                         writer.Close ();
 483
 484                         FileInfo info;
 485                         info = new FileInfo (FullName);
 486                         info.LastWriteTime = Mtime;
 487                 }
 488
 489                 //////////////////////////////////////////////////////////////
 490
 491                 //
 492                 // Code to determine a a file will match a particular query
 493                 //
 494
 495                 private bool MatchesQueryPart (QueryPart abstract_part)
 496                 {
 497                         bool is_match;
 498                         is_match = false;
 499
 500                         if (abstract_part is QueryPart_Text) {
 501                                 QueryPart_Text part;
 502                                 part = abstract_part as QueryPart_Text;
 503
 504                                 if ((part.SearchTextProperties && Name == part.Text)
 505                                     || (part.SearchFullText && BodyContains (part.Text)))
 506                                         is_match = true;
 507
 508                         } else if (abstract_part is QueryPart_Or) {
 509                                 QueryPart_Or part;
 510                                 part = abstract_part as QueryPart_Or;
 511
 512                                 foreach (QueryPart sub_part in part.SubParts) {
 513                                         if (MatchesQueryPart (sub_part)) {
 514                                                 is_match = true;
 515                                                 break;
 516                                         }
 517                                 }
 518                         } else if (abstract_part is QueryPart_Property) {
 519                                 QueryPart_Property part;
 520                                 part = abstract_part as QueryPart_Property;
 521
 522                                 if (part.Key == "beagle:MimeType") {
 523                                         if (part.Value == "inode/directory")
 524                                                 is_match = IsDirectory;
 525                                         else if (part.Value == "text/plain")
 526                                                 is_match = IsFile;
 527                                         else
 528                                                 is_match = false;
 529                                 } else if (part.Key == "beagle:ExactFilename") {
 530                                         is_match = (Name == part.Value);
 531                                 } else {
 532                                         throw new Exception ("Unsupported property " + part.Key);
 533                                 }
 534                         } else if (abstract_part is QueryPart_DateRange) {
 535                                 QueryPart_DateRange part;
 536                                 part = abstract_part as QueryPart_DateRange;
 537
 538                                 // FIXME: We assume that the query refers to the file timestamp.
 539                                 // Instead, we should explicitly check part.Key.
 540                                 is_match = (part.StartDate <= Mtime && Mtime <= part.EndDate);
 541
 542                         } else {
 543                                 throw new Exception ("Unsupported part");
 544                         }
 545
 546                         if (abstract_part.Logic == QueryPartLogic.Prohibited)
 547                                 is_match = ! is_match;
 548
 549                         return is_match;
 550                 }
 551
 552                 public bool MatchesQuery (Query query)
 553                 {
 554                         // We assume the root node never matches any query.
 555                         if (IsRoot)
 556                                 return false;
 557
 558                         foreach (QueryPart part in query.Parts) {
 559                                 if (! MatchesQueryPart (part))
 560                                         return false;
 561                         }
 562
 563                         return true;
 564                 }
 565
 566                 private void RecursiveQueryCheck (ArrayList match_list, Query query)
 567                 {
 568                         if (MatchesQuery (query))
 569                                 match_list.Add (this);
 570
 571                         if (children != null)
 572                                 foreach (FileModel file in children.Values)
 573                                         file.RecursiveQueryCheck (match_list, query);
 574                 }
 575
 576                 public ArrayList GetMatchingDescendants (Query query)
 577                 {
 578                         ArrayList match_list;
 579                         match_list = new ArrayList ();
 580                         RecursiveQueryCheck (match_list, query);
 581                         return match_list;
 582                 }
 583         }
 584 }
 585