/usr/include/x86_64-linux-gnu/qcc/Stream.h is in liballjoyn-common-dev-1604 16.04a+dfsg.1-2.
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 | /**
* @file
*
* This file defines a base class used for streaming data sources.
*/
/******************************************************************************
*
*
* 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 _QCC_STREAM_H
#define _QCC_STREAM_H
#include <qcc/platform.h>
#include <qcc/String.h>
#include <qcc/Event.h>
#include <qcc/Socket.h>
#include <Status.h>
namespace qcc {
/**
* Source is pure virtual class that defines a standard interface for
* a streaming data source.
*/
class Source {
public:
/** Singleton null source */
static Source nullSource;
/** Construct a NULL source */
Source() { }
/** Destructor */
virtual ~Source() { }
/**
* 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 Time to wait to pull the requested bytes.
* @return ER_OK if successful. ER_EOF if source is exhausted. Otherwise an error.
*/
virtual QStatus PullBytes(void* buf, size_t reqBytes, size_t& actualBytes, uint32_t timeout = Event::WAIT_FOREVER) {
QCC_UNUSED(buf);
QCC_UNUSED(reqBytes);
QCC_UNUSED(actualBytes);
QCC_UNUSED(timeout);
return ER_EOF;
}
/**
* Pull bytes and any accompanying file/socket descriptors 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 [OUT] Actual number of bytes retrieved from source.
* @param fdList Array to receive file descriptors.
* @param numFds [IN,OUT] On IN the size of fdList on OUT number of files descriptors pulled.
* @param timeout Timeout in milliseconds.
* @return ER_OK if successful. ER_EOF if source is exhausted. Otherwise an error.
*/
virtual QStatus PullBytesAndFds(void* buf, size_t reqBytes, size_t& actualBytes, SocketFd* fdList, size_t& numFds, uint32_t timeout = Event::WAIT_FOREVER) {
QCC_UNUSED(buf);
QCC_UNUSED(reqBytes);
QCC_UNUSED(actualBytes);
QCC_UNUSED(fdList);
QCC_UNUSED(numFds);
QCC_UNUSED(timeout);
return ER_NOT_IMPLEMENTED;
}
/**
* Get the Event indicating that data is available when signaled.
*
* @return Event that is signaled when data is available.
*/
virtual Event& GetSourceEvent() { return Event::neverSet; }
/**
* Read source up to end of line or end of file.
*
* @param outStr Line output.
* @return ER_OK if successful. ER_EOF if source is exhausted. Otherwise an error.
*/
virtual QStatus GetLine(qcc::String& outStr, uint32_t timeout = Event::WAIT_FOREVER);
};
/**
* Sink is pure virtual class that defines a standard interface for
* a streaming data sink.
*/
class Sink {
public:
/** Construct a NULL sink */
Sink() { }
/** Destructor */
virtual ~Sink() { }
/**
* Push zero or more bytes into the sink with infinite ttl.
*
* @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.
*/
virtual QStatus PushBytes(const void* buf, size_t numBytes, size_t& numSent) {
QCC_UNUSED(buf);
QCC_UNUSED(numBytes);
QCC_UNUSED(numSent);
return ER_NOT_IMPLEMENTED;
}
/**
* Push zero or more 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.
* @param ttl Time-to-live for message or 0 for infinite.
* @return ER_OK if successful.
*/
virtual QStatus PushBytes(const void* buf, size_t numBytes, size_t& numSent, uint32_t ttl) {
QCC_UNUSED(ttl);
return PushBytes(buf, numBytes, numSent);
}
/**
* Push one or more byte accompanied by one or more file/socket descriptors to a sink.
*
* @param buf Buffer containing bytes to push
* @param numBytes Number of bytes from buf to send to sink, must be at least 1.
* @param numSent [OUT] Number of bytes actually consumed by sink.
* @param fdList Array of file descriptors to push.
* @param numFds Number of files descriptors, must be at least 1.
* @param pid Process id required on some platforms.
*
* @return ER_OK or an error.
*/
virtual QStatus PushBytesAndFds(const void* buf, size_t numBytes, size_t& numSent, SocketFd* fdList, size_t numFds, uint32_t pid = (uint32_t)-1) {
QCC_UNUSED(buf);
QCC_UNUSED(numBytes);
QCC_UNUSED(numSent);
QCC_UNUSED(fdList);
QCC_UNUSED(numFds);
QCC_UNUSED(pid);
return ER_NOT_IMPLEMENTED;
}
/**
* Get the Event that indicates when data can be pushed to sink.
*
* @return Event that is signaled when sink can accept more bytes.
*/
virtual Event& GetSinkEvent() { return Event::alwaysSet; }
/**
* Set the send timeout for this sink.
*
* @param sendTimeout Send timeout in ms.
*/
virtual void SetSendTimeout(uint32_t sendTimeout) {
QCC_UNUSED(sendTimeout);
}
};
/**
* Stream is a virtual class that defines a standard interface for a streaming source and sink.
*/
class Stream : public Source, public Sink {
public:
Stream() { UpdateIdleInformation(true); }
virtual ~Stream() { UpdateIdleInformation(false); }
/**
* Used to perform an 'orderly' release of the stream. The orderly release
* is as follows:
* -# PushBytes() or PushBytesAndFds() to transmit all bytes.
* -# Shutdown()
* -# PullBytes() or PullBytesAndFds() until the receive side is drained.
* -# Close()
*
* @return #ER_OK if successful
*/
virtual QStatus Shutdown() { return ER_OK; }
/**
* Sets the stream to discard any queued data and immediately tear down
* the resource on Close().
*
* This is used to perform an 'abortive' release of the stream. The
* abortive release is as follows:
* -# Abort()
* -# Close()
*
* @return #ER_OK if successful
*/
virtual QStatus Abort() { return ER_OK; }
/** Close the stream */
virtual void Close() { }
/**
* Indicates whether no stream objects have been created or destroyed for a specified time.
* @param minTime Minimum idle time in milliseconds.
* @return true if no stream objects have been created or destroyed for at least that time, otherwise false.
*/
static bool AJ_CALL IsIdle(uint64_t minTime);
private:
/**
* Updates the static number of stream objects.
* @param isStarting true - if a stream is being created
* false - if a stream is being destroyed
*/
static void UpdateIdleInformation(bool isStarting);
/** Current number of stream object instances */
static volatile int32_t s_instanceCount;
/** Timestamp of the latest stream object instance destroyal, in milliseconds */
static volatile uint64_t s_lastDestroyTimestamp;
};
/**
* NonBlockingStream is a type of stream that is not blocking i.e. Reads/Writes will return immediately.
*/
class NonBlockingStream : public Stream {
public:
/** Destructor */
virtual ~NonBlockingStream() { }
/** Close the stream */
virtual void Close() { }
};
} /* namespace */
#endif
|