src/db/InstrumentsDbUtilities.h

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2007 - 2009 Grigor Iliev                                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#include "../common/global_private.h"

#ifndef __LS_INSTRUMENTSDBUTILITIES_H__
#define __LS_INSTRUMENTSDBUTILITIES_H__

#include <memory>
#include <vector>
#if AC_APPLE_UNIVERSAL_BUILD
# include <libgig/gig.h>
#else
# include <gig.h>
#endif
#include <sqlite3.h>

#include "../common/File.h"
#include "../common/optional.h"

namespace LinuxSampler {

    class DbInstrument {
        public:
            String InstrFile;
            int    InstrNr;
            String FormatFamily;
            String FormatVersion;
            long long int Size;
            String Created;
            String Modified;
            String Description;
            bool   IsDrum;
            String Product;
            String Artists;
            String Keywords;

            DbInstrument() { }
            DbInstrument(const DbInstrument& Instr) { Copy(Instr); }
            void operator=(const DbInstrument& Instr) { Copy(Instr); }
            void Copy(const DbInstrument&);
    };

    class DbDirectory {
        public:
            String Created;
            String Modified;
            String Description;

            DbDirectory() { }
            DbDirectory(const DbDirectory& Dir) { Copy(Dir); }
            void operator=(const DbDirectory& Dir) { Copy(Dir); }
            void Copy(const DbDirectory&);
    };

    class SearchQuery {
        public:
            enum InstrumentType {
                CHROMATIC = 0,
                DRUM = 1,
                BOTH = 2
            };

            String Name;
            std::vector<String> FormatFamilies;
            long long MinSize;
            long long MaxSize;
            String CreatedBefore;
            String CreatedAfter;
            String ModifiedBefore;
            String ModifiedAfter;
            String Description;
            String Product;
            String Artists;
            String Keywords;
            InstrumentType InstrType;
            
            SearchQuery();
            void SetFormatFamilies(String s);
            void SetSize(String s);
            void SetCreated(String s);
            void SetModified(String s);

        private:
            String GetMin(String s);
            String GetMax(String s);
    };

    enum ScanMode {
        RECURSIVE = 0,
        NON_RECURSIVE = 1,
        FLAT = 2
    };

#if __cplusplus >= 201103L && !CONFIG_NO_CPP11STL
    typedef std::unique_ptr<std::vector<int>> IntListPtr;
    typedef std::unique_ptr<std::vector<String>> StringListPtr;
#else
    typedef std::auto_ptr<std::vector<int> > IntListPtr;
    typedef std::auto_ptr<std::vector<String> > StringListPtr;
#endif

    class ScanJob {
        public:
            int JobId;
            int FilesTotal;
            int FilesScanned;
            String Scanning;
            int Status;

            ScanJob() : FilesTotal(0), FilesScanned(0), Status(0) { }
            ScanJob(const ScanJob& Job) { Copy(Job); }
            void operator=(const ScanJob& Job) { Copy(Job); }
            void Copy(const ScanJob&);
    };
    
    class JobList {
        public:
            JobList() { Counter = 0; }

            /**
             * Adds the specified job to the list and keeps the list
             * to have maximum 3 jobs (the oldest one is removed).
             * @returns The ID used to identify this job.
             */
            int AddJob(ScanJob Job);

            /**
             * Returns the job with ID JobId.
             * @throws Exception If job with ID JobId doesn't exist.
             */
            ScanJob& GetJobById(int JobId);

        private:
            std::vector<ScanJob> Jobs;
            int Counter;
    };

    class DirectoryHandler {
        public:
            virtual void ProcessDirectory(String Path, int DirId) = 0;
    };

    class AbstractFinder : public DirectoryHandler {
        public:
            virtual void ProcessDirectory(String Path, int DirId) = 0;

            bool IsRegex(String Pattern);
            void AddSql(String Col, String Pattern, std::stringstream& Sql);

        protected:
            std::vector<String> Params;
    };

    class DirectoryFinder : public AbstractFinder {
        public:
            DirectoryFinder(SearchQuery* pQuery);
            ~DirectoryFinder();
            StringListPtr GetDirectories();
            virtual void ProcessDirectory(String Path, int DirId);

        private:
            sqlite3_stmt* pStmt;
            String SqlQuery;
            SearchQuery* pQuery;
            StringListPtr pDirectories;
    };

