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                 // Properties of the root directory:
  14                 // name contains full path of BEAGLE_HOME
  15                 // parent is null
  16                 // body is null
  17                 // children is non-null
  18
  19                 // Properties of a non-root directory:
  20                 // name is a token
  21                 // parent is non-null
  22                 // body is null
  23                 // children is non-null
  24
  25                 // Properties of a file:
  26                 // name is a token
  27                 // parent is non-null, and is a directory
  28                 // body is non-null
  29                 // children is null
  30
  31                 private string name = null;
  32                 private FileModel parent = null;
  33                 private string [] body = null;
  34                 private Hashtable children = null;
  35
  36                 //////////////////////////////////////////////////////////////
  37
  38                 public bool IsRoot {
  39                         get { return parent == null; }
  40                 }
  41
  42                 public bool IsDirectory {
  43                         get { return body == null; }
  44                 }
  45
  46                 public bool IsFile {
  47                         get { return body != null; }
  48                 }
  49
  50                 public string Name {
  51                         get { return name; }
  52                 }
  53
  54                 public string FullName {
  55                         get { return IsRoot ? Name : Path.Combine (parent.FullName, name); }
  56                 }
  57
  58                 public Uri Uri {
  59                         get { return UriFu.PathToFileUri (FullName); }
  60                 }
  61
  62                 public string [] Body {
  63                         get { return body; }
  64                 }
  65
  66                 public ICollection Children {
  67                         get { return children.Values; }
  68                 }
  69
  70                 public int Size {
  71                         get {
  72                                 if (IsFile)
  73                                         return 1;
  74                                 int sum = 0;
  75                                 if (IsDirectory)
  76                                         sum = 1; // count ourselves
  77                                 foreach (FileModel child in children.Values)
  78                                         sum += child.Size;
  79                                 return sum;
  80                         }
  81                 }
  82
  83                 //////////////////////////////////////////////////////////////
  84
  85                 private void RecursiveListAdd (ArrayList list, bool add_dirs, bool add_files)
  86                 {
  87                         if ((add_dirs && IsDirectory) || (add_files && IsFile))
  88                                 list.Add (this);
  89                         if (children != null)
  90                                 foreach (FileModel file in children.Values)
  91                                         file.RecursiveListAdd (list, add_files, add_files);
  92                 }
  93
  94                 public ArrayList GetDescendants ()
  95                 {
  96                         ArrayList list = new ArrayList ();
  97                         RecursiveListAdd (list, true, true);
  98                         list.RemoveAt (0); // remove ourselves
  99                         return list;
 100                 }
 101
 102                 public ArrayList GetFileDescendants ()
 103                 {
 104                         ArrayList list = new ArrayList ();
 105                         RecursiveListAdd (list, false, true);
 106                         list.RemoveAt (0); // remove ourselves
 107                         return list;
 108                 }
 109
 110                 public ArrayList GetDirectoryDescendants ()
 111                 {
 112                         ArrayList list = new ArrayList ();
 113                         RecursiveListAdd (list, true, false);
 114                         list.RemoveAt (0); // remove ourselves
 115                         return list;
 116                 }
 117
 118                 //////////////////////////////////////////////////////////////
 119
 120                 static Random random = new Random ();
 121
 122                 public FileModel PickDescendant ()
 123                 {
 124                         ArrayList all;
 125                         all = GetDescendants ();
 126                         if (all.Count == 0)
 127                                 return null;
 128                         return all [random.Next (all.Count)] as FileModel;
 129                 }
 130
 131                 public FileModel PickFileDescendant ()
 132                 {
 133                         ArrayList all;
 134                         all = GetFileDescendants ();
 135                         if (all.Count == 0)
 136                                 return null;
 137                         return all [random.Next (all.Count)] as FileModel;
 138                 }
 139
 140                 public FileModel PickDirectoryDescendant ()
 141                 {
 142                         ArrayList all;
 143                         all = GetDirectoryDescendants ();
 144                         if (all.Count == 0)
 145                                 return null;
 146                         return all [random.Next (all.Count)] as FileModel;
 147                 }
 148
 149                 //////////////////////////////////////////////////////////////
 150
 151                 public bool BodyContains (string token)
 152                 {
 153                         if (body == null)
 154                                 return false;
 155
 156                         // FIXME: Do a binary search (or something smarter)
 157                         // instead
 158                         for (int i = 0; i < body.Length; ++i)
 159                                 if (body [i] == token)
 160                                         return true;
 161                         return false;
 162                 }
 163
 164                 public bool Contains (string token)
 165                 {
 166                         return name == token || BodyContains (token);
 167                 }
 168
 169                 //////////////////////////////////////////////////////////////
 170
 171                 private FileModel () { }
 172
 173                 public static FileModel NewRoot ()
 174                 {
 175                         FileModel root = new FileModel ();
 176                         root.name = PathFinder.HomeDir;
 177                         root.children = new Hashtable ();
 178                         return root;
 179                 }
 180
 181                 // Creates a randomly-named new directory.
 182                 // Avoid name collisions with existing files.
 183                 public FileModel NewDirectory ()
 184                 {
 185                         if (! IsDirectory)
 186                                 throw new ArgumentException ("parent must be a directory");
 187
 188                         // no more names left
 189                         if (children.Count == Token.Count)
 190                                 return null;
 191
 192                         FileModel child;
 193                         child = new FileModel ();
 194                         child.name = PickName (this);
 195                         child.children = new Hashtable ();
 196
 197                         child.parent = this;
 198                         children [child.name] = child;
 199
 200                         // Actually create the directory
 201                         Directory.CreateDirectory (child.FullName);
 202
 203                         return child;
 204                 }
 205
 206                 public FileModel NewFile ()
 207                 {
 208                         if (! IsDirectory)
 209                                 throw new ArgumentException ("parent must be a directory");
 210
 211                         // no more names left
 212                         if (children.Count == Token.Count)
 213                                 return null;
 214
 215                         FileModel child;
 216                         child = new FileModel ();
 217                         child.name = PickName (this);
 218                         child.body = NewBody (10);
 219
 220                         child.parent = this;
 221                         children [child.name] = child;
 222
 223                         // Create the file
 224                         child.Write ();
 225
 226                         return child;
 227                 }
 228
 229                 //////////////////////////////////////////////////////////////
 230
 231                 public void Grow (int depth)
 232                 {
 233                         const int num_dirs = 2;
 234                         const int num_files = 5;
 235
 236                         if (depth > 0) {
 237                                 for (int i = 0; i < num_dirs; ++i) {
 238                                         FileModel file;
 239                                         file = NewDirectory ();
 240                                         if (file != null)
 241                                                 file.Grow (depth - 1);
 242                                 }
 243                         }
 244
 245                         for (int i = 0; i < num_files; ++i)
 246                                 NewFile ();
 247                 }
 248
 249                 //////////////////////////////////////////////////////////////
 250
 251                 public void Delete ()
 252                 {
 253                         if (IsRoot)
 254                                 throw new Exception ("Can't delete the root!");
 255
 256                         if (IsDirectory)
 257                                 Directory.Delete (FullName, true); // recursive
 258                         else
 259                                 File.Delete (FullName);
 260
 261                         parent.children.Remove (name);
 262                         parent = null;
 263                 }
 264
 265
 266                 //////////////////////////////////////////////////////////////
 267
 268                 static private string PickName (FileModel p)
 269                 {
 270                         string pick;
 271                         do {
 272                                 pick = Token.GetRandom ();
 273                         } while (p.children.Contains (pick));
 274                         return pick;
 275                 }
 276
 277                 static private string [] NewBody (int size)
 278                 {
 279                         string [] body;
 280                         body = new string [size];
 281                         for (int i = 0; i < size; ++i)
 282                                 body [i] = Token.GetRandom ();
 283                         Array.Sort (body);
 284                         return body;
 285                 }
 286
 287                 private void Write ()
 288                 {
 289                         TextWriter writer;
 290                         writer = new StreamWriter (FullName);
 291                         for (int i = 0; i < body.Length; ++i)
 292                                 writer.WriteLine (body [i]);
 293                         writer.Close ();
 294                 }
 295
 296                 //////////////////////////////////////////////////////////////
 297
 298                 //
 299                 // Code to determine a a file will match a particular query
 300                 //
 301
 302                 private bool MatchesQueryPart (QueryPart abstract_part)
 303                 {
 304                         bool is_match;
 305                         is_match = false;
 306
 307                         if (abstract_part is QueryPart_Text) {
 308                                 QueryPart_Text part;
 309                                 part = abstract_part as QueryPart_Text;
 310
 311                                 if ((part.SearchTextProperties && Name == part.Text)
 312                                     || (part.SearchFullText && BodyContains (part.Text)))
 313                                         is_match = true;
 314
 315                         } else if (abstract_part is QueryPart_Or) {
 316                                 QueryPart_Or part;
 317                                 part = abstract_part as QueryPart_Or;
 318
 319                                 foreach (QueryPart sub_part in part.SubParts) {
 320                                         if (MatchesQueryPart (sub_part)) {
 321                                                 is_match = true;
 322                                                 break;
 323                                         }
 324                                 }
 325                         } else if (abstract_part is QueryPart_Property) {
 326                                 QueryPart_Property part;
 327                                 part = abstract_part as QueryPart_Property;
 328
 329                                 if (part.Key == "beagle:MimeType") {
 330                                         if (part.Value == "inode/directory")
 331                                                 is_match = IsDirectory;
 332                                         else if (part.Value == "text/plain")
 333                                                 is_match = IsFile;
 334                                         else
 335                                                 is_match = false;
 336                                 } else if (part.Key == "beagle:ExactFilename") {
 337                                         is_match = (Name == part.Value);
 338                                 } else {
 339                                         throw new Exception ("Unsupported property " + part.Key);
 340                                 }
 341                         } else {
 342                                 throw new Exception ("Unsupported part");
 343                         }
 344
 345                         if (abstract_part.Logic == QueryPartLogic.Prohibited)
 346                                 is_match = ! is_match;
 347
 348                         return is_match;
 349                 }
 350
 351                 public bool MatchesQuery (Query query)
 352                 {
 353                         // We assume the root node never matches any query.
 354                         if (IsRoot)
 355                                 return false;
 356
 357                         foreach (QueryPart part in query.Parts) {
 358                                 if (! MatchesQueryPart (part))
 359                                         return false;
 360                         }
 361
 362                         return true;
 363                 }
 364
 365                 private void RecursiveQueryCheck (ArrayList match_list, Query query)
 366                 {
 367                         if (MatchesQuery (query))
 368                                 match_list.Add (this);
 369
 370                         if (children != null)
 371                                 foreach (FileModel file in children.Values)
 372                                         file.RecursiveQueryCheck (match_list, query);
 373                 }
 374
 375                 public ArrayList GetMatchingDescendants (Query query)
 376                 {
 377                         ArrayList match_list;
 378                         match_list = new ArrayList ();
 379                         RecursiveQueryCheck (match_list, query);
 380                         return match_list;
 381                 }
 382         }
 383 }
 384