← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/cached_directory.h

Monty fixes pluss a few from me for charset.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/cached_directory.h
25
25
 *   Defines the interface to the CachedDirectory class.
26
26
 */
27
27
 
28
 
#ifndef DRIZZLED_CACHED_DIRECTORY_H
29
 
#define DRIZZLED_CACHED_DIRECTORY_H
30
 
 
31
 
#include <dirent.h>
32
 
 
33
 
#include <iostream>
 
28
#ifndef MYSYS_CACHED_DIRECTORY_H
 
29
#define MYSYS_CACHED_DIRECTORY_H
 
30
 
34
31
#include <vector>
35
 
#include <set>
36
32
#include <string>
37
 
#include <cstdlib>
38
 
#include <cerrno>
 
33
#include <dirent.h>
 
34
#include <stdlib.h>
 
35
#include <errno.h>
39
36
 
40
 
namespace drizzled
41
 
{
42
37
 
43
38
/**
44
39
 * A utility class to handle processing the entries/files within a directory.
45
40
 *
46
41
 * This class will allow the user to either get a list of the entry names 
47
 
 * within a given directory.
 
42
 * within a given directory, or, alternatively, apply a function to each
 
43
 * entry as it is read from the directory.
48
44
 */
49
45
class CachedDirectory
50
46
{
51
47
public:
52
 
  enum FILTER {
53
 
    NONE,
54
 
    DIRECTORY,
55
 
    FILE,
56
 
    MAX
57
 
  };
58
 
 
59
48
  class Entry
60
49
  {
61
 
    Entry();
62
50
  public:
63
51
    std::string filename;
64
 
    explicit Entry(std::string in_name)
 
52
    Entry(std::string in_name)
65
53
      : filename(in_name)
66
54
    {}
67
55
  };
68
56
  typedef std::vector<Entry *> Entries;
 
57
private:
 
58
  int error; ///< Error code stored from various syscalls
 
59
  Entries entries; ///< Entries in the directory
 
60
 
69
61
  /**
70
 
   * Empty Constructor.
 
62
   * Encapsulate the logic to open the directory.
 
63
   * @param[in] dirPath The path to the directory to open and read.
 
64
   * @retval true Success
 
65
   * @retval false Failure
71
66
   */
72
 
  CachedDirectory();
 
67
  bool open(const std::string &dirPath);
 
68
 
 
69
public:
 
70
  explicit CachedDirectory()
 
71
    : error(0)
 
72
  {}
73
73
      
74
74
  /**
75
75
   * Constructor taking full directory path as sole parameter.
76
76
   *
77
77
   * @param[in] Path to the directory to open
78
 
   * @param[in] File extensions to allow
79
 
   */
80
 
  CachedDirectory(const std::string& in_path); 
81
 
 
82
 
  /**
83
 
   * Constructor taking full directory path as sole parameter.
84
 
   *
85
 
   * @param[in] Path to the directory to open
86
 
   * @param[in] File extensions to allow
87
 
   */
88
 
  CachedDirectory(const std::string& in_path, std::set<std::string>& allowed_exts);
89
 
  CachedDirectory(const std::string& in_path, enum CachedDirectory::FILTER filter);
90
 
 
91
 
  /**
92
 
   * Destructor.  Cleans up any resources we've taken 
93
 
   */
 
78
   */
 
79
 CachedDirectory(const std::string &in_path); 
 
80
 /**
 
81
  * Destructor.  Cleans up any resources we've taken 
 
82
  */
94
83
  ~CachedDirectory();
95
84
 
96
85
  /**
110
99
    return error;
111
100
  }
112
101
 
113
 
  /** 
114
 
   * Returns the current path for the cached directory
115
 
   */
116
 
  inline const char *getPath() const
117
 
  {
118
 
    return path.c_str();
119
 
  }
120
 
 
121
102
  /**
122
 
   * Return the list of entries read from the directory
 
103
   * Return a list of directory entries populated in the call to open().
 
104
   *
 
105
   * @note
 
106
   *   You must call the open() method before getList() if you want the
 
107
   *   list contain any elements.
123
108
   *
124
109
   * @returns
125
110
   *   A vector of strings containing the directory entry names.
128
113
  {
129
114
    return entries;
130
115
  }
131
 
private:
132
 
  std::string path; ///< Path to the directory
133
 
  int error; ///< Error code stored from various syscalls
134
 
  Entries entries; ///< Entries in the directory
135
 
 
136
 
  /**
137
 
   * Encapsulate the logic to open the directory.
138
 
   * @param[in] The path to the directory to open and read
139
 
   *
140
 
   * @retval true Success
141
 
   * @retval false Failure
142
 
   */
143
 
  bool open(const std::string &in_path);
144
 
 
145
 
  /**
146
 
   * Encapsulate the logic to open the directory with a set of allowed
147
 
   * file extensions to filter for.
148
 
   *
149
 
   * @param[in] The path to the directory to open and read
150
 
   * @param[in] File extensions to allow
151
 
   *
152
 
   * @retval true Success
153
 
   * @retval false Failure
154
 
   */
155
 
  bool open(const std::string &in_path, std::set<std::string> &allowable_exts);
156
 
  bool open(const std::string &in_path, std::set<std::string> &allowed_exts, enum CachedDirectory::FILTER filter);
157
 
 
158
 
  friend std::ostream& operator<<(std::ostream& output, CachedDirectory &directory)
159
 
  {
160
 
    output << "CachedDirectory:(Path: " << directory.getPath() << ")\n";
161
 
 
162
 
    CachedDirectory::Entries files= directory.getEntries();
163
 
 
164
 
    for (CachedDirectory::Entries::iterator fileIter= files.begin();
165
 
         fileIter != files.end(); fileIter++)
166
 
    {
167
 
      CachedDirectory::Entry *entry= *fileIter;
168
 
      output << "\t(" << entry->filename << ")\n";
169
 
    }
170
 
 
171
 
    return output;  // for multiple << operators.
172
 
  }
173
 
 
174
116
};
175
117
 
176
 
} /* namespace drizzled */
177
 
 
178
 
#endif /* DRIZZLED_CACHED_DIRECTORY_H */
 
118
#endif  /* MYSYS_CACHED_DIRECTORY_H */