    class InstrumentFinder : public AbstractFinder {
        public:
            InstrumentFinder(SearchQuery* pQuery);
            ~InstrumentFinder();
            StringListPtr GetInstruments();
            virtual void ProcessDirectory(String Path, int DirId);

        private:
            sqlite3_stmt* pStmt;
            String SqlQuery;
            SearchQuery* pQuery;
            StringListPtr pInstruments;
    };

    class DirectoryCounter : public DirectoryHandler {
        public:
            DirectoryCounter() { count = 0; }
            virtual void ProcessDirectory(String Path, int DirId);
            int GetDirectoryCount() { return count; }

        private:
            int count;
    };

    class InstrumentCounter : public DirectoryHandler {
        public:
            InstrumentCounter() { count = 0; }
            virtual void ProcessDirectory(String Path, int DirId);
            int GetInstrumentCount() { return count; }

        private:
            int count;
    };

    class DirectoryCopier : public DirectoryHandler {
        public:
            DirectoryCopier(String SrcParentDir, String DestDir);
            virtual void ProcessDirectory(String Path, int DirId);

        private:
            String SrcParentDir;
            String DestDir;
    };

    /**
     * Used to monitor the scan progress of instrument files
     */
    class ScanProgress {
        public:
            ScanProgress();
            
            /**
             * Invoked when there is some progress on the monitored task.
             */
            void StatusChanged();

            /**
             * Gets the total number of files scheduled for scanning.
             */
            int GetTotalFileCount();

            /**
             * Sets the total number of files scheduled for scanning.
             */
            void SetTotalFileCount(int Count);

            /**
             * Gets the current nuber of scanned files.
             */
            int GetScannedFileCount();

            /**
             * Sets the current nuber of scanned files.
             */
            void SetScannedFileCount(int Count);

            /**
             * Returns an integer value between 0 and 100 indicating the
             * scanning progress percentage of the file which is currently
             * being scanned. Negative value indicates an error.
             */
            int GetStatus();

            /**
             * Sets the scanning progress percentage of the file which is
             * currently being scanned. If negative value is specified, the
             * status is set to 0. If value greater then 100 is specified,
             * the status is set to 100.
             */
            void SetStatus(int Status);
            
            /**
             * Sets and error code to indicate task failure.
             * @param Err Should be negative value. If positive value
             * is suplied, it is reverted to negative.
             */
            void SetErrorStatus(int Err);
            
            /**
             * The absolute path name of the file which is currently being scanned.
             */
            String CurrentFile;

            int JobId;
            ::gig::progress_t GigFileProgress;

        private:
            int TotalFileCount;
            int ScannedFileCount;
            int Status;

            static void GigFileProgressCallback(::gig::progress_t* pProgress);
    };

    /**
     * A job which adds the instruments in the specified
     * file to the specified instruments database directory.
     */
    class AddInstrumentsFromFileJob : public Runnable {
        public:
            /**
             * param JobId the ID of this job.
             * @param DbDir The absolute path name of a directory in the
             * instruments database in which only the new instruments
             * (that are not already in the database) will be added.
             * @param FilePath The absolute path name of the instrument file.
             * @param Index The index of the instrument (in the given
             * instrument file) to add. If -1 is specified, all instruments in
             * the supplied instrument file will be added.
                         * @param insDir if true a separate directory will be created for
                         * the gig file.
             */
            AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index = -1, bool insDir = false);
            
            /**
             * The entry point of the job.
             */
            virtual void Run();

