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 Part;
104 class Parts;
105 class Pb;
106 class Pedal;
107 class PgFoot;
108 class PgHead;
109 class Phrase;
110 class PitchInflection;
111 class Plica;
112 class Proport;
113 class RepeatMark;
114 class Reh;
115 class Refrain;
116 class Rend;
117 class Rest;
118 class RunningElement;
119 class Sb;
120 class Score;
121 class ScoreOrPartElement;
122 class ScoreDef;
123 class ScoreDefElement;
124 class Section;
125 class Slur;
126 class Space;
127 class Staff;
128 class StaffAlignment;
129 class StaffDef;
130 class StaffGrp;
131 class Stem;
132 class Surface;
133 class Svg;
134 class Syl;
135 class Syllable;
136 class Symbol;
137 class System;
138 class SystemAligner;
139 class SystemElement;
140 class SystemMilestoneEnd;
141 class TabDurSym;
142 class TabGrp;
143 class Tempo;
144 class Text;
145 class TextElement;
146 class TextLayoutElement;
147 class Tie;
148 class TimestampAligner;
149 class TimestampAttr;
150 class Trill;
151 class Tuning;
152 class Tuplet;
153 class TupletBracket;
154 class TupletNum;
155 class Turn;
156 class Volta;
157 class Verse;
158 class Zone;
159 
160 //----------------------------------------------------------------------------
161 // FunctorInterface
162 //----------------------------------------------------------------------------
163 
168 class FunctorInterface {
169 public:
174  FunctorInterface() {}
175  virtual ~FunctorInterface() = default;
177 
182  virtual FunctorCode VisitObject(Object *) { return FUNCTOR_CONTINUE; }
183  virtual FunctorCode VisitObjectEnd(Object *) { return FUNCTOR_CONTINUE; }
184  virtual FunctorCode VisitDoc(Doc *doc);
185  virtual FunctorCode VisitDocEnd(Doc *doc);
187 
192  virtual FunctorCode VisitCourse(Course *course);
193  virtual FunctorCode VisitCourseEnd(Course *course);
194  virtual FunctorCode VisitGrpSym(GrpSym *grpSym);
195  virtual FunctorCode VisitGrpSymEnd(GrpSym *grpSym);
196  virtual FunctorCode VisitInstrDef(InstrDef *instrDef);
197  virtual FunctorCode VisitInstrDefEnd(InstrDef *instrDef);
198  virtual FunctorCode VisitLabel(Label *label);
199  virtual FunctorCode VisitLabelEnd(Label *label);
200  virtual FunctorCode VisitLabelAbbr(LabelAbbr *labelAbbr);
201  virtual FunctorCode VisitLabelAbbrEnd(LabelAbbr *labelAbbr);
202  virtual FunctorCode VisitLayer(Layer *layer);
203  virtual FunctorCode VisitLayerEnd(Layer *layer);
204  virtual FunctorCode VisitLayerDef(LayerDef *layerDef);
205  virtual FunctorCode VisitLayerDefEnd(LayerDef *layerDef);
206  virtual FunctorCode VisitMeasure(Measure *measure);
207  virtual FunctorCode VisitMeasureEnd(Measure *measure);
208  virtual FunctorCode VisitOssia(Ossia *ossia);
209  virtual FunctorCode VisitOssiaEnd(Ossia *ossia);
210  virtual FunctorCode VisitPage(Page *page);
211  virtual FunctorCode VisitPageEnd(Page *page);
212  virtual FunctorCode VisitPages(Pages *pages);
213  virtual FunctorCode VisitPagesEnd(Pages *pages);
214  virtual FunctorCode VisitPb(Pb *pb);
215  virtual FunctorCode VisitPbEnd(Pb *pb);
216  virtual FunctorCode VisitSb(Sb *sb);
217  virtual FunctorCode VisitSbEnd(Sb *sb);
218  virtual FunctorCode VisitScoreDef(ScoreDef *scoreDef);
219  virtual FunctorCode VisitScoreDefEnd(ScoreDef *scoreDef);
220  virtual FunctorCode VisitScoreDefElement(ScoreDefElement *scoreDefElement);
221  virtual FunctorCode VisitScoreDefElementEnd(ScoreDefElement *scoreDefElement);
222  virtual FunctorCode VisitStaff(Staff *staff);
223  virtual FunctorCode VisitStaffEnd(Staff *staff);
224  virtual FunctorCode VisitStaffDef(StaffDef *staffDef);
225  virtual FunctorCode VisitStaffDefEnd(StaffDef *staffDef);
226  virtual FunctorCode VisitStaffGrp(StaffGrp *staffGrp);
227  virtual FunctorCode VisitStaffGrpEnd(StaffGrp *staffGrp);
228  virtual FunctorCode VisitSystem(System *system);
229  virtual FunctorCode VisitSystemEnd(System *system);
230  virtual FunctorCode VisitTuning(Tuning *tuning);
231  virtual FunctorCode VisitTuningEnd(Tuning *tuning);
233 
239  virtual FunctorCode VisitEditorialElement(EditorialElement *editorialElement);
240  virtual FunctorCode VisitEditorialElementEnd(EditorialElement *editorialElement);
242 
247  virtual FunctorCode VisitDiv(Div *div);
248  virtual FunctorCode VisitDivEnd(Div *div);
249  virtual FunctorCode VisitRunningElement(RunningElement *runningElement);
250  virtual FunctorCode VisitRunningElementEnd(RunningElement *runningElement);
251  virtual FunctorCode VisitPgFoot(PgFoot *pgFoot);
252  virtual FunctorCode VisitPgFootEnd(PgFoot *pgFoot);
253  virtual FunctorCode VisitPgHead(PgHead *pgHead);
254  virtual FunctorCode VisitPgHeadEnd(PgHead *pgHead);
255  virtual FunctorCode VisitTextLayoutElement(TextLayoutElement *textLayoutElement);
256  virtual FunctorCode VisitTextLayoutElementEnd(TextLayoutElement *textLayoutElement);
258 
263  virtual FunctorCode VisitEnding(Ending *ending);
264  virtual FunctorCode VisitEndingEnd(Ending *ending);
265  virtual FunctorCode VisitExpansion(Expansion *expansion);
266  virtual FunctorCode VisitExpansionEnd(Expansion *expansion);
267  virtual FunctorCode VisitSection(Section *section);
268  virtual FunctorCode VisitSectionEnd(Section *section);
269  virtual FunctorCode VisitSystemElement(SystemElement *systemElement);
270  virtual FunctorCode VisitSystemElementEnd(SystemElement *systemElement);
271  virtual FunctorCode VisitSystemMilestone(SystemMilestoneEnd *systemMilestoneEnd);
272  virtual FunctorCode VisitSystemMilestoneEnd(SystemMilestoneEnd *systemMilestoneEnd);
274 
279  virtual FunctorCode VisitMdiv(Mdiv *mdiv);
280  virtual FunctorCode VisitMdivEnd(Mdiv *mdiv);
281  virtual FunctorCode VisitPart(Part *part);
282  virtual FunctorCode VisitPartEnd(Part *part);
283  virtual FunctorCode VisitParts(Parts *parts);
284  virtual FunctorCode VisitPartsEnd(Parts *parts);
285  virtual FunctorCode VisitScore(Score *score);
286  virtual FunctorCode VisitScoreEnd(Score *score);
287  virtual FunctorCode VisitPageElement(PageElement *pageElement);
288  virtual FunctorCode VisitPageElementEnd(PageElement *pageElement);
289  virtual FunctorCode VisitPageMilestone(PageMilestoneEnd *pageMilestoneEnd);
290  virtual FunctorCode VisitPageMilestoneEnd(PageMilestoneEnd *pageMilestoneEnd);
291  virtual FunctorCode VisitScoreOrPartElement(ScoreOrPartElement *scoreOrPart);
292  virtual FunctorCode VisitScoreOrPartElementEnd(ScoreOrPartElement *scoreOrPart);
294 
299  virtual FunctorCode VisitAnchoredText(AnchoredText *anchoredText);
300  virtual FunctorCode VisitAnchoredTextEnd(AnchoredText *anchoredText);
301  virtual FunctorCode VisitAnnotScore(AnnotScore *annotScore);
302  virtual FunctorCode VisitAnnotScoreEnd(AnnotScore *annotScore);
303  virtual FunctorCode VisitArpeg(Arpeg *arpeg);
304  virtual FunctorCode VisitArpegEnd(Arpeg *arpeg);
305  virtual FunctorCode VisitBeamSpan(BeamSpan *beamSpan);
306  virtual FunctorCode VisitBeamSpanEnd(BeamSpan *beamSpan);
307  virtual FunctorCode VisitBracketSpan(BracketSpan *bracketSpan);
308  virtual FunctorCode VisitBracketSpanEnd(BracketSpan *bracketSpan);
309  virtual FunctorCode VisitBreath(Breath *breath);
310  virtual FunctorCode VisitBreathEnd(Breath *breath);
311  virtual FunctorCode VisitCaesura(Caesura *caesura);
312  virtual FunctorCode VisitCaesuraEnd(Caesura *caesura);
313  virtual FunctorCode VisitControlElement(ControlElement *controlElement);
314  virtual FunctorCode VisitControlElementEnd(ControlElement *controlElement);
315  virtual FunctorCode VisitCpMark(CpMark *cpMark);
316  virtual FunctorCode VisitCpMarkEnd(CpMark *cpMark);
317  virtual FunctorCode VisitDir(Dir *dir);
318  virtual FunctorCode VisitDirEnd(Dir *dir);
319  virtual FunctorCode VisitDynam(Dynam *dynam);
320  virtual FunctorCode VisitDynamEnd(Dynam *dynam);
321  virtual FunctorCode VisitFermata(Fermata *fermata);
322  virtual FunctorCode VisitFermataEnd(Fermata *fermata);
323  virtual FunctorCode VisitFing(Fing *fing);
324  virtual FunctorCode VisitFingEnd(Fing *fing);
325  virtual FunctorCode VisitGliss(Gliss *gliss);
326  virtual FunctorCode VisitGlissEnd(Gliss *gliss);
327  virtual FunctorCode VisitHairpin(Hairpin *hairpin);
328  virtual FunctorCode VisitHairpinEnd(Hairpin *hairpin);
329  virtual FunctorCode VisitHarm(Harm *harm);
330  virtual FunctorCode VisitHarmEnd(Harm *harm);
331  virtual FunctorCode VisitLv(Lv *lv);
332  virtual FunctorCode VisitLvEnd(Lv *lv);
333  virtual FunctorCode VisitMordent(Mordent *mordent);
334  virtual FunctorCode VisitMordentEnd(Mordent *mordent);
335  virtual FunctorCode VisitOctave(Octave *octave);
336  virtual FunctorCode VisitOctaveEnd(Octave *octave);
337  virtual FunctorCode VisitOrnam(Ornam *ornam);
338  virtual FunctorCode VisitOrnamEnd(Ornam *ornam);
339  virtual FunctorCode VisitPedal(Pedal *pedal);
340  virtual FunctorCode VisitPedalEnd(Pedal *pedal);
341  virtual FunctorCode VisitPhrase(Phrase *phrase);
342  virtual FunctorCode VisitPhraseEnd(Phrase *phrase);
343  virtual FunctorCode VisitPitchInflection(PitchInflection *pitchInflection);
344  virtual FunctorCode VisitPitchInflectionEnd(PitchInflection *pitchInflection);
345  virtual FunctorCode VisitReh(Reh *reh);
346  virtual FunctorCode VisitRehEnd(Reh *reh);
347  virtual FunctorCode VisitRepeatMark(RepeatMark *repeatMark);
348  virtual FunctorCode VisitRepeatMarkEnd(RepeatMark *repeatMark);
349  virtual FunctorCode VisitSlur(Slur *slur);
350  virtual FunctorCode VisitSlurEnd(Slur *slur);
351  virtual FunctorCode VisitTempo(Tempo *tempo);
352  virtual FunctorCode VisitTempoEnd(Tempo *tempo);
353  virtual FunctorCode VisitTie(Tie *tie);
354  virtual FunctorCode VisitTieEnd(Tie *tie);
355  virtual FunctorCode VisitTrill(Trill *trill);
356  virtual FunctorCode VisitTrillEnd(Trill *trill);
357  virtual FunctorCode VisitTurn(Turn *turn);
358  virtual FunctorCode VisitTurnEnd(Turn *turn);
360 
365  virtual FunctorCode VisitAccid(Accid *accid);
366  virtual FunctorCode VisitAccidEnd(Accid *accid);
367  virtual FunctorCode VisitArtic(Artic *artic);
368  virtual FunctorCode VisitArticEnd(Artic *artic);
369  virtual FunctorCode VisitBarLine(BarLine *barLine);
370  virtual FunctorCode VisitBarLineEnd(BarLine *barLine);
371  virtual FunctorCode VisitBeam(Beam *beam);
372  virtual FunctorCode VisitBeamEnd(Beam *beam);
373  virtual FunctorCode VisitBeatRpt(BeatRpt *beatRpt);
374  virtual FunctorCode VisitBeatRptEnd(BeatRpt *beatRpt);
375  virtual FunctorCode VisitBTrem(BTrem *bTrem);
376  virtual FunctorCode VisitBTremEnd(BTrem *bTrem);
377  virtual FunctorCode VisitChord(Chord *chord);
378  virtual FunctorCode VisitChordEnd(Chord *chord);
379  virtual FunctorCode VisitClef(Clef *clef);
380  virtual FunctorCode VisitClefEnd(Clef *clef);
381  virtual FunctorCode VisitCursor(Cursor *cursor);
382  virtual FunctorCode VisitCursorEnd(Cursor *cursor);
383  virtual FunctorCode VisitCustos(Custos *custos);
384  virtual FunctorCode VisitCustosEnd(Custos *custos);
385  virtual FunctorCode VisitDot(Dot *dot);
386  virtual FunctorCode VisitDotEnd(Dot *dot);
387  virtual FunctorCode VisitDots(Dots *dots);
388  virtual FunctorCode VisitDotsEnd(Dots *dots);
389  virtual FunctorCode VisitFlag(Flag *flag);
390  virtual FunctorCode VisitFlagEnd(Flag *flag);
391  virtual FunctorCode VisitFTrem(FTrem *fTrem);
392  virtual FunctorCode VisitFTremEnd(FTrem *fTrem);
393  virtual FunctorCode VisitGenericLayerElement(GenericLayerElement *genericLayerElement);
394  virtual FunctorCode VisitGenericLayerElementEnd(GenericLayerElement *genericLayerElement);
395  virtual FunctorCode VisitGraceGrp(GraceGrp *graceGrp);
396  virtual FunctorCode VisitGraceGrpEnd(GraceGrp *graceGrp);
397  virtual FunctorCode VisitHalfmRpt(HalfmRpt *halfmRpt);
398  virtual FunctorCode VisitHalfmRptEnd(HalfmRpt *halfmRpt);
399  virtual FunctorCode VisitKeyAccid(KeyAccid *keyAccid);
400  virtual FunctorCode VisitKeyAccidEnd(KeyAccid *keyAccid);
401  virtual FunctorCode VisitKeySig(KeySig *keySig);
402  virtual FunctorCode VisitKeySigEnd(KeySig *keySig);
403  virtual FunctorCode VisitLayerElement(LayerElement *layerElement);
404  virtual FunctorCode VisitLayerElementEnd(LayerElement *layerElement);
405  virtual FunctorCode VisitLyricElement(LyricElement *lyricElement);
406  virtual FunctorCode VisitLyricElementEnd(LyricElement *lyricElement);
407  virtual FunctorCode VisitLigature(Ligature *ligature);
408  virtual FunctorCode VisitLigatureEnd(Ligature *ligature);
409  virtual FunctorCode VisitMensur(Mensur *mensur);
410  virtual FunctorCode VisitMensurEnd(Mensur *mensur);
411  virtual FunctorCode VisitMeterSig(MeterSig *meterSig);
412  virtual FunctorCode VisitMeterSigEnd(MeterSig *meterSig);
413  virtual FunctorCode VisitMeterSigGrp(MeterSigGrp *meterSigGrp);
414  virtual FunctorCode VisitMeterSigGrpEnd(MeterSigGrp *meterSigGrp);
415  virtual FunctorCode VisitMRest(MRest *mRest);
416  virtual FunctorCode VisitMRestEnd(MRest *mRest);
417  virtual FunctorCode VisitMRpt(MRpt *mRpt);
418  virtual FunctorCode VisitMRptEnd(MRpt *mRpt);
419  virtual FunctorCode VisitMRpt2(MRpt2 *mRpt2);
420  virtual FunctorCode VisitMRpt2End(MRpt2 *mRpt2);
421  virtual FunctorCode VisitMSpace(MSpace *mSpace);
422  virtual FunctorCode VisitMSpaceEnd(MSpace *mSpace);
423  virtual FunctorCode VisitMultiRest(MultiRest *multiRest);
424  virtual FunctorCode VisitMultiRestEnd(MultiRest *multiRest);
425  virtual FunctorCode VisitMultiRpt(MultiRpt *multiRpt);
426  virtual FunctorCode VisitMultiRptEnd(MultiRpt *multiRpt);
427  virtual FunctorCode VisitNc(Nc *nc);
428  virtual FunctorCode VisitNcEnd(Nc *nc);
429  virtual FunctorCode VisitNeume(Neume *neume);
430  virtual FunctorCode VisitNeumeEnd(Neume *neume);
431  virtual FunctorCode VisitNote(Note *note);
432  virtual FunctorCode VisitNoteEnd(Note *note);
433  virtual FunctorCode VisitPlica(Plica *plica);
434  virtual FunctorCode VisitPlicaEnd(Plica *plica);
435  virtual FunctorCode VisitProport(Proport *proport);
436  virtual FunctorCode VisitProportEnd(Proport *proport);
437  virtual FunctorCode VisitRefrain(Refrain *refrain);
438  virtual FunctorCode VisitRefrainEnd(Refrain *refrain);
439  virtual FunctorCode VisitRest(Rest *rest);
440  virtual FunctorCode VisitRestEnd(Rest *rest);
441  virtual FunctorCode VisitSpace(Space *space);
442  virtual FunctorCode VisitSpaceEnd(Space *space);
443  virtual FunctorCode VisitStem(Stem *stem);
444  virtual FunctorCode VisitStemEnd(Stem *stem);
445  virtual FunctorCode VisitSyl(Syl *syl);
446  virtual FunctorCode VisitSylEnd(Syl *syl);
447  virtual FunctorCode VisitSyllable(Syllable *syllable);
448  virtual FunctorCode VisitSyllableEnd(Syllable *syllable);
449  virtual FunctorCode VisitTabDurSym(TabDurSym *tabDurSym);
450  virtual FunctorCode VisitTabDurSymEnd(TabDurSym *tabDurSym);
451  virtual FunctorCode VisitTabGrp(TabGrp *tabGrp);
452  virtual FunctorCode VisitTabGrpEnd(TabGrp *tabGrp);
453  virtual FunctorCode VisitTimestamp(TimestampAttr *timestamp);
454  virtual FunctorCode VisitTimestampEnd(TimestampAttr *timestamp);
455  virtual FunctorCode VisitTuplet(Tuplet *tuplet);
456  virtual FunctorCode VisitTupletEnd(Tuplet *tuplet);
457  virtual FunctorCode VisitTupletBracket(TupletBracket *tupletBracket);
458  virtual FunctorCode VisitTupletBracketEnd(TupletBracket *tupletBracket);
459  virtual FunctorCode VisitTupletNum(TupletNum *tupletNum);
460  virtual FunctorCode VisitTupletNumEnd(TupletNum *tupletNum);
461  virtual FunctorCode VisitVolta(Volta *volta);
462  virtual FunctorCode VisitVoltaEnd(Volta *volta);
463  virtual FunctorCode VisitVerse(Verse *verse);
464  virtual FunctorCode VisitVerseEnd(Verse *verse);
466 
471  virtual FunctorCode VisitF(F *f);
472  virtual FunctorCode VisitFEnd(F *f);
473  virtual FunctorCode VisitFb(Fb *fb);
474  virtual FunctorCode VisitFbEnd(Fb *fb);
475  virtual FunctorCode VisitFig(Fig *fig);
476  virtual FunctorCode VisitFigEnd(Fig *fig);
477  virtual FunctorCode VisitLb(Lb *lb);
478  virtual FunctorCode VisitLbEnd(Lb *lb);
479  virtual FunctorCode VisitMNum(MNum *mNum);
480  virtual FunctorCode VisitMNumEnd(MNum *mNum);
481  virtual FunctorCode VisitNum(Num *num);
482  virtual FunctorCode VisitNumEnd(Num *num);
483  virtual FunctorCode VisitRend(Rend *rend);
484  virtual FunctorCode VisitRendEnd(Rend *rend);
485  virtual FunctorCode VisitSvg(Svg *svg);
486  virtual FunctorCode VisitSvgEnd(Svg *svg);
487  virtual FunctorCode VisitSymbol(Symbol *symbol);
488  virtual FunctorCode VisitSymbolEnd(Symbol *symbol);
489  virtual FunctorCode VisitText(Text *text);
490  virtual FunctorCode VisitTextEnd(Text *text);
491  virtual FunctorCode VisitTextElement(TextElement *textElement);
492  virtual FunctorCode VisitTextElementEnd(TextElement *textElement);
494 
499  virtual FunctorCode VisitFacsimile(Facsimile *facsimile);
500  virtual FunctorCode VisitFacsimileEnd(Facsimile *facsimile);
501  virtual FunctorCode VisitGraphic(Graphic *graphic);
502  virtual FunctorCode VisitGraphicEnd(Graphic *graphic);
503  virtual FunctorCode VisitSurface(Surface *surface);
504  virtual FunctorCode VisitSurfaceEnd(Surface *surface);
505  virtual FunctorCode VisitZone(Zone *zone);
506  virtual FunctorCode VisitZoneEnd(Zone *zone);
508 
513  virtual FunctorCode VisitAlignment(Alignment *alignment);
514  virtual FunctorCode VisitAlignmentEnd(Alignment *alignment);
515  virtual FunctorCode VisitAlignmentReference(AlignmentReference *alignmentReference);
516  virtual FunctorCode VisitAlignmentReferenceEnd(AlignmentReference *alignmentReference);
517  virtual FunctorCode VisitHorizontalAligner(HorizontalAligner *horizontalAligner);
518  virtual FunctorCode VisitHorizontalAlignerEnd(HorizontalAligner *horizontalAligner);
519  virtual FunctorCode VisitMeasureAligner(MeasureAligner *measureAligner);
520  virtual FunctorCode VisitMeasureAlignerEnd(MeasureAligner *measureAligner);
521  virtual FunctorCode VisitGraceAligner(GraceAligner *graceAligner);
522  virtual FunctorCode VisitGraceAlignerEnd(GraceAligner *graceAligner);
523  virtual FunctorCode VisitTimestampAligner(TimestampAligner *timestampAligner);
524  virtual FunctorCode VisitTimestampAlignerEnd(TimestampAligner *timestampAligner);
526 
531  virtual FunctorCode VisitSystemAligner(SystemAligner *systemAligner);
532  virtual FunctorCode VisitSystemAlignerEnd(SystemAligner *systemAligner);
533  virtual FunctorCode VisitStaffAlignment(StaffAlignment *staffAlignment);
534  virtual FunctorCode VisitStaffAlignmentEnd(StaffAlignment *staffAlignment);
536 
541  virtual FunctorCode VisitFloatingObject(FloatingObject *floatingObject);
542  virtual FunctorCode VisitFloatingObjectEnd(FloatingObject *floatingObject);
544 
545 private:
546  //
547 public:
548  //
549 private:
550  //
551 };
552 
553 //----------------------------------------------------------------------------
554 // ConstFunctorInterface
555 //----------------------------------------------------------------------------
556 
561 class ConstFunctorInterface {
562 public:
567  ConstFunctorInterface() {}
568  virtual ~ConstFunctorInterface() = default;
570 
575  virtual FunctorCode VisitObject(const Object *) { return FUNCTOR_CONTINUE; }
576  virtual FunctorCode VisitObjectEnd(const Object *) { return FUNCTOR_CONTINUE; }
577  virtual FunctorCode VisitDoc(const Doc *doc);
578  virtual FunctorCode VisitDocEnd(const Doc *doc);
580 
585  virtual FunctorCode VisitCourse(const Course *course);
586  virtual FunctorCode VisitCourseEnd(const Course *course);
587  virtual FunctorCode VisitGrpSym(const GrpSym *grpSym);
588  virtual FunctorCode VisitGrpSymEnd(const GrpSym *grpSym);
589  virtual FunctorCode VisitInstrDef(const InstrDef *instrDef);
590  virtual FunctorCode VisitInstrDefEnd(const InstrDef *instrDef);
591  virtual FunctorCode VisitLabel(const Label *label);
592  virtual FunctorCode VisitLabelEnd(const Label *label);
593  virtual FunctorCode VisitLabelAbbr(const LabelAbbr *labelAbbr);
594  virtual FunctorCode VisitLabelAbbrEnd(const LabelAbbr *labelAbbr);
595  virtual FunctorCode VisitLayer(const Layer *layer);
596  virtual FunctorCode VisitLayerEnd(const Layer *layer);
597  virtual FunctorCode VisitLayerDef(const LayerDef *layerDef);
598  virtual FunctorCode VisitLayerDefEnd(const LayerDef *layerDef);
599  virtual FunctorCode VisitMeasure(const Measure *measure);
600  virtual FunctorCode VisitMeasureEnd(const Measure *measure);
601  virtual FunctorCode VisitOssia(const Ossia *ossia);
602  virtual FunctorCode VisitOssiaEnd(const Ossia *ossia);
603  virtual FunctorCode VisitPage(const Page *page);
604  virtual FunctorCode VisitPageEnd(const Page *page);
605  virtual FunctorCode VisitPages(const Pages *pages);
606  virtual FunctorCode VisitPagesEnd(const Pages *pages);
607  virtual FunctorCode VisitPb(const Pb *pb);
608  virtual FunctorCode VisitPbEnd(const Pb *pb);
609  virtual FunctorCode VisitSb(const Sb *sb);
610  virtual FunctorCode VisitSbEnd(const Sb *sb);
611  virtual FunctorCode VisitScoreDef(const ScoreDef *scoreDef);
612  virtual FunctorCode VisitScoreDefEnd(const ScoreDef *scoreDef);
613  virtual FunctorCode VisitScoreDefElement(const ScoreDefElement *scoreDefElement);
614  virtual FunctorCode VisitScoreDefElementEnd(const ScoreDefElement *scoreDefElement);
615  virtual FunctorCode VisitStaff(const Staff *staff);
616  virtual FunctorCode VisitStaffEnd(const Staff *staff);
617  virtual FunctorCode VisitStaffDef(const StaffDef *staffDef);
618  virtual FunctorCode VisitStaffDefEnd(const StaffDef *staffDef);
619  virtual FunctorCode VisitStaffGrp(const StaffGrp *staffGrp);
620  virtual FunctorCode VisitStaffGrpEnd(const StaffGrp *staffGrp);
621  virtual FunctorCode VisitSystem(const System *system);
622  virtual FunctorCode VisitSystemEnd(const System *system);
623  virtual FunctorCode VisitTuning(const Tuning *tuning);
624  virtual FunctorCode VisitTuningEnd(const Tuning *tuning);
626 
632  virtual FunctorCode VisitEditorialElement(const EditorialElement *editorialElement);
633  virtual FunctorCode VisitEditorialElementEnd(const EditorialElement *editorialElement);
635 
640  virtual FunctorCode VisitDiv(const Div *div);
641  virtual FunctorCode VisitDivEnd(const Div *div);
642  virtual FunctorCode VisitRunningElement(const RunningElement *runningElement);
643  virtual FunctorCode VisitRunningElementEnd(const RunningElement *runningElement);
644  virtual FunctorCode VisitPgFoot(const PgFoot *pgFoot);
645  virtual FunctorCode VisitPgFootEnd(const PgFoot *pgFoot);
646  virtual FunctorCode VisitPgHead(const PgHead *pgHead);
647  virtual FunctorCode VisitPgHeadEnd(const PgHead *pgHead);
648  virtual FunctorCode VisitTextLayoutElement(const TextLayoutElement *textLayoutElement);
649  virtual FunctorCode VisitTextLayoutElementEnd(const TextLayoutElement *textLayoutElement);
651 
656  virtual FunctorCode VisitEnding(const Ending *ending);
657  virtual FunctorCode VisitEndingEnd(const Ending *ending);
658  virtual FunctorCode VisitExpansion(const Expansion *expansion);
659  virtual FunctorCode VisitExpansionEnd(const Expansion *expansion);
660  virtual FunctorCode VisitSection(const Section *section);
661  virtual FunctorCode VisitSectionEnd(const Section *section);
662  virtual FunctorCode VisitSystemElement(const SystemElement *systemElement);
663  virtual FunctorCode VisitSystemElementEnd(const SystemElement *systemElement);
664  virtual FunctorCode VisitSystemMilestone(const SystemMilestoneEnd *systemMilestoneEnd);
665  virtual FunctorCode VisitSystemMilestoneEnd(const SystemMilestoneEnd *systemMilestoneEnd);
667 
672  virtual FunctorCode VisitMdiv(const Mdiv *mdiv);
673  virtual FunctorCode VisitMdivEnd(const Mdiv *mdiv);
674  virtual FunctorCode VisitPart(const Part *part);
675  virtual FunctorCode VisitPartEnd(const Part *part);
676  virtual FunctorCode VisitParts(const Parts *parts);
677  virtual FunctorCode VisitPartsEnd(const Parts *parts);
678  virtual FunctorCode VisitScore(const Score *score);
679  virtual FunctorCode VisitScoreEnd(const Score *score);
680  virtual FunctorCode VisitPageElement(const PageElement *pageElement);
681  virtual FunctorCode VisitPageElementEnd(const PageElement *pageElement);
682  virtual FunctorCode VisitPageMilestone(const PageMilestoneEnd *pageMilestoneEnd);
683  virtual FunctorCode VisitPageMilestoneEnd(const PageMilestoneEnd *pageMilestoneEnd);
684  virtual FunctorCode VisitScoreOrPartElement(const ScoreOrPartElement *scoreOrPart);
685  virtual FunctorCode VisitScoreOrPartElementEnd(const ScoreOrPartElement *scoreOrPart);
687 
692  virtual FunctorCode VisitAnchoredText(const AnchoredText *anchoredText);
693  virtual FunctorCode VisitAnchoredTextEnd(const AnchoredText *anchoredText);
694  virtual FunctorCode VisitAnnotScore(const AnnotScore *annotScore);
695  virtual FunctorCode VisitAnnotScoreEnd(const AnnotScore *annotScore);
696  virtual FunctorCode VisitArpeg(const Arpeg *arpeg);
697  virtual FunctorCode VisitArpegEnd(const Arpeg *arpeg);
698  virtual FunctorCode VisitBeamSpan(const BeamSpan *beamSpan);
699  virtual FunctorCode VisitBeamSpanEnd(const BeamSpan *beamSpan);
700  virtual FunctorCode VisitBracketSpan(const BracketSpan *bracketSpan);
701  virtual FunctorCode VisitBracketSpanEnd(const BracketSpan *bracketSpan);
702  virtual FunctorCode VisitBreath(const Breath *breath);
703  virtual FunctorCode VisitBreathEnd(const Breath *breath);
704  virtual FunctorCode VisitCaesura(const Caesura *caesura);
705  virtual FunctorCode VisitCaesuraEnd(const Caesura *caesura);
706  virtual FunctorCode VisitControlElement(const ControlElement *controlElement);
707  virtual FunctorCode VisitControlElementEnd(const ControlElement *controlElement);
708  virtual FunctorCode VisitCpMark(const CpMark *cpMark);
709  virtual FunctorCode VisitCpMarkEnd(const CpMark *cpMark);
710  virtual FunctorCode VisitDir(const Dir *dir);
711  virtual FunctorCode VisitDirEnd(const Dir *dir);
712  virtual FunctorCode VisitDynam(const Dynam *dynam);
713  virtual FunctorCode VisitDynamEnd(const Dynam *dynam);
714  virtual FunctorCode VisitFermata(const Fermata *fermata);
715  virtual FunctorCode VisitFermataEnd(const Fermata *fermata);
716  virtual FunctorCode VisitFing(const Fing *fing);
717  virtual FunctorCode VisitFingEnd(const Fing *fing);
718  virtual FunctorCode VisitGliss(const Gliss *gliss);
719  virtual FunctorCode VisitGlissEnd(const Gliss *gliss);
720  virtual FunctorCode VisitHairpin(const Hairpin *hairpin);
721  virtual FunctorCode VisitHairpinEnd(const Hairpin *hairpin);
722  virtual FunctorCode VisitHarm(const Harm *harm);
723  virtual FunctorCode VisitHarmEnd(const Harm *harm);
724  virtual FunctorCode VisitLv(const Lv *lv);
725  virtual FunctorCode VisitLvEnd(const Lv *lv);
726  virtual FunctorCode VisitMordent(const Mordent *mordent);
727  virtual FunctorCode VisitMordentEnd(const Mordent *mordent);
728  virtual FunctorCode VisitOctave(const Octave *octave);
729  virtual FunctorCode VisitOctaveEnd(const Octave *octave);
730  virtual FunctorCode VisitOrnam(const Ornam *ornam);
731  virtual FunctorCode VisitOrnamEnd(const Ornam *ornam);
732  virtual FunctorCode VisitPedal(const Pedal *pedal);
733  virtual FunctorCode VisitPedalEnd(const Pedal *pedal);
734  virtual FunctorCode VisitPhrase(const Phrase *phrase);
735  virtual FunctorCode VisitPhraseEnd(const Phrase *phrase);
736  virtual FunctorCode VisitPitchInflection(const PitchInflection *pitchInflection);
737  virtual FunctorCode VisitPitchInflectionEnd(const PitchInflection *pitchInflection);
738  virtual FunctorCode VisitReh(const Reh *reh);
739  virtual FunctorCode VisitRehEnd(const Reh *reh);
740  virtual FunctorCode VisitRepeatMark(const RepeatMark *repeatMark);
741  virtual FunctorCode VisitRepeatMarkEnd(const RepeatMark *repeatMark);
742  virtual FunctorCode VisitSlur(const Slur *slur);
743  virtual FunctorCode VisitSlurEnd(const Slur *slur);
744  virtual FunctorCode VisitTempo(const Tempo *tempo);
745  virtual FunctorCode VisitTempoEnd(const Tempo *tempo);
746  virtual FunctorCode VisitTie(const Tie *tie);
747  virtual FunctorCode VisitTieEnd(const Tie *tie);
748  virtual FunctorCode VisitTrill(const Trill *trill);
749  virtual FunctorCode VisitTrillEnd(const Trill *trill);
750  virtual FunctorCode VisitTurn(const Turn *turn);
751  virtual FunctorCode VisitTurnEnd(const Turn *turn);
753 
758  virtual FunctorCode VisitAccid(const Accid *accid);
759  virtual FunctorCode VisitAccidEnd(const Accid *accid);
760  virtual FunctorCode VisitArtic(const Artic *artic);
761  virtual FunctorCode VisitArticEnd(const Artic *artic);
762  virtual FunctorCode VisitBarLine(const BarLine *barLine);
763  virtual FunctorCode VisitBarLineEnd(const BarLine *barLine);
764  virtual FunctorCode VisitBeam(const Beam *beam);
765  virtual FunctorCode VisitBeamEnd(const Beam *beam);
766  virtual FunctorCode VisitBeatRpt(const BeatRpt *beatRpt);
767  virtual FunctorCode VisitBeatRptEnd(const BeatRpt *beatRpt);
768  virtual FunctorCode VisitBTrem(const BTrem *bTrem);
769  virtual FunctorCode VisitBTremEnd(const BTrem *bTrem);
770  virtual FunctorCode VisitChord(const Chord *chord);
771  virtual FunctorCode VisitChordEnd(const Chord *chord);
772  virtual FunctorCode VisitClef(const Clef *clef);
773  virtual FunctorCode VisitClefEnd(const Clef *clef);
774  virtual FunctorCode VisitCursor(const Cursor *cursor);
775  virtual FunctorCode VisitCursorEnd(const Cursor *cursor);
776  virtual FunctorCode VisitCustos(const Custos *custos);
777  virtual FunctorCode VisitCustosEnd(const Custos *custos);
778  virtual FunctorCode VisitDot(const Dot *dot);
779  virtual FunctorCode VisitDotEnd(const Dot *dot);
780  virtual FunctorCode VisitDots(const Dots *dots);
781  virtual FunctorCode VisitDotsEnd(const Dots *dots);
782  virtual FunctorCode VisitFlag(const Flag *flag);
783  virtual FunctorCode VisitFlagEnd(const Flag *flag);
784  virtual FunctorCode VisitFTrem(const FTrem *fTrem);
785  virtual FunctorCode VisitFTremEnd(const FTrem *fTrem);
786  virtual FunctorCode VisitGenericLayerElement(const GenericLayerElement *genericLayerElement);
787  virtual FunctorCode VisitGenericLayerElementEnd(const GenericLayerElement *genericLayerElement);
788  virtual FunctorCode VisitGraceGrp(const GraceGrp *graceGrp);
789  virtual FunctorCode VisitGraceGrpEnd(const GraceGrp *graceGrp);
790  virtual FunctorCode VisitHalfmRpt(const HalfmRpt *halfmRpt);
791  virtual FunctorCode VisitHalfmRptEnd(const HalfmRpt *halfmRpt);
792  virtual FunctorCode VisitKeyAccid(const KeyAccid *keyAccid);
793  virtual FunctorCode VisitKeyAccidEnd(const KeyAccid *keyAccid);
794  virtual FunctorCode VisitKeySig(const KeySig *keySig);
795  virtual FunctorCode VisitKeySigEnd(const KeySig *keySig);
796  virtual FunctorCode VisitLayerElement(const LayerElement *layerElement);
797  virtual FunctorCode VisitLayerElementEnd(const LayerElement *layerElement);
798  virtual FunctorCode VisitLyricElement(const LyricElement *lyricElement);
799  virtual FunctorCode VisitLyricElementEnd(const LyricElement *lyricElement);
800  virtual FunctorCode VisitLigature(const Ligature *ligature);
801  virtual FunctorCode VisitLigatureEnd(const Ligature *ligature);
802  virtual FunctorCode VisitMensur(const Mensur *mensur);
803  virtual FunctorCode VisitMensurEnd(const Mensur *mensur);
804  virtual FunctorCode VisitMeterSig(const MeterSig *meterSig);
805  virtual FunctorCode VisitMeterSigEnd(const MeterSig *meterSig);
806  virtual FunctorCode VisitMeterSigGrp(const MeterSigGrp *meterSigGrp);
807  virtual FunctorCode VisitMeterSigGrpEnd(const MeterSigGrp *meterSigGrp);
808  virtual FunctorCode VisitMRest(const MRest *mRest);
809  virtual FunctorCode VisitMRestEnd(const MRest *mRest);
810  virtual FunctorCode VisitMRpt(const MRpt *mRpt);
811  virtual FunctorCode VisitMRptEnd(const MRpt *mRpt);
812  virtual FunctorCode VisitMRpt2(const MRpt2 *mRpt2);
813  virtual FunctorCode VisitMRpt2End(const MRpt2 *mRpt2);
814  virtual FunctorCode VisitMSpace(const MSpace *mSpace);
815  virtual FunctorCode VisitMSpaceEnd(const MSpace *mSpace);
816  virtual FunctorCode VisitMultiRest(const MultiRest *multiRest);
817  virtual FunctorCode VisitMultiRestEnd(const MultiRest *multiRest);
818  virtual FunctorCode VisitMultiRpt(const MultiRpt *multiRpt);
819  virtual FunctorCode VisitMultiRptEnd(const MultiRpt *multiRpt);
820  virtual FunctorCode VisitNc(const Nc *nc);
821  virtual FunctorCode VisitNcEnd(const Nc *nc);
822  virtual FunctorCode VisitNeume(const Neume *neume);
823  virtual FunctorCode VisitNeumeEnd(const Neume *neume);
824  virtual FunctorCode VisitNote(const Note *note);
825  virtual FunctorCode VisitNoteEnd(const Note *note);
826  virtual FunctorCode VisitPlica(const Plica *plica);
827  virtual FunctorCode VisitPlicaEnd(const Plica *plica);
828  virtual FunctorCode VisitProport(const Proport *proport);
829  virtual FunctorCode VisitProportEnd(const Proport *proport);
830  virtual FunctorCode VisitRefrain(const Refrain *refrain);
831  virtual FunctorCode VisitRefrainEnd(const Refrain *refrain);
832  virtual FunctorCode VisitRest(const Rest *rest);
833  virtual FunctorCode VisitRestEnd(const Rest *rest);
834  virtual FunctorCode VisitSpace(const Space *space);
835  virtual FunctorCode VisitSpaceEnd(const Space *space);
836  virtual FunctorCode VisitStem(const Stem *stem);
837  virtual FunctorCode VisitStemEnd(const Stem *stem);
838  virtual FunctorCode VisitSyl(const Syl *syl);
839  virtual FunctorCode VisitSylEnd(const Syl *syl);
840  virtual FunctorCode VisitSyllable(const Syllable *syllable);
841  virtual FunctorCode VisitSyllableEnd(const Syllable *syllable);
842  virtual FunctorCode VisitTabDurSym(const TabDurSym *tabDurSym);
843  virtual FunctorCode VisitTabDurSymEnd(const TabDurSym *tabDurSym);
844  virtual FunctorCode VisitTabGrp(const TabGrp *tabGrp);
845  virtual FunctorCode VisitTabGrpEnd(const TabGrp *tabGrp);
846  virtual FunctorCode VisitTimestamp(const TimestampAttr *timestamp);
847  virtual FunctorCode VisitTimestampEnd(const TimestampAttr *timestamp);
848  virtual FunctorCode VisitTuplet(const Tuplet *tuplet);
849  virtual FunctorCode VisitTupletEnd(const Tuplet *tuplet);
850  virtual FunctorCode VisitTupletBracket(const TupletBracket *tupletBracket);
851  virtual FunctorCode VisitTupletBracketEnd(const TupletBracket *tupletBracket);
852  virtual FunctorCode VisitTupletNum(const TupletNum *tupletNum);
853  virtual FunctorCode VisitTupletNumEnd(const TupletNum *tupletNum);
854  virtual FunctorCode VisitVolta(const Volta *volta);
855  virtual FunctorCode VisitVoltaEnd(const Volta *volta);
856  virtual FunctorCode VisitVerse(const Verse *verse);
857  virtual FunctorCode VisitVerseEnd(const Verse *verse);
859 
864  virtual FunctorCode VisitF(const F *f);
865  virtual FunctorCode VisitFEnd(const F *f);
866  virtual FunctorCode VisitFb(const Fb *fb);
867  virtual FunctorCode VisitFbEnd(const Fb *fb);
868  virtual FunctorCode VisitFig(const Fig *fig);
869  virtual FunctorCode VisitFigEnd(const Fig *fig);
870  virtual FunctorCode VisitLb(const Lb *lb);
871  virtual FunctorCode VisitLbEnd(const Lb *lb);
872  virtual FunctorCode VisitMNum(const MNum *mNum);
873  virtual FunctorCode VisitMNumEnd(const MNum *mNum);
874  virtual FunctorCode VisitNum(const Num *num);
875  virtual FunctorCode VisitNumEnd(const Num *num);
876  virtual FunctorCode VisitRend(const Rend *rend);
877  virtual FunctorCode VisitRendEnd(const Rend *rend);
878  virtual FunctorCode VisitSvg(const Svg *svg);
879  virtual FunctorCode VisitSvgEnd(const Svg *svg);
880  virtual FunctorCode VisitSymbol(const Symbol *symbol);
881  virtual FunctorCode VisitSymbolEnd(const Symbol *symbol);
882  virtual FunctorCode VisitText(const Text *text);
883  virtual FunctorCode VisitTextEnd(const Text *text);
884  virtual FunctorCode VisitTextElement(const TextElement *textElement);
885  virtual FunctorCode VisitTextElementEnd(const TextElement *textElement);
887 
892  virtual FunctorCode VisitFacsimile(const Facsimile *facsimile);
893  virtual FunctorCode VisitFacsimileEnd(const Facsimile *facsimile);
894  virtual FunctorCode VisitGraphic(const Graphic *graphic);
895  virtual FunctorCode VisitGraphicEnd(const Graphic *graphic);
896  virtual FunctorCode VisitSurface(const Surface *surface);
897  virtual FunctorCode VisitSurfaceEnd(const Surface *surface);
898  virtual FunctorCode VisitZone(const Zone *zone);
899  virtual FunctorCode VisitZoneEnd(const Zone *zone);
901 
906  virtual FunctorCode VisitAlignment(const Alignment *alignment);
907  virtual FunctorCode VisitAlignmentEnd(const Alignment *alignment);
908  virtual FunctorCode VisitAlignmentReference(const AlignmentReference *alignmentReference);
909  virtual FunctorCode VisitAlignmentReferenceEnd(const AlignmentReference *alignmentReference);
910  virtual FunctorCode VisitHorizontalAligner(const HorizontalAligner *horizontalAligner);
911  virtual FunctorCode VisitHorizontalAlignerEnd(const HorizontalAligner *horizontalAligner);
912  virtual FunctorCode VisitMeasureAligner(const MeasureAligner *measureAligner);
913  virtual FunctorCode VisitMeasureAlignerEnd(const MeasureAligner *measureAligner);
914  virtual FunctorCode VisitGraceAligner(const GraceAligner *graceAligner);
915  virtual FunctorCode VisitGraceAlignerEnd(const GraceAligner *graceAligner);
916  virtual FunctorCode VisitTimestampAligner(const TimestampAligner *timestampAligner);
917  virtual FunctorCode VisitTimestampAlignerEnd(const TimestampAligner *timestampAligner);
919 
924  virtual FunctorCode VisitSystemAligner(const SystemAligner *systemAligner);
925  virtual FunctorCode VisitSystemAlignerEnd(const SystemAligner *systemAligner);
926  virtual FunctorCode VisitStaffAlignment(const StaffAlignment *staffAlignment);
927  virtual FunctorCode VisitStaffAlignmentEnd(const StaffAlignment *staffAlignment);
929 
934  virtual FunctorCode VisitFloatingObject(const FloatingObject *floatingObject);
935  virtual FunctorCode VisitFloatingObjectEnd(const FloatingObject *floatingObject);
937 
938 private:
939  //
940 public:
941  //
942 private:
943  //
944 };
945 
946 } // namespace vrv
947 
948 #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:298
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:561
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:168
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:578
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:370
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:433
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::Part
This class represent a <part> MEI.
Definition: part.h:22
vrv::Parts
This class represents a <parts> MEI.
Definition: parts.h:24
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> MEI.
Definition: score.h:22
vrv::ScoreOrPartElement
This class represents a <score> or a <part> in MEI.
Definition: scoreorpartelement.h:33
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:180
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:33
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:672
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