Pattern.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2024 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * 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, see https://www.gnu.org/licenses
 *
 */
 
#ifndef H2C_PATTERN_H
#define H2C_PATTERN_H
 
#include <set>
#include <memory>
#include <core/License.h>
#include <core/Object.h>
#include <core/Basics/Note.h>
#include <core/Helpers/Xml.h>
 
namespace H2Core
{
 
class XMLNode;
class Instrument;
class InstrumentList;
class PatternList;
 
class Pattern : public H2Core::Object<Pattern>
{
                H2_OBJECT(Pattern)
        public:
                typedef std::multimap <int, Note*> notes_t;
                typedef notes_t::iterator notes_it_t;
                typedef notes_t::const_iterator notes_cst_it_t;
                typedef std::set <Pattern*> virtual_patterns_t;
                typedef virtual_patterns_t::iterator virtual_patterns_it_t;
                typedef virtual_patterns_t::const_iterator virtual_patterns_cst_it_t;
 
        std::set<Pattern*>::iterator begin();
        std::set<Pattern*>::iterator end();
        
                Pattern( const QString& name="Pattern", const QString& info="", const QString& category="not_categorized", int length=MAX_NOTES, int denominator=4 );
                Pattern( Pattern* other );
                ~Pattern();
 
                static Pattern* load_file( const QString& pattern_path, std::shared_ptr<InstrumentList> instruments );
        static Pattern* load_from( XMLNode* node, std::shared_ptr<InstrumentList> instruments, bool bSilent = false );
                bool save_file( const QString& drumkit_name, const QString& author, const License& license, const QString& pattern_path, bool overwrite=false ) const;
 
                void set_name( const QString& name );
                const QString& get_name() const;
                void set_category( const QString& category );
                void set_info( const QString& info );
                const QString& get_info() const;
                const QString& get_category() const;
                void set_length( int length );
                int get_length() const;
                void set_denominator( int denominator );
                int get_denominator() const;
                const notes_t* get_notes() const;
                const virtual_patterns_t* get_virtual_patterns() const;
                const virtual_patterns_t* get_flattened_virtual_patterns() const;
 
                void insert_note( Note* note );
                Note* find_note( int idx_a, int idx_b, std::shared_ptr<Instrument> instrument, bool strict=true ) const;
                Note* find_note( int idx_a, int idx_b, std::shared_ptr<Instrument> instrument, Note::Key key, Note::Octave octave, bool strict=true) const;
                void remove_note( Note* note );
 
                bool references( std::shared_ptr<Instrument> instr );
        void purge_instrument( std::shared_ptr<Instrument> instr, bool bRequiredLock = true );
                void set_to_old();
 
                bool virtual_patterns_empty() const;
                void virtual_patterns_clear();
                void virtual_patterns_add( Pattern* pattern );
                void virtual_patterns_del( Pattern* pattern );
                void flattened_virtual_patterns_clear();
                void flattened_virtual_patterns_compute();
        void addFlattenedVirtualPatterns( PatternList* pPatternList );
        void removeFlattenedVirtualPatterns( PatternList* pPatternList );
 
        int longestVirtualPatternLength() const;
        bool isVirtual() const;
 
                void save_to( XMLNode* node, const std::shared_ptr<Instrument> instrumentOnly = nullptr ) const;
                QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
 
