SegmentEntityStore.h

Go to the documentation of this file.

// Copyright (c) XJ Music Inc. (https://xjmusic.com) All Rights Reserved.
 
#ifndef XJMUSIC_SEGMENT_ENTITY_STORE_H
#define XJMUSIC_SEGMENT_ENTITY_STORE_H
 
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include "Chain.h"
#include "Segment.h"
#include "SegmentChoice.h"
#include "SegmentChoiceArrangement.h"
#include "SegmentChoiceArrangementPick.h"
#include "SegmentChord.h"
#include "SegmentChordVoicing.h"
#include "SegmentMeme.h"
#include "SegmentMessage.h"
#include "SegmentMeta.h"
#include "xjmusic/util/EntityUtils.h"
 
using namespace XJ;
 
#define SEGMENT_STORE_CORE_HEADERS(ENTITY, ENTITIES)                           \
  const ENTITY *put(const ENTITY &choice);                                     \
  std::optional<const ENTITY *> read##ENTITY(int segmentId, const UUID &id);   \
  std::set<const ENTITY *> readAll##ENTITIES(int segmentId);                   \
  std::set<const ENTITY *> readAll##ENTITIES(const std::set<int> &segmentIds); \
  void delete##ENTITY(int segmentId, const UUID &id);
 
 
namespace XJ {
 
  class SegmentEntityStore {
    std::optional<Chain> chain;
    std::map<int, Segment> segments;
    std::map<int, std::map<UUID, SegmentChoice>> segmentChoices;
    std::map<int, std::map<UUID, SegmentChoiceArrangement>> segmentChoiceArrangements;
    std::map<int, std::map<UUID, SegmentChoiceArrangementPick>> segmentChoiceArrangementPicks;
    std::map<int, std::map<UUID, SegmentChord>> segmentChords;
    std::map<int, std::map<UUID, SegmentChordVoicing>> segmentChordVoicings;
    std::map<int, std::map<UUID, SegmentMeme>> segmentMemes;
    std::map<int, std::map<UUID, SegmentMessage>> segmentMessages;
    std::map<int, std::map<UUID, SegmentMeta>> segmentMetas;
 
    static void validate(SegmentMeme entity);
 
    static void validate(Segment entity);
 
  public:
    SEGMENT_STORE_CORE_HEADERS(SegmentChoice, SegmentChoices)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentChoiceArrangement, SegmentChoiceArrangements)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentChoiceArrangementPick, SegmentChoiceArrangementPicks)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentChord, SegmentChords)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentChordVoicing, SegmentChordVoicings)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentMeme, SegmentMemes)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentMessage, SegmentMessages)
 
    SEGMENT_STORE_CORE_HEADERS(SegmentMeta, SegmentMetas);
 
    SegmentEntityStore() = default;
 
    Chain *put(const Chain &c);
 
    const Segment *put(const Segment &segment);
 
    std::optional<Chain *> readChain();
 
    std::optional<const Segment *> readSegment(int segmentId);
 
    std::optional<const Segment *> readSegmentAtChainMicros(const unsigned long long int chainMicros);
 
    std::vector<const Segment *> readAllSegments();
 
    std::vector<const Segment *> readAllSegmentsInState(Segment::State segmentState);
 
    std::vector<const Segment *> readSegmentsFromToOffset(int fromOffset, int toOffset);
 
    std::set<const SegmentEntity *> readAllSegmentEntities(const std::set<int> &segmentIds);
 
    std::vector<const Segment *> readAllSegmentsSpanning(const unsigned long long int fromChainMicros, const unsigned long long int toChainMicros);
 
    int readLastSegmentId() const;
 
    std::optional<const Segment *> readSegmentLast();
 
    std::optional<const SegmentChoice *> readChoice(int segmentId, Program::Type programType);
 
    std::string readChoiceHash(const Segment &segment);
 
    std::set<const SegmentChoiceArrangementPick *>
    readAllSegmentChoiceArrangementPicks(const std::vector<const Segment *> &forSegments);
 
    std::set<const SegmentChoiceArrangementPick *> readAllSegmentChoiceArrangementPicks(const SegmentChoice *segmentChoice);
 
    std::vector<const SegmentChord *> readOrderedSegmentChords(int segmentId);
 
    int getSegmentCount() const;
 
    bool empty() const;
 
    const Segment *updateSegment(Segment &segment);
 
    void deleteChain();
 
    void deleteSegment(int id);
 
    void deleteSegmentsBefore(int lastSegmentId);
 
    void deleteSegmentsAfter(int lastSegmentId);
 
    void clear();
 
    static void protectSegmentStateTransition(Segment::State fromState, Segment::State toState);
 
    static void onlyAllowSegmentStateTransitions(Segment::State toState, const std::set<Segment::State> &allowedStates);
  };
 
}// namespace XJ
 
#endif//XJMUSIC_SEGMENT_ENTITY_STORE_H