juce/source/src/io/streams/juce_InputStream.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_InputStream.h"
  31 #include "juce_MemoryOutputStream.h"
  32
  33
  34 //==============================================================================
  35 char InputStream::readByte()
  36 {
  37     char temp = 0;
  38     read (&temp, 1);
  39     return temp;
  40 }
  41
  42 bool InputStream::readBool()
  43 {
  44     return readByte() != 0;
  45 }
  46
  47 short InputStream::readShort()
  48 {
  49     char temp[2];
  50
  51     if (read (temp, 2) == 2)
  52         return (short) ByteOrder::littleEndianShort (temp);
  53
  54     return 0;
  55 }
  56
  57 short InputStream::readShortBigEndian()
  58 {
  59     char temp[2];
  60
  61     if (read (temp, 2) == 2)
  62         return (short) ByteOrder::bigEndianShort (temp);
  63
  64     return 0;
  65 }
  66
  67 int InputStream::readInt()
  68 {
  69     char temp[4];
  70
  71     if (read (temp, 4) == 4)
  72         return (int) ByteOrder::littleEndianInt (temp);
  73
  74     return 0;
  75 }
  76
  77 int InputStream::readIntBigEndian()
  78 {
  79     char temp[4];
  80
  81     if (read (temp, 4) == 4)
  82         return (int) ByteOrder::bigEndianInt (temp);
  83
  84     return 0;
  85 }
  86
  87 int InputStream::readCompressedInt()
  88 {
  89     const unsigned char sizeByte = readByte();
  90     if (sizeByte == 0)
  91         return 0;
  92
  93     const int numBytes = (sizeByte & 0x7f);
  94     if (numBytes > 4)
  95     {
  96         jassertfalse;    // trying to read corrupt data - this method must only be used
  97                        // to read data that was written by OutputStream::writeCompressedInt()
  98         return 0;
  99     }
 100
 101     char bytes[4] = { 0, 0, 0, 0 };
 102     if (read (bytes, numBytes) != numBytes)
 103         return 0;
 104
 105     const int num = (int) ByteOrder::littleEndianInt (bytes);
 106     return (sizeByte >> 7) ? -num : num;
 107 }
 108
 109 int64 InputStream::readInt64()
 110 {
 111     union { uint8 asBytes[8]; uint64 asInt64; } n;
 112
 113     if (read (n.asBytes, 8) == 8)
 114         return (int64) ByteOrder::swapIfBigEndian (n.asInt64);
 115
 116     return 0;
 117 }
 118
 119 int64 InputStream::readInt64BigEndian()
 120 {
 121     union { uint8 asBytes[8]; uint64 asInt64; } n;
 122
 123     if (read (n.asBytes, 8) == 8)
 124         return (int64) ByteOrder::swapIfLittleEndian (n.asInt64);
 125
 126     return 0;
 127 }
 128
 129 float InputStream::readFloat()
 130 {
 131     // the union below relies on these types being the same size...
 132     static_jassert (sizeof (int32) == sizeof (float));
 133     union { int32 asInt; float asFloat; } n;
 134     n.asInt = (int32) readInt();
 135     return n.asFloat;
 136 }
 137
 138 float InputStream::readFloatBigEndian()
 139 {
 140     union { int32 asInt; float asFloat; } n;
 141     n.asInt = (int32) readIntBigEndian();
 142     return n.asFloat;
 143 }
 144
 145 double InputStream::readDouble()
 146 {
 147     union { int64 asInt; double asDouble; } n;
 148     n.asInt = readInt64();
 149     return n.asDouble;
 150 }
 151
 152 double InputStream::readDoubleBigEndian()
 153 {
 154     union { int64 asInt; double asDouble; } n;
 155     n.asInt = readInt64BigEndian();
 156     return n.asDouble;
 157 }
 158
 159 String InputStream::readString()
 160 {
 161     MemoryBlock buffer (256);
 162     char* data = static_cast<char*> (buffer.getData());
 163     size_t i = 0;
 164
 165     while ((data[i] = readByte()) != 0)
 166     {
 167         if (++i >= buffer.getSize())
 168         {
 169             buffer.setSize (buffer.getSize() + 512);
 170             data = static_cast<char*> (buffer.getData());
 171         }
 172     }
 173
 174     return String::fromUTF8 (data, (int) i);
 175 }
 176
 177 String InputStream::readNextLine()
 178 {
 179     MemoryBlock buffer (256);
 180     char* data = static_cast<char*> (buffer.getData());
 181     size_t i = 0;
 182
 183     while ((data[i] = readByte()) != 0)
 184     {
 185         if (data[i] == '\n')
 186             break;
 187
 188         if (data[i] == '\r')
 189         {
 190             const int64 lastPos = getPosition();
 191
 192             if (readByte() != '\n')
 193                 setPosition (lastPos);
 194
 195             break;
 196         }
 197
 198         if (++i >= buffer.getSize())
 199         {
 200             buffer.setSize (buffer.getSize() + 512);
 201             data = static_cast<char*> (buffer.getData());
 202         }
 203     }
 204
 205     return String::fromUTF8 (data, (int) i);
 206 }
 207
 208 int InputStream::readIntoMemoryBlock (MemoryBlock& block, int numBytes)
 209 {
 210     MemoryOutputStream mo (block, true);
 211     return mo.writeFromInputStream (*this, numBytes);
 212 }
 213
 214 String InputStream::readEntireStreamAsString()
 215 {
 216     MemoryOutputStream mo;
 217     mo.writeFromInputStream (*this, -1);
 218     return mo.toString();
 219 }
 220
 221 //==============================================================================
 222 void InputStream::skipNextBytes (int64 numBytesToSkip)
 223 {
 224     if (numBytesToSkip > 0)
 225     {
 226         const int skipBufferSize = (int) jmin (numBytesToSkip, (int64) 16384);
 227         HeapBlock<char> temp (skipBufferSize);
 228
 229         while (numBytesToSkip > 0 && ! isExhausted())
 230             numBytesToSkip -= read (temp, (int) jmin (numBytesToSkip, (int64) skipBufferSize));
 231     }
 232 }
 233
 234 END_JUCE_NAMESPACE