/usr/include/cupt/file.hpp is in libcupt3-dev 2.6.4.
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 | /**************************************************************************
* Copyright (C) 2010 by Eugene V. Lyubimkin *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License *
* (version 3 or above) as published by the Free Software Foundation. *
* *
* This program 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 GPL *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA *
**************************************************************************/
#ifndef CUPT_FILE_SEEN
#define CUPT_FILE_SEEN
/// @cond
#include <functional>
#include <cupt/common.hpp>
namespace cupt {
namespace internal {
struct FileImpl;
}
/// high-level interface to file routines
class CUPT_API File
{
internal::FileImpl* __impl;
File(const File&) = delete;
public:
struct RawBuffer
{
const char* data;
size_t size;
operator bool() const { return size; }
operator string() const { return string(data, size); }
RawBuffer chompAsRecord() const;
};
/// constructor
/**
* Constructs new object for a regular file or reading shell pipe.
*
* @warning You must not use constructed object if @a error is not empty.
*
* @param path path to file or shell command, see @a mode
* @param mode any value, accepted as @a mode in @c fopen(3); or @c "pr" /
* @c "pw" - special values to treat @a path as shell pipe with an opened
* handle for reading / writing, respectively
* @param [out] error if open fails, human readable error will be placed here
*/
File(const string& path, const char* mode, string& error);
File(File&&);
/// destructor
virtual ~File();
/// reads new line
/**
* Reads new line (that is, a sequence of characters which ends with newline
* character (@c "\n")).
*
* If the end of file was encountered when reading, newline character will be
* not added.
*
* @param [in, out] buffer will contain a pointer to read data
* @param [out] size the size (in bytes) of the buffer, a value @c 0 means end of file
* @return reference to self
*/
File& rawGetLine(const char*& buffer, size_t& size);
/// reads new line
/**
* Reads new line. Newline character from the end is strip if present.
*
* End of file must be checked by querying @ref eof right after @ref getLine. You can use
* @a line only if @ref eof returned false.
*
* @param [out] line container for read data
* @return reference to self
*
* @par Example:
* Reading file line by line.
* @code
* string line;
* while (!file.getLine(line).eof())
* {
* // process line
* }
* @endcode
*/
File& getLine(string& line);
RawBuffer getRecord();
RawBuffer getBlock(size_t size);
/// reads all available data from current position
/**
* It's usually used just after opening the file and for small files.
*
* @param block container for read data
*/
void getFile(string& block);
/// writes data
/**
* @param data data to write
*/
void put(const string& data);
/// writes data
/**
* @param data pointer to the data buffer
* @param size size of the buffer
*/
void put(const char* data, size_t size);
void unbufferedPut(const char* data, size_t size);
/// checks for the end of file condition
bool eof() const;
/// seeks to a new position
/**
* Sets new position of the file to write/read.
* Will throw Exception if called against File opened as pipe.
*
* @param newPosition new file position
*/
void seek(size_t newPosition);
/// gets current file position
size_t tell() const;
/// perform @c flock(2) on file
/**
* @param flags flags passed to @c flock
*/
void lock(int flags);
};
// File wrapper which throws on open errors
class CUPT_API RequiredFile: public File
{
public:
/*
* Passes @a path and @a mode to File::File(). If file failed to open (i.e.
* !openError.empty()), throws the exception.
*/
RequiredFile(const string& path, const char* mode);
};
} // namespace
/// @endcond
#endif
|