            private:
                int JobId;
                String DbDir;
                String FilePath;
                int Index;
                ScanProgress Progress;
                                bool insDir;
    };

    /**
     * A job which adds all supported instruments in the specified
     * directory to the specified instruments database directory.
     */
    class AddInstrumentsJob : public Runnable {
        public:
            /**
             * param JobId the ID of this job.
             * @param Mode Determines the scanning mode. If RECURSIVE is
             * specified, all supported instruments in the specified file system
             * direcotry will be added to the specified instruments database
             * directory, including the instruments in subdirectories
             * of the supplied directory. If NON_RECURSIVE is specified,
             * the instruments in the subdirectories will not be processed.
             * If FLAT is specified, all supported instruments in the specified
             * file system direcotry will be added, including the instruments in
             * subdirectories of the supplied directory, but the respective
             * subdirectory structure will not be recreated in the instruments
             * database and all instruments will be added directly in the
             * specified database directory.
             * @param DbDir The absolute path name of a directory in the
             * instruments database in which only the new instruments
             * (that are not already in the database) will be added.
             * @param FsDir The absolute path name of a directory in the
             * file system.
                         * @param insDir If true a separate directory will be created for 
                         * each gig file
             */
            AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir, bool insDir = false);
            
            /**
             * The entry point of the job.
             */
            virtual void Run();

            private:
                int JobId;
                ScanMode Mode;
                String DbDir;
                String FsDir;
                ScanProgress Progress;
                                bool insDir;

                int GetFileCount();
    };
    
    class DirectoryScanner: public File::DirectoryWalker {
        public:
            /**
             * Recursively scans all subdirectories of the specified file
             * system directory and adds the supported instruments to the database.
                         * @param insDir is true this will create a directory for each gig file.
             * @param pProgress The progress used to monitor the scan process.
             * @throws Exception - if the specified directories are invalid.
             */
           void Scan(String DbDir, String FsDir, bool Flat, bool insDir = false, ScanProgress* pProgress = NULL);

           virtual void DirectoryEntry(std::string Path);
           virtual void FileEntry(std::string Path) { }

        private:
            String DbDir;
            String FsDir;
            bool Flat;
            ScanProgress* pProgress;
            bool HasInstrumentFiles(String Dir);
                        bool insDir;
    };
    
    class InstrumentFileCounter: public File::DirectoryWalker {
        public:
            /**
             * Recursively scans all subdirectories of the specified file
             * system directory and returns the number of supported instrument files.
             * @param FsDir The file system directory to process.
             * @throws Exception - if the specified directory is invalid.
             */
            int Count(String FsDir);

            virtual void DirectoryEntry(std::string Path) { }
            virtual void FileEntry(std::string Path);

        private:
            int FileCount;
    };

    struct InstrumentInfo {
        String instrumentName;
        String product;
        String artists;
        String keywords;
        String comments;
        bool   isDrum;

        InstrumentInfo() : isDrum(false) {}
    };

    class InstrumentFileInfo {
    public:
        virtual ~InstrumentFileInfo() {}
        virtual optional<InstrumentInfo> getInstrumentInfo(int index, ScanProgress* pProgress) = 0;
        virtual String formatName() = 0;
        virtual String formatVersion() = 0;

        static InstrumentFileInfo* getFileInfoFor(String filename);
        static bool isSupportedFile(String filename);

    protected:
        InstrumentFileInfo(String filename) : m_fileName(filename) {}

        String m_fileName;
    };

} // namespace LinuxSampler

