src/db/InstrumentsDbUtilities.h

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2007 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.h"

#if HAVE_SQLITE3

#ifndef __LS_INSTRUMENTSDBUTILITIES_H__
#define __LS_INSTRUMENTSDBUTILITIES_H__

#include <vector>
#include <gig.h>
#include <sqlite3.h>
#include <sys/stat.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
    };

    typedef std::auto_ptr<std::vector<int> > IntListPtr;
    typedef std::auto_ptr<std::vector<String> > StringListPtr;

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

            ScanJob() { }
            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;
            struct ::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.
             */
            AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index = -1);
            
            /**
             * The entry point of the job.
             */
            virtual void Run();

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

    /**
     * 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.
             */
            AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir);
            
            /**
             * The entry point of the job.
             */
            virtual void Run();

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

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

        private:
            static String DbDir;
            static String FsDir;
            static bool Flat;
            static ScanProgress* pProgress;
            static int FtwCallback(const char* fpath, const struct stat* sb, int typeflag);
            static bool HasInstrumentFiles(String Dir);
    };
    
    class InstrumentFileCounter {
        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.
             */
            static int Count(String FsDir);

            static int FtwCallback(const char* fpath, const struct stat* sb, int typeflag);

        private:
            static int FileCount;
    };
            
} // namespace LinuxSampler

#endif // __LS_INSTRUMENTSDBUTILITIES_H__

