--- dyld/dyld-1340/lsl/ByteStream.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*- vim: ft=cpp et ts=4 sw=4:
- *
- * Copyright (c) 2023 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-// FIXME: Move to std::endian when libc++ implements it
-
-#ifndef ByteStream_h
-#define ByteStream_h
-
-#include <cstdint>
-#include <cstring>
-#include <string_view>
-//#include <libkern/OSByteOrder.h>
-
-#include "Vector.h"
-
-/* This provides a thin wrapper over Vector<std::byte>. The primary feature it includes is the ability to handle endian swaps.
- * This is useful when a stream contains both big and little endian data, for example, when AppleArchive (little endian) wraps
- * a binary plist (big endian). It is implemented by overloading push_back for all integer types (where swaps are handled), as well
- * as for non-integer types that do not need swapping such as string_views.
- */
-
-struct ByteStream {
-    enum Endian {
-        Little  = 0,
-        Big     = 1,
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-        Native  = Little
-#else
-        Native  = Big
-#endif
-    };
-    template<typename T> using Vector = lsl::Vector<T>;
-    using Allocator = lsl::Allocator;
-    using value_type = std::byte;
-
-    ByteStream(Allocator& allocator) : _bytes(allocator) {}
-    using iterator = Vector<std::byte>::iterator;
-    using const_iterator = Vector<std::byte>::const_iterator;
-    iterator begin() {
-        return _bytes.begin();
-    }
-    iterator end() {
-        return _bytes.end();
-    }
-    const_iterator begin() const {
-        return _bytes.begin();
-    }
-    const_iterator end() const {
-        return _bytes.end();
-    }
-    const_iterator cbegin() const {
-        return _bytes.begin();
-    }
-    const_iterator cend() const {
-        return _bytes.end();
-    }
-
-    template<typename T>
-    void push_back(T value) {
-        if (_endian != Endian::Native) {
-            if constexpr(sizeof(T) == 2) {
-                value = __builtin_bswap16(value);
-            } else if constexpr(sizeof(T) == 4) {
-                value = __builtin_bswap32(value);
-            } else if constexpr(sizeof(T) == 8) {
-                value = __builtin_bswap64(value);
-            }
-        }
-        std::byte* swappedValueBytes = reinterpret_cast<std::byte*>(&value);
-        std::copy(swappedValueBytes, swappedValueBytes+sizeof(T), std::back_inserter(_bytes));
-    }
-
-    template<>
-    void push_back<std::byte>(std::byte value) {
-        _bytes.push_back(value);
-    }
-
-    template<>
-    void push_back<uint8_t>(uint8_t value) {
-        _bytes.push_back(std::byte{value});
-    }
-
-    template<>
-    void push_back<std::string_view>(std::string_view value) {
-        (void)_bytes.insert(_bytes.end(), (std::byte*)&*value.begin(), (std::byte*)&*value.end());
-    }
-
-    template<>
-    void push_back<const char*>(const char* value) {
-       (void)_bytes.insert(_bytes.end(), (std::byte*)value, (std::byte*)value+strlen(value));
-    }
-
-    void push_back(uint8_t size, uint64_t value) {
-        switch (size) {
-            case 1: push_back((uint8_t)value); break;
-            case 2: push_back((uint16_t)value); break;
-            case 4: push_back((uint32_t)value); break;
-            case 8: push_back((uint64_t)value); break;
-        }
-    }
-
-    uint64_t size() const {
-        return _bytes.size();
-    }
-    void resize(uint64_t newCapacity) {
-        _bytes.resize(newCapacity);
-    }
-    void clear() {
-        _bytes.clear();
-    }
-    Allocator& allocator() {
-        return *_bytes.allocator();
-    }
-    void setEndian(Endian endian) {
-        _endian = endian;
-    }
-    std::byte* bytes() {
-        return _bytes.data();
-    }
-    const std::byte* bytes() const {
-        return _bytes.data();
-    }
-    std::byte&          operator[](uint64_t pos)       { return _bytes[pos]; }
-    const std::byte&    operator[](uint64_t pos) const { return _bytes[pos]; }
-
-    template< class InputIt >
-    iterator insert(const_iterator pos, InputIt first, InputIt last ) {
-        return _bytes.insert(pos, first, last);
-    }
-    const std::span<std::byte> span() const {
-        if (_bytes.empty()) { return std::span<std::byte>(); }
-        return std::span((std::byte*)_bytes.data(), (size_t)_bytes.size());
-    }
-private:
-    Vector<std::byte>   _bytes;
-    Endian              _endian = Endian::Little;
-};
-
-
-#endif /* ByteStream_h */