ContentEntityStore.h

Go to the documentation of this file.

// Copyright (c) XJ Music Inc. (https://xjmusic.com) All Rights Reserved.
 
#ifndef XJMUSIC_CONTENT_STORE_H
#define XJMUSIC_CONTENT_STORE_H
 
#include <fstream>
#include <map>
#include <optional>
#include <set>
#include <vector>
 
#include "Instrument.h"
#include "InstrumentAudio.h"
#include "InstrumentMeme.h"
#include "Library.h"
#include "Program.h"
#include "ProgramMeme.h"
#include "ProgramSequence.h"
#include "ProgramSequenceBinding.h"
#include "ProgramSequenceBindingMeme.h"
#include "ProgramSequenceChord.h"
#include "ProgramSequenceChordVoicing.h"
#include "ProgramSequencePattern.h"
#include "ProgramSequencePatternEvent.h"
#include "ProgramVoice.h"
#include "ProgramVoiceTrack.h"
#include "Project.h"
#include "Template.h"
#include "TemplateBinding.h"
 
using namespace XJ;
 
#define CONTENT_STORE_CORE_HEADERS(ENTITY, ENTITIES)                  \
  std::optional<const ENTITY *> get##ENTITY(const UUID &id);          \
  std::set<const ENTITY *> get##ENTITIES();                           \
  ContentEntityStore set##ENTITIES(const std::set<ENTITY> &entities); \
  ENTITY *put(const ENTITY &entity);
 
namespace XJ {
 
  class ContentEntityStore {
    std::map<UUID, Instrument> instruments{};
    std::map<UUID, InstrumentAudio> instrumentAudios{};
    std::map<UUID, InstrumentMeme> instrumentMemes{};
    std::map<UUID, Library> libraries{};
    std::map<UUID, Program> programs{};
    std::map<UUID, ProgramMeme> programMemes{};
    std::map<UUID, ProgramSequence> programSequences{};
    std::map<UUID, ProgramSequenceBinding> programSequenceBindings{};
    std::map<UUID, ProgramSequenceBindingMeme> programSequenceBindingMemes{};
    std::map<UUID, ProgramSequenceChord> programSequenceChords{};
    std::map<UUID, ProgramSequenceChordVoicing> programSequenceChordVoicings{};
    std::map<UUID, ProgramSequencePattern> programSequencePatterns{};
    std::map<UUID, ProgramSequencePatternEvent> programSequencePatternEvents{};
    std::map<UUID, ProgramVoice> programVoices{};
    std::map<UUID, ProgramVoiceTrack> programVoiceTracks{};
    std::map<UUID, Project> projects{};
    std::map<UUID, Template> templates{};
    std::map<UUID, TemplateBinding> templateBindings{};
 
  public:
    CONTENT_STORE_CORE_HEADERS(Instrument, Instruments)
 
    CONTENT_STORE_CORE_HEADERS(InstrumentAudio, InstrumentAudios)
 
    CONTENT_STORE_CORE_HEADERS(InstrumentMeme, InstrumentMemes)
 
    CONTENT_STORE_CORE_HEADERS(Library, Libraries)
 
    CONTENT_STORE_CORE_HEADERS(Program, Programs)
 