        private:
                int __length;
                int __denominator;                                           
                QString __name;                                         
                QString __category;                                     
                QString __info;                                                                                 
                notes_t __notes;                                        
                virtual_patterns_t __virtual_patterns;                  
                virtual_patterns_t __flattened_virtual_patterns;        
        static bool loadDoc( const QString& sPatternPath, std::shared_ptr<InstrumentList> pInstrumentList, XMLDoc* pDoc, bool bSilent = false );
};
 
#define FOREACH_NOTE_CST_IT_BEGIN_END(_notes,_it) \
        for( Pattern::notes_cst_it_t _it=(_notes)->begin(); (_it)!=(_notes)->end(); (_it)++ )
 
#define FOREACH_NOTE_CST_IT_BOUND_END(_notes,_it,_bound) \
        for( Pattern::notes_cst_it_t _it=(_notes)->lower_bound((_bound)); (_it)!=(_notes)->end() && (_it)->first == (_bound); (_it)++ )
 
#define FOREACH_NOTE_IT_BEGIN_END(_notes,_it) \
        for( Pattern::notes_it_t _it=(_notes)->begin(); (_it)!=(_notes)->end(); (_it)++ )
 
#define FOREACH_NOTE_IT_BOUND_END(_notes,_it,_bound)                                            \
        for( Pattern::notes_it_t _it=(_notes)->lower_bound((_bound)); (_it)!=(_notes)->end() && (_it)->first == (_bound); (_it)++ )
 
#define FOREACH_NOTE_CST_IT_BEGIN_LENGTH(_notes,_it,_pattern)                   \
        for( Pattern::notes_cst_it_t _it=(_notes)->begin(); (_it)!=(_notes)->end() && (_it)->first < (_pattern)->get_length(); (_it)++ )
 
#define FOREACH_NOTE_CST_IT_BOUND_LENGTH(_notes,_it,_bound,_pattern) \
        for( Pattern::notes_cst_it_t _it=(_notes)->lower_bound((_bound)); (_it)!=(_notes)->end() && (_it)->first == (_bound) && (_it)->first < (_pattern)->get_length(); (_it)++ )
 
#define FOREACH_NOTE_IT_BEGIN_LENGTH(_notes,_it,_pattern) \
        for( Pattern::notes_it_t _it=(_notes)->begin(); (_it)!=(_notes)->end() && (_it)->first < (_pattern)->get_length(); (_it)++ )
 
#define FOREACH_NOTE_IT_BOUND_LENGTH(_notes,_it,_bound,_pattern) \
        for( Pattern::notes_it_t _it=(_notes)->lower_bound((_bound)); (_it)!=(_notes)->end() && (_it)->first == (_bound) && (_it)->first < (_pattern)->get_length(); (_it)++ )
 
// DEFINITIONS
 
inline void Pattern::set_name( const QString& name )
{
        __name = name;
}
 
inline const QString& Pattern::get_name() const
{
        return __name;
}
 
inline void Pattern::set_info( const QString& info )
{
        __info = info;
}
 
inline const QString& Pattern::get_info() const
{
        return __info;
}
 
inline void Pattern::set_category( const QString& category )
{
        __category = category;
}
 
inline const QString& Pattern::get_category() const
{
        return __category;
}
 
inline void Pattern::set_length( int length )
{
        __length = length;
}
 
inline int Pattern::get_length() const
{
        return __length;
}
 
inline void Pattern::set_denominator( int denominator )
{
        __denominator = denominator;
}
 
inline int Pattern::get_denominator() const
{
        return __denominator;
}
 
inline const Pattern::notes_t* Pattern::get_notes() const
{
        return &__notes;
}
 
inline const Pattern::virtual_patterns_t* Pattern::get_virtual_patterns() const
{
        return &__virtual_patterns;
}
 
inline const Pattern::virtual_patterns_t* Pattern::get_flattened_virtual_patterns() const
{
        return &__flattened_virtual_patterns;
}
 
inline void Pattern::insert_note( Note* note )
{
        __notes.insert( std::make_pair( note->get_position(), note ) );
}
 
inline bool Pattern::virtual_patterns_empty() const
{
        return __virtual_patterns.empty();
}
 
inline void Pattern::virtual_patterns_clear()
{
        __virtual_patterns.clear();
}
 
inline void Pattern::virtual_patterns_add( Pattern* pattern )
{
        __virtual_patterns.insert( pattern );
}
 
inline void Pattern::virtual_patterns_del( Pattern* pattern )
{
        virtual_patterns_cst_it_t it = __virtual_patterns.find( pattern );
        if ( it!=__virtual_patterns.end() ) __virtual_patterns.erase( it );
}
 
inline void Pattern::flattened_virtual_patterns_clear()
{
        __flattened_virtual_patterns.clear();
}
 
};
 
#endif // H2C_PATTERN_H
 
/* vim: set softtabstop=4 noexpandtab:  */