1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef AAPT_IO_FILE_H 18 #define AAPT_IO_FILE_H 19 20 #include <list> 21 #include <memory> 22 #include <vector> 23 24 #include "android-base/macros.h" 25 26 #include "Source.h" 27 #include "io/Data.h" 28 #include "util/Files.h" 29 #include "util/Util.h" 30 31 namespace aapt { 32 namespace io { 33 34 // Interface for a file, which could be a real file on the file system, or a 35 // file inside a ZIP archive. 36 class IFile { 37 public: 38 virtual ~IFile() = default; 39 40 // Open the file and return it as a block of contiguous memory. How this 41 // occurs is implementation dependent. For example, if this is a file on the file 42 // system, it may simply mmap the contents. If this file represents a compressed file in a 43 // ZIP archive, it may need to inflate it to memory, incurring a copy. 44 // Returns nullptr on failure. 45 virtual std::unique_ptr<IData> OpenAsData() = 0; 46 47 virtual std::unique_ptr<io::InputStream> OpenInputStream() = 0; 48 49 // Returns the source of this file. This is for presentation to the user and 50 // may not be a valid file system path (for example, it may contain a '@' sign to separate 51 // the files within a ZIP archive from the path to the containing ZIP archive. 52 virtual const Source& GetSource() const = 0; 53 54 IFile* CreateFileSegment(size_t offset, size_t len); 55 56 // Returns whether the file was compressed before it was stored in memory. WasCompressed()57 virtual bool WasCompressed() { 58 return false; 59 } 60 61 private: 62 // Any segments created from this IFile need to be owned by this IFile, so 63 // keep them 64 // in a list. This will never be read, so we prefer better insertion 65 // performance 66 // than cache locality, hence the list. 67 std::list<std::unique_ptr<IFile>> segments_; 68 }; 69 70 // An IFile that wraps an underlying IFile but limits it to a subsection of that file. 71 class FileSegment : public IFile { 72 public: FileSegment(IFile * file,size_t offset,size_t len)73 explicit FileSegment(IFile* file, size_t offset, size_t len) 74 : file_(file), offset_(offset), len_(len) {} 75 76 std::unique_ptr<IData> OpenAsData() override; 77 std::unique_ptr<io::InputStream> OpenInputStream() override; 78 GetSource()79 const Source& GetSource() const override { 80 return file_->GetSource(); 81 } 82 83 private: 84 DISALLOW_COPY_AND_ASSIGN(FileSegment); 85 86 IFile* file_; 87 size_t offset_; 88 size_t len_; 89 }; 90 91 class IFileCollectionIterator { 92 public: 93 virtual ~IFileCollectionIterator() = default; 94 95 virtual bool HasNext() = 0; 96 virtual IFile* Next() = 0; 97 }; 98 99 // Interface for a collection of files, all of which share a common source. That source may 100 // simply be the filesystem, or a ZIP archive. 101 class IFileCollection { 102 public: 103 virtual ~IFileCollection() = default; 104 105 virtual IFile* FindFile(const android::StringPiece& path) = 0; 106 virtual std::unique_ptr<IFileCollectionIterator> Iterator() = 0; 107 virtual char GetDirSeparator() = 0; 108 }; 109 110 } // namespace io 111 } // namespace aapt 112 113 #endif /* AAPT_IO_FILE_H */ 114