contrib/llvm/include/llvm/Support/BinaryStreamRef.h

   1 //===- BinaryStreamRef.h - A copyable reference to a stream -----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_SUPPORT_BINARYSTREAMREF_H
  11 #define LLVM_SUPPORT_BINARYSTREAMREF_H
  12
  13 #include "llvm/ADT/ArrayRef.h"
  14 #include "llvm/Support/BinaryStream.h"
  15 #include "llvm/Support/BinaryStreamError.h"
  16 #include "llvm/Support/Error.h"
  17 #include <algorithm>
  18 #include <cstdint>
  19
  20 namespace llvm {
  21
  22 /// Common stuff for mutable and immutable StreamRefs.
  23 template <class StreamType, class RefType> class BinaryStreamRefBase {
  24 public:
  25   BinaryStreamRefBase() : Stream(nullptr), ViewOffset(0), Length(0) {}
  26   BinaryStreamRefBase(StreamType &Stream, uint32_t Offset, uint32_t Length)
  27       : Stream(&Stream), ViewOffset(Offset), Length(Length) {}
  28
  29   llvm::support::endianness getEndian() const { return Stream->getEndian(); }
  30
  31   uint32_t getLength() const { return Length; }
  32   const StreamType *getStream() const { return Stream; }
  33
  34   /// Return a new BinaryStreamRef with the first \p N elements removed.
  35   RefType drop_front(uint32_t N) const {
  36     if (!Stream)
  37       return RefType();
  38
  39     N = std::min(N, Length);
  40     return RefType(*Stream, ViewOffset + N, Length - N);
  41   }
  42
  43   /// Return a new BinaryStreamRef with only the first \p N elements remaining.
  44   RefType keep_front(uint32_t N) const {
  45     if (!Stream)
  46       return RefType();
  47     N = std::min(N, Length);
  48     return RefType(*Stream, ViewOffset, N);
  49   }
  50
  51   /// Return a new BinaryStreamRef with the first \p Offset elements removed,
  52   /// and retaining exactly \p Len elements.
  53   RefType slice(uint32_t Offset, uint32_t Len) const {
  54     return drop_front(Offset).keep_front(Len);
  55   }
  56
  57   bool operator==(const RefType &Other) const {
  58     if (Stream != Other.Stream)
  59       return false;
  60     if (ViewOffset != Other.ViewOffset)
  61       return false;
  62     if (Length != Other.Length)
  63       return false;
  64     return true;
  65   }
  66
  67 protected:
  68   Error checkOffset(uint32_t Offset, uint32_t DataSize) const {
  69     if (Offset > getLength())
  70       return make_error<BinaryStreamError>(stream_error_code::invalid_offset);
  71     if (getLength() < DataSize + Offset)
  72       return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
  73     return Error::success();
  74   }
  75
  76   StreamType *Stream;
  77   uint32_t ViewOffset;
  78   uint32_t Length;
  79 };
  80
  81 /// \brief BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.  It
  82 /// provides copy-semantics and read only access to a "window" of the underlying
  83 /// BinaryStream. Note that BinaryStreamRef is *not* a BinaryStream.  That is to
  84 /// say, it does not inherit and override the methods of BinaryStream.  In
  85 /// general, you should not pass around pointers or references to BinaryStreams
  86 /// and use inheritance to achieve polymorphism.  Instead, you should pass
  87 /// around BinaryStreamRefs by value and achieve polymorphism that way.
  88 class BinaryStreamRef
  89     : public BinaryStreamRefBase<BinaryStream, BinaryStreamRef> {
  90 public:
  91   BinaryStreamRef() = default;
  92   BinaryStreamRef(BinaryStream &Stream)
  93       : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {}
  94   BinaryStreamRef(BinaryStream &Stream, uint32_t Offset, uint32_t Length)
  95       : BinaryStreamRefBase(Stream, Offset, Length) {}
  96
  97   // Use BinaryStreamRef.slice() instead.
  98   BinaryStreamRef(BinaryStreamRef &S, uint32_t Offset,
  99                   uint32_t Length) = delete;
 100
 101   /// Given an Offset into this StreamRef and a Size, return a reference to a
 102   /// buffer owned by the stream.
 103   ///
 104   /// \returns a success error code if the entire range of data is within the
 105   /// bounds of this BinaryStreamRef's view and the implementation could read
 106   /// the data, and an appropriate error code otherwise.
 107   Error readBytes(uint32_t Offset, uint32_t Size,
 108                   ArrayRef<uint8_t> &Buffer) const {
 109     if (auto EC = checkOffset(Offset, Size))
 110       return EC;
 111
 112     return Stream->readBytes(ViewOffset + Offset, Size, Buffer);
 113   }
 114
 115   /// Given an Offset into this BinaryStreamRef, return a reference to the
 116   /// largest buffer the stream could support without necessitating a copy.
 117   ///
 118   /// \returns a success error code if implementation could read the data,
 119   /// and an appropriate error code otherwise.
 120   Error readLongestContiguousChunk(uint32_t Offset,
 121                                    ArrayRef<uint8_t> &Buffer) const {
 122     if (auto EC = checkOffset(Offset, 1))
 123       return EC;
 124
 125     if (auto EC =
 126             Stream->readLongestContiguousChunk(ViewOffset + Offset, Buffer))
 127       return EC;
 128     // This StreamRef might refer to a smaller window over a larger stream.  In
 129     // that case we will have read out more bytes than we should return, because
 130     // we should not read past the end of the current view.
 131     uint32_t MaxLength = Length - Offset;
 132     if (Buffer.size() > MaxLength)
 133       Buffer = Buffer.slice(0, MaxLength);
 134     return Error::success();
 135   }
 136 };
 137
 138 class WritableBinaryStreamRef
 139     : public BinaryStreamRefBase<WritableBinaryStream,
 140                                  WritableBinaryStreamRef> {
 141 public:
 142   WritableBinaryStreamRef() = default;
 143   WritableBinaryStreamRef(WritableBinaryStream &Stream)
 144       : BinaryStreamRefBase(Stream, 0, Stream.getLength()) {}
 145   WritableBinaryStreamRef(WritableBinaryStream &Stream, uint32_t Offset,
 146                           uint32_t Length)
 147       : BinaryStreamRefBase(Stream, Offset, Length) {}
 148
 149   // Use WritableBinaryStreamRef.slice() instead.
 150   WritableBinaryStreamRef(WritableBinaryStreamRef &S, uint32_t Offset,
 151                           uint32_t Length) = delete;
 152
 153   /// Given an Offset into this WritableBinaryStreamRef and some input data,
 154   /// writes the data to the underlying stream.
 155   ///
 156   /// \returns a success error code if the data could fit within the underlying
 157   /// stream at the specified location and the implementation could write the
 158   /// data, and an appropriate error code otherwise.
 159   Error writeBytes(uint32_t Offset, ArrayRef<uint8_t> Data) const {
 160     if (auto EC = checkOffset(Offset, Data.size()))
 161       return EC;
 162
 163     return Stream->writeBytes(ViewOffset + Offset, Data);
 164   }
 165
 166   operator BinaryStreamRef() { return BinaryStreamRef(*Stream); }
 167
 168   /// \brief For buffered streams, commits changes to the backing store.
 169   Error commit() { return Stream->commit(); }
 170 };
 171
 172 } // end namespace llvm
 173
 174 #endif // LLVM_SUPPORT_BINARYSTREAMREF_H