Fabricator.h

Go to the documentation of this file.

// Copyright (c) XJ Music Inc. (https://xjmusic.com) All Rights Reserved.
 
#ifndef XJMUSIC_FABRICATOR_H
#define XJMUSIC_FABRICATOR_H
 
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "xjmusic/content/ContentEntityStore.h"
#include "xjmusic/content/Instrument.h"
#include "xjmusic/content/InstrumentAudio.h"
#include "xjmusic/content/InstrumentConfig.h"
#include "xjmusic/content/Program.h"
#include "xjmusic/content/ProgramConfig.h"
#include "xjmusic/content/ProgramSequence.h"
#include "xjmusic/content/ProgramSequenceBinding.h"
#include "xjmusic/content/ProgramSequenceChord.h"
#include "xjmusic/content/ProgramSequenceChordVoicing.h"
#include "xjmusic/content/ProgramSequencePattern.h"
#include "xjmusic/content/ProgramSequencePatternEvent.h"
#include "xjmusic/content/ProgramVoice.h"
#include "xjmusic/content/TemplateBinding.h"
#include "xjmusic/content/TemplateConfig.h"
#include "xjmusic/fabricator/SegmentRetrospective.h"
#include "xjmusic/meme/MemeIsometry.h"
#include "xjmusic/meme/MemeTaxonomy.h"
#include "xjmusic/music/Chord.h"
#include "xjmusic/music/Note.h"
#include "xjmusic/music/NoteRange.h"
#include "xjmusic/music/StickyBun.h"
#include "xjmusic/segment/Chain.h"
#include "xjmusic/segment/Segment.h"
#include "xjmusic/segment/SegmentChoice.h"
#include "xjmusic/segment/SegmentChoiceArrangement.h"
#include "xjmusic/segment/SegmentChoiceArrangementPick.h"
#include "xjmusic/segment/SegmentChord.h"
#include "xjmusic/segment/SegmentChordVoicing.h"
#include "xjmusic/segment/SegmentEntityStore.h"
#include "xjmusic/segment/SegmentMeme.h"
#include "xjmusic/segment/SegmentMessage.h"
#include "xjmusic/segment/SegmentMeta.h"
#include "xjmusic/util/EntityUtils.h"
 
namespace XJ {
 
  class Fabricator {
  public:
    virtual ~Fabricator() = default;
 
    explicit Fabricator(
        ContentEntityStore *contentEntityStore,
        SegmentEntityStore *segmentEntityStore,
        const SegmentRetrospective *segmentRetrospective,
        int segmentId,
        std::optional<Segment::Type> overrideSegmentType);
 
    enum class ControlMode {
      Auto,
      Macro,
      Taxonomy
    };
 
    virtual void addMessage(SegmentMessage::Type messageType, std::string body);
 
    virtual void addErrorMessage(std::string body);
 
    virtual void addWarningMessage(std::string body);
 
    virtual void addInfoMessage(std::string body);
 
    virtual void deletePick(const UUID &id);
 
    virtual std::set<const SegmentChoiceArrangement *> getArrangements();
 
    virtual std::set<const SegmentChoiceArrangement *> getArrangements(std::set<const SegmentChoice *> &choices);
 
    virtual Chain *getChain();
 
    virtual TemplateConfig getTemplateConfig();
 
    [[nodiscard]] virtual std::set<const SegmentChoice *> getChoices() const;
 
    virtual std::optional<const SegmentChoice *> getChoiceIfContinued(const ProgramVoice *voice);
 
    virtual std::set<const SegmentChoice *> getChoicesIfContinued(const Program::Type programType);
 
    virtual std::optional<const SegmentChoice *> getChoiceIfContinued(Instrument::Type instrumentType);
 
    virtual std::optional<const SegmentChoice *>
    getChoiceIfContinued(Instrument::Type instrumentType, Instrument::Mode instrumentMode);
 
    virtual std::optional<const SegmentChord *> getChordAt(float position);
 
    virtual std::optional<const SegmentChoice *> getCurrentMainChoice();
 
    virtual std::optional<const ProgramSequence *> getCurrentMainSequence();
 
    virtual std::set<const SegmentChoice *> getCurrentDetailChoices();
 
    virtual std::optional<const SegmentChoice *> getCurrentBeatChoice();
 
    virtual std::set<Instrument::Type> getDistinctChordVoicingTypes();
 
    virtual long getElapsedMicros();
 
    virtual Chord getKeyForChoice(const SegmentChoice *choice);
 
    virtual std::optional<const SegmentChoice *> getMacroChoiceOfPreviousSegment();
 
    virtual std::optional<const SegmentChoice *> getPreviousMainChoice();
 
    virtual ProgramConfig getCurrentMainProgramConfig();
 
