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);

  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