/usr/include/octave-3.8.1/octave/file-stat.h is in liboctave-dev 3.8.1-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 | /*
Copyright (C) 1996-2013 John W. Eaton
This file is part of Octave.
Octave 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 3 of the License, or (at your
option) any later version.
Octave is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with Octave; see the file COPYING. If not, see
<http://www.gnu.org/licenses/>.
*/
#if !defined (octave_file_stat_h)
#define octave_file_stat_h 1
#include <string>
#include "oct-time.h"
#include <sys/types.h>
class
OCTAVE_API
base_file_stat
{
public:
base_file_stat (void)
: initialized (false), fail (false), errmsg (), fs_mode (),
fs_ino (), fs_dev (), fs_nlink (), fs_uid (), fs_gid (),
fs_size (), fs_atime (), fs_mtime (), fs_ctime (), fs_rdev (),
fs_blksize (), fs_blocks () { }
base_file_stat (const base_file_stat& fs)
: initialized (fs.initialized), fail (fs.fail), errmsg (fs.errmsg),
fs_mode (fs.fs_mode), fs_ino (fs.fs_ino), fs_dev (fs.fs_dev),
fs_nlink (fs.fs_nlink), fs_uid (fs.fs_uid), fs_gid (fs.fs_gid),
fs_size (fs.fs_size), fs_atime (fs.fs_atime), fs_mtime (fs.fs_mtime),
fs_ctime (fs.fs_ctime), fs_rdev (fs.fs_rdev),
fs_blksize (fs.fs_blksize), fs_blocks (fs.fs_blocks) { }
base_file_stat& operator = (const base_file_stat& fs)
{
if (this != &fs)
{
initialized = fs.initialized;
fail = fs.fail;
errmsg = fs.errmsg;
fs_mode = fs.fs_mode;
fs_ino = fs.fs_ino;
fs_dev = fs.fs_dev;
fs_nlink = fs.fs_nlink;
fs_uid = fs.fs_uid;
fs_gid = fs.fs_gid;
fs_size = fs.fs_size;
fs_atime = fs.fs_atime;
fs_mtime = fs.fs_mtime;
fs_ctime = fs.fs_ctime;
fs_rdev = fs.fs_rdev;
fs_blksize = fs.fs_blksize;
fs_blocks = fs.fs_blocks;
}
return *this;
}
// The minimum difference in file time stamp values.
// FIXME: This value should come from the filesystem itself.
// How can we get that info?
octave_time time_resolution (void) const
{
static octave_time resolution (1.0);
return resolution;
}
// File status and info. The is_XXX functions will return false for
// file_stat objects that are not properly initialized. The others
// should all return 0 (or the equivalent, for the given object)
// which is likely not meaningful.
bool is_blk (void) const;
bool is_chr (void) const;
bool is_dir (void) const;
bool is_fifo (void) const;
bool is_lnk (void) const;
bool is_reg (void) const;
bool is_sock (void) const;
static bool is_blk (mode_t mode);
static bool is_chr (mode_t mode);
static bool is_dir (mode_t mode);
static bool is_fifo (mode_t mode);
static bool is_lnk (mode_t mode);
static bool is_reg (mode_t mode);
static bool is_sock (mode_t mode);
ino_t ino (void) const { return fs_ino; }
dev_t dev (void) const { return fs_dev; }
nlink_t nlink (void) const { return fs_nlink; }
uid_t uid (void) const { return fs_uid; }
gid_t gid (void) const { return fs_gid; }
off_t size (void) const { return fs_size; }
octave_time atime (void) const { return fs_atime; }
octave_time mtime (void) const { return fs_mtime; }
octave_time ctime (void) const { return fs_ctime; }
dev_t rdev (void) const { return fs_rdev; }
long blksize (void) const { return fs_blksize; }
long blocks (void) const { return fs_blocks; }
mode_t mode (void) const { return fs_mode; }
std::string mode_as_string (void) const;
bool ok (void) const { return initialized && ! fail; }
operator bool () const { return ok (); }
bool exists (void) const { return ok (); }
std::string error (void) const { return ok () ? std::string () : errmsg; }
// Has the file referenced by this object been modified since TIME?
bool is_newer (const octave_time& time) const { return fs_mtime > time; }
// It's nice to be able to hide the file_stat object if we don't
// really care about it.
static int is_newer (const std::string&, const octave_time&);
protected:
virtual ~base_file_stat (void) { }
// TRUE means we have already called stat.
bool initialized;
// TRUE means the stat for this file failed.
bool fail;
// If a failure occurs, this contains the system error text.
std::string errmsg;
// file type and permissions
mode_t fs_mode;
// serial number
ino_t fs_ino;
// device number
dev_t fs_dev;
// number of links
nlink_t fs_nlink;
// user ID of owner
uid_t fs_uid;
// group ID of owner
gid_t fs_gid;
// size in bytes, for regular files
off_t fs_size;
// time of last access
octave_time fs_atime;
// time of last modification
octave_time fs_mtime;
// time of last file status change
octave_time fs_ctime;
// device number for special files
dev_t fs_rdev;
// best I/O block size
long fs_blksize;
// number of 512-byte blocks allocated
long fs_blocks;
};
class
OCTAVE_API
file_stat : public base_file_stat
{
public:
file_stat (const std::string& n = std::string (), bool fl = true)
: base_file_stat (), file_name (n), follow_links (fl)
{
if (! file_name.empty ())
update_internal ();
}
file_stat (const file_stat& fs)
: base_file_stat (fs), file_name (fs.file_name),
follow_links (fs.follow_links) { }
file_stat& operator = (const file_stat& fs)
{
if (this != &fs)
{
base_file_stat::operator = (fs);
file_name = fs.file_name;
follow_links = fs.follow_links;
}
return *this;
}
~file_stat (void) { }
void get_stats (bool force = false)
{
if (! initialized || force)
update_internal (force);
}
void get_stats (const std::string& n, bool force = false)
{
if (n != file_name || ! initialized || force)
{
initialized = false;
file_name = n;
update_internal (force);
}
}
private:
// Name of the file.
std::string file_name;
// TRUE means follow symbolic links to the ultimate file (stat).
// FALSE means get information about the link itself (lstat).
bool follow_links;
void update_internal (bool force = false);
};
class
OCTAVE_API
file_fstat : public base_file_stat
{
public:
file_fstat (int n) : base_file_stat (), fid (n)
{
update_internal ();
}
file_fstat (const file_fstat& fs)
: base_file_stat (fs), fid (fs.fid) { }
file_fstat& operator = (const file_fstat& fs)
{
if (this != &fs)
{
base_file_stat::operator = (fs);
fid = fs.fid;
}
return *this;
}
~file_fstat (void) { }
void get_stats (bool force = false)
{
if (! initialized || force)
update_internal (force);
}
void get_stats (int n, bool force = false)
{
if (n != fid || ! initialized || force)
{
initialized = false;
fid = n;
update_internal (force);
}
}
private:
// Open file descriptor.
int fid;
void update_internal (bool force = false);
};
#endif
|