/[svn]/linuxsampler/trunk/src/db/InstrumentsDb.h
ViewVC logotype

Annotation of /linuxsampler/trunk/src/db/InstrumentsDb.h

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1187 - (hide annotations) (download) (as text)
Wed May 16 14:22:26 2007 UTC (17 years ago) by iliev
File MIME type: text/x-c++hdr
File size: 37741 byte(s) 
* updated instruments db support
* added transactions for improving the db performance
* added commands for copying and finding instruments and directories
1 iliev 1161 /***************************************************************************
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_INSTRUMENTSDB_H__
26     #define __LS_INSTRUMENTSDB_H__
27    
28     #include <sqlite3.h>
29     #include <vector>
30     #include <sys/stat.h>
31     #include <gig.h>
32     #include "../common/Mutex.h"
33     #include "../EventListeners.h"
34    
35     namespace LinuxSampler {
36    
37     class DbInstrument {
38     public:
39     String InstrFile;
40     int InstrNr;
41     String FormatFamily;
42     String FormatVersion;
43     long long int Size;
44     String Created;
45     String Modified;
46     String Description;
47     bool IsDrum;
48     String Product;
49     String Artists;
50     String Keywords;
51    
52     DbInstrument() { }
53     DbInstrument(const DbInstrument& Instr) { Copy(Instr); }
54     void operator=(const DbInstrument& Instr) { Copy(Instr); }
55     void Copy(const DbInstrument&);
56     };
57    
58     class DbDirectory {
59     public:
60     String Created;
61     String Modified;
62     String Description;
63    
64     DbDirectory() { }
65     DbDirectory(const DbDirectory& Dir) { Copy(Dir); }
66     void operator=(const DbDirectory& Dir) { Copy(Dir); }
67     void Copy(const DbDirectory&);
68     };
69 iliev 1187
70     class SearchQuery {
71     public:
72     enum InstrumentType {
73     CHROMATIC = 0,
74     DRUM = 1,
75     BOTH = 2
76     };
77    
78     String Name;
79     std::vector<String> FormatFamilies;
80     long long MinSize;
81     long long MaxSize;
82     String CreatedBefore;
83     String CreatedAfter;
84     String ModifiedBefore;
85     String ModifiedAfter;
86     String Description;
87     String Product;
88     String Artists;
89     String Keywords;
90     InstrumentType InstrType;
91    
92     SearchQuery();
93     void SetFormatFamilies(String s);
94     void SetSize(String s);
95     void SetCreated(String s);
96     void SetModified(String s);
97    
98     private:
99     String GetMin(String s);
100     String GetMax(String s);
101     };
102    
103 iliev 1161 typedef std::auto_ptr<std::vector<int> > IntListPtr;
104     typedef std::auto_ptr<std::vector<String> > StringListPtr;
105    
106     /**
107     * @brief Provides access to the instruments database.
108     */
109     class InstrumentsDb {
110     public:
111    
112     /**
113     * This class is used as a listener, which is notified when
114     * changes to the instruments database are made.
115     */
116     class Listener {
117     public:
118     /**
119     * Invoked when the number of instrument directories
120     * in a specific directory has changed.
121     * @param Dir The absolute pathname of the directory in
122     * which the number of directories is changed.
123     */
124     virtual void DirectoryCountChanged(String Dir) = 0;
125    
126     /**
127     * Invoked when the settings of an instrument directory
128     * are changed.
129     * @param Dir The absolute pathname of the directory
130     * whose settings are changed.
131     */
132     virtual void DirectoryInfoChanged(String Dir) = 0;
133    
134     /**
135     * Invoked when an instrument directory is renamed.
136     * @param Dir The old absolute pathname of the directory.
137     * @param NewName The new name of the directory.
138     */
139     virtual void DirectoryNameChanged(String Dir, String NewName) = 0;
140    
141     /**
142     * Invoked when the number of instruments
143     * in a specific directory has changed.
144     * @param Dir The absolute pathname of the directory in
145     * which the number of instruments is changed.
146     */
147     virtual void InstrumentCountChanged(String Dir) = 0;
148    
149     /**
150     * Invoked when the settings of an instrument are changed.
151     * @param Instr The absolute pathname of the instrument
152     * whose settings are changed.
153     */
154     virtual void InstrumentInfoChanged(String Instr) = 0;
155    
156     /**
157     * Invoked when an instrument is renamed.
158     * @param Instr The old absolute pathname of the instrument.
159     * @param NewName The new name of the directory.
160     */
161     virtual void InstrumentNameChanged(String Instr, String NewName) = 0;
162     };
163    
164     /**
165     * Registers the specified listener to be notified
166     * when changes to the instruments database are made.
167     */
168     void AddInstrumentsDbListener(InstrumentsDb::Listener* l);
169    
170     /**
171     * Removes the specified listener.
172     */
173     void RemoveInstrumentsDbListener(InstrumentsDb::Listener* l);
174    
175     /**
176 iliev 1187 * Creates an instruments database file.
177     * @param File the pathname of the file to create.
178     * @throws Exception If the creation of the database file failed.
179     */
180     static void CreateInstrumentsDb(String File);
181    
182     /**
183 iliev 1161 * This method is used to access the instruments database.
184     */
185     static InstrumentsDb* GetInstrumentsDb();
186    
187     /**
188     * Sets the absolute path name of the instruments database file to use.
189     * The instruments database file location should be set before
190     * any attempt to access the database and once set could not be changed.
191     * @throws Exception - if an empty string is provided or if
192     * the method is called more than once.
193     */
194     void SetDbFile(String File);
195    
196     /**
197     * Gets the number of directories in the specified directory.
198     * @param Dir The absolute path name of the directory.
199 iliev 1187 * @param Recursive If true, the number of all directories
200     * in the specified subtree will be returned.
201 iliev 1161 * @throws Exception - if database error occurs, or
202     * the specified path name is invalid.
203 iliev 1163 * @returns The number of directories in the specified directory.
204 iliev 1161 */
205 iliev 1187 int GetDirectoryCount(String Dir, bool Recursive);
206 iliev 1161
207     /**
208     * Gets the list of directories in the specified directory.
209     * @param Dir The absolute path name of the directory.
210 iliev 1187 * @param Recursive If true, all directories
211     * in the specified subtree will be returned.
212 iliev 1161 * @throws Exception - if database error occurs, or
213     * the specified path name is invalid.
214     */
215 iliev 1187 StringListPtr GetDirectories(String Dir, bool Recursive);
216 iliev 1161
217     /**
218     * Adds the specified directory to the database.
219     * @param Dir The absolute path name of the directory to add.
220     * @throws Exception - if database error occurs, or the
221     * specified path is invalid.
222     */
223     void AddDirectory(String Dir);
224    
225     /**
226     * Removes the specified directory from the database.
227     * @param Dir The absolute path name of the directory to remove.
228     * @throws Exception - If the specified path is invalid, or
229     * Force is false and the specified directory is
230     * not empty, or if database error occurs.
231     */
232     void RemoveDirectory(String Dir, bool Force = false);
233    
234     /**
235     * Determines whether the specified directory exists in the database.
236     * @throws Exception - If database error occurs.
237     */
238     bool DirectoryExist(String Dir);
239    
240     /**
241     * Gets information about the specified directory.
242     * @param Dir The absolute path name of the directory.
243     * @throws Exception - if database error occurs, or if
244     * the specified directory is not found.
245     */
246     DbDirectory GetDirectoryInfo(String Dir);
247    
248     /**
249     * Renames the specified directory.
250     * @param Dir The absolute path name of the directory to rename.
251     * @param Name The new name for the directory.
252     * @throws Exception - In case the given directory does not exists,
253     * or the specified name is not a valid name,
254     * or if a directory with name equal to the new name already
255     * exists, or if database error occurs.
256     */
257     void RenameDirectory(String Dir, String Name);
258    
259     /**
260     * Moves the specified directory into the specified location.
261     * @param Dir The absolute path name of the directory to move.
262     * @param Dst The location where the directory will be moved to.
263     * @throws Exception - In case a given directory does not exists,
264     * or if a directory with name equal to the directory name already
265     * exists in the specified destination directory, or if database error
266     * occurs. Error is also thrown when trying to move a directory to a
267     * subdirectory of itself.
268     */
269     void MoveDirectory(String Dir, String Dst);
270    
271     /**
272 iliev 1187 * Copies the specified directory into the specified location.
273     * @param Dir The absolute path name of the directory to copy.
274     * @param Dst The location where the directory will be copied to.
275     * @throws Exception - In case a given directory does not exists,
276     * or if a directory with name equal to the directory name already
277     * exists in the specified destination directory, or if database error
278     * occurs. Error is also thrown when trying to copy a directory to a
279     * subdirectory of itself.
280     */
281     void CopyDirectory(String Dir, String Dst);
282    
283     /**
284 iliev 1161 * Changes the description of the specified directory.
285     * @throws Exception - if database error occurs, or if
286     * the specified directory is not found.
287     */
288     void SetDirectoryDescription(String Dir, String Desc);
289 iliev 1187
290     /**
291     * Finds all directories that match the search query.
292     * @param Dir The absolute path name of the database
293     * directory to search in.
294     * @throws Exception - if database error occurs, or
295     * if the specified path name is invalid.
296     * @returns The absolute path names of all directories
297     * that match the search query.
298     */
299     StringListPtr FindDirectories(String Dir, SearchQuery* pQuery, bool Recursive);
300 iliev 1161
301     /**
302     * Adds the instruments in the specified file or
303     * directory to the specified instruments database directory.
304     * @param DbDir The absolute path name of a directory in the
305     * instruments database in which only the new instruments
306     * (that are not already in the database) will be added.
307     * @param FilePath The absolute path name of a file or
308     * directory in the file system. In case a directory is
309     * supplied, all supported instruments in the specified directory
310     * will be added to the instruments database, including the
311     * instruments in the subdirectories. The respective subdirectory
312     * structure will be recreated in the supplied database directory.
313     * @param Index The index of the instrument (in the given
314     * instrument file) to add. If -1 is specified, all instruments in
315     * the supplied instrument file will be added. Error is thrown if
316     * a directory is supplied and Index is not equal to -1.
317     * @throws Exception if the operation failed.
318     */
319     void AddInstruments(String DbDir, String FilePath, int Index = -1);
320    
321     /**
322     * Adds all supported instruments in the specified directory
323     * to the specified instruments database directory. The
324     * instruments in the subdirectories will not be processed
325     * @param DbDir The absolute path name of a directory in the
326     * instruments database in which only the new instruments
327     * (that are not already in the database) will be added.
328     * @param FsDir The absolute path name of a directory in the file
329     * system.
330     * @throws Exception if the operation failed.
331     */
332     void AddInstrumentsNonrecursive(String DbDir, String FsDir);
333    
334     /**
335     * Adds all supported instruments in the specified file system
336     * direcotry to the specified instruments database directory,
337     * including the instruments in the subdirectories of the
338     * supplied directory.
339     * @param DbDir The absolute path name of a directory in the
340     * instruments database in which only the new instruments
341     * (that are not already in the database) will be added.
342     * @param FsDir The absolute path name of an existing
343     * directory in the file system.
344     * @param Flat If true, the respective subdirectory structure will
345     * not be recreated in the instruments database and all instruments
346     * will be added directly in the specified database directory.
347     * @throws Exception if the operation failed.
348     */
349     void AddInstrumentsRecursive(String DbDir, String FsDir, bool Flat = false);
350    
351     /**
352     * Gets the number of instruments in the specified directory.
353     * @param Dir The absolute path name of the directory.
354 iliev 1187 * @param Recursive If true, the number of all instruments
355     * in the specified subtree will be returned.
356 iliev 1161 * @throws Exception - if database error occurs, or
357     * the specified path name is invalid.
358 iliev 1163 * @returns The number of instruments in the specified directory.
359 iliev 1161 */
360 iliev 1187 int GetInstrumentCount(String Dir, bool Recursive);
361 iliev 1161
362     /**
363     * Gets the list of instruments in the specified directory.
364     * @param Dir The absolute path name of the directory.
365 iliev 1187 * @param Recursive If true, all instruments
366     * in the specified subtree will be returned.
367 iliev 1161 * @throws Exception - if database error occurs, or
368     * the specified path name is invalid.
369     */
370 iliev 1187 StringListPtr GetInstruments(String Dir, bool Recursive);
371 iliev 1161
372     /**
373     * Removes the specified instrument from the database.
374     * @param Instr The absolute path name of the instrument to remove.
375     * @throws Exception - If the specified instrument does not exist,
376     * or database error occurs.
377     */
378     void RemoveInstrument(String Instr);
379    
380     /**
381     * Gets information about the specified instrument.
382     * @param Instr The absolute path name of the instrument.
383     * @throws Exception - if database error occurs, or if
384     * the specified instrument is not found.
385     */
386     DbInstrument GetInstrumentInfo(String Instr);
387    
388     /**
389     * Renames the specified instrument.
390     * @param Instr The absolute path name of the instrument to rename.
391     * @param Name The new name for the instrument.
392     * @throws Exception - In case the given instrument does not exists,
393     * or the specified name is not a valid name, or if an instrument
394     * with name equal to the new name already exists, or
395     * if database error occurs.
396     */
397     void RenameInstrument(String Instr, String Name);
398    
399     /**
400     * Moves the specified instrument into the specified directory.
401     * @param Instr The absolute path name of the instrument to move.
402     * @param Dst The directory where the instrument will be moved to.
403     * @throws Exception - In case the given directory or instrument
404     * does not exist, or if an instrument with name equal to the name
405     * of the specified instrument already exists in the specified
406     * destination directory, or if database error occurs.
407     */
408     void MoveInstrument(String Instr, String Dst);
409    
410     /**
411 iliev 1187 * Copies the specified instrument into the specified directory.
412     * @param Instr The absolute path name of the instrument to copy.
413     * @param Dst The directory where the instrument will be copied to.
414     * @throws Exception - In case the given directory or instrument
415     * does not exist, or if an instrument with name equal to the name
416     * of the specified instrument already exists in the specified
417     * destination directory, or if database error occurs.
418     */
419     void CopyInstrument(String Instr, String Dst);
420    
421     /**
422 iliev 1161 * Changes the description of the specified instrument.
423     * @throws Exception - if database error occurs, or if
424     * the specified instrument is not found.
425     */
426     void SetInstrumentDescription(String Instr, String Desc);
427    
428     /**
429 iliev 1187 * Finds all instruments that match the search query.
430     * @param Dir The absolute path name of the database
431     * directory to search in.
432     * @throws Exception - if database error occurs, or
433     * if the specified path name is invalid.
434     * @returns The absolute path names of all instruments
435     * that match the search query.
436     */
437     StringListPtr FindInstruments(String Dir, SearchQuery* pQuery, bool Recursive);
438    
439     /**
440 iliev 1161 * Closes the database connection if opened and deletes
441     * the InstrumentsDb instance.
442     */
443     static void Destroy();
444    
445 iliev 1187
446     private:
447     class DirectoryHandler {
448     public:
449     virtual void ProcessDirectory(String Path, int DirId) = 0;
450     };
451 iliev 1161
452 iliev 1187 class AbstractFinder : public DirectoryHandler {
453     public:
454     virtual void ProcessDirectory(String Path, int DirId) = 0;
455    
456     bool IsRegex(String Pattern);
457     void AddSql(String Col, String Pattern, std::stringstream& Sql);
458    
459     protected:
460     std::vector<String> Params;
461     };
462    
463     class DirectoryFinder : public AbstractFinder {
464     public:
465     DirectoryFinder(SearchQuery* pQuery);
466     ~DirectoryFinder();
467     StringListPtr GetDirectories();
468     virtual void ProcessDirectory(String Path, int DirId);
469    
470     private:
471     sqlite3_stmt* pStmt;
472     String SqlQuery;
473     SearchQuery* pQuery;
474     StringListPtr pDirectories;
475    
476     };
477    
478     class InstrumentFinder : public AbstractFinder {
479     public:
480     InstrumentFinder(SearchQuery* pQuery);
481     ~InstrumentFinder();
482     StringListPtr GetInstruments();
483     virtual void ProcessDirectory(String Path, int DirId);
484    
485     private:
486     sqlite3_stmt* pStmt;
487     String SqlQuery;
488     SearchQuery* pQuery;
489     StringListPtr pInstruments;
490     };
491    
492     class DirectoryCounter : public DirectoryHandler {
493     public:
494     DirectoryCounter() { count = 0; }
495     virtual void ProcessDirectory(String Path, int DirId);
496     int GetDirectoryCount() { return count; }
497    
498     private:
499     int count;
500     };
501    
502     class InstrumentCounter : public DirectoryHandler {
503     public:
504     InstrumentCounter() { count = 0; }
505     virtual void ProcessDirectory(String Path, int DirId);
506     int GetInstrumentCount() { return count; }
507    
508     private:
509     int count;
510     };
511    
512     class DirectoryCopier : public DirectoryHandler {
513     public:
514     DirectoryCopier(String SrcParentDir, String DestDir);
515     virtual void ProcessDirectory(String Path, int DirId);
516    
517     private:
518     String SrcParentDir;
519     String DestDir;
520     };
521    
522 iliev 1161 sqlite3* db;
523     String DbFile;
524     static InstrumentsDb* pInstrumentsDb;
525     Mutex DbInstrumentsMutex;
526     ListenerList<InstrumentsDb::Listener*> llInstrumentsDbListeners;
527 iliev 1187 bool InTransaction;
528 iliev 1161
529     InstrumentsDb();
530     ~InstrumentsDb();
531    
532     /**
533     * Gets the instruments database. If the database is not
534     * opened, a connection to the database is established first.
535     * @returns The instruments database.
536     * @throws Exception if fail to open the database.
537     */
538     sqlite3* GetDb();
539    
540     /**
541     * Gets the number of directories in the directory
542     * with ID DirId.
543     * @returns The number of directories in the specified directory
544     * or -1 if the directory doesn't exist.
545     */
546     int GetDirectoryCount(int DirId);
547    
548     /**
549     * Gets a list containing the IDs of all directories in
550     * the specified instrument directory.
551     * @returns The IDs of all directories in the specified directory.
552     * @throws Exception - if database error occurs.
553     */
554     IntListPtr GetDirectoryIDs(int DirId);
555    
556     /**
557 iliev 1187 * Gets the list of directories in the specified directory.
558     * @param DirId The ID of the directory.
559     * @throws Exception - if database error occurs, or
560     * the specified ID is invalid.
561     */
562     StringListPtr GetDirectories(int DirId);
563    
564     /**
565 iliev 1161 * Gets the directory ID.
566     * @param Dir The absolute path name of the directory.
567     * @returns The directory ID or -1 if the directory is not found.
568     * @throws Exception - if database error occurs.
569     */
570     int GetDirectoryId(String Dir);
571    
572     /**
573     * Gets the directory ID.
574     * @param ParentDirId The ID of the parent directory.
575     * @param DirName The directory name.
576     * @throws Exception - if database error occurs.
577     * @returns The ID of the specified directory
578     * or -1 if the directory doesn't exist.
579     */
580     int GetDirectoryId(int ParentDirId, String DirName);
581    
582     /**
583 iliev 1187 * Gets the name of the specified directory.
584     * @throws Exception - if the directory is not found
585     * or if database error occurs.
586     */
587     String GetDirectoryName(int DirId);
588    
589     /**
590     * Gets the ID of the parent directory.
591     * @throws Exception - if the root directory is specified, or if the
592     * specified directory is not found, or if database error occurs.
593     */
594     int GetParentDirectoryId(int DirId);
595    
596     /**
597     * Gets the absolute path name of the specified directory.
598     * @param DirId The ID of the directory, which absolute
599     * path name should be returned.
600     * @throws Exception If the specified directory is not
601     * found or if database error occurs.
602     */
603     String GetDirectoryPath(int DirId);
604    
605     /**
606 iliev 1161 * Removes the specified directory from the database.
607     * @param DirId The ID of the directory to remove.
608     * @throws Exception - If the specified directory is not empty.
609     */
610     void RemoveDirectory(int DirId);
611    
612     /**
613     * Removes all directories in the specified directory.
614     * Do NOT call this method before ensuring that all
615     * directories in the specified directory are empty.
616     * @param DirId The ID of the directory.
617     * @throws Exception - if at least one of the directories in the
618     * specified directory is not empty or if database error occurs.
619     * @see IsDirectoryEmpty
620     */
621     void RemoveAllDirectories(int DirId);
622    
623     /**
624     * Determines whether the specified directory is empty.
625     * If the directory doesn't exist the return value is false.
626     * @throws Exception - if database error occurs.
627     */
628     bool IsDirectoryEmpty(int DirId);
629    
630     /**
631     * Removes the content of the specified directory from the database.
632     * @param DirId The ID of the directory.
633     * @param Level Used to prevent stack overflow, which may occur
634     * due to large or infinite recursive loop.
635     * @throws Exception - If database error occurs.
636     */
637     void RemoveDirectoryContent(int DirId, int Level = 0);
638    
639     /**
640     * Gets the ID of the specified database instrument.
641     * @param Instr The absolute path name of the instrument.
642     * @returns The instrument ID or -1 if the instrument is not found.
643     * @throws Exception - if database error occurs.
644     */
645     int GetInstrumentId(String Instr);
646    
647     /**
648     * Gets the ID of the specified database instrument.
649     * @param DirId The ID of the directory containing the instrument.
650     * @param InstrName The name of the instrument.
651     * @returns The instrument ID or -1 if the instrument is not found.
652     * @throws Exception - if database error occurs.
653     */
654     int GetInstrumentId(int DirId, String InstrName);
655    
656     /**
657 iliev 1187 * Gets the name of the instrument with the specified ID.
658     * @param InstrId The ID of the instrument, which name should be obtained.
659     * @returns The name of the specified instrument.
660     * @throws Exception - if database error occurs.
661     */
662     String GetInstrumentName(int InstrId);
663    
664     /**
665 iliev 1161 * Removes the specified instrument from the database.
666     * @param InstrId The ID of the instrument to remove.
667     * @throws Exception - If the specified instrument does not exist.
668     */
669     void RemoveInstrument(int InstrId);
670    
671     /**
672     * Removes all instruments in the specified directory.
673     * @param DirId The ID of the directory.
674     * @throws Exception - if database error occurs.
675     */
676     void RemoveAllInstruments(int DirId);
677    
678     /**
679     * Gets the number of instruments in the directory
680     * with ID DirId.
681     * @returns The number of instruments in the specified directory
682     * or -1 if the directory doesn't exist.
683     */
684     int GetInstrumentCount(int DirId);
685    
686     /**
687     * Gets a list containing the IDs of all instruments in
688     * the specified instrument directory.
689     * @returns The IDs of all instruments in the specified directory.
690     * @throws Exception - if database error occurs.
691     */
692     IntListPtr GetInstrumentIDs(int DirId);
693    
694     /**
695 iliev 1187 * Gets information about the specified instrument.
696     * @param InstrId The ID of the instrument.
697     * @throws Exception - if database error occurs.
698     */
699     DbInstrument GetInstrumentInfo(int InstrId);
700    
701     /**
702     * Copies the specified instrument into the specified directory.
703     * @param InstrId The ID of the instrument to copy.
704     * @param InstrId The name of the instrument to copy.
705     * @param DstDirId The ID of the directory where the
706     * instrument will be copied to.
707     * @param DstDirId The name of the directory where the
708     * instrument will be copied to.
709     * @throws Exception - If database error occurs.
710     */
711     void CopyInstrument(int InstrId, String InstrName, int DstDirId, String DstDir);
712    
713     /**
714 iliev 1161 * Adds the instruments in the specified file
715     * to the specified instruments database directory.
716     * @param DbDir The absolute path name of a directory in the
717     * instruments database in which only the new instruments
718     * (that are not already in the database) will be added.
719     * @param File The absolute path name of a file in the file system.
720     * @param Index The index of the instrument (in the given
721     * instrument file) to add. If -1 is specified, all instruments in
722     * the supplied instrument file will be added.
723     * @throws Exception if the operation failed.
724     */
725     void AddInstrumentsFromFile(String DbDir, String File, int Index = -1);
726    
727     /**
728     * Adds the specified GIG instrument(s) to the specified location
729     * in the instruments database.
730     * @param DbDir The instruments database directory
731     * in which the instrument will be added.
732     * @param File The absolute path name of the instrument file.
733     * @param Index The index of the instrument (in the given
734     * instrument file) to add. If -1 is specified, all instruments in
735     * the supplied instrument file will be added.
736     * @throws Exception if the operation failed.
737     */
738     void AddGigInstruments(String DbDir, String File, int Index = -1);
739    
740     /**
741     * Adds the specified GIG instrument.
742     * @throws Exception if the operation failed.
743     */
744     void AddGigInstrument(sqlite3_stmt* pStmt, String DbDir, int DirId, String File, ::gig::Instrument* pInstrument, int Index);
745 iliev 1187
746     void DirectoryTreeWalk(String Path, DirectoryHandler* pHandler);
747 iliev 1161
748 iliev 1187 void DirectoryTreeWalk(DirectoryHandler* pHandler, String Path, int DirId, int Level);
749    
750     /** Locks the DbInstrumentsMutex and starts a transaction. */
751     void BeginTransaction();
752    
753     /** Commits the transaction and unocks the DbInstrumentsMutex. */
754     void EndTransaction();
755    
756 iliev 1161 /**
757     * Used to execute SQL commands which return empty result set.
758     */
759     void ExecSql(String Sql);
760    
761     /**
762     * Used to execute SQL commands which return empty result set.
763     */
764     void ExecSql(String Sql, String Param);
765    
766     /**
767     * Used to execute SQL commands which returns integer.
768     */
769     int ExecSqlInt(String Sql);
770    
771     /**
772     * Used to execute SQL commands which returns integer.
773     */
774     int ExecSqlInt(String Sql, String Param);
775    
776     /**
777     * Used to execute SQL commands which returns integer.
778     */
779     String ExecSqlString(String Sql);
780    
781     /**
782     * Used to execute SQL commands which returns integer list.
783     */
784     IntListPtr ExecSqlIntList(String Sql);
785    
786     /**
787     * Used to execute SQL commands which returns string list.
788     */
789     StringListPtr ExecSqlStringList(String Sql);
790    
791     /**
792     * Binds the specified text parameter.
793     */
794     void BindTextParam(sqlite3_stmt* pStmt, int Index, String Text);
795    
796     /**
797     * Binds the specified integer parameter.
798     */
799     void BindIntParam(sqlite3_stmt* pStmt, int Index, int Param);
800    
801     /**
802     * Checks whether an instrument with the specified name already
803     * exists in the specified directory and if so a new unique name
804     * is returnded. The new name is generated by adding the suffix
805     * [<nr>] to the end of the name , where <nr> is a number between
806     * 2 and 1000.
807     * throws Exception if cannot find an unique name. This is done
808     * because it is highly unlikely that this can happen, so it is
809     * supposed that this is due to a bug or an infinite loop.
810     */
811     String GetUniqueInstrumentName(int DirId, String Name);
812    
813     void FireDirectoryCountChanged(String Dir);
814     void FireDirectoryInfoChanged(String Dir);
815     void FireDirectoryNameChanged(String Dir, String NewName);
816     void FireInstrumentCountChanged(String Dir);
817     void FireInstrumentInfoChanged(String Instr);
818     void FireInstrumentNameChanged(String Instr, String NewName);
819    
820     /**
821     * Strips the non-directory suffix from the file name. If the string
822     * ends with `/' only the last character is removed. If the string
823     * doesn't starts with `/' charater, an empty string is returned.
824     */
825     static String GetDirectoryPath(String File);
826    
827     /**
828     * Returns the file name extracted from the specified absolute path
829     * name. If the string doesn't starts with `/' or ends with `/',
830     * an empty string is returned.
831     */
832     static String GetFileName(String Path);
833    
834     /**
835     * Strips the last directory from the specified path name. If the
836     * string doesn't starts with `/' an empty string is returned.
837     */
838     static String GetParentDirectory(String Dir);
839    
840     /**
841     * Checks whether the specified path is valid.
842     * @throws Exception - if the specified path is invalid.
843     */
844     static void CheckPathName(String Path);
845    
846     /**
847     * Checks whether the specified file name is valid.
848     * @throws Exception - if the specified file name is invalid.
849     */
850     static void CheckFileName(String File);
851 iliev 1187
852     /** SQLite user function for handling regular expressions */
853     static void Regexp(sqlite3_context* pContext, int argc, sqlite3_value** ppValue);
854 iliev 1161 };
855    
856     /**
857     * This class is used for recursive
858     */
859     class DirectoryScanner {
860     public:
861     /**
862     * Recursively scans all subdirectories of the specified
863     * directory and adds the supported instruments to the database.
864     * @throws Exception - if the specified directories are invalid.
865     */
866     static void Scan(String DbDir, String FsDir, bool Flat);
867    
868     private:
869     static String DbDir;
870     static String FsDir;
871     static bool Flat;
872     static int FtwCallback(const char* fpath, const struct stat* sb, int typeflag);
873     };
874    
875     } // namespace LinuxSampler
876    
877     #endif // __LS_INSTRUMENTSDB_H__
878    
879     #endif // HAVE_SQLITE3
  ViewVC Help
Powered by ViewVC