source/modules/water/streams/OutputStream.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the Water library.
   5    Copyright (c) 2016 ROLI Ltd.
   6    Copyright (C) 2017-2022 Filipe Coelho <falktx@falktx.com>
   7
   8    Permission is granted to use this software under the terms of the ISC license
   9    http://www.isc.org/downloads/software-support-policy/isc-license/
  10
  11    Permission to use, copy, modify, and/or distribute this software for any
  12    purpose with or without fee is hereby granted, provided that the above
  13    copyright notice and this permission notice appear in all copies.
  14
  15    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD
  16    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
  18    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  19    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  21    OF THIS SOFTWARE.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "OutputStream.h"
  27 #include "../files/FileInputStream.h"
  28 #include "../memory/ByteOrder.h"
  29 #include "../memory/MemoryBlock.h"
  30 #include "../text/NewLine.h"
  31
  32 namespace water {
  33
  34 //==============================================================================
  35 OutputStream::OutputStream()
  36     : newLineString (NewLine::getDefault())
  37 {
  38 }
  39
  40 OutputStream::~OutputStream()
  41 {
  42 }
  43
  44 //==============================================================================
  45 bool OutputStream::writeBool (const bool b)
  46 {
  47     return writeByte (b ? (char) 1
  48                         : (char) 0);
  49 }
  50
  51 bool OutputStream::writeByte (char byte)
  52 {
  53     return write (&byte, 1);
  54 }
  55
  56 bool OutputStream::writeRepeatedByte (uint8 byte, size_t numTimesToRepeat)
  57 {
  58     for (size_t i = 0; i < numTimesToRepeat; ++i)
  59         if (! writeByte ((char) byte))
  60             return false;
  61
  62     return true;
  63 }
  64
  65 bool OutputStream::writeShort (short value)
  66 {
  67     const unsigned short v = ByteOrder::swapIfBigEndian ((unsigned short) value);
  68     return write (&v, 2);
  69 }
  70
  71 bool OutputStream::writeShortBigEndian (short value)
  72 {
  73     const unsigned short v = ByteOrder::swapIfLittleEndian ((unsigned short) value);
  74     return write (&v, 2);
  75 }
  76
  77 bool OutputStream::writeInt (int value)
  78 {
  79     const unsigned int v = ByteOrder::swapIfBigEndian ((unsigned int) value);
  80     return write (&v, 4);
  81 }
  82
  83 bool OutputStream::writeIntBigEndian (int value)
  84 {
  85     const unsigned int v = ByteOrder::swapIfLittleEndian ((unsigned int) value);
  86     return write (&v, 4);
  87 }
  88
  89 bool OutputStream::writeCompressedInt (int value)
  90 {
  91     unsigned int un = (value < 0) ? (unsigned int) -value
  92                                   : (unsigned int) value;
  93
  94     uint8 data[5];
  95     int num = 0;
  96
  97     while (un > 0)
  98     {
  99         data[++num] = (uint8) un;
 100         un >>= 8;
 101     }
 102
 103     data[0] = (uint8) num;
 104
 105     if (value < 0)
 106         data[0] |= 0x80;
 107
 108     return write (data, (size_t) num + 1);
 109 }
 110
 111 bool OutputStream::writeInt64 (int64 value)
 112 {
 113     const uint64 v = ByteOrder::swapIfBigEndian ((uint64) value);
 114     return write (&v, 8);
 115 }
 116
 117 bool OutputStream::writeInt64BigEndian (int64 value)
 118 {
 119     const uint64 v = ByteOrder::swapIfLittleEndian ((uint64) value);
 120     return write (&v, 8);
 121 }
 122
 123 bool OutputStream::writeFloat (float value)
 124 {
 125     union { int asInt; float asFloat; } n;
 126     n.asFloat = value;
 127     return writeInt (n.asInt);
 128 }
 129
 130 bool OutputStream::writeFloatBigEndian (float value)
 131 {
 132     union { int asInt; float asFloat; } n;
 133     n.asFloat = value;
 134     return writeIntBigEndian (n.asInt);
 135 }
 136
 137 bool OutputStream::writeDouble (double value)
 138 {
 139     union { int64 asInt; double asDouble; } n;
 140     n.asDouble = value;
 141     return writeInt64 (n.asInt);
 142 }
 143
 144 bool OutputStream::writeDoubleBigEndian (double value)
 145 {
 146     union { int64 asInt; double asDouble; } n;
 147     n.asDouble = value;
 148     return writeInt64BigEndian (n.asInt);
 149 }
 150
 151 bool OutputStream::writeString (const String& text)
 152 {
 153     return write (text.toRawUTF8(), text.getNumBytesAsUTF8() + 1);
 154 }
 155
 156 bool OutputStream::writeText (const String& text, const bool asUTF16,
 157                               const bool writeUTF16ByteOrderMark)
 158 {
 159     if (asUTF16)
 160     {
 161         if (writeUTF16ByteOrderMark)
 162             write ("\x0ff\x0fe", 2);
 163
 164         CharPointer_UTF8 src (text.getCharPointer());
 165         bool lastCharWasReturn = false;
 166
 167         for (;;)
 168         {
 169             const water_uchar c = src.getAndAdvance();
 170
 171             if (c == 0)
 172                 break;
 173
 174             if (c == '\n' && ! lastCharWasReturn)
 175                 writeShort ((short) '\r');
 176
 177             lastCharWasReturn = (c == L'\r');
 178
 179             if (! writeShort ((short) c))
 180                 return false;
 181         }
 182     }
 183     else
 184     {
 185         const char* src = text.toUTF8();
 186         const char* t = src;
 187
 188         for (;;)
 189         {
 190             if (*t == '\n')
 191             {
 192                 if (t > src)
 193                     if (! write (src, (size_t) (t - src)))
 194                         return false;
 195
 196                 if (! write ("\r\n", 2))
 197                     return false;
 198
 199                 src = t + 1;
 200             }
 201             else if (*t == '\r')
 202             {
 203                 if (t[1] == '\n')
 204                     ++t;
 205             }
 206             else if (*t == 0)
 207             {
 208                 if (t > src)
 209                     if (! write (src, (size_t) (t - src)))
 210                         return false;
 211
 212                 break;
 213             }
 214
 215             ++t;
 216         }
 217     }
 218
 219     return true;
 220 }
 221
 222 int64 OutputStream::writeFromInputStream (InputStream& source, int64 numBytesToWrite)
 223 {
 224     if (numBytesToWrite < 0)
 225         numBytesToWrite = std::numeric_limits<int64>::max();
 226
 227     int64 numWritten = 0;
 228
 229     while (numBytesToWrite > 0)
 230     {
 231         char buffer [8192];
 232         const int num = source.read (buffer, (int) jmin (numBytesToWrite, (int64) sizeof (buffer)));
 233
 234         if (num <= 0)
 235             break;
 236
 237         write (buffer, (size_t) num);
 238
 239         numBytesToWrite -= num;
 240         numWritten += num;
 241     }
 242
 243     return numWritten;
 244 }
 245
 246 //==============================================================================
 247 void OutputStream::setNewLineString (const String& newLineString_)
 248 {
 249     newLineString = newLineString_;
 250 }
 251
 252 //==============================================================================
 253 template <typename IntegerType>
 254 static void writeIntToStream (OutputStream& stream, IntegerType number)
 255 {
 256     char buffer [NumberToStringConverters::charsNeededForInt];
 257     char* end = buffer + numElementsInArray (buffer);
 258     const char* start = NumberToStringConverters::numberToString (end, number);
 259     stream.write (start, (size_t) (end - start - 1));
 260 }
 261
 262 OutputStream& operator<< (OutputStream& stream, const int number)
 263 {
 264     writeIntToStream (stream, number);
 265     return stream;
 266 }
 267
 268 OutputStream& operator<< (OutputStream& stream, const int64 number)
 269 {
 270     writeIntToStream (stream, number);
 271     return stream;
 272 }
 273
 274 OutputStream& operator<< (OutputStream& stream, const double number)
 275 {
 276     return stream << String (number);
 277 }
 278
 279 OutputStream& operator<< (OutputStream& stream, const char character)
 280 {
 281     stream.writeByte (character);
 282     return stream;
 283 }
 284
 285 OutputStream& operator<< (OutputStream& stream, const char* const text)
 286 {
 287     stream.write (text, strlen (text));
 288     return stream;
 289 }
 290
 291 OutputStream& operator<< (OutputStream& stream, const MemoryBlock& data)
 292 {
 293     if (data.getSize() > 0)
 294         stream.write (data.getData(), data.getSize());
 295
 296     return stream;
 297 }
 298
 299 OutputStream& operator<< (OutputStream& stream, const File& fileToRead)
 300 {
 301     FileInputStream in (fileToRead);
 302
 303     if (in.openedOk())
 304         return stream << in;
 305
 306     return stream;
 307 }
 308
 309 OutputStream& operator<< (OutputStream& stream, InputStream& streamToRead)
 310 {
 311     stream.writeFromInputStream (streamToRead, -1);
 312     return stream;
 313 }
 314
 315 OutputStream& operator<< (OutputStream& stream, const NewLine&)
 316 {
 317     return stream << stream.getNewLineString();
 318 }
 319
 320 }