#endif // HAVE_SQLITE3
1	/***************************************************************************
2	* *
3	* Copyright (C) 2007 Grigor Iliev *
4	* *
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	#include "../common/global.h"
22
23	#if HAVE_SQLITE3
24
25	#ifndef __LS_INSTRUMENTSDBUTILITIES_H__
26	#define __LS_INSTRUMENTSDBUTILITIES_H__
27
28	#include <vector>
29	#include <gig.h>
30	#include <sqlite3.h>
31	#include <sys/stat.h>
32
33	namespace LinuxSampler {
34
35	class DbInstrument {
36	public:
37	String InstrFile;
38	int InstrNr;
39	String FormatFamily;
40	String FormatVersion;
41	long long int Size;
42	String Created;
43	String Modified;
44	String Description;
45	bool IsDrum;
46	String Product;
47	String Artists;
48	String Keywords;
49
50	DbInstrument() { }
51	DbInstrument(const DbInstrument& Instr) { Copy(Instr); }
52	void operator=(const DbInstrument& Instr) { Copy(Instr); }
53	void Copy(const DbInstrument&);
54	};
55
56	class DbDirectory {
57	public:
58	String Created;
59	String Modified;
60	String Description;
61
62	DbDirectory() { }
63	DbDirectory(const DbDirectory& Dir) { Copy(Dir); }
64	void operator=(const DbDirectory& Dir) { Copy(Dir); }
65	void Copy(const DbDirectory&);
66	};
67
68	class SearchQuery {
69	public:
70	enum InstrumentType {
71	CHROMATIC = 0,
72	DRUM = 1,
73	BOTH = 2
74	};
75
76	String Name;
77	std::vector<String> FormatFamilies;
78	long long MinSize;
79	long long MaxSize;
80	String CreatedBefore;
81	String CreatedAfter;
82	String ModifiedBefore;
83	String ModifiedAfter;
84	String Description;
85	String Product;
86	String Artists;
87	String Keywords;
88	InstrumentType InstrType;
89
90	SearchQuery();
91	void SetFormatFamilies(String s);
92	void SetSize(String s);
93	void SetCreated(String s);
94	void SetModified(String s);
95
96	private:
97	String GetMin(String s);
98	String GetMax(String s);
99	};
100
101	enum ScanMode {
102	RECURSIVE = 0,
103	NON_RECURSIVE = 1,
104	FLAT = 2
105	};
106
107	typedef std::auto_ptr<std::vector<int> > IntListPtr;
108	typedef std::auto_ptr<std::vector<String> > StringListPtr;
109
110	class ScanJob {
111	public:
112	int JobId;
113	int FilesTotal;
114	int FilesScanned;
115	String Scanning;
116	int Status;
117
118	ScanJob() { }
119	ScanJob(const ScanJob& Job) { Copy(Job); }
120	void operator=(const ScanJob& Job) { Copy(Job); }
121	void Copy(const ScanJob&);
122	};
123
124	class JobList {
125	public:
126	JobList() { Counter = 0; }
127
128	/**
129	* Adds the specified job to the list and keeps the list
130	* to have maximum 3 jobs (the oldest one is removed).
131	* @returns The ID used to identify this job.
132	*/
133	int AddJob(ScanJob Job);
134
135	/**
136	* Returns the job with ID JobId.
137	* @throws Exception If job with ID JobId doesn't exist.
138	*/
139	ScanJob& GetJobById(int JobId);
140
141	private:
142	std::vector<ScanJob> Jobs;
143	int Counter;
144	};
145
146	class DirectoryHandler {
147	public:
148	virtual void ProcessDirectory(String Path, int DirId) = 0;
149	};
150
151	class AbstractFinder : public DirectoryHandler {
152	public:
153	virtual void ProcessDirectory(String Path, int DirId) = 0;
154
155	bool IsRegex(String Pattern);
156	void AddSql(String Col, String Pattern, std::stringstream& Sql);
157
158	protected:
159	std::vector<String> Params;
160	};
161
162	class DirectoryFinder : public AbstractFinder {
163	public:
164	DirectoryFinder(SearchQuery* pQuery);
165	~DirectoryFinder();
166	StringListPtr GetDirectories();
167	virtual void ProcessDirectory(String Path, int DirId);
168
169	private:
170	sqlite3_stmt* pStmt;
171	String SqlQuery;
172	SearchQuery* pQuery;
173	StringListPtr pDirectories;
174	};
175
176	class InstrumentFinder : public AbstractFinder {
177	public:
178	InstrumentFinder(SearchQuery* pQuery);
179	~InstrumentFinder();
180	StringListPtr GetInstruments();
181	virtual void ProcessDirectory(String Path, int DirId);
182
183	private:
184	sqlite3_stmt* pStmt;
185	String SqlQuery;
186	SearchQuery* pQuery;
187	StringListPtr pInstruments;
188	};
189
190	class DirectoryCounter : public DirectoryHandler {
191	public:
192	DirectoryCounter() { count = 0; }
193	virtual void ProcessDirectory(String Path, int DirId);
194	int GetDirectoryCount() { return count; }
195
196	private:
197	int count;
198	};
199
200	class InstrumentCounter : public DirectoryHandler {
201	public:
202	InstrumentCounter() { count = 0; }
203	virtual void ProcessDirectory(String Path, int DirId);
204	int GetInstrumentCount() { return count; }
205
206	private:
207	int count;
208	};
209
210	class DirectoryCopier : public DirectoryHandler {
211	public:
212	DirectoryCopier(String SrcParentDir, String DestDir);
213	virtual void ProcessDirectory(String Path, int DirId);
214
215	private:
216	String SrcParentDir;
217	String DestDir;
218	};
219
220	/**
221	* Used to monitor the scan progress of instrument files
222	*/
223	class ScanProgress {
224	public:
225	ScanProgress();
226
227	/**
228	* Invoked when there is some progress on the monitored task.
229	*/
230	void StatusChanged();
231
232	/**
233	* Gets the total number of files scheduled for scanning.
234	*/
235	int GetTotalFileCount();
236
237	/**
238	* Sets the total number of files scheduled for scanning.
239	*/
240	void SetTotalFileCount(int Count);
241
242	/**
243	* Gets the current nuber of scanned files.
244	*/
245	int GetScannedFileCount();
246
247	/**
248	* Sets the current nuber of scanned files.
249	*/
250	void SetScannedFileCount(int Count);
251
252	/**
253	* Returns an integer value between 0 and 100 indicating the
254	* scanning progress percentage of the file which is currently
255	* being scanned. Negative value indicates an error.
256	*/
257	int GetStatus();
258
259	/**
260	* Sets the scanning progress percentage of the file which is
261	* currently being scanned. If negative value is specified, the
262	* status is set to 0. If value greater then 100 is specified,
263	* the status is set to 100.
264	*/
265	void SetStatus(int Status);
266
267	/**
268	* Sets and error code to indicate task failure.
269	* @param Err Should be negative value. If positive value
270	* is suplied, it is reverted to negative.
271	*/
272	void SetErrorStatus(int Err);
273
274	/**
275	* The absolute path name of the file which is currently being scanned.
276	*/
277	String CurrentFile;
278
279	int JobId;
280	struct ::gig::progress_t GigFileProgress;
281
282	private:
283	int TotalFileCount;
284	int ScannedFileCount;
285	int Status;
286
287	static void GigFileProgressCallback(::gig::progress_t* pProgress);
288	};
289
290	/**
291	* A job which adds the instruments in the specified
292	* file to the specified instruments database directory.
293	*/
294	class AddInstrumentsFromFileJob : public Runnable {
295	public:
296	/**
297	* param JobId the ID of this job.
298	* @param DbDir The absolute path name of a directory in the
299	* instruments database in which only the new instruments
300	* (that are not already in the database) will be added.
301	* @param FilePath The absolute path name of the instrument file.
302	* @param Index The index of the instrument (in the given
303	* instrument file) to add. If -1 is specified, all instruments in
304	* the supplied instrument file will be added.
305	*/
306	AddInstrumentsFromFileJob(int JobId, String DbDir, String FilePath, int Index = -1);
307
308	/**
309	* The entry point of the job.
310	*/
311	virtual void Run();
312
313	private:
314	int JobId;
315	String DbDir;
316	String FilePath;
317	int Index;
318	ScanProgress Progress;
319	};
320
321	/**
322	* A job which adds all supported instruments in the specified
323	* directory to the specified instruments database directory.
324	*/
325	class AddInstrumentsJob : public Runnable {
326	public:
327	/**
328	* param JobId the ID of this job.
329	* @param Mode Determines the scanning mode. If RECURSIVE is
330	* specified, all supported instruments in the specified file system
331	* direcotry will be added to the specified instruments database
332	* directory, including the instruments in subdirectories
333	* of the supplied directory. If NON_RECURSIVE is specified,
334	* the instruments in the subdirectories will not be processed.
335	* If FLAT is specified, all supported instruments in the specified
336	* file system direcotry will be added, including the instruments in
337	* subdirectories of the supplied directory, but the respective
338	* subdirectory structure will not be recreated in the instruments
339	* database and all instruments will be added directly in the
340	* specified database directory.
341	* @param DbDir The absolute path name of a directory in the
342	* instruments database in which only the new instruments
343	* (that are not already in the database) will be added.
344	* @param FsDir The absolute path name of a directory in the
345	* file system.
346	*/
347	AddInstrumentsJob(int JobId, ScanMode Mode, String DbDir, String FsDir);
348
349	/**
350	* The entry point of the job.
351	*/
352	virtual void Run();
353
354	private:
355	int JobId;
356	ScanMode Mode;
357	String DbDir;
358	String FsDir;
359	ScanProgress Progress;
360
361	int GetFileCount();
362	};
363
364	class DirectoryScanner {
365	public:
366	/**
367	* Recursively scans all subdirectories of the specified file
368	* system directory and adds the supported instruments to the database.
369	* @param pProgress The progress used to monitor the scan process.
370	* @throws Exception - if the specified directories are invalid.
371	*/
372	static void Scan(String DbDir, String FsDir, bool Flat, ScanProgress* pProgress = NULL);
373
374	private:
375	static String DbDir;
376	static String FsDir;
377	static bool Flat;
378	static ScanProgress* pProgress;
379	static int FtwCallback(const char* fpath, const struct stat* sb, int typeflag);
380	static bool HasInstrumentFiles(String Dir);
381	};
382
383	class InstrumentFileCounter {
384	public:
385	/**
386	* Recursively scans all subdirectories of the specified file
387	* system directory and returns the number of supported instrument files.
388	* @param FsDir The file system directory to process.
389	* @throws Exception - if the specified directory is invalid.
390	*/
391	static int Count(String FsDir);
392
393	static int FtwCallback(const char* fpath, const struct stat* sb, int typeflag);
394
395	private:
396	static int FileCount;
397	};
398
399	} // namespace LinuxSampler
400
401	#endif // __LS_INSTRUMENTSDBUTILITIES_H__
402
403	#endif // HAVE_SQLITE3