#endif // __LS_INSTRUMENTSDBUTILITIES_H__
1	iliev	1200	/***************************************************************************
2			* *
3	persson	1943	* Copyright (C) 2007 - 2009 Grigor Iliev *
4	iliev	1200	* *
5			* This program is free software; you can redistribute it and/or modify *
6			* it under the terms of the GNU General Public License as published by *
7			* the Free Software Foundation; either version 2 of the License, or *
8			* (at your option) any later version. *
9			* *
10			* This program is distributed in the hope that it will be useful, *
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13			* GNU General Public License for more details. *
14			* *
15			* You should have received a copy of the GNU General Public License *
16			* along with this program; if not, write to the Free Software *
17			* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
18			* MA 02110-1301 USA *
19			***************************************************************************/
20
21	schoenebeck	1424	#include "../common/global_private.h"
22	iliev	1200
23			#ifndef __LS_INSTRUMENTSDBUTILITIES_H__
24			#define __LS_INSTRUMENTSDBUTILITIES_H__
25
26	persson	1713	#include <memory>
27	iliev	1200	#include <vector>
28	schoenebeck	3091	#if AC_APPLE_UNIVERSAL_BUILD
29			# include <libgig/gig.h>
30			#else
31			# include <gig.h>
32			#endif
33	iliev	1200	#include <sqlite3.h>
34
35	iliev	1717	#include "../common/File.h"
36	schoenebeck	3092	#include "../common/optional.h"
37	iliev	1717
38	iliev	1200	namespace LinuxSampler {
39
40			class DbInstrument {
41			public:
42			String InstrFile;
43			int InstrNr;
44			String FormatFamily;
45			String FormatVersion;
46			long long int Size;
47			String Created;
48			String Modified;
49			String Description;
50			bool IsDrum;
51			String Product;
52			String Artists;
53			String Keywords;
54
55			DbInstrument() { }
56			DbInstrument(const DbInstrument& Instr) { Copy(Instr); }
57			void operator=(const DbInstrument& Instr) { Copy(Instr); }
58			void Copy(const DbInstrument&);
59			};
60
61			class DbDirectory {
62			public:
63			String Created;
64			String Modified;
65			String Description;
66
67			DbDirectory() { }
68			DbDirectory(const DbDirectory& Dir) { Copy(Dir); }
69			void operator=(const DbDirectory& Dir) { Copy(Dir); }
70			void Copy(const DbDirectory&);
71			};
72
73			class SearchQuery {
74			public:
75			enum InstrumentType {
76			CHROMATIC = 0,
77			DRUM = 1,
78			BOTH = 2
79			};
80
81			String Name;
82			std::vector<String> FormatFamilies;
83			long long MinSize;
84			long long MaxSize;
85			String CreatedBefore;
86			String CreatedAfter;
87			String ModifiedBefore;
88			String ModifiedAfter;
89			String Description;
90			String Product;
91			String Artists;
92			String Keywords;
93			InstrumentType InstrType;
94
95			SearchQuery();
96			void SetFormatFamilies(String s);
97			void SetSize(String s);
98			void SetCreated(String s);
99			void SetModified(String s);
100
101			private:
102			String GetMin(String s);
103			String GetMax(String s);
104			};
105
106			enum ScanMode {
107			RECURSIVE = 0,
108			NON_RECURSIVE = 1,
109			FLAT = 2
110			};
111
112	schoenebeck	3091	#if __cplusplus >= 201103L && !CONFIG_NO_CPP11STL
113	persson	2840	typedef std::unique_ptr<std::vector<int>> IntListPtr;
114			typedef std::unique_ptr<std::vector<String>> StringListPtr;
115			#else
116	iliev	1200	typedef std::auto_ptr<std::vector<int> > IntListPtr;
117			typedef std::auto_ptr<std::vector<String> > StringListPtr;
118	persson	2840	#endif
119	iliev	1200
120			class ScanJob {
121			public:
122			int JobId;
123			int FilesTotal;
124			int FilesScanned;
125			String Scanning;
126			int Status;
127
128	persson	1943	ScanJob() : FilesTotal(0), FilesScanned(0), Status(0) { }
129	iliev	1200	ScanJob(const ScanJob& Job) { Copy(Job); }
130			void operator=(const ScanJob& Job) { Copy(Job); }
131			void Copy(const ScanJob&);
132			};
133
134			class JobList {
135			public:
136			JobList() { Counter = 0; }
137
138			/**
139			* Adds the specified job to the list and keeps the list
140			* to have maximum 3 jobs (the oldest one is removed).
141			* @returns The ID used to identify this job.
142			*/
143			int AddJob(ScanJob Job);
144
145			/**
146			* Returns the job with ID JobId.
147			* @throws Exception If job with ID JobId doesn't exist.
148			*/
149			ScanJob& GetJobById(int JobId);
150
151			private:
152			std::vector<ScanJob> Jobs;
153			int Counter;
154			};
155
156			class DirectoryHandler {
157			public:
158			virtual void ProcessDirectory(String Path, int DirId) = 0;
159			};
160
161			class AbstractFinder : public DirectoryHandler {
162			public:
163			virtual void ProcessDirectory(String Path, int DirId) = 0;
164
165			bool IsRegex(String Pattern);
166			void AddSql(String Col, String Pattern, std::stringstream& Sql);
167
168			protected:
169			std::vector<String> Params;
170			};
171
172			class DirectoryFinder : public AbstractFinder {
173			public:
174			DirectoryFinder(SearchQuery* pQuery);
175			~DirectoryFinder();
176			StringListPtr GetDirectories();
177			virtual void ProcessDirectory(String Path, int DirId);
178
179			private:
180			sqlite3_stmt* pStmt;
181			String SqlQuery;
182			SearchQuery* pQuery;
183			StringListPtr pDirectories;
184			};
185
186			class InstrumentFinder : public AbstractFinder {
187			public:
188			InstrumentFinder(SearchQuery* pQuery);
189			~InstrumentFinder();
190			StringListPtr GetInstruments();
191			virtual void ProcessDirectory(String Path, int DirId);
192
193			private:
194			sqlite3_stmt* pStmt;
195			String SqlQuery;
196			SearchQuery* pQuery;
197			StringListPtr pInstruments;
198			};
199
200			class DirectoryCounter : public DirectoryHandler {
201			public:
202			DirectoryCounter() { count = 0; }
203			virtual void ProcessDirectory(String Path, int DirId);
204			int GetDirectoryCount() { return count; }
205
206			private:
207			int count;
208			};
209
210			class InstrumentCounter : public DirectoryHandler {
211			public:
212			InstrumentCounter() { count = 0; }
213			virtual void ProcessDirectory(String Path, int DirId);
214			int GetInstrumentCount() { return count; }
215
216			private:
217			int count;
218			};
219
220			class DirectoryCopier : public DirectoryHandler {
221			public:
222			DirectoryCopier(String SrcParentDir, String DestDir);
223			virtual void ProcessDirectory(String Path, int DirId);
224
225			private:
226			String SrcParentDir;
227			String DestDir;
228			};
229
230			/**
231			* Used to monitor the scan progress of instrument files
232			*/
233			class ScanProgress {
234			public:
235			ScanProgress();
236
237			/**
238			* Invoked when there is some progress on the monitored task.
239			*/
240			void StatusChanged();
241
242			/**
243			* Gets the total number of files scheduled for scanning.
244			*/
245			int GetTotalFileCount();
246
247			/**
248			* Sets the total number of files scheduled for scanning.
249			*/
250			void SetTotalFileCount(int Count);
251
252			/**
253			* Gets the current nuber of scanned files.
254			*/
255			int GetScannedFileCount();
256
257			/**
258			* Sets the current nuber of scanned files.
259			*/
260			void SetScannedFileCount(int Count);
261
262			/**
263			* Returns an integer value between 0 and 100 indicating the
264			* scanning progress percentage of the file which is currently
265			* being scanned. Negative value indicates an error.
266			*/
267			int GetStatus();
268
269			/**
270			* Sets the scanning progress percentage of the file which is
271			* currently being scanned. If negative value is specified, the
272			* status is set to 0. If value greater then 100 is specified,
273			* the status is set to 100.
274			*/
275			void SetStatus(int Status);
276
277			/**
278			* Sets and error code to indicate task failure.
279			* @param Err Should be negative value. If positive value
280			* is suplied, it is reverted to negative.
281			*/
282			void SetErrorStatus(int Err);
283
284			/**
285			* The absolute path name of the file which is currently being scanned.
286			*/
287			String CurrentFile;
288
289			int JobId;
290	schoenebeck	2684	::gig::progress_t GigFileProgress;
291	iliev	1200
292			private:
293			int TotalFileCount;
294			int ScannedFileCount;
295			int Status;
296
297			static void GigFileProgressCallback(::gig::progress_t* pProgress);
298			};
299
300			/**
301			* A job which adds the instruments in the specified
302			* file to the specified instruments database directory.
303			*/
304			class AddInstrumentsFromFileJob : public Runnable {
305			public:
306			/**
307			* param JobId the ID of this job.
308			* @param DbDir The absolute path name of a directory in the
309			* instruments database in which only the new instruments
310			* (that are not already in the database) will be added.
311			* @param FilePath The absolute path name of the instrument file.
312			* @param Index The index of the instrument (in the given
313			* instrument file) to add. If -1 is specified, all instruments in
314			* the supplied instrument file will be added.
315	iliev	1781	* @param insDir if true a separate directory will be created for
316			* the gig file.
317	iliev	1200	*/
318	iliev	1781	AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index = -1, bool insDir = false);
319	iliev	1200
320			/**
321			* The entry point of the job.
322			*/
323			virtual void Run();
324
325			private:
326			int JobId;
327			String DbDir;
328			String FilePath;
329			int Index;
330			ScanProgress Progress;
331	iliev	1781	bool insDir;
332	iliev	1200	};
333
334			/**
335			* A job which adds all supported instruments in the specified
336			* directory to the specified instruments database directory.
337			*/
338			class AddInstrumentsJob : public Runnable {
339			public:
340			/**
341			* param JobId the ID of this job.
342			* @param Mode Determines the scanning mode. If RECURSIVE is
343			* specified, all supported instruments in the specified file system
344			* direcotry will be added to the specified instruments database
345			* directory, including the instruments in subdirectories
346			* of the supplied directory. If NON_RECURSIVE is specified,
347			* the instruments in the subdirectories will not be processed.
348			* If FLAT is specified, all supported instruments in the specified
349			* file system direcotry will be added, including the instruments in
350			* subdirectories of the supplied directory, but the respective
351			* subdirectory structure will not be recreated in the instruments
352			* database and all instruments will be added directly in the
353			* specified database directory.
354			* @param DbDir The absolute path name of a directory in the
355			* instruments database in which only the new instruments
356			* (that are not already in the database) will be added.
357			* @param FsDir The absolute path name of a directory in the
358			* file system.
359	iliev	1781	* @param insDir If true a separate directory will be created for
360			* each gig file
361	iliev	1200	*/
362	iliev	1781	AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir, bool insDir = false);
363	iliev	1200
364			/**
365			* The entry point of the job.
366			*/
367			virtual void Run();
368
369			private:
370			int JobId;
371			ScanMode Mode;
372			String DbDir;
373			String FsDir;
374			ScanProgress Progress;
375	iliev	1781	bool insDir;
376	iliev	1200
377			int GetFileCount();
378			};
379
380	iliev	1717	class DirectoryScanner: public File::DirectoryWalker {
381	iliev	1200	public:
382			/**
383			* Recursively scans all subdirectories of the specified file
384			* system directory and adds the supported instruments to the database.
385	iliev	1781	* @param insDir is true this will create a directory for each gig file.
386	iliev	1200	* @param pProgress The progress used to monitor the scan process.
387			* @throws Exception - if the specified directories are invalid.
388			*/
389	iliev	1781	void Scan(String DbDir, String FsDir, bool Flat, bool insDir = false, ScanProgress* pProgress = NULL);
390	iliev	1200
391	iliev	1717	virtual void DirectoryEntry(std::string Path);
392			virtual void FileEntry(std::string Path) { }
393
394	iliev	1200	private:
395	iliev	1717	String DbDir;
396			String FsDir;
397			bool Flat;
398			ScanProgress* pProgress;
399			bool HasInstrumentFiles(String Dir);
400	iliev	1781	bool insDir;
401	iliev	1200	};
402
403	iliev	1717	class InstrumentFileCounter: public File::DirectoryWalker {
404	iliev	1200	public:
405			/**
406			* Recursively scans all subdirectories of the specified file
407	iliev	1208	* system directory and returns the number of supported instrument files.
408	iliev	1200	* @param FsDir The file system directory to process.
409			* @throws Exception - if the specified directory is invalid.
410			*/
411	iliev	1717	int Count(String FsDir);
412	iliev	1200
413	iliev	1717	virtual void DirectoryEntry(std::string Path) { }
414			virtual void FileEntry(std::string Path);
415	iliev	1200
416			private:
417	iliev	1717	int FileCount;
418	iliev	1200	};
419	schoenebeck	3092
420			struct InstrumentInfo {
421			String instrumentName;
422			String product;
423			String artists;
424			String keywords;
425			String comments;
426			bool isDrum;
427
428			InstrumentInfo() : isDrum(false) {}
429			};
430
431			class InstrumentFileInfo {
432			public:
433			virtual ~InstrumentFileInfo() {}
434			virtual optional<InstrumentInfo> getInstrumentInfo(int index, ScanProgress* pProgress) = 0;
435			virtual String formatName() = 0;
436			virtual String formatVersion() = 0;
437
438			static InstrumentFileInfo* getFileInfoFor(String filename);
439			static bool isSupportedFile(String filename);
440
441			protected:
442			InstrumentFileInfo(String filename) : m_fileName(filename) {}
443
444			String m_fileName;
445			};
446
447	iliev	1200	} // namespace LinuxSampler
448
449			#endif // __LS_INSTRUMENTSDBUTILITIES_H__