    virtual std::optional<const ProgramSequence *> getPreviousMainSequence();
 
    virtual MemeIsometry getMemeIsometryOfNextSequenceInPreviousMacro();
 
    virtual MemeIsometry getMemeIsometryOfSegment();
 
    virtual int getNextSequenceBindingOffset(const SegmentChoice *choice);
 
    static std::vector<std::string> getNotes(const SegmentChordVoicing *voicing);
 
    virtual std::set<const SegmentChoiceArrangementPick *> getPicks();
 
    virtual std::vector<const SegmentChoiceArrangementPick *> getPicks(const SegmentChoice *choice);
 
    virtual std::optional<const InstrumentAudio *> getPreferredAudio(const std::string &parentIdent, const std::string &ident);
 
    virtual std::optional<const Program *> getProgram(const SegmentChoice *choice);
 
    virtual std::vector<const ProgramSequenceChord *> getProgramSequenceChords(const ProgramSequence *programSequence);
 
    virtual NoteRange getProgramRange(const UUID &programId, Instrument::Type instrumentType);
 
    virtual int
    getProgramRangeShiftOctaves(Instrument::Type instrumentType, NoteRange *sourceRange, NoteRange *targetRange);
 
    virtual std::optional<const ProgramSequence *> getProgramSequence(const SegmentChoice *choice);
 
    virtual int getProgramTargetShift(Instrument::Type instrumentType, const Chord *fromChord, const Chord *toChord);
 
    virtual Program::Type getProgramType(const ProgramVoice *voice);
 
 
    virtual Instrument::Type getProgramVoiceType(const ProgramSequenceChordVoicing *voicing);
 
    virtual NoteRange getProgramVoicingNoteRange(Instrument::Type instrumentType);
 
    virtual std::optional<const ProgramSequence *> getRandomlySelectedSequence(const Program *program);
 
    virtual std::optional<const ProgramSequencePattern *>
    getRandomlySelectedPatternOfSequenceByVoiceAndType(const SegmentChoice *choice);
 
    virtual std::optional<const ProgramSequenceBinding *>
    getRandomlySelectedSequenceBindingAtOffset(const Program *program, int offset);
 
    virtual std::optional<Note> getRootNoteMidRange(const std::string &voicingNotes, const Chord *chord);
 
    virtual long getSegmentMicrosAtPosition(float tempo, float position);
 
    virtual long getTotalSegmentMicros();
 
    virtual const Segment *getSegment();
 
    virtual std::vector<const SegmentChord *> getSegmentChords();
 
    virtual std::set<const SegmentChordVoicing *> getChordVoicings();
 
    virtual std::set<const SegmentMeme *> getSegmentMemes();
 
    virtual std::optional<const ProgramSequence *> getSequence(const SegmentChoice *choice);
 
    virtual int getSequenceBindingOffsetForChoice(const SegmentChoice *choice);
 
    virtual void putStickyBun(StickyBun bun);
 
    virtual std::optional<const StickyBun> getStickyBun(const UUID &eventId);
 
    virtual std::string getTrackName(const ProgramSequencePatternEvent *event);
 
    virtual Segment::Type getType();
 
    virtual std::optional<const SegmentChordVoicing *>
    chooseVoicing(const SegmentChord *chord, Instrument::Type instrumentType);
 
    virtual bool hasMoreSequenceBindingOffsets(const SegmentChoice *choice, int N);
 
    virtual bool hasOneMoreSequenceBindingOffset(const SegmentChoice *choice);
 
    virtual bool hasTwoMoreSequenceBindingOffsets(const SegmentChoice *choice);
 
    virtual bool isContinuationOfMacroProgram();
 
    virtual bool isDirectlyBound(const Instrument *instrument);
 
    virtual bool isDirectlyBound(const InstrumentAudio *instrumentAudio);
 
    virtual bool isDirectlyBound(const Program *program);
 
    virtual bool isOneShot(const Instrument *instrument, const std::string &trackName);
 
    virtual bool isOneShot(const Instrument *instrument);
 
    virtual bool isOneShotCutoffEnabled(const Instrument *instrument);
 
    virtual bool isInitialSegment();
 
    virtual std::optional<const SegmentChoice *> put(const SegmentChoice &entity, const bool force);
 
    virtual const SegmentChoiceArrangement *put(const SegmentChoiceArrangement &entity);
 
    virtual const SegmentChoiceArrangementPick *put(const SegmentChoiceArrangementPick &entity);
 
    virtual const SegmentChord *put(const SegmentChord &entity);
 
    virtual const SegmentChordVoicing *put(const SegmentChordVoicing &entity);
 
    virtual std::optional<const SegmentMeme *> put(const SegmentMeme &entity, bool force);
 
    virtual const SegmentMessage *put(const SegmentMessage &entity);
 
