| import 'dart:async'; |
| |
| import 'header.dart'; |
| |
| /// An entry in a tar file. |
| /// |
| /// Usually, tar entries are read from a stream, and they're bound to the stream |
| /// from which they've been read. This means that they can only be read once, |
| /// and that only one [TarEntry] is active at a time. |
| final class TarEntry { |
| /// The parsed [TarHeader] of this tar entry. |
| final TarHeader header; |
| |
| /// The content stream of the active tar entry. |
| /// |
| /// For tar entries read through the reader provided by this library, |
| /// [contents] is a single-subscription streamed backed by the original stream |
| /// used to create the reader. |
| /// When listening on [contents], the stream needs to be fully drained before |
| /// the next call to [StreamIterator.moveNext]. It's acceptable to not listen |
| /// to [contents] at all before calling [StreamIterator.moveNext] again. |
| /// In that case, this library will take care of draining the stream to get to |
| /// the next entry. |
| final Stream<List<int>> contents; |
| |
| /// The name of this entry, as indicated in the header or a previous pax |
| /// entry. |
| String get name => header.name; |
| |
| /// The type of tar entry (file, directory, etc.). |
| TypeFlag get type => header.typeFlag; |
| |
| /// The content size of this entry, in bytes. |
| int get size => header.size; |
| |
| /// Time of the last modification of this file, as indicated in the [header]. |
| DateTime get modified => header.modified; |
| |
| /// Creates a tar entry from a [header] and the [contents] stream. |
| /// |
| /// If the total length of [contents] is known, consider setting the |
| /// [header]'s [TarHeader.size] property to the appropriate value. |
| /// Otherwise, the tar writer needs to buffer contents to determine the right |
| /// size. |
| // factory so that this class can't be extended |
| factory TarEntry(TarHeader header, Stream<List<int>> contents) = TarEntry._; |
| |
| TarEntry._(this.header, this.contents); |
| |
| /// Creates an in-memory tar entry from the [header] and the [data] to store. |
| static SynchronousTarEntry data(TarHeader header, List<int> data) { |
| (header as HeaderImpl).size = data.length; |
| return SynchronousTarEntry._(header, data); |
| } |
| } |
| |
| /// A tar entry stored in memory. |
| final class SynchronousTarEntry extends TarEntry { |
| /// The contents of this tar entry as a byte array. |
| final List<int> data; |
| |
| SynchronousTarEntry._(TarHeader header, this.data) |
| : super._(header, Stream.value(data)); |
| } |