← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cached_directory.h

  • Committer: Monty Taylor
  • Date: 2010-12-24 02:13:05 UTC
  • mto: This revision was merged to the branch mainline in revision 2038.
  • Revision ID: mordred@inaugust.com-20101224021305-e3slv1cyjczqorij
Changed the bzrignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cached_directory.h
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
/**
 
21
 * @file
 
22
 *   cached_directory.h
 
23
 *
 
24
 * @brief
 
25
 *   Defines the interface to the CachedDirectory class.
 
26
 */
 
27
 
 
28
#ifndef DRIZZLED_CACHED_DIRECTORY_H
 
29
#define DRIZZLED_CACHED_DIRECTORY_H
 
30
 
 
31
#include <dirent.h>
 
32
 
 
33
#include <iostream>
 
34
#include <vector>
 
35
#include <set>
 
36
#include <string>
 
37
#include <cstdlib>
 
38
#include <cerrno>
 
39
 
 
40
namespace drizzled
 
41
{
 
42
 
 
43
/**
 
44
 * A utility class to handle processing the entries/files within a directory.
 
45
 *
 
46
 * This class will allow the user to either get a list of the entry names 
 
47
 * within a given directory.
 
48
 */
 
49
class CachedDirectory
 
50
{
 
51
public:
 
52
  enum FILTER {
 
53
    NONE,
 
54
    DIRECTORY,
 
55
    FILE,
 
56
    MAX
 
57
  };
 
58
 
 
59
  class Entry
 
60
  {
 
61
    Entry();
 
62
  public:
 
63
    std::string filename;
 
64
    explicit Entry(std::string in_name)
 
65
      : filename(in_name)
 
66
    {}
 
67
  };
 
68
  typedef std::vector<Entry *> Entries;
 
69
  /**
 
70
   * Empty Constructor.
 
71
   */
 
72
  CachedDirectory();
 
73
      
 
74
  /**
 
75
   * Constructor taking full directory path as sole parameter.
 
76
   *
 
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
   */
 
94
  ~CachedDirectory();
 
95
 
 
96
  /**
 
97
   * Returns whether the CachedDirectory object is in a failed state
 
98
   */
 
99
  inline bool fail() const 
 
100
  {
 
101
    return error != 0;
 
102
  }
 
103
 
 
104
  /** 
 
105
   * Returns the stored error code of the last action the directory
 
106
   * object took (open, read, etc)
 
107
   */
 
108
  inline int getError() const
 
109
  {
 
110
    return error;
 
111
  }
 
112
 
 
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
  /**
 
122
   * Return the list of entries read from the directory
 
123
   *
 
124
   * @returns
 
125
   *   A vector of strings containing the directory entry names.
 
126
   */
 
127
  inline const Entries &getEntries()
 
128
  {
 
129
    return entries;
 
130
  }
 
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
};
 
175
 
 
176
} /* namespace drizzled */
 
177
 
 
178
#endif /* DRIZZLED_CACHED_DIRECTORY_H */