Verovio
Source code documentation
functorinterface.h
1 // Name: functorinterface.h
3 // Author: David Bauer
4 // Created: 2022
5 // Copyright (c) Authors and others. All rights reserved.
7 
8 #ifndef __VRV_FUNCTOR_INTERFACE_H__
9 #define __VRV_FUNCTOR_INTERFACE_H__
10 
11 #include "vrvdef.h"
12 
13 namespace vrv {
14 
15 class Accid;
16 class Alignment;
17 class AlignmentReference;
18 class AnchoredText;
19 class AnnotScore;
20 class Arpeg;
21 class Artic;
22 class BarLine;
23 class Beam;
24 class BeamSpan;
25 class BeatRpt;
26 class BracketSpan;
27 class Breath;
28 class BTrem;
29 class Caesura;
30 class Chord;
31 class Clef;
32 class ControlElement;
33 class Course;
34 class CpMark;
35 class Cursor;
36 class Custos;
37 class Dir;
38 class Div;
39 class Dot;
40 class Dots;
41 class Doc;
42 class Dynam;
43 class EditorialElement;
44 class Ending;
45 class Expansion;
46 class F;
47 class Facsimile;
48 class Fb;
49 class Fermata;
50 class Fing;
51 class Fig;
52 class Flag;
53 class FloatingObject;
54 class FTrem;
55 class GenericLayerElement;
56 class Gliss;
57 class GraceAligner;
58 class GraceGrp;
59 class Graphic;
60 class GrpSym;
61 class Hairpin;
62 class HalfmRpt;
63 class Harm;
64 class HorizontalAligner;
65 class InstrDef;
66 class KeyAccid;
67 class KeySig;
68 class Label;
69 class LabelAbbr;
70 class Layer;
71 class LayerDef;
72 class LayerElement;
73 class LyricElement;
74 class Lb;
75 class Ligature;
76 class Lv;
77 class Mdiv;
78 class Measure;
79 class MeasureAligner;
80 class Mensur;
81 class MeterSig;
82 class MeterSigGrp;
83 class Mordent;
84 class MNum;
85 class MRest;
86 class MRpt;
87 class MRpt2;
88 class MSpace;
89 class MultiRest;
90 class MultiRpt;
91 class Nc;
92 class Neume;
93 class Note;
94 class Num;
95 class Object;
96 class Octave;
97 class Ornam;
98 class Ossia;
99 class Page;
100 class PageElement;
101 class PageMilestoneEnd;
102 class Pages;
103 class Pb;
104 class Pedal;
105 class PgFoot;
106 class PgHead;
107 class Phrase;
108 class PitchInflection;
109 class Plica;
110 class Proport;
111 class RepeatMark;
112 class Reh;
113 class Refrain;
114 class Rend;
115 class Rest;
116 class RunningElement;
117 class Sb;
118 class Score;
119 class ScoreDef;
120 class ScoreDefElement;
121 class Section;
122 class Slur;
123 class Space;
124 class Staff;
125 class StaffAlignment;
126 class StaffDef;
127 class StaffGrp;
128 class Stem;
129 class Surface;
130 class Svg;
131 class Syl;
132 class Syllable;
133 class Symbol;
134 class System;
135 class SystemAligner;
136 class SystemElement;
137 class SystemMilestoneEnd;
138 class TabDurSym;
139 class TabGrp;
140 class Tempo;
141 class Text;
142 class TextElement;
143 class TextLayoutElement;
144 class Tie;
145 class TimestampAligner;
146 class TimestampAttr;
147 class Trill;
148 class Tuning;
149 class Tuplet;
150 class TupletBracket;
151 class TupletNum;
152 class Turn;
153 class Volta;
154 class Verse;
155 class Zone;
156 
157 //----------------------------------------------------------------------------
158 // FunctorInterface
159 //----------------------------------------------------------------------------
160 
165 class FunctorInterface {
166 public:
171  FunctorInterface() {}
172  virtual ~FunctorInterface() = default;
174 
179  virtual FunctorCode VisitObject(Object *) { return FUNCTOR_CONTINUE; }
180  virtual FunctorCode VisitObjectEnd(Object *) { return FUNCTOR_CONTINUE; }
181  virtual FunctorCode VisitDoc(Doc *doc);
182  virtual FunctorCode VisitDocEnd(Doc *doc);
184 
189  virtual FunctorCode VisitCourse(Course *course);
190  virtual FunctorCode VisitCourseEnd(Course *course);
191  virtual FunctorCode VisitGrpSym(GrpSym *grpSym);
192  virtual FunctorCode VisitGrpSymEnd(GrpSym *grpSym);
193  virtual FunctorCode VisitInstrDef(InstrDef *instrDef);
194  virtual FunctorCode VisitInstrDefEnd(InstrDef *instrDef);
195  virtual FunctorCode VisitLabel(Label *label);
196  virtual FunctorCode VisitLabelEnd(Label *label);
197  virtual FunctorCode VisitLabelAbbr(LabelAbbr *labelAbbr);
198  virtual FunctorCode VisitLabelAbbrEnd(LabelAbbr *labelAbbr);
199  virtual FunctorCode VisitLayer(Layer *layer);
200  virtual FunctorCode VisitLayerEnd(Layer *layer);
201  virtual FunctorCode VisitLayerDef(LayerDef *layerDef);
202  virtual FunctorCode VisitLayerDefEnd(LayerDef *layerDef);
203  virtual FunctorCode VisitMeasure(Measure *measure);
204  virtual FunctorCode VisitMeasureEnd(Measure *measure);
205  virtual FunctorCode VisitOssia(Ossia *ossia);
206  virtual FunctorCode VisitOssiaEnd(Ossia *ossia);
207  virtual FunctorCode VisitPage(Page *page);
208  virtual FunctorCode VisitPageEnd(Page *page);
209  virtual FunctorCode VisitPages(Pages *pages);
210  virtual FunctorCode VisitPagesEnd(Pages *pages);
211  virtual FunctorCode VisitPb(Pb *pb);
212  virtual FunctorCode VisitPbEnd(Pb *pb);
213  virtual FunctorCode VisitSb(Sb *sb);
214  virtual FunctorCode VisitSbEnd(Sb *sb);
215  virtual FunctorCode VisitScoreDef(ScoreDef *scoreDef);
216  virtual FunctorCode VisitScoreDefEnd(ScoreDef *scoreDef);
217  virtual FunctorCode VisitScoreDefElement(ScoreDefElement *scoreDefElement);
218  virtual FunctorCode VisitScoreDefElementEnd(ScoreDefElement *scoreDefElement);
219  virtual FunctorCode VisitStaff(Staff *staff);
220  virtual FunctorCode VisitStaffEnd(Staff *staff);
221  virtual FunctorCode VisitStaffDef(StaffDef *staffDef);
222  virtual FunctorCode VisitStaffDefEnd(StaffDef *staffDef);
223  virtual FunctorCode VisitStaffGrp(StaffGrp *staffGrp);
224  virtual FunctorCode VisitStaffGrpEnd(StaffGrp *staffGrp);
225  virtual FunctorCode VisitSystem(System *system);
226  virtual FunctorCode VisitSystemEnd(System *system);
227  virtual FunctorCode VisitTuning(Tuning *tuning);
228  virtual FunctorCode VisitTuningEnd(Tuning *tuning);
230 
236  virtual FunctorCode VisitEditorialElement(EditorialElement *editorialElement);
237  virtual FunctorCode VisitEditorialElementEnd(EditorialElement *editorialElement);
239 
244  virtual FunctorCode VisitDiv(Div *div);
245  virtual FunctorCode VisitDivEnd(Div *div);
246  virtual FunctorCode VisitRunningElement(RunningElement *runningElement);
247  virtual FunctorCode VisitRunningElementEnd(RunningElement *runningElement);
248  virtual FunctorCode VisitPgFoot(PgFoot *pgFoot);
249  virtual FunctorCode VisitPgFootEnd(PgFoot *pgFoot);
250  virtual FunctorCode VisitPgHead(PgHead *pgHead);
251  virtual FunctorCode VisitPgHeadEnd(PgHead *pgHead);
252  virtual FunctorCode VisitTextLayoutElement(TextLayoutElement *textLayoutElement);
253  virtual FunctorCode VisitTextLayoutElementEnd(TextLayoutElement *textLayoutElement);
255 
260  virtual FunctorCode VisitEnding(Ending *ending);
261  virtual FunctorCode VisitEndingEnd(Ending *ending);
262  virtual FunctorCode VisitExpansion(Expansion *expansion);
263  virtual FunctorCode VisitExpansionEnd(Expansion *expansion);
264  virtual FunctorCode VisitSection(Section *section);
265  virtual FunctorCode VisitSectionEnd(Section *section);
266  virtual FunctorCode VisitSystemElement(SystemElement *systemElement);
267  virtual FunctorCode VisitSystemElementEnd(SystemElement *systemElement);
268  virtual FunctorCode VisitSystemMilestone(SystemMilestoneEnd *systemMilestoneEnd);
269  virtual FunctorCode VisitSystemMilestoneEnd(SystemMilestoneEnd *systemMilestoneEnd);
271 
276  virtual FunctorCode VisitMdiv(Mdiv *mdiv);
277  virtual FunctorCode VisitMdivEnd(Mdiv *mdiv);
278  virtual FunctorCode VisitPageElement(PageElement *pageElement);
279  virtual FunctorCode VisitPageElementEnd(PageElement *pageElement);
280  virtual FunctorCode VisitPageMilestone(PageMilestoneEnd *pageMilestoneEnd);
281  virtual FunctorCode VisitPageMilestoneEnd(PageMilestoneEnd *pageMilestoneEnd);
282  virtual FunctorCode VisitScore(Score *score);
283  virtual FunctorCode VisitScoreEnd(Score *score);
285 
290  virtual FunctorCode VisitAnchoredText(AnchoredText *anchoredText);
291  virtual FunctorCode VisitAnchoredTextEnd(AnchoredText *anchoredText);
292  virtual FunctorCode VisitAnnotScore(AnnotScore *annotScore);
293  virtual FunctorCode VisitAnnotScoreEnd(AnnotScore *annotScore);
294  virtual FunctorCode VisitArpeg(Arpeg *arpeg);
295  virtual FunctorCode VisitArpegEnd(Arpeg *arpeg);
296  virtual FunctorCode VisitBeamSpan(BeamSpan *beamSpan);
297  virtual FunctorCode VisitBeamSpanEnd(BeamSpan *beamSpan);
298  virtual FunctorCode VisitBracketSpan(BracketSpan *bracketSpan);
299  virtual FunctorCode VisitBracketSpanEnd(BracketSpan *bracketSpan);
300  virtual FunctorCode VisitBreath(Breath *breath);
301  virtual FunctorCode VisitBreathEnd(Breath *breath);
302  virtual FunctorCode VisitCaesura(Caesura *caesura);
303  virtual FunctorCode VisitCaesuraEnd(Caesura *caesura);
304  virtual FunctorCode VisitControlElement(ControlElement *controlElement);
305  virtual FunctorCode VisitControlElementEnd(ControlElement *controlElement);
306  virtual FunctorCode VisitCpMark(CpMark *cpMark);
307  virtual FunctorCode VisitCpMarkEnd(CpMark *cpMark);
308  virtual FunctorCode VisitDir(Dir *dir);
309  virtual FunctorCode VisitDirEnd(Dir *dir);
310  virtual FunctorCode VisitDynam(Dynam *dynam);
311  virtual FunctorCode VisitDynamEnd(Dynam *dynam);
312  virtual FunctorCode VisitFermata(Fermata *fermata);
313  virtual FunctorCode VisitFermataEnd(Fermata *fermata);
314  virtual FunctorCode VisitFing(Fing *fing);
315  virtual FunctorCode VisitFingEnd(Fing *fing);
316  virtual FunctorCode VisitGliss(Gliss *gliss);
317  virtual FunctorCode VisitGlissEnd(Gliss *gliss);
318  virtual FunctorCode VisitHairpin(Hairpin *hairpin);
319  virtual FunctorCode VisitHairpinEnd(Hairpin *hairpin);
320  virtual FunctorCode VisitHarm(Harm *harm);
321  virtual FunctorCode VisitHarmEnd(Harm *harm);
322  virtual FunctorCode VisitLv(Lv *lv);
323  virtual FunctorCode VisitLvEnd(Lv *lv);
324  virtual FunctorCode VisitMordent(Mordent *mordent);
325  virtual FunctorCode VisitMordentEnd(Mordent *mordent);
326  virtual FunctorCode VisitOctave(Octave *octave);
327  virtual FunctorCode VisitOctaveEnd(Octave *octave);
328  virtual FunctorCode VisitOrnam(Ornam *ornam);
329  virtual FunctorCode VisitOrnamEnd(Ornam *ornam);
330  virtual FunctorCode VisitPedal(Pedal *pedal);
331  virtual FunctorCode VisitPedalEnd(Pedal *pedal);
332  virtual FunctorCode VisitPhrase(Phrase *phrase);
333  virtual FunctorCode VisitPhraseEnd(Phrase *phrase);
334  virtual FunctorCode VisitPitchInflection(PitchInflection *pitchInflection);
335  virtual FunctorCode VisitPitchInflectionEnd(PitchInflection *pitchInflection);
336  virtual FunctorCode VisitReh(Reh *reh);
337  virtual FunctorCode VisitRehEnd(Reh *reh);
338  virtual FunctorCode VisitRepeatMark(RepeatMark *repeatMark);
339  virtual FunctorCode VisitRepeatMarkEnd(RepeatMark *repeatMark);
340  virtual FunctorCode VisitSlur(Slur *slur);
341  virtual FunctorCode VisitSlurEnd(Slur *slur);
342  virtual FunctorCode VisitTempo(Tempo *tempo);
343  virtual FunctorCode VisitTempoEnd(Tempo *tempo);
344  virtual FunctorCode VisitTie(Tie *tie);
345  virtual FunctorCode VisitTieEnd(Tie *tie);
346  virtual FunctorCode VisitTrill(Trill *trill);
347  virtual FunctorCode VisitTrillEnd(Trill *trill);
348  virtual FunctorCode VisitTurn(Turn *turn);
349  virtual FunctorCode VisitTurnEnd(Turn *turn);
351 
356  virtual FunctorCode VisitAccid(Accid *accid);
357  virtual FunctorCode VisitAccidEnd(Accid *accid);
358  virtual FunctorCode VisitArtic(Artic *artic);
359  virtual FunctorCode VisitArticEnd(Artic *artic);
360  virtual FunctorCode VisitBarLine(BarLine *barLine);
361  virtual FunctorCode VisitBarLineEnd(BarLine *barLine);
362  virtual FunctorCode VisitBeam(Beam *beam);
363  virtual FunctorCode VisitBeamEnd(Beam *beam);
364  virtual FunctorCode VisitBeatRpt(BeatRpt *beatRpt);
365  virtual FunctorCode VisitBeatRptEnd(BeatRpt *beatRpt);
366  virtual FunctorCode VisitBTrem(BTrem *bTrem);
367  virtual FunctorCode VisitBTremEnd(BTrem *bTrem);
368  virtual FunctorCode VisitChord(Chord *chord);
369  virtual FunctorCode VisitChordEnd(Chord *chord);
370  virtual FunctorCode VisitClef(Clef *clef);
371  virtual FunctorCode VisitClefEnd(Clef *clef);
372  virtual FunctorCode VisitCursor(Cursor *cursor);
373  virtual FunctorCode VisitCursorEnd(Cursor *cursor);
374  virtual FunctorCode VisitCustos(Custos *custos);
375  virtual FunctorCode VisitCustosEnd(Custos *custos);
376  virtual FunctorCode VisitDot(Dot *dot);
377  virtual FunctorCode VisitDotEnd(Dot *dot);
378  virtual FunctorCode VisitDots(Dots *dots);
379  virtual FunctorCode VisitDotsEnd(Dots *dots);
380  virtual FunctorCode VisitFlag(Flag *flag);
381  virtual FunctorCode VisitFlagEnd(Flag *flag);
382  virtual FunctorCode VisitFTrem(FTrem *fTrem);
383  virtual FunctorCode VisitFTremEnd(FTrem *fTrem);
384  virtual FunctorCode VisitGenericLayerElement(GenericLayerElement *genericLayerElement);
385  virtual FunctorCode VisitGenericLayerElementEnd(GenericLayerElement *genericLayerElement);
386  virtual FunctorCode VisitGraceGrp(GraceGrp *graceGrp);
387  virtual FunctorCode VisitGraceGrpEnd(GraceGrp *graceGrp);
388  virtual FunctorCode VisitHalfmRpt(HalfmRpt *halfmRpt);
389  virtual FunctorCode VisitHalfmRptEnd(HalfmRpt *halfmRpt);
390  virtual FunctorCode VisitKeyAccid(KeyAccid *keyAccid);
391  virtual FunctorCode VisitKeyAccidEnd(KeyAccid *keyAccid);
392  virtual FunctorCode VisitKeySig(KeySig *keySig);
393  virtual FunctorCode VisitKeySigEnd(KeySig *keySig);
394  virtual FunctorCode VisitLayerElement(LayerElement *layerElement);
395  virtual FunctorCode VisitLayerElementEnd(LayerElement *layerElement);
396  virtual FunctorCode VisitLyricElement(LyricElement *lyricElement);
397  virtual FunctorCode VisitLyricElementEnd(LyricElement *lyricElement);
398  virtual FunctorCode VisitLigature(Ligature *ligature);
399  virtual FunctorCode VisitLigatureEnd(Ligature *ligature);
400  virtual FunctorCode VisitMensur(Mensur *mensur);
401  virtual FunctorCode VisitMensurEnd(Mensur *mensur);
402  virtual FunctorCode VisitMeterSig(MeterSig *meterSig);
403  virtual FunctorCode VisitMeterSigEnd(MeterSig *meterSig);
404  virtual FunctorCode VisitMeterSigGrp(MeterSigGrp *meterSigGrp);
405  virtual FunctorCode VisitMeterSigGrpEnd(MeterSigGrp *meterSigGrp);
406  virtual FunctorCode VisitMRest(MRest *mRest);
407  virtual FunctorCode VisitMRestEnd(MRest *mRest);
408  virtual FunctorCode VisitMRpt(MRpt *mRpt);
409  virtual FunctorCode VisitMRptEnd(MRpt *mRpt);
410  virtual FunctorCode VisitMRpt2(MRpt2 *mRpt2);
411  virtual FunctorCode VisitMRpt2End(MRpt2 *mRpt2);
412  virtual FunctorCode VisitMSpace(MSpace *mSpace);
413  virtual FunctorCode VisitMSpaceEnd(MSpace *mSpace);
414  virtual FunctorCode VisitMultiRest(MultiRest *multiRest);
415  virtual FunctorCode VisitMultiRestEnd(MultiRest *multiRest);
416  virtual FunctorCode VisitMultiRpt(MultiRpt *multiRpt);
417  virtual FunctorCode VisitMultiRptEnd(MultiRpt *multiRpt);
418  virtual FunctorCode VisitNc(Nc *nc);
419  virtual FunctorCode VisitNcEnd(Nc *nc);
420  virtual FunctorCode VisitNeume(Neume *neume);
421  virtual FunctorCode VisitNeumeEnd(Neume *neume);
422  virtual FunctorCode VisitNote(Note *note);
423  virtual FunctorCode VisitNoteEnd(Note *note);
424  virtual FunctorCode VisitPlica(Plica *plica);
425  virtual FunctorCode VisitPlicaEnd(Plica *plica);
426  virtual FunctorCode VisitProport(Proport *proport);
427  virtual FunctorCode VisitProportEnd(Proport *proport);
428  virtual FunctorCode VisitRefrain(Refrain *refrain);
429  virtual FunctorCode VisitRefrainEnd(Refrain *refrain);
430  virtual FunctorCode VisitRest(Rest *rest);
431  virtual FunctorCode VisitRestEnd(Rest *rest);
432  virtual FunctorCode VisitSpace(Space *space);
433  virtual FunctorCode VisitSpaceEnd(Space *space);
434  virtual FunctorCode VisitStem(Stem *stem);
435  virtual FunctorCode VisitStemEnd(Stem *stem);
436  virtual FunctorCode VisitSyl(Syl *syl);
437  virtual FunctorCode VisitSylEnd(Syl *syl);
438  virtual FunctorCode VisitSyllable(Syllable *syllable);
439  virtual FunctorCode VisitSyllableEnd(Syllable *syllable);
440  virtual FunctorCode VisitTabDurSym(TabDurSym *tabDurSym);
441  virtual FunctorCode VisitTabDurSymEnd(TabDurSym *tabDurSym);
442  virtual FunctorCode VisitTabGrp(TabGrp *tabGrp);
443  virtual FunctorCode VisitTabGrpEnd(TabGrp *tabGrp);
444  virtual FunctorCode VisitTimestamp(TimestampAttr *timestamp);
445  virtual FunctorCode VisitTimestampEnd(TimestampAttr *timestamp);
446  virtual FunctorCode VisitTuplet(Tuplet *tuplet);
447  virtual FunctorCode VisitTupletEnd(Tuplet *tuplet);
448  virtual FunctorCode VisitTupletBracket(TupletBracket *tupletBracket);
449  virtual FunctorCode VisitTupletBracketEnd(TupletBracket *tupletBracket);
450  virtual FunctorCode VisitTupletNum(TupletNum *tupletNum);
451  virtual FunctorCode VisitTupletNumEnd(TupletNum *tupletNum);
452  virtual FunctorCode VisitVolta(Volta *volta);
453  virtual FunctorCode VisitVoltaEnd(Volta *volta);
454  virtual FunctorCode VisitVerse(Verse *verse);
455  virtual FunctorCode VisitVerseEnd(Verse *verse);
457 
462  virtual FunctorCode VisitF(F *f);
463  virtual FunctorCode VisitFEnd(F *f);
464  virtual FunctorCode VisitFb(Fb *fb);
465  virtual FunctorCode VisitFbEnd(Fb *fb);
466  virtual FunctorCode VisitFig(Fig *fig);
467  virtual FunctorCode VisitFigEnd(Fig *fig);
468  virtual FunctorCode VisitLb(Lb *lb);
469  virtual FunctorCode VisitLbEnd(Lb *lb);
470  virtual FunctorCode VisitMNum(MNum *mNum);
471  virtual FunctorCode VisitMNumEnd(MNum *mNum);
472  virtual FunctorCode VisitNum(Num *num);
473  virtual FunctorCode VisitNumEnd(Num *num);
474  virtual FunctorCode VisitRend(Rend *rend);
475  virtual FunctorCode VisitRendEnd(Rend *rend);
476  virtual FunctorCode VisitSvg(Svg *svg);
477  virtual FunctorCode VisitSvgEnd(Svg *svg);
478  virtual FunctorCode VisitSymbol(Symbol *symbol);
479  virtual FunctorCode VisitSymbolEnd(Symbol *symbol);
480  virtual FunctorCode VisitText(Text *text);
481  virtual FunctorCode VisitTextEnd(Text *text);
482  virtual FunctorCode VisitTextElement(TextElement *textElement);
483  virtual FunctorCode VisitTextElementEnd(TextElement *textElement);
485 
490  virtual FunctorCode VisitFacsimile(Facsimile *facsimile);
491  virtual FunctorCode VisitFacsimileEnd(Facsimile *facsimile);
492  virtual FunctorCode VisitGraphic(Graphic *graphic);
493  virtual FunctorCode VisitGraphicEnd(Graphic *graphic);
494  virtual FunctorCode VisitSurface(Surface *surface);
495  virtual FunctorCode VisitSurfaceEnd(Surface *surface);
496  virtual FunctorCode VisitZone(Zone *zone);
497  virtual FunctorCode VisitZoneEnd(Zone *zone);
499 
504  virtual FunctorCode VisitAlignment(Alignment *alignment);
505  virtual FunctorCode VisitAlignmentEnd(Alignment *alignment);
506  virtual FunctorCode VisitAlignmentReference(AlignmentReference *alignmentReference);
507  virtual FunctorCode VisitAlignmentReferenceEnd(AlignmentReference *alignmentReference);
508  virtual FunctorCode VisitHorizontalAligner(HorizontalAligner *horizontalAligner);
509  virtual FunctorCode VisitHorizontalAlignerEnd(HorizontalAligner *horizontalAligner);
510  virtual FunctorCode VisitMeasureAligner(MeasureAligner *measureAligner);
511  virtual FunctorCode VisitMeasureAlignerEnd(MeasureAligner *measureAligner);
512  virtual FunctorCode VisitGraceAligner(GraceAligner *graceAligner);
513  virtual FunctorCode VisitGraceAlignerEnd(GraceAligner *graceAligner);
514  virtual FunctorCode VisitTimestampAligner(TimestampAligner *timestampAligner);
515  virtual FunctorCode VisitTimestampAlignerEnd(TimestampAligner *timestampAligner);
517 
522  virtual FunctorCode VisitSystemAligner(SystemAligner *systemAligner);
523  virtual FunctorCode VisitSystemAlignerEnd(SystemAligner *systemAligner);
524  virtual FunctorCode VisitStaffAlignment(StaffAlignment *staffAlignment);
525  virtual FunctorCode VisitStaffAlignmentEnd(StaffAlignment *staffAlignment);
527 
532  virtual FunctorCode VisitFloatingObject(FloatingObject *floatingObject);
533  virtual FunctorCode VisitFloatingObjectEnd(FloatingObject *floatingObject);
535 
536 private:
537  //
538 public:
539  //
540 private:
541  //
542 };
543 
544 //----------------------------------------------------------------------------
545 // ConstFunctorInterface
546 //----------------------------------------------------------------------------
547 
552 class ConstFunctorInterface {
553 public:
558  ConstFunctorInterface() {}
559  virtual ~ConstFunctorInterface() = default;
561 
566  virtual FunctorCode VisitObject(const Object *) { return FUNCTOR_CONTINUE; }
567  virtual FunctorCode VisitObjectEnd(const Object *) { return FUNCTOR_CONTINUE; }
568  virtual FunctorCode VisitDoc(const Doc *doc);
569  virtual FunctorCode VisitDocEnd(const Doc *doc);
571 
576  virtual FunctorCode VisitCourse(const Course *course);
577  virtual FunctorCode VisitCourseEnd(const Course *course);
578  virtual FunctorCode VisitGrpSym(const GrpSym *grpSym);
579  virtual FunctorCode VisitGrpSymEnd(const GrpSym *grpSym);
580  virtual FunctorCode VisitInstrDef(const InstrDef *instrDef);
581  virtual FunctorCode VisitInstrDefEnd(const InstrDef *instrDef);
582  virtual FunctorCode VisitLabel(const Label *label);
583  virtual FunctorCode VisitLabelEnd(const Label *label);
584  virtual FunctorCode VisitLabelAbbr(const LabelAbbr *labelAbbr);
585  virtual FunctorCode VisitLabelAbbrEnd(const LabelAbbr *labelAbbr);
586  virtual FunctorCode VisitLayer(const Layer *layer);
587  virtual FunctorCode VisitLayerEnd(const Layer *layer);
588  virtual FunctorCode VisitLayerDef(const LayerDef *layerDef);
589  virtual FunctorCode VisitLayerDefEnd(const LayerDef *layerDef);
590  virtual FunctorCode VisitMeasure(const Measure *measure);
591  virtual FunctorCode VisitMeasureEnd(const Measure *measure);
592  virtual FunctorCode VisitOssia(const Ossia *ossia);
593  virtual FunctorCode VisitOssiaEnd(const Ossia *ossia);
594  virtual FunctorCode VisitPage(const Page *page);
595  virtual FunctorCode VisitPageEnd(const Page *page);
596  virtual FunctorCode VisitPages(const Pages *pages);
597  virtual FunctorCode VisitPagesEnd(const Pages *pages);
598  virtual FunctorCode VisitPb(const Pb *pb);
599  virtual FunctorCode VisitPbEnd(const Pb *pb);
600  virtual FunctorCode VisitSb(const Sb *sb);
601  virtual FunctorCode VisitSbEnd(const Sb *sb);
602  virtual FunctorCode VisitScoreDef(const ScoreDef *scoreDef);
603  virtual FunctorCode VisitScoreDefEnd(const ScoreDef *scoreDef);
604  virtual FunctorCode VisitScoreDefElement(const ScoreDefElement *scoreDefElement);
605  virtual FunctorCode VisitScoreDefElementEnd(const ScoreDefElement *scoreDefElement);
606  virtual FunctorCode VisitStaff(const Staff *staff);
607  virtual FunctorCode VisitStaffEnd(const Staff *staff);
608  virtual FunctorCode VisitStaffDef(const StaffDef *staffDef);
609  virtual FunctorCode VisitStaffDefEnd(const StaffDef *staffDef);
610  virtual FunctorCode VisitStaffGrp(const StaffGrp *staffGrp);
611  virtual FunctorCode VisitStaffGrpEnd(const StaffGrp *staffGrp);
612  virtual FunctorCode VisitSystem(const System *system);
613  virtual FunctorCode VisitSystemEnd(const System *system);
614  virtual FunctorCode VisitTuning(const Tuning *tuning);
615  virtual FunctorCode VisitTuningEnd(const Tuning *tuning);
617 
623  virtual FunctorCode VisitEditorialElement(const EditorialElement *editorialElement);
624  virtual FunctorCode VisitEditorialElementEnd(const EditorialElement *editorialElement);
626 
631  virtual FunctorCode VisitDiv(const Div *div);
632  virtual FunctorCode VisitDivEnd(const Div *div);
633  virtual FunctorCode VisitRunningElement(const RunningElement *runningElement);
634  virtual FunctorCode VisitRunningElementEnd(const RunningElement *runningElement);
635  virtual FunctorCode VisitPgFoot(const PgFoot *pgFoot);
636  virtual FunctorCode VisitPgFootEnd(const PgFoot *pgFoot);
637  virtual FunctorCode VisitPgHead(const PgHead *pgHead);
638  virtual FunctorCode VisitPgHeadEnd(const PgHead *pgHead);
639  virtual FunctorCode VisitTextLayoutElement(const TextLayoutElement *textLayoutElement);
640  virtual FunctorCode VisitTextLayoutElementEnd(const TextLayoutElement *textLayoutElement);
642 
647  virtual FunctorCode VisitEnding(const Ending *ending);
648  virtual FunctorCode VisitEndingEnd(const Ending *ending);
649  virtual FunctorCode VisitExpansion(const Expansion *expansion);
650  virtual FunctorCode VisitExpansionEnd(const Expansion *expansion);
651  virtual FunctorCode VisitSection(const Section *section);
652  virtual FunctorCode VisitSectionEnd(const Section *section);
653  virtual FunctorCode VisitSystemElement(const SystemElement *systemElement);
654  virtual FunctorCode VisitSystemElementEnd(const SystemElement *systemElement);
655  virtual FunctorCode VisitSystemMilestone(const SystemMilestoneEnd *systemMilestoneEnd);
656  virtual FunctorCode VisitSystemMilestoneEnd(const SystemMilestoneEnd *systemMilestoneEnd);
658 
663  virtual FunctorCode VisitMdiv(const Mdiv *mdiv);
664  virtual FunctorCode VisitMdivEnd(const Mdiv *mdiv);
665  virtual FunctorCode VisitPageElement(const PageElement *pageElement);
666  virtual FunctorCode VisitPageElementEnd(const PageElement *pageElement);
667  virtual FunctorCode VisitPageMilestone(const PageMilestoneEnd *pageMilestoneEnd);
668  virtual FunctorCode VisitPageMilestoneEnd(const PageMilestoneEnd *pageMilestoneEnd);
669  virtual FunctorCode VisitScore(const Score *score);
670  virtual FunctorCode VisitScoreEnd(const Score *score);
672 
677  virtual FunctorCode VisitAnchoredText(const AnchoredText *anchoredText);
678  virtual FunctorCode VisitAnchoredTextEnd(const AnchoredText *anchoredText);
679  virtual FunctorCode VisitAnnotScore(const AnnotScore *annotScore);
680  virtual FunctorCode VisitAnnotScoreEnd(const AnnotScore *annotScore);
681  virtual FunctorCode VisitArpeg(const Arpeg *arpeg);
682  virtual FunctorCode VisitArpegEnd(const Arpeg *arpeg);
683  virtual FunctorCode VisitBeamSpan(const BeamSpan *beamSpan);
684  virtual FunctorCode VisitBeamSpanEnd(const BeamSpan *beamSpan);
685  virtual FunctorCode VisitBracketSpan(const BracketSpan *bracketSpan);
686  virtual FunctorCode VisitBracketSpanEnd(const BracketSpan *bracketSpan);
687  virtual FunctorCode VisitBreath(const Breath *breath);
688  virtual FunctorCode VisitBreathEnd(const Breath *breath);
689  virtual FunctorCode VisitCaesura(const Caesura *caesura);
690  virtual FunctorCode VisitCaesuraEnd(const Caesura *caesura);
691  virtual FunctorCode VisitControlElement(const ControlElement *controlElement);
692  virtual FunctorCode VisitControlElementEnd(const ControlElement *controlElement);
693  virtual FunctorCode VisitCpMark(const CpMark *cpMark);
694  virtual FunctorCode VisitCpMarkEnd(const CpMark *cpMark);
695  virtual FunctorCode VisitDir(const Dir *dir);
696  virtual FunctorCode VisitDirEnd(const Dir *dir);
697  virtual FunctorCode VisitDynam(const Dynam *dynam);
698  virtual FunctorCode VisitDynamEnd(const Dynam *dynam);
699  virtual FunctorCode VisitFermata(const Fermata *fermata);
700  virtual FunctorCode VisitFermataEnd(const Fermata *fermata);
701  virtual FunctorCode VisitFing(const Fing *fing);
702  virtual FunctorCode VisitFingEnd(const Fing *fing);
703  virtual FunctorCode VisitGliss(const Gliss *gliss);
704  virtual FunctorCode VisitGlissEnd(const Gliss *gliss);
705  virtual FunctorCode VisitHairpin(const Hairpin *hairpin);
706  virtual FunctorCode VisitHairpinEnd(const Hairpin *hairpin);
707  virtual FunctorCode VisitHarm(const Harm *harm);
708  virtual FunctorCode VisitHarmEnd(const Harm *harm);
709  virtual FunctorCode VisitLv(const Lv *lv);
710  virtual FunctorCode VisitLvEnd(const Lv *lv);
711  virtual FunctorCode VisitMordent(const Mordent *mordent);
712  virtual FunctorCode VisitMordentEnd(const Mordent *mordent);
713  virtual FunctorCode VisitOctave(const Octave *octave);
714  virtual FunctorCode VisitOctaveEnd(const Octave *octave);
715  virtual FunctorCode VisitOrnam(const Ornam *ornam);
716  virtual FunctorCode VisitOrnamEnd(const Ornam *ornam);
717  virtual FunctorCode VisitPedal(const Pedal *pedal);
718  virtual FunctorCode VisitPedalEnd(const Pedal *pedal);
719  virtual FunctorCode VisitPhrase(const Phrase *phrase);
720  virtual FunctorCode VisitPhraseEnd(const Phrase *phrase);
721  virtual FunctorCode VisitPitchInflection(const PitchInflection *pitchInflection);
722  virtual FunctorCode VisitPitchInflectionEnd(const PitchInflection *pitchInflection);
723  virtual FunctorCode VisitReh(const Reh *reh);
724  virtual FunctorCode VisitRehEnd(const Reh *reh);
725  virtual FunctorCode VisitRepeatMark(const RepeatMark *repeatMark);
726  virtual FunctorCode VisitRepeatMarkEnd(const RepeatMark *repeatMark);
727  virtual FunctorCode VisitSlur(const Slur *slur);
728  virtual FunctorCode VisitSlurEnd(const Slur *slur);
729  virtual FunctorCode VisitTempo(const Tempo *tempo);
730  virtual FunctorCode VisitTempoEnd(const Tempo *tempo);
731  virtual FunctorCode VisitTie(const Tie *tie);
732  virtual FunctorCode VisitTieEnd(const Tie *tie);
733  virtual FunctorCode VisitTrill(const Trill *trill);
734  virtual FunctorCode VisitTrillEnd(const Trill *trill);
735  virtual FunctorCode VisitTurn(const Turn *turn);
736  virtual FunctorCode VisitTurnEnd(const Turn *turn);
738 
743  virtual FunctorCode VisitAccid(const Accid *accid);
744  virtual FunctorCode VisitAccidEnd(const Accid *accid);
745  virtual FunctorCode VisitArtic(const Artic *artic);
746  virtual FunctorCode VisitArticEnd(const Artic *artic);
747  virtual FunctorCode VisitBarLine(const BarLine *barLine);
748  virtual FunctorCode VisitBarLineEnd(const BarLine *barLine);
749  virtual FunctorCode VisitBeam(const Beam *beam);
750  virtual FunctorCode VisitBeamEnd(const Beam *beam);
751  virtual FunctorCode VisitBeatRpt(const BeatRpt *beatRpt);
752  virtual FunctorCode VisitBeatRptEnd(const BeatRpt *beatRpt);
753  virtual FunctorCode VisitBTrem(const BTrem *bTrem);
754  virtual FunctorCode VisitBTremEnd(const BTrem *bTrem);
755  virtual FunctorCode VisitChord(const Chord *chord);
756  virtual FunctorCode VisitChordEnd(const Chord *chord);
757  virtual FunctorCode VisitClef(const Clef *clef);
758  virtual FunctorCode VisitClefEnd(const Clef *clef);
759  virtual FunctorCode VisitCursor(const Cursor *cursor);
760  virtual FunctorCode VisitCursorEnd(const Cursor *cursor);
761  virtual FunctorCode VisitCustos(const Custos *custos);
762  virtual FunctorCode VisitCustosEnd(const Custos *custos);
763  virtual FunctorCode VisitDot(const Dot *dot);
764  virtual FunctorCode VisitDotEnd(const Dot *dot);
765  virtual FunctorCode VisitDots(const Dots *dots);
766  virtual FunctorCode VisitDotsEnd(const Dots *dots);
767  virtual FunctorCode VisitFlag(const Flag *flag);
768  virtual FunctorCode VisitFlagEnd(const Flag *flag);
769  virtual FunctorCode VisitFTrem(const FTrem *fTrem);
770  virtual FunctorCode VisitFTremEnd(const FTrem *fTrem);
771  virtual FunctorCode VisitGenericLayerElement(const GenericLayerElement *genericLayerElement);
772  virtual FunctorCode VisitGenericLayerElementEnd(const GenericLayerElement *genericLayerElement);
773  virtual FunctorCode VisitGraceGrp(const GraceGrp *graceGrp);
774  virtual FunctorCode VisitGraceGrpEnd(const GraceGrp *graceGrp);
775  virtual FunctorCode VisitHalfmRpt(const HalfmRpt *halfmRpt);
776  virtual FunctorCode VisitHalfmRptEnd(const HalfmRpt *halfmRpt);
777  virtual FunctorCode VisitKeyAccid(const KeyAccid *keyAccid);
778  virtual FunctorCode VisitKeyAccidEnd(const KeyAccid *keyAccid);
779  virtual FunctorCode VisitKeySig(const KeySig *keySig);
780  virtual FunctorCode VisitKeySigEnd(const KeySig *keySig);
781  virtual FunctorCode VisitLayerElement(const LayerElement *layerElement);
782  virtual FunctorCode VisitLayerElementEnd(const LayerElement *layerElement);
783  virtual FunctorCode VisitLyricElement(const LyricElement *lyricElement);
784  virtual FunctorCode VisitLyricElementEnd(const LyricElement *lyricElement);
785  virtual FunctorCode VisitLigature(const Ligature *ligature);
786  virtual FunctorCode VisitLigatureEnd(const Ligature *ligature);
787  virtual FunctorCode VisitMensur(const Mensur *mensur);
788  virtual FunctorCode VisitMensurEnd(const Mensur *mensur);
789  virtual FunctorCode VisitMeterSig(const MeterSig *meterSig);
790  virtual FunctorCode VisitMeterSigEnd(const MeterSig *meterSig);
791  virtual FunctorCode VisitMeterSigGrp(const MeterSigGrp *meterSigGrp);
792  virtual FunctorCode VisitMeterSigGrpEnd(const MeterSigGrp *meterSigGrp);
793  virtual FunctorCode VisitMRest(const MRest *mRest);
794  virtual FunctorCode VisitMRestEnd(const MRest *mRest);
795  virtual FunctorCode VisitMRpt(const MRpt *mRpt);
796  virtual FunctorCode VisitMRptEnd(const MRpt *mRpt);
797  virtual FunctorCode VisitMRpt2(const MRpt2 *mRpt2);
798  virtual FunctorCode VisitMRpt2End(const MRpt2 *mRpt2);
799  virtual FunctorCode VisitMSpace(const MSpace *mSpace);
800  virtual FunctorCode VisitMSpaceEnd(const MSpace *mSpace);
801  virtual FunctorCode VisitMultiRest(const MultiRest *multiRest);
802  virtual FunctorCode VisitMultiRestEnd(const MultiRest *multiRest);
803  virtual FunctorCode VisitMultiRpt(const MultiRpt *multiRpt);
804  virtual FunctorCode VisitMultiRptEnd(const MultiRpt *multiRpt);
805  virtual FunctorCode VisitNc(const Nc *nc);
806  virtual FunctorCode VisitNcEnd(const Nc *nc);
807  virtual FunctorCode VisitNeume(const Neume *neume);
808  virtual FunctorCode VisitNeumeEnd(const Neume *neume);
809  virtual FunctorCode VisitNote(const Note *note);
810  virtual FunctorCode VisitNoteEnd(const Note *note);
811  virtual FunctorCode VisitPlica(const Plica *plica);
812  virtual FunctorCode VisitPlicaEnd(const Plica *plica);
813  virtual FunctorCode VisitProport(const Proport *proport);
814  virtual FunctorCode VisitProportEnd(const Proport *proport);
815  virtual FunctorCode VisitRefrain(const Refrain *refrain);
816  virtual FunctorCode VisitRefrainEnd(const Refrain *refrain);
817  virtual FunctorCode VisitRest(const Rest *rest);
818  virtual FunctorCode VisitRestEnd(const Rest *rest);
819  virtual FunctorCode VisitSpace(const Space *space);
820  virtual FunctorCode VisitSpaceEnd(const Space *space);
821  virtual FunctorCode VisitStem(const Stem *stem);
822  virtual FunctorCode VisitStemEnd(const Stem *stem);
823  virtual FunctorCode VisitSyl(const Syl *syl);
824  virtual FunctorCode VisitSylEnd(const Syl *syl);
825  virtual FunctorCode VisitSyllable(const Syllable *syllable);
826  virtual FunctorCode VisitSyllableEnd(const Syllable *syllable);
827  virtual FunctorCode VisitTabDurSym(const TabDurSym *tabDurSym);
828  virtual FunctorCode VisitTabDurSymEnd(const TabDurSym *tabDurSym);
829  virtual FunctorCode VisitTabGrp(const TabGrp *tabGrp);
830  virtual FunctorCode VisitTabGrpEnd(const TabGrp *tabGrp);
831  virtual FunctorCode VisitTimestamp(const TimestampAttr *timestamp);
832  virtual FunctorCode VisitTimestampEnd(const TimestampAttr *timestamp);
833  virtual FunctorCode VisitTuplet(const Tuplet *tuplet);
834  virtual FunctorCode VisitTupletEnd(const Tuplet *tuplet);
835  virtual FunctorCode VisitTupletBracket(const TupletBracket *tupletBracket);
836  virtual FunctorCode VisitTupletBracketEnd(const TupletBracket *tupletBracket);
837  virtual FunctorCode VisitTupletNum(const TupletNum *tupletNum);
838  virtual FunctorCode VisitTupletNumEnd(const TupletNum *tupletNum);
839  virtual FunctorCode VisitVolta(const Volta *volta);
840  virtual FunctorCode VisitVoltaEnd(const Volta *volta);
841  virtual FunctorCode VisitVerse(const Verse *verse);
842  virtual FunctorCode VisitVerseEnd(const Verse *verse);
844 
849  virtual FunctorCode VisitF(const F *f);
850  virtual FunctorCode VisitFEnd(const F *f);
851  virtual FunctorCode VisitFb(const Fb *fb);
852  virtual FunctorCode VisitFbEnd(const Fb *fb);
853  virtual FunctorCode VisitFig(const Fig *fig);
854  virtual FunctorCode VisitFigEnd(const Fig *fig);
855  virtual FunctorCode VisitLb(const Lb *lb);
856  virtual FunctorCode VisitLbEnd(const Lb *lb);
857  virtual FunctorCode VisitMNum(const MNum *mNum);
858  virtual FunctorCode VisitMNumEnd(const MNum *mNum);
859  virtual FunctorCode VisitNum(const Num *num);
860  virtual FunctorCode VisitNumEnd(const Num *num);
861  virtual FunctorCode VisitRend(const Rend *rend);
862  virtual FunctorCode VisitRendEnd(const Rend *rend);
863  virtual FunctorCode VisitSvg(const Svg *svg);
864  virtual FunctorCode VisitSvgEnd(const Svg *svg);
865  virtual FunctorCode VisitSymbol(const Symbol *symbol);
866  virtual FunctorCode VisitSymbolEnd(const Symbol *symbol);
867  virtual FunctorCode VisitText(const Text *text);
868  virtual FunctorCode VisitTextEnd(const Text *text);
869  virtual FunctorCode VisitTextElement(const TextElement *textElement);
870  virtual FunctorCode VisitTextElementEnd(const TextElement *textElement);
872 
877  virtual FunctorCode VisitFacsimile(const Facsimile *facsimile);
878  virtual FunctorCode VisitFacsimileEnd(const Facsimile *facsimile);
879  virtual FunctorCode VisitGraphic(const Graphic *graphic);
880  virtual FunctorCode VisitGraphicEnd(const Graphic *graphic);
881  virtual FunctorCode VisitSurface(const Surface *surface);
882  virtual FunctorCode VisitSurfaceEnd(const Surface *surface);
883  virtual FunctorCode VisitZone(const Zone *zone);
884  virtual FunctorCode VisitZoneEnd(const Zone *zone);
886 
891  virtual FunctorCode VisitAlignment(const Alignment *alignment);
892  virtual FunctorCode VisitAlignmentEnd(const Alignment *alignment);
893  virtual FunctorCode VisitAlignmentReference(const AlignmentReference *alignmentReference);
894  virtual FunctorCode VisitAlignmentReferenceEnd(const AlignmentReference *alignmentReference);
895  virtual FunctorCode VisitHorizontalAligner(const HorizontalAligner *horizontalAligner);
896  virtual FunctorCode VisitHorizontalAlignerEnd(const HorizontalAligner *horizontalAligner);
897  virtual FunctorCode VisitMeasureAligner(const MeasureAligner *measureAligner);
898  virtual FunctorCode VisitMeasureAlignerEnd(const MeasureAligner *measureAligner);
899  virtual FunctorCode VisitGraceAligner(const GraceAligner *graceAligner);
900  virtual FunctorCode VisitGraceAlignerEnd(const GraceAligner *graceAligner);
901  virtual FunctorCode VisitTimestampAligner(const TimestampAligner *timestampAligner);
902  virtual FunctorCode VisitTimestampAlignerEnd(const TimestampAligner *timestampAligner);
904 
909  virtual FunctorCode VisitSystemAligner(const SystemAligner *systemAligner);
910  virtual FunctorCode VisitSystemAlignerEnd(const SystemAligner *systemAligner);
911  virtual FunctorCode VisitStaffAlignment(const StaffAlignment *staffAlignment);
912  virtual FunctorCode VisitStaffAlignmentEnd(const StaffAlignment *staffAlignment);
914 
919  virtual FunctorCode VisitFloatingObject(const FloatingObject *floatingObject);
920  virtual FunctorCode VisitFloatingObjectEnd(const FloatingObject *floatingObject);
922 
923 private:
924  //
925 public:
926  //
927 private:
928  //
929 };
930 
931 } // namespace vrv
932 
933 #endif // __VRV_FUNCTOR_INTERFACE_H__
vrv::Accid
This class models the MEI <accid> element.
Definition: accid.h:41
vrv::Alignment
This class stores an alignment position elements will point to.
Definition: horizontalaligner.h:77
vrv::AlignmentReference
This class stores a references of LayerElements for a staff.
Definition: horizontalaligner.h:294
vrv::AnchoredText
This class is an interface for <anchoredText> elements at the measure level.
Definition: anchoredtext.h:25
vrv::AnnotScore
This class models the MEI <annot> element where @type is score.
Definition: annotscore.h:24
vrv::Arpeg
This class models the MEI <arpeg> element.
Definition: arpeg.h:31
vrv::Artic
Definition: artic.h:31
vrv::BTrem
This class models the MEI <bTrem> element.
Definition: btrem.h:27
vrv::BarLine
This class models the MEI <barLine> element.
Definition: barline.h:34
vrv::Beam
Definition: beam.h:284
vrv::BeamSpan
This class models the MEI <beamSpan> element.
Definition: beamspan.h:36
vrv::BeatRpt
This class models the MEI <beatRpt> element.
Definition: beatrpt.h:25
vrv::BracketSpan
This class models the MEI <bracketSpan> element.
Definition: bracketspan.h:28
vrv::Breath
This class models the MEI <breath> element.
Definition: breath.h:24
vrv::Caesura
This class models the MEI <caesura> element.
Definition: caesura.h:29
vrv::Chord
This class represents a collection of notes in the same layer with the same onset time.
Definition: chord.h:44
vrv::Clef
This class models the MEI <clef> element.
Definition: clef.h:41
vrv::ConstFunctorInterface
This class is an interface for const functors based on a visitor pattern.
Definition: functorinterface.h:552
vrv::ControlElement
This class represents elements appearing within a measure.
Definition: controlelement.h:35
vrv::Course
This class models the MEI <course> element.
Definition: course.h:23
vrv::CpMark
This class models the MEI <cpMark> element.
Definition: cpmark.h:26
vrv::Cursor
This class implements a curor for the editor.
Definition: cursor.h:27
vrv::Custos
Definition: custos.h:31
vrv::Dir
This class models the MEI <dir> element.
Definition: dir.h:33
vrv::Div
This class represents an MEI Div.
Definition: div.h:24
vrv::Doc
This class is a hold the data and corresponds to the model of a MVC design pattern.
Definition: doc.h:41
vrv::Dot
Definition: dot.h:23
vrv::Dots
This class models a group of dots as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:27
vrv::Dynam
Definition: dynam.h:33
vrv::EditorialElement
This class is a base class for the editorial element containing musical content, for example <rgd> or...
Definition: editorial.h:43
vrv::Ending
This class represents a MEI ending.
Definition: ending.h:33
vrv::Expansion
This class represents a MEI expansion.
Definition: expansion.h:26
vrv::F
This class models the MEI <f> element.
Definition: f.h:24
vrv::FTrem
This class models the MEI <fTrem> element.
Definition: ftrem.h:25
vrv::Facsimile
Implements the facsimile element in MEI.
Definition: facsimile.h:31
vrv::Fb
This class models the MEI <fb> element.
Definition: fb.h:23
vrv::Fermata
This class models the MEI <fermata> element.
Definition: fermata.h:32
vrv::Fig
This class models the MEI <fig> element.
Definition: fig.h:23
vrv::Fing
This class models the MEI <fing> element.
Definition: fing.h:25
vrv::Flag
This class models a stem as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:97
vrv::FloatingObject
This class represents elements appearing within a measure.
Definition: floatingobject.h:28
vrv::FunctorInterface
This class is an interface for functors based on a visitor pattern.
Definition: functorinterface.h:165
vrv::GenericLayerElement
This class holds generic elements existing within MEI <layer> but not supported by Verovio.
Definition: genericlayerelement.h:22
vrv::Gliss
This class models the MEI <gliss> element.
Definition: gliss.h:28
vrv::GraceAligner
This class aligns the content of a grace note group It contains a vector of Alignment.
Definition: horizontalaligner.h:574
vrv::GraceGrp
Definition: gracegrp.h:20
vrv::Graphic
Implements the graphic element in MEI.
Definition: graphic.h:30
vrv::GrpSym
This class represents a MEI grpSym.
Definition: grpsym.h:30
vrv::Hairpin
This class models the MEI <hairpin> element.
Definition: hairpin.h:32
vrv::HalfmRpt
This class models the MEI <halfmRpt> element.
Definition: halfmrpt.h:27
vrv::Harm
This class models the MEI <harm> element.
Definition: harm.h:32
vrv::HorizontalAligner
This class aligns the content horizontally It contains a vector of Alignment.
Definition: horizontalaligner.h:366
vrv::InstrDef
This class models the MEI <instrDef> element.
Definition: instrdef.h:28
vrv::KeyAccid
This class models the MEI <keyAccid> element.
Definition: keyaccid.h:33
vrv::KeySig
This class models the MEI <keySig> element.
Definition: keysig.h:51
vrv::LabelAbbr
This class models the MEI <labelAbbr> element.
Definition: labelabbr.h:22
vrv::Label
This class models the MEI <label> element.
Definition: label.h:22
vrv::LayerDef
Definition: layerdef.h:18
vrv::LayerElement
This class is a base class for the Layer (<layer>) content.
Definition: layerelement.h:51
vrv::Layer
This class represents a layer in a laid-out score (Doc).
Definition: layer.h:40
vrv::Lb
This class models the MEI <lb>
Definition: lb.h:23
vrv::Ligature
This class represents a collection of notes in the same layer with successive onset times,...
Definition: ligature.h:28
vrv::Lv
This class models the MEI <lv> element.
Definition: lv.h:22
vrv::LyricElement
Shared implementation for note-attached verse and refrain lyrics.
Definition: lyricelement.h:33
vrv::MNum
This class models the MEI <mNum> element.
Definition: mnum.h:31
vrv::MRest
This class models the MEI <mRest> element.
Definition: mrest.h:36
vrv::MRpt2
This class models the MEI <mRpt2> element.
Definition: mrpt2.h:26
vrv::MRpt
This class models the MEI <mRpt> element.
Definition: mrpt.h:26
vrv::MSpace
This class models the MEI <space> element.
Definition: mspace.h:22
vrv::Mdiv
This class represent a <mdiv> in page-based MEI.
Definition: mdiv.h:29
vrv::MeasureAligner
This class aligns the content of a measure It contains a vector of Alignment.
Definition: horizontalaligner.h:429
vrv::Measure
This class represents a measure in a page-based score (Doc).
Definition: measure.h:46
vrv::Mensur
This class models the MEI <mensur> element.
Definition: mensur.h:34
vrv::MeterSigGrp
This class represents a MEI meterSigGrp.
Definition: metersiggrp.h:32
vrv::MeterSig
This class models the MEI <meterSig> element.
Definition: metersig.h:34
vrv::Mordent
This class models the MEI <mordent> element.
Definition: mordent.h:33
vrv::MultiRest
This class models the MEI <multiRest> element.
Definition: multirest.h:32
vrv::MultiRpt
This class models the MEI <multiRpt> element.
Definition: multirpt.h:25
vrv::Nc
This class models the MEI <nc> element.
Definition: nc.h:43
vrv::Neume
This class models the MEI <neume> element.
Definition: neume.h:60
vrv::Note
This class models the MEI <note> element.
Definition: note.h:69
vrv::Num
This class models the MEI <num> element.
Definition: num.h:24
vrv::Object
This class represents a basic object.
Definition: object.h:66
vrv::Octave
This class models the MEI <octave> element.
Definition: octave.h:31
vrv::Ornam
This class models the MEI <ornam> element.
Definition: ornam.h:31
vrv::Ossia
This class represents an ossia.
Definition: ossia.h:28
vrv::PageElement
This class represents elements appearing within a page.
Definition: pageelement.h:25
vrv::Page
This class represents a page in a laid-out score (Doc).
Definition: page.h:31
vrv::PageMilestoneEnd
This class models an end milestone element and has no MEI equivalent.
Definition: pagemilestone.h:26
vrv::Pages
This class represent a <pages> in page-based MEI.
Definition: pages.h:27
vrv::Pb
This class represents a MEI pb in score-based MEI.
Definition: pb.h:25
vrv::Pedal
This class models the MEI <pedal> element.
Definition: pedal.h:34
vrv::PgFoot
This class represents an MEI pgFoot.
Definition: pgfoot.h:22
vrv::PgHead
This class represents an MEI pgHead.
Definition: pghead.h:22
vrv::Phrase
Definition: phrase.h:19
vrv::PitchInflection
This class models the MEI <dir> element.
Definition: pitchinflection.h:23
vrv::Plica
Definition: plica.h:20
vrv::Proport
This class models the MEI <proport> element.
Definition: proport.h:23
vrv::Refrain
Recurring note-attached lyrics, such as a chorus.
Definition: refrain.h:19
vrv::Reh
This class models the MEI <reh> element.
Definition: reh.h:30
vrv::Rend
This class models the MEI <rend> element.
Definition: rend.h:33
vrv::RepeatMark
This class models the MEI <ornam> element.
Definition: repeatmark.h:32
vrv::Rest
This class models the MEI <rest> element.
Definition: rest.h:49
vrv::RunningElement
This class represents running elements (headers and footers).
Definition: runningelement.h:28
vrv::Sb
This class represents a MEI sb in score-based MEI.
Definition: sb.h:25
vrv::ScoreDefElement
This class is a base class for MEI scoreDef or staffDef elements.
Definition: scoredef.h:43
vrv::ScoreDef
This class represents a MEI scoreDef.
Definition: scoredef.h:136
vrv::Score
This class represent a <score> in MEI.
Definition: score.h:30
vrv::Section
This class represents a MEI section.
Definition: section.h:28
vrv::Slur
Definition: slur.h:59
vrv::Space
This class models the MEI <space> element.
Definition: space.h:23
vrv::StaffAlignment
This class stores an alignement position staves will point to.
Definition: verticalaligner.h:173
vrv::StaffDef
This class represents a MEI staffDef.
Definition: staffdef.h:37
vrv::StaffGrp
This class represents a MEI staffGrp.
Definition: staffgrp.h:39
vrv::Staff
This class represents a staff in a laid-out score (Doc).
Definition: staff.h:110
vrv::Stem
This class models a stem as a layer element part and as MEI <stem> element.
Definition: stem.h:27
vrv::Surface
Implements the surface element in MEI.
Definition: surface.h:30
vrv::Svg
Definition: svg.h:20
vrv::Syl
Syl is a TimeSpanningInterface for managing syllable connectors.
Definition: syl.h:38
vrv::Syllable
This class models the MEI <mensur> element.
Definition: syllable.h:25
vrv::Symbol
This class models the MEI <symbol> element.
Definition: symbol.h:25
vrv::SystemAligner
This class aligns the content of a system It contains a vector of StaffAlignment.
Definition: verticalaligner.h:32
vrv::SystemElement
This class represents elements appearing within a measure.
Definition: systemelement.h:26
vrv::System
This class represents a system in a laid-out score (Doc).
Definition: system.h:36
vrv::SystemMilestoneEnd
This class models an end milestone element at the system level.
Definition: systemmilestone.h:28
vrv::TabDurSym
This class models the MEI <tabDurSym> element.
Definition: tabdursym.h:29
vrv::TabGrp
This class models the MEI <tabGrp> element.
Definition: tabgrp.h:24
vrv::Tempo
This class is an interface for <tempo> elements at the measure level.
Definition: tempo.h:33
vrv::TextElement
Definition: textelement.h:22
vrv::Text
This class models CDATA (text)
Definition: text.h:23
vrv::TextLayoutElement
This class represents a text element featuring horizontal and vertical layout.
Definition: textlayoutelement.h:24
vrv::Tie
This class models the MEI <tie> element.
Definition: tie.h:32
vrv::TimestampAligner
This class stores the timestamps (TimestampsAttr) in a measure.
Definition: horizontalaligner.h:668
vrv::TimestampAttr
Definition: timestamp.h:19
vrv::Trill
This class models the MEI <trill> element.
Definition: trill.h:35
vrv::Tuning
This class models the MEI <tuning> element.
Definition: tuning.h:23
vrv::TupletBracket
This class models a bracket as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:150
vrv::Tuplet
Definition: tuplet.h:33
vrv::TupletNum
This class models a tuplet num as a layer element part and has no direct MEI equivalent.
Definition: elementpart.h:250
vrv::Turn
This class models the MEI <turn> element.
Definition: turn.h:33
vrv::Verse
Definition: verse.h:21
vrv::Volta
Sung text for a specific iteration of a repeated section of music.
Definition: volta.h:26
vrv::Zone
Implements the zone element in MEI.
Definition: zone.h:30