1/***************************************************************************
2 copyright : (C) 2002 - 2008 by Scott Wheeler
3 email : wheeler@kde.org
4 ***************************************************************************/
5
6/***************************************************************************
7 * This library is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU Lesser General Public License version *
9 * 2.1 as published by the Free Software Foundation. *
10 * *
11 * This library is distributed in the hope that it will be useful, but *
12 * WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14 * Lesser General Public License for more details. *
15 * *
16 * You should have received a copy of the GNU Lesser General Public *
17 * License along with this library; if not, write to the Free Software *
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA *
19 * 02110-1301 USA *
20 * *
21 * Alternatively, this file is available under the Mozilla Public *
22 * License Version 1.1. You may obtain a copy of the License at *
23 * http://www.mozilla.org/MPL/ *
24 ***************************************************************************/
25
26#ifndef TAGLIB_FILEREF_H
27#define TAGLIB_FILEREF_H
28
29#include "tfile.h"
30#include "tstringlist.h"
31
32#include "taglib_export.h"
33#include "audioproperties.h"
34
35namespace TagLib {
36
37 class Tag;
38
39 //! This class provides a simple abstraction for creating and handling files
40
41 /*!
42 * FileRef exists to provide a minimal, generic and value-based wrapper around
43 * a File. It is lightweight and implicitly shared, and as such suitable for
44 * pass-by-value use. This hides some of the uglier details of TagLib::File
45 * and the non-generic portions of the concrete file implementations.
46 *
47 * This class is useful in a "simple usage" situation where it is desirable
48 * to be able to get and set some of the tag information that is similar
49 * across file types.
50 *
51 * Also note that it is probably a good idea to plug this into your mime
52 * type system rather than using the constructor that accepts a file name using
53 * the FileTypeResolver.
54 *
55 * \see FileTypeResolver
56 * \see addFileTypeResolver()
57 */
58
59 class TAGLIB_EXPORT FileRef
60 {
61 public:
62
63 //! A class for pluggable file type resolution.
64
65 /*!
66 * This class is used to add extend TagLib's very basic file name based file
67 * type resolution.
68 *
69 * This can be accomplished with:
70 *
71 * \code
72 *
73 * class MyFileTypeResolver : FileTypeResolver
74 * {
75 * TagLib::File *createFile(TagLib::FileName *fileName, bool, AudioProperties::ReadStyle) const
76 * {
77 * if(someCheckForAnMP3File(fileName))
78 * return new TagLib::MPEG::File(fileName);
79 * return 0;
80 * }
81 * }
82 *
83 * FileRef::addFileTypeResolver(new MyFileTypeResolver);
84 *
85 * \endcode
86 *
87 * Naturally a less contrived example would be slightly more complex. This
88 * can be used to plug in mime-type detection systems or to add new file types
89 * to TagLib.
90 */
91
92 class TAGLIB_EXPORT FileTypeResolver
93 {
94 TAGLIB_IGNORE_MISSING_DESTRUCTOR
95 public:
96 /*!
97 * This method must be overridden to provide an additional file type
98 * resolver. If the resolver is able to determine the file type it should
99 * return a valid File object; if not it should return 0.
100 *
101 * \note The created file is then owned by the FileRef and should not be
102 * deleted. Deletion will happen automatically when the FileRef passes
103 * out of scope.
104 */
105 virtual File *createFile(FileName fileName,
106 bool readAudioProperties = true,
107 AudioProperties::ReadStyle
108 audioPropertiesStyle = AudioProperties::Average) const = 0;
109 };
110
111 /*!
112 * Creates a null FileRef.
113 */
114 FileRef();
115
116 /*!
117 * Create a FileRef from \a fileName. If \a readAudioProperties is true then
118 * the audio properties will be read using \a audioPropertiesStyle. If
119 * \a readAudioProperties is false then \a audioPropertiesStyle will be
120 * ignored.
121 *
122 * Also see the note in the class documentation about why you may not want to
123 * use this method in your application.
124 */
125 explicit FileRef(FileName fileName,
126 bool readAudioProperties = true,
127 AudioProperties::ReadStyle
128 audioPropertiesStyle = AudioProperties::Average);
129
130 /*!
131 * Construct a FileRef from an opened \a IOStream. If \a readAudioProperties
132 * is true then the audio properties will be read using \a audioPropertiesStyle.
133 * If \a readAudioProperties is false then \a audioPropertiesStyle will be
134 * ignored.
135 *
136 * Also see the note in the class documentation about why you may not want to
137 * use this method in your application.
138 *
139 * \note TagLib will *not* take ownership of the stream, the caller is
140 * responsible for deleting it after the File object.
141 */
142 explicit FileRef(IOStream* stream,
143 bool readAudioProperties = true,
144 AudioProperties::ReadStyle
145 audioPropertiesStyle = AudioProperties::Average);
146
147 /*!
148 * Construct a FileRef using \a file. The FileRef now takes ownership of the
149 * pointer and will delete the File when it passes out of scope.
150 */
151 explicit FileRef(File *file);
152
153 /*!
154 * Make a copy of \a ref.
155 */
156 FileRef(const FileRef &ref);
157
158 /*!
159 * Destroys this FileRef instance.
160 */
161 virtual ~FileRef();
162
163 /*!
164 * Returns a pointer to represented file's tag.
165 *
166 * \warning This pointer will become invalid when this FileRef and all
167 * copies pass out of scope.
168 *
169 * \warning Do not cast it to any subclasses of \class Tag.
170 * Use tag returning methods of appropriate subclasses of \class File instead.
171 *
172 * \see File::tag()
173 */
174 Tag *tag() const;
175
176 /*!
177 * Returns the audio properties for this FileRef. If no audio properties
178 * were read then this will returns a null pointer.
179 */
180 AudioProperties *audioProperties() const;
181
182 /*!
183 * Returns a pointer to the file represented by this handler class.
184 *
185 * As a general rule this call should be avoided since if you need to work
186 * with file objects directly, you are probably better served instantiating
187 * the File subclasses (i.e. MPEG::File) manually and working with their APIs.
188 *
189 * This <i>handle</i> exists to provide a minimal, generic and value-based
190 * wrapper around a File. Accessing the file directly generally indicates
191 * a moving away from this simplicity (and into things beyond the scope of
192 * FileRef).
193 *
194 * \warning This pointer will become invalid when this FileRef and all
195 * copies pass out of scope.
196 */
197 File *file() const;
198
199 /*!
200 * Saves the file. Returns true on success.
201 */
202 bool save();
203
204 /*!
205 * Adds a FileTypeResolver to the list of those used by TagLib. Each
206 * additional FileTypeResolver is added to the front of a list of resolvers
207 * that are tried. If the FileTypeResolver returns zero the next resolver
208 * is tried.
209 *
210 * Returns a pointer to the added resolver (the same one that's passed in --
211 * this is mostly so that static initializers have something to use for
212 * assignment).
213 *
214 * \see FileTypeResolver
215 */
216 static const FileTypeResolver *addFileTypeResolver(const FileTypeResolver *resolver);
217
218 /*!
219 * As is mentioned elsewhere in this class's documentation, the default file
220 * type resolution code provided by TagLib only works by comparing file
221 * extensions.
222 *
223 * This method returns the list of file extensions that are used by default.
224 *
225 * The extensions are all returned in lowercase, though the comparison used
226 * by TagLib for resolution is case-insensitive.
227 *
228 * \note This does not account for any additional file type resolvers that
229 * are plugged in. Also note that this is not intended to replace a proper
230 * mime-type resolution system, but is just here for reference.
231 *
232 * \see FileTypeResolver
233 */
234 static StringList defaultFileExtensions();
235
236 /*!
237 * Returns true if the file (and as such other pointers) are null.
238 */
239 bool isNull() const;
240
241 /*!
242 * Assign the file pointed to by \a ref to this FileRef.
243 */
244 FileRef &operator=(const FileRef &ref);
245
246 /*!
247 * Exchanges the content of the FileRef by the content of \a ref.
248 */
249 void swap(FileRef &ref);
250
251 /*!
252 * Returns true if this FileRef and \a ref point to the same File object.
253 */
254 bool operator==(const FileRef &ref) const;
255
256 /*!
257 * Returns true if this FileRef and \a ref do not point to the same File
258 * object.
259 */
260 bool operator!=(const FileRef &ref) const;
261
262 /*!
263 * A simple implementation of file type guessing. If \a readAudioProperties
264 * is true then the audio properties will be read using
265 * \a audioPropertiesStyle. If \a readAudioProperties is false then
266 * \a audioPropertiesStyle will be ignored.
267 *
268 * \note You generally shouldn't use this method, but instead the constructor
269 * directly.
270 *
271 * \deprecated
272 */
273 static File *create(FileName fileName,
274 bool readAudioProperties = true,
275 AudioProperties::ReadStyle audioPropertiesStyle = AudioProperties::Average);
276
277
278 private:
279 class FileRefPrivate;
280 FileRefPrivate *d;
281 };
282
283} // namespace TagLib
284
285#endif
286