    CONTENT_STORE_CORE_HEADERS(ProgramMeme, ProgramMemes)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequence, ProgramSequences)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequenceBinding, ProgramSequenceBindings)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequenceBindingMeme, ProgramSequenceBindingMemes)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequenceChord, ProgramSequenceChords)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequenceChordVoicing, ProgramSequenceChordVoicings)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequencePattern, ProgramSequencePatterns)
 
    CONTENT_STORE_CORE_HEADERS(ProgramSequencePatternEvent, ProgramSequencePatternEvents)
 
    CONTENT_STORE_CORE_HEADERS(ProgramVoice, ProgramVoices)
 
    CONTENT_STORE_CORE_HEADERS(ProgramVoiceTrack, ProgramVoiceTracks)
 
    CONTENT_STORE_CORE_HEADERS(Project, Projects)
 
    CONTENT_STORE_CORE_HEADERS(Template, Templates)
 
    CONTENT_STORE_CORE_HEADERS(TemplateBinding, TemplateBindings)
 
 
    
    explicit ContentEntityStore();
 
    explicit ContentEntityStore(std::ifstream &input);
 
    explicit ContentEntityStore(std::string &input);
 
    std::optional<Project *> getProject();
 
    std::optional<const ProgramVoiceTrack *> getTrackOfEvent(const ProgramSequencePatternEvent *event);
 
    std::optional<const ProgramVoice *> getVoiceOfEvent(const ProgramSequencePatternEvent *event);
 
    Instrument::Type getInstrumentTypeOfEvent(const ProgramSequencePatternEvent *event);
 
    bool hasInstrumentsOfType(Instrument::Type type);
 
    bool hasInstrumentsOfMode(Instrument::Mode mode);
 
    bool hasInstrumentsOfTypeAndMode(Instrument::Type type, Instrument::Mode mode);
 
    std::vector<int> getAvailableOffsets(const ProgramSequenceBinding *sequenceBinding) const;
 
    std::set<const InstrumentAudio *> getAudiosOfInstrument(const UUID &id) const;
 
    std::set<const InstrumentAudio *> getAudiosOfInstrument(const Instrument *instrument) const;
 
    std::vector<const ProgramSequenceBinding *> getBindingsOfSequence(const ProgramSequence *sequence) const;
 
    std::vector<const ProgramSequenceBinding *> getBindingsOfSequence(const UUID &sequenceId) const;
 
    std::set<const ProgramSequenceBindingMeme *> getSequenceBindingMemesOfProgram(const Program *program) const;
 
    std::set<const ProgramSequenceBindingMeme *> getSequenceBindingMemesOfProgram(const UUID &programId) const;
 
    std::vector<const ProgramSequenceBinding *>
    getBindingsAtOffsetOfProgram(const Program *program, int offset, bool includeNearest) const;
 
    std::vector<const ProgramSequenceBinding *>
    getBindingsAtOffsetOfProgram(const UUID &programId, int offset, bool includeNearest) const;
 
    std::vector<const ProgramSequenceChord *> getChordsOfSequence(const ProgramSequence *sequence) const;
 
    std::vector<const ProgramSequenceChord *> getChordsOfSequence(const UUID &programSequenceId) const;
 
    std::vector<const ProgramSequencePatternEvent *> getEventsOfPattern(const ProgramSequencePattern *pattern) const;
 
    std::vector<const ProgramSequencePatternEvent *> getEventsOfPattern(const UUID &patternId) const;
 
    std::set<const ProgramSequencePattern *>
    getPatternsOfSequenceAndVoice(const UUID &programSequenceId, const UUID &programVoiceId) const;
 
    std::set<const TemplateBinding *> getBindingsOfTemplate(const UUID &templateId) const;
 
    std::set<const ProgramSequencePattern *> getSequencePatternsOfProgram(const UUID &programId) const;
 
    std::set<const ProgramSequencePattern *> getSequencePatternsOfProgram(const Program *program) const;
 
    std::vector<const ProgramSequencePatternEvent *> getSequencePatternEventsOfProgram(const UUID &programId) const;
 
    std::vector<const ProgramSequencePatternEvent *> getEventsOfTrack(const ProgramVoiceTrack *track) const;
 
    std::vector<const ProgramSequencePatternEvent *> getEventsOfTrack(const UUID &trackId) const;
 
    std::vector<const ProgramSequencePatternEvent *>
    getEventsOfPatternAndTrack(const ProgramSequencePattern *pattern, const ProgramVoiceTrack *track) const;
 
    std::vector<const ProgramSequencePatternEvent *>
    getEventsOfPatternAndTrack(const UUID &patternId, const UUID &trackId) const;
 
    std::set<const InstrumentAudio *> getAudiosOfInstrumentTypesAndModes(const std::set<Instrument::Type> &types,
                                                                         const std::set<Instrument::Mode> &modes) const;
 
    std::set<const InstrumentAudio *> getAudiosOfInstrumentTypes(const std::set<Instrument::Type> &types) const;
 
    std::set<const Instrument *> getInstrumentsOfType(const Instrument::Type &type) const;
 
    std::set<const Instrument *> getInstrumentsOfTypesAndModes(const std::set<Instrument::Type> &types,
                                                               const std::set<Instrument::Mode> &modes) const;
 
    std::set<const Instrument *> getInstrumentsOfTypes(const std::set<Instrument::Type> &types) const;
 
    std::set<const InstrumentMeme *> getMemesOfInstrument(const UUID &instrumentId) const;
 
    std::set<const Instrument *> getInstrumentsOfLibrary(const Library *library) const;
 
    std::set<const Instrument *> getInstrumentsOfLibrary(const UUID &libraryId) const;
 
    Instrument::Type getInstrumentTypeOfAudio(const UUID &instrumentAudioId) const;
 
    std::set<const ProgramMeme *> getMemesOfProgram(const UUID &programId) const;
 
 
    std::set<std::string> getMemesAtBeginning(const Program *program) const;
 
    std::set<const ProgramSequenceBindingMeme *>
    getMemesOfSequenceBinding(const ProgramSequenceBinding *programSequenceBinding) const;
 
    std::set<const ProgramSequenceBindingMeme *> getMemesOfSequenceBinding(const UUID &programSequenceBindingId) const;
 
    UUID getPatternIdOfEvent(const UUID &eventId);
 
    std::set<const ProgramSequencePattern *> getPatternsOfSequence(const ProgramSequence *sequence);
 
    std::set<const ProgramSequencePattern *> getPatternsOfSequence(const UUID &sequence);
 
    std::set<const ProgramSequencePattern *> getPatternsOfVoice(const ProgramVoice *voice) const;
 
    std::set<const ProgramSequencePattern *> getPatternsOfVoice(const UUID &voiceId) const;
 
    std::set<const Program *> getProgramsOfLibrary(const Library *library) const;
 
    std::set<const Program *> getProgramsOfLibrary(const UUID &libraryId) const;
 
    std::set<const Program *> getProgramsOfType(Program::Type type) const;
 
    std::optional<const ProgramSequence *> getSequenceOfBinding(const ProgramSequenceBinding *sequenceBinding);
 
    std::set<const ProgramSequence *> getSequencesOfProgram(const UUID &programId) const;
 
    std::vector<const ProgramSequenceBinding *> getSequenceBindingsOfProgram(const UUID &programId) const;
 
    std::vector<const ProgramSequenceChord *> getSequenceChordsOfProgram(const UUID &programId) const;
 
    std::set<const ProgramSequenceChordVoicing *> getSequenceChordVoicingsOfProgram(const UUID &programId) const;
 
    std::set<const ProgramVoiceTrack *> getTracksOfProgram(const UUID &programId) const;
 
    std::set<const ProgramVoiceTrack *> getTracksOfProgramType(Program::Type type) const;
 
    std::set<const ProgramVoiceTrack *> getTracksOfVoice(const ProgramVoice *voice) const;
 
    std::set<const ProgramVoiceTrack *> getTracksOfVoice(const UUID &voiceId) const;
 
    std::set<std::string> getTrackNamesOfVoice(const ProgramVoice *voice) const;
 
    std::set<const ProgramSequenceChordVoicing *> getVoicingsOfChord(const ProgramSequenceChord *chord) const;
 
    std::set<const ProgramSequenceChordVoicing *> getVoicingsOfChord(const UUID &chordId) const;
 
    std::set<const ProgramSequenceChordVoicing *>
    getVoicingsOfChordAndVoice(const ProgramSequenceChord *chord, const ProgramVoice *voice) const;
 
    std::set<const ProgramSequenceChordVoicing *>
    getVoicingsOfChordAndVoice(const UUID &chordId, const UUID &voiceId) const;
 
    std::set<const ProgramVoice *> getVoicesOfProgram(const Program *program) const;
 
    std::set<const ProgramVoice *> getVoicesOfProgram(const UUID &programId) const;
 
    std::optional<const Template *> getTemplateByIdentifier(const std::optional<std::string>::value_type &identifier);
 
    std::optional<const Template *> getFirstTemplate();
 
    MemeTaxonomy getMemeTaxonomy();
 
    ContentEntityStore forTemplate(const Template *tmpl);
 
    void clear();
 
    void put(const ContentEntityStore *other);
 
    std::string toString();
 
    ~ContentEntityStore();
  };
 
}// namespace XJ
 
#endif//XJMUSIC_CONTENT_STORE_H