directory_tree.h

Go to the documentation of this file.

#ifndef DIRECTORY_TREE_CLASS
#define DIRECTORY_TREE_CLASS
 
/*****************************************************************************\
*                                                                             *
*  Name   : directory_tree                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2004-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include "directory.h"
#include "file_info.h"
 
#include <basis/byte_array.h>
#include <basis/contracts.h>
#include <basis/outcome.h>
#include <structures/string_array.h>
 
namespace filesystem {
 
// forward declarations.
class dir_tree_iterator;
class filename;
class filename_list;
class filename_tree;
class fname_tree_creator;
 
 
class directory_tree : public virtual basis::packable
{
public:
  directory_tree();  
 
  directory_tree(const basis::astring &path, const char *pattern = "*",
          bool ignore_files = false);
 
  ~directory_tree();
 
  DEFINE_CLASS_NAME("directory_tree");
 
  bool good() const { return _scanned_okay; }
 
  const basis::astring &path() const;
 
  bool reset(const basis::astring &path, const char *pattern = "*");
 
  filename_tree *seek(const basis::astring &dir_name, bool ignore_initial) const;
 
  virtual int packed_size() const;
  virtual void pack(basis::byte_array &packed_form) const;
  virtual bool unpack(basis::byte_array &packed_form);
 
  bool calculate(bool just_size);
 
  bool calculate(filename_tree *start, bool just_size);
 
  basis::outcome add_path(const basis::astring &new_item, bool just_size = false);
 
  basis::outcome remove_path(const basis::astring &zap_item);
 
  basis::outcome make_directories(const basis::astring new_root);
 
  static bool compare_trees(const directory_tree &source,
          const directory_tree &target, filename_list &differences,
          file_info::file_similarity how_to_compare);
 
  static bool compare_trees(const directory_tree &source,
          const basis::astring &source_start, const directory_tree &target,
          const basis::astring &target_start, filename_list &differences,
          file_info::file_similarity how_to_compare);
    // compares the trees but not at their roots.  the location on the source
    // side is specified by "source_start", which must be a path found under
    // the "source" tree.  similarly, the "target_start" will be the location
    // compared with the "source" + "source_start".  the "diffs" will still
    // be valid with respect to "source" rather than "source_start".
 
  void text_form(basis::astring &tree_dump, bool show_files = true);
 
  // Note on the iterator functions: the iterator becomes invalid if the
  // directory tree is reset.  the only valid operation on the iterator
  // at that point is to call throw_out().
 
  enum traversal_types {
    prefix,  
    infix,  
    postfix  
  };
 
  dir_tree_iterator *start(traversal_types type) const;
 
  dir_tree_iterator *start_at(filename_tree *start,
          traversal_types type) const;
 
  static bool jump_to(dir_tree_iterator &scanning, const basis::astring &sub_path);
 
  static bool current_dir(dir_tree_iterator &scanning, filename &dir_name);
 
  static bool current(dir_tree_iterator &scanning, filename &dir_name,
          structures::string_array &to_fill);
 
  static bool current(dir_tree_iterator &scanning, filename &dir_name,
          filename_list &to_fill);
 
  static filename_list *access(dir_tree_iterator &scanning);
 
  static bool depth(dir_tree_iterator &scanning, int &depth);
 
  static bool children(dir_tree_iterator &scanning, int &children);
 
  static bool next(dir_tree_iterator &scanning);
 
  static void throw_out(dir_tree_iterator * &to_whack);
 
private:
  bool _scanned_okay;  
  basis::astring *_path;  
  basis::astring *_pattern;  
  filename_tree *_real_tree;  
  bool _ignore_files;  
  fname_tree_creator *_creator;  
 
  static filename_tree *goto_current(dir_tree_iterator &scanning);
 
  void traverse(const basis::astring &path, const char *pattern,
          filename_tree &add_to);
 
  basis::outcome find_common_root(const basis::astring &path, bool exists,
          filename_tree * &common_root, basis::astring &common_path,
          structures::string_array &pieces, int &match_place);
 
};
 
} //namespace.
 
#endif