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