    virtual const SegmentMeta *put(const SegmentMeta &entity);
 
    virtual void putPreferredAudio(
        const std::string &parentIdent,
        const std::string &ident,
        const InstrumentAudio *instrumentAudio);
 
    virtual const Segment *updateSegment(Segment segment);
 
    virtual const SegmentRetrospective *getRetrospective();
 
    virtual ContentEntityStore *getSourceMaterial();
 
    virtual double getMicrosPerBeat(float tempo);
 
    virtual int getSecondMacroSequenceBindingOffset(const Program *macroProgram);
 
    virtual double getTempo();
 
    [[nodiscard]] virtual MemeTaxonomy getMemeTaxonomy() const;
 
    static int getSegmentId(const SegmentChoice *segmentChoice);
 
    static int getSegmentId(const SegmentChoiceArrangement *segmentChoiceArrangement);
 
    static int getSegmentId(const SegmentChoiceArrangementPick *segmentChoiceArrangementPick);
 
    static int getSegmentId(const SegmentChord *segmentChord);
 
    static int getSegmentId(const SegmentChordVoicing *segmentChordVoicing);
 
    static int getSegmentId(const SegmentMeme *segmentMeme);
 
    static int getSegmentId(const SegmentMessage *segmentMessage);
 
    static int getSegmentId(const SegmentMeta *segmentMeta);
 
    static std::string toString(ControlMode controlMode);
 
    static ControlMode parseControlMode(const char * str);
 
  private:
    static const std::string KEY_VOICE_TRACK_TEMPLATE;
    static const std::string NAME_SEPARATOR;
    static const std::string UNKNOWN_KEY;
    Chain *chain;
    std::set<const TemplateBinding *> templateBindings;
    ContentEntityStore *sourceMaterial;
    std::map<double, std::optional<SegmentChord *>> chordAtPosition;
    std::map<Instrument::Type, NoteRange> voicingNoteRange;
    std::map<const SegmentChoice *, const ProgramSequence *> sequenceForChoice;
    std::map<std::string, const InstrumentAudio *> preferredAudios;
    std::map<std::string, InstrumentConfig> instrumentConfigs;
    std::map<std::string, InstrumentConfig> pickInstrumentConfigs;
    std::map<std::string, int> rangeShiftOctave;
    std::map<std::string, int> targetShift;
    std::map<std::string, NoteRange> rangeForChoice;
    std::map<std::string, std::optional<Note>> rootNotesByVoicingAndChord;
    std::map<UUID, std::vector<const ProgramSequenceChord *>> completeChordsForProgramSequence;
    std::map<UUID, std::vector<const SegmentChoiceArrangementPick *>> picksForChoice;
    SegmentEntityStore *store;
    int segmentId;
    const SegmentRetrospective * retrospective;
    std::set<UUID> boundInstrumentIds;
    std::set<UUID> boundProgramIds;
    std::chrono::high_resolution_clock::time_point startAtSystemNanoTime;
    std::optional<Segment::Type> type;
 
    std::optional<const SegmentChoice *> macroChoiceOfPreviousSegment;
    std::optional<const SegmentChoice *> mainChoiceOfPreviousSegment;
 
    double microsPerBeat{};
 
    std::set<Instrument::Type> distinctChordVoicingTypes;
 
    [[nodiscard]] std::optional<const SegmentMeta *> getSegmentMeta(const std::string &key) const;
 
    [[nodiscard]] std::optional<const SegmentChoice *> getChoiceOfType(Program::Type programType) const;
 
    [[nodiscard]] std::set<const SegmentChoice *> getBeatChoices() const;
 
    static int computeLowestOptimalRangeShiftOctaves(const NoteRange &sourceRange, const NoteRange &targetRange);
 
    static std::string computeShipKey(const Chain *chain, const Segment *segment);
 
    void ensureShipKey();
 
    Segment::Type computeType();
 
    [[nodiscard]] int getPreviousSegmentDelta() const;
 
    std::map<std::string, const InstrumentAudio *> computePreferredInstrumentAudio();
 
    bool isValidChoiceAndMemesHaveBeenAdded(const SegmentChoice &choice, const MemeStack &memeStack, bool force);
 
    bool isValidMemeAddition(const SegmentMeme &meme, const MemeStack &memeStack, bool force);
 
    static std::string computeCacheKeyForPreferredAudio(const std::string &parentIdent, const std::string &ident);
 
    std::string computeCacheKeyForVoiceTrack(const SegmentChoiceArrangementPick *pick);
 
    [[nodiscard]] NoteRange computeProgramRange(const UUID &programId, Instrument::Type instrumentType) const;
  };
 
}// namespace XJ
 
#endif//XJMUSIC_FABRICATOR_H