1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
#include <wibble/sys/fs.h>
#include <wibble/sys/process.h>
#include <wibble/string.h>
#include <wibble/exception.h>
#include <fstream>
#include <sys/stat.h>
#include <errno.h>
namespace wibble {
namespace sys {
namespace fs {
std::auto_ptr<struct stat> stat(const std::string& pathname)
{
std::auto_ptr<struct stat> res(new struct stat);
if (::stat(pathname.c_str(), res.get()) == -1)
if (errno == ENOENT)
return std::auto_ptr<struct stat>();
else
throw wibble::exception::System("getting file information for " + pathname);
return res;
}
bool access(const std::string &s, int m)
{
return ::access(s.c_str(), m) == 0;
}
std::string abspath(const std::string& pathname)
{
if (pathname[0] == '/')
return str::normpath(pathname);
else
return str::normpath(str::joinpath(process::getcwd(), pathname));
}
void mkdirIfMissing(const std::string& dir, mode_t mode)
{
std::auto_ptr<struct stat> st = wibble::sys::fs::stat(dir);
if (st.get() == NULL)
{
// If it does not exist, make it
if (::mkdir(dir.c_str(), mode) == -1)
throw wibble::exception::System("creating directory " + dir);
} else if (! S_ISDIR(st->st_mode)) {
// If it exists but it is not a directory, complain
throw wibble::exception::Consistency("ensuring path " + dir + " exists", dir + " exists but it is not a directory");
}
}
void mkpath(const std::string& dir)
{
size_t pos = dir.rfind('/');
if (pos != 0 && pos != std::string::npos)
// First ensure that the upper path exists
mkpath(dir.substr(0, pos));
mkdirIfMissing(dir, 0777);
}
void mkFilePath(const std::string& file)
{
size_t pos = file.rfind('/');
if (pos != std::string::npos)
mkpath(file.substr(0, pos));
}
std::string readFile( const std::string &file )
{
std::ifstream in( file.c_str(), std::ios::binary );
if (!in.is_open())
throw wibble::exception::System( "reading file " + file );
std::string ret;
size_t length;
in.seekg(0, std::ios::end);
length = in.tellg();
in.seekg(0, std::ios::beg);
char buffer[ length ];
in.read(buffer, length);
return std::string( buffer, length );
}
void writeFile( const std::string &file, const std::string &data )
{
std::ofstream out( file.c_str(), std::ios::binary );
if (!out.is_open())
throw wibble::exception::System( "writing file " + file );
out << data;
}
Directory::const_iterator Directory::begin()
{
DIR* dir = opendir(m_path.c_str());
if (!dir)
throw wibble::exception::System("reading directory " + m_path);
return const_iterator(dir);
}
Directory::const_iterator Directory::end() const
{
return const_iterator();
}
bool Directory::valid()
{
// Check that the directory exists
std::auto_ptr<struct stat> st = stat(path());
if (st.get() == NULL)
return false;
// Check that it is a directory
if (!S_ISDIR(st->st_mode))
return false;
return true;
}
}
}
}
// vim:set ts=4 sw=4:
|
