← 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: 2008-11-16 23:47:43 UTC
  • mto: (584.1.10 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116234743-c38gmv0pa2kdefaj
Broke out cached_item.

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
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 */