/usr/include/x86_64-linux-gnu/qcc/windows/FileStream.h is in liballjoyn-common-dev-1509 15.09a-5.
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 | /**
* @file
*
* Sink/Source wrapper FILE operations
*/
/******************************************************************************
* Copyright AllSeen Alliance. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************************/
#ifndef _OS_QCC_FILESTREAM_H
#define _OS_QCC_FILESTREAM_H
#include <qcc/platform.h>
#include <winsock2.h>
#include <windows.h>
#include <string>
#include <qcc/String.h>
#include <qcc/Stream.h>
#include <Status.h>
namespace qcc {
/**
* Platform abstraction for deleting a file
*
* @param fileName The name of the file to delete
*
* @eturn ER_OK if the file was deleted or an error status otherwise.
*/
QStatus DeleteFile(qcc::String fileName);
/**
* Platform abstraction for checking for the existence of a file
*
* @param fileName The name of the file to check for existence
*
* @return ER_OK if the file exists; ER_FAIL if not.
*/
QStatus FileExists(const qcc::String& fileName);
/**
* FileSource is an implementation of Source used for reading from files.
*/
class FileSource : public Source {
public:
/**
* Create an FileSource
*
* @param fileName Name of file to read/write
*/
FileSource(qcc::String fileName);
/**
* Create an FileSource from STDIN
*/
FileSource();
/**
* Copy constructor.
*
* @param other FileSource to copy from.
*/
FileSource(const FileSource& other);
/**
* Assignment.
*
* @param other FileSource to copy from.
* @return This FileSource.
*/
FileSource operator=(const FileSource& other);
/** Destructor */
virtual ~FileSource();
/**
* Return the size of the file
*
* @param fileSize The size of the file in bytes
*/
QStatus GetSize(int64_t& fileSize);
/**
* Pull bytes from the source.
* The source is exhausted when ER_EOF is returned.
*
* @param buf Buffer to store pulled bytes
* @param reqBytes Number of bytes requested to be pulled from source.
* @param actualBytes Actual number of bytes retrieved from source.
* @param timeout Timeout in milliseconds.
* @return ER_OK if successful. ER_EOF if source is exhausted. Otherwise an error.
*/
QStatus PullBytes(void* buf, size_t reqBytes, size_t& actualBytes, uint32_t timeout = Event::WAIT_FOREVER);
/**
* Get the Event indicating that data is available when signaled.
*
* @return Event that is signaled when data is available.
*/
Event& GetSourceEvent() { return *event; }
/**
* Check validity of FILE.
*
* @return true iff stream was successfully initialized.
*/
bool IsValid() { return INVALID_HANDLE_VALUE != handle; }
/**
* Lock the underlying file for exclusive access
*
* @param block If block is true the function will block until file access if permitted.
*
* @return Returns true if the file was locked, false if the file was not locked or if the file
* was not valid, i.e. if IsValid() would returnf false;
*/
bool Lock(bool block = false);
/**
* Unlock the file if previously locked
*/
void Unlock();
private:
HANDLE handle; /**< File handle */
Event* event; /**< Source event */
bool ownsHandle; /**< True if Source is responsible for closing handle */
bool locked; /**< true if the sink has been locked for exclusive access */
};
/**
* FileSink is an implementation of Sink used to write to files.
*/
class FileSink : public Sink {
public:
/**
* File creation mode.
*/
typedef enum {
PRIVATE = 0, /**< Private to the calling user */
WORLD_READABLE = 1, /**< World readable */
WORLD_WRITABLE = 2, /**< World writable */
} Mode;
/**
* Create an FileSink.
*
* @param fileName Name of file to use as sink.
*/
FileSink(qcc::String fileName, Mode mode = WORLD_READABLE);
/**
* Create a FileSink from stdout
*/
FileSink();
/**
* Copy constructor.
*
* @param other FileSink to copy from.
*/
FileSink(const FileSink& other);
/**
* Assignment.
*
* @param other FileSink to copy from.
* @return This FileSink.
*/
FileSink operator=(const FileSink& other);
/** FileSink Destructor */
virtual ~FileSink();
/**
* Push bytes into the sink.
*
* @param buf Buffer to store pulled bytes
* @param numBytes Number of bytes from buf to send to sink.
* @param numSent Number of bytes actually consumed by sink.
* @return ER_OK if successful.
*/
QStatus PushBytes(const void* buf, size_t numBytes, size_t& numSent);
/**
* Get the Event that indicates when data can be pushed to sink.
*
* @return Event that is signaled when sink can accept more bytes.
*/
Event& GetSinkEvent() { return *event; }
/**
* Check validity of FILE.
*
* @return true iff stream was successfully initialized.
*/
bool IsValid() { return INVALID_HANDLE_VALUE != handle; }
/**
* Lock the underlying file for exclusive access
*
* @param block If block is true the function will block until file access if permitted.
*
* @return Returns true if the file was locked, false if the file was not locked or if the file
* was not valid, i.e. if IsValid() would returnf false;
*/
bool Lock(bool block = false);
/**
* Unlock the file if previously locked
*/
void Unlock();
private:
HANDLE handle; /**< File handle */
Event* event; /**< I/O event */
bool ownsHandle; /**< True if Source is responsible for closing handle */
bool locked; /**< true if the sink has been locked for exclusive access */
};
} /* namespace */
#endif
|