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/Util.h" 29 30namespace aapt { 31namespace io { 32 33// Interface for a file, which could be a real file on the file system, or a 34// file inside a ZIP archive. 35class IFile { 36 public: 37 virtual ~IFile() = default; 38 39 // Open the file and return it as a block of contiguous memory. How this 40 // occurs is implementation dependent. For example, if this is a file on the file 41 // system, it may simply mmap the contents. If this file represents a compressed file in a 42 // ZIP archive, it may need to inflate it to memory, incurring a copy. 43 // Returns nullptr on failure. 44 virtual std::unique_ptr<IData> OpenAsData() = 0; 45 46 // Returns the source of this file. This is for presentation to the user and 47 // may not be a valid file system path (for example, it may contain a '@' sign to separate 48 // the files within a ZIP archive from the path to the containing ZIP archive. 49 virtual const Source& GetSource() const = 0; 50 51 IFile* CreateFileSegment(size_t offset, size_t len); 52 53 // Returns whether the file was compressed before it was stored in memory. 54 virtual bool WasCompressed() { 55 return false; 56 } 57 58 private: 59 // Any segments created from this IFile need to be owned by this IFile, so 60 // keep them 61 // in a list. This will never be read, so we prefer better insertion 62 // performance 63 // than cache locality, hence the list. 64 std::list<std::unique_ptr<IFile>> segments_; 65}; 66 67// An IFile that wraps an underlying IFile but limits it to a subsection of that file. 68class FileSegment : public IFile { 69 public: 70 explicit FileSegment(IFile* file, size_t offset, size_t len) 71 : file_(file), offset_(offset), len_(len) {} 72 73 std::unique_ptr<IData> OpenAsData() override; 74 75 const Source& GetSource() const override { return file_->GetSource(); } 76 77 private: 78 DISALLOW_COPY_AND_ASSIGN(FileSegment); 79 80 IFile* file_; 81 size_t offset_; 82 size_t len_; 83}; 84 85class IFileCollectionIterator { 86 public: 87 virtual ~IFileCollectionIterator() = default; 88 89 virtual bool HasNext() = 0; 90 virtual IFile* Next() = 0; 91}; 92 93// Interface for a collection of files, all of which share a common source. That source may 94// simply be the filesystem, or a ZIP archive. 95class IFileCollection { 96 public: 97 virtual ~IFileCollection() = default; 98 99 virtual IFile* FindFile(const android::StringPiece& path) = 0; 100 virtual std::unique_ptr<IFileCollectionIterator> Iterator() = 0; 101}; 102 103} // namespace io 104} // namespace aapt 105 106#endif /* AAPT_IO_FILE_H */ 107