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 Custos;
36 class Dir;
37 class Div;
38 class Dot;
39 class Dots;
40 class Doc;
41 class Dynam;
42 class EditorialElement;
43 class Ending;
44 class Expansion;
45 class F;
46 class Facsimile;
47 class Fb;
48 class Fermata;
49 class Fing;
50 class Fig;
51 class Flag;
52 class FloatingObject;
53 class FTrem;
54 class GenericLayerElement;
55 class Gliss;
56 class GraceAligner;
57 class GraceGrp;
58 class Graphic;
59 class GrpSym;
60 class Hairpin;
61 class HalfmRpt;
62 class Harm;
63 class HorizontalAligner;
64 class InstrDef;
65 class KeyAccid;
66 class KeySig;
67 class Label;
68 class LabelAbbr;
69 class Layer;
70 class LayerDef;
71 class LayerElement;
72 class Lb;
73 class Ligature;
74 class Lv;
75 class Mdiv;
76 class Measure;
77 class MeasureAligner;
78 class Mensur;
79 class MeterSig;
80 class MeterSigGrp;
81 class Mordent;
82 class MNum;
83 class MRest;
84 class MRpt;
85 class MRpt2;
86 class MSpace;
87 class MultiRest;
88 class MultiRpt;
89 class Nc;
90 class Neume;
91 class Note;
92 class Num;
93 class Object;
94 class Octave;
95 class Ornam;
96 class Ossia;
97 class Page;
98 class PageElement;
99 class PageMilestoneEnd;
100 class Pages;
101 class Pb;
102 class Pedal;
103 class PgFoot;
104 class PgHead;
105 class Phrase;
106 class PitchInflection;
107 class Plica;
108 class Proport;
109 class RepeatMark;
110 class Reh;
111 class Rend;
112 class Rest;
113 class RunningElement;
114 class Sb;
115 class Score;
116 class ScoreDef;
117 class ScoreDefElement;
118 class Section;
119 class Slur;
120 class Space;
121 class Staff;
122 class StaffAlignment;
123 class StaffDef;
124 class StaffGrp;
125 class Stem;
126 class Surface;
127 class Svg;
128 class Syl;
129 class Syllable;
130 class Symbol;
131 class System;
132 class SystemAligner;
133 class SystemElement;
134 class SystemMilestoneEnd;
135 class TabDurSym;
136 class TabGrp;
137 class Tempo;
138 class Text;
139 class TextElement;
140 class TextLayoutElement;
141 class Tie;
142 class TimestampAligner;
143 class TimestampAttr;
144 class Trill;
145 class Tuning;
146 class Tuplet;
147 class TupletBracket;
148 class TupletNum;
149 class Turn;
150 class Verse;
151 class Zone;
152 
153 //----------------------------------------------------------------------------
154 // FunctorInterface
155 //----------------------------------------------------------------------------
156 
161 class FunctorInterface {
162 public:
167  FunctorInterface() {}
168  virtual ~FunctorInterface() = default;
170 
175  virtual FunctorCode VisitObject(Object *) { return FUNCTOR_CONTINUE; }
176  virtual FunctorCode VisitObjectEnd(Object *) { return FUNCTOR_CONTINUE; }
177  virtual FunctorCode VisitDoc(Doc *doc);
178  virtual FunctorCode VisitDocEnd(Doc *doc);
180 
185  virtual FunctorCode VisitCourse(Course *course);
186  virtual FunctorCode VisitCourseEnd(Course *course);
187  virtual FunctorCode VisitGrpSym(GrpSym *grpSym);
188  virtual FunctorCode VisitGrpSymEnd(GrpSym *grpSym);
189  virtual FunctorCode VisitInstrDef(InstrDef *instrDef);
190  virtual FunctorCode VisitInstrDefEnd(InstrDef *instrDef);
191  virtual FunctorCode VisitLabel(Label *label);
192  virtual FunctorCode VisitLabelEnd(Label *label);
193  virtual FunctorCode VisitLabelAbbr(LabelAbbr *labelAbbr);
194  virtual FunctorCode VisitLabelAbbrEnd(LabelAbbr *labelAbbr);
195  virtual FunctorCode VisitLayer(Layer *layer);
196  virtual FunctorCode VisitLayerEnd(Layer *layer);
197  virtual FunctorCode VisitLayerDef(LayerDef *layerDef);
198  virtual FunctorCode VisitLayerDefEnd(LayerDef *layerDef);
199  virtual FunctorCode VisitMeasure(Measure *measure);
200  virtual FunctorCode VisitMeasureEnd(Measure *measure);
201  virtual FunctorCode VisitOssia(Ossia *ossia);
202  virtual FunctorCode VisitOssiaEnd(Ossia *ossia);
203  virtual FunctorCode VisitPage(Page *page);
204  virtual FunctorCode VisitPageEnd(Page *page);
205  virtual FunctorCode VisitPages(Pages *pages);
206  virtual FunctorCode VisitPagesEnd(Pages *pages);
207  virtual FunctorCode VisitPb(Pb *pb);
208  virtual FunctorCode VisitPbEnd(Pb *pb);
209  virtual FunctorCode VisitSb(Sb *sb);
210  virtual FunctorCode VisitSbEnd(Sb *sb);
211  virtual FunctorCode VisitScoreDef(ScoreDef *scoreDef);
212  virtual FunctorCode VisitScoreDefEnd(ScoreDef *scoreDef);
213  virtual FunctorCode VisitScoreDefElement(ScoreDefElement *scoreDefElement);
214  virtual FunctorCode VisitScoreDefElementEnd(ScoreDefElement *scoreDefElement);
215  virtual FunctorCode VisitStaff(Staff *staff);
216  virtual FunctorCode VisitStaffEnd(Staff *staff);
217  virtual FunctorCode VisitStaffDef(StaffDef *staffDef);
218  virtual FunctorCode VisitStaffDefEnd(StaffDef *staffDef);
219  virtual FunctorCode VisitStaffGrp(StaffGrp *staffGrp);
220  virtual FunctorCode VisitStaffGrpEnd(StaffGrp *staffGrp);
221  virtual FunctorCode VisitSystem(System *system);
222  virtual FunctorCode VisitSystemEnd(System *system);
223  virtual FunctorCode VisitTuning(Tuning *tuning);
224  virtual FunctorCode VisitTuningEnd(Tuning *tuning);
226 
232  virtual FunctorCode VisitEditorialElement(EditorialElement *editorialElement);
233  virtual FunctorCode VisitEditorialElementEnd(EditorialElement *editorialElement);
235 
240  virtual FunctorCode VisitDiv(Div *div);
241  virtual FunctorCode VisitDivEnd(Div *div);
242  virtual FunctorCode VisitRunningElement(RunningElement *runningElement);
243  virtual FunctorCode VisitRunningElementEnd(RunningElement *runningElement);
244  virtual FunctorCode VisitPgFoot(PgFoot *pgFoot);
245  virtual FunctorCode VisitPgFootEnd(PgFoot *pgFoot);
246  virtual FunctorCode VisitPgHead(PgHead *pgHead);
247  virtual FunctorCode VisitPgHeadEnd(PgHead *pgHead);
248  virtual FunctorCode VisitTextLayoutElement(TextLayoutElement *textLayoutElement);
249  virtual FunctorCode VisitTextLayoutElementEnd(TextLayoutElement *textLayoutElement);
251 
256  virtual FunctorCode VisitEnding(Ending *ending);
257  virtual FunctorCode VisitEndingEnd(Ending *ending);
258  virtual FunctorCode VisitExpansion(Expansion *expansion);
259  virtual FunctorCode VisitExpansionEnd(Expansion *expansion);
260  virtual FunctorCode VisitSection(Section *section);
261  virtual FunctorCode VisitSectionEnd(Section *section);
262  virtual FunctorCode VisitSystemElement(SystemElement *systemElement);
263  virtual FunctorCode VisitSystemElementEnd(SystemElement *systemElement);
264  virtual FunctorCode VisitSystemMilestone(SystemMilestoneEnd *systemMilestoneEnd);
265  virtual FunctorCode VisitSystemMilestoneEnd(SystemMilestoneEnd *systemMilestoneEnd);
267 
272  virtual FunctorCode VisitMdiv(Mdiv *mdiv);
273  virtual FunctorCode VisitMdivEnd(Mdiv *mdiv);
274  virtual FunctorCode VisitPageElement(PageElement *pageElement);
275  virtual FunctorCode VisitPageElementEnd(PageElement *pageElement);
276  virtual FunctorCode VisitPageMilestone(PageMilestoneEnd *pageMilestoneEnd);
277  virtual FunctorCode VisitPageMilestoneEnd(PageMilestoneEnd *pageMilestoneEnd);
278  virtual FunctorCode VisitScore(Score *score);
279  virtual FunctorCode VisitScoreEnd(Score *score);
281 
286  virtual FunctorCode VisitAnchoredText(AnchoredText *anchoredText);
287  virtual FunctorCode VisitAnchoredTextEnd(AnchoredText *anchoredText);
288  virtual FunctorCode VisitAnnotScore(AnnotScore *annotScore);
289  virtual FunctorCode VisitAnnotScoreEnd(AnnotScore *annotScore);
290  virtual FunctorCode VisitArpeg(Arpeg *arpeg);
291  virtual FunctorCode VisitArpegEnd(Arpeg *arpeg);
292  virtual FunctorCode VisitBeamSpan(BeamSpan *beamSpan);
293  virtual FunctorCode VisitBeamSpanEnd(BeamSpan *beamSpan);
294  virtual FunctorCode VisitBracketSpan(BracketSpan *bracketSpan);
295  virtual FunctorCode VisitBracketSpanEnd(BracketSpan *bracketSpan);
296  virtual FunctorCode VisitBreath(Breath *breath);
297  virtual FunctorCode VisitBreathEnd(Breath *breath);
298  virtual FunctorCode VisitCaesura(Caesura *caesura);
299  virtual FunctorCode VisitCaesuraEnd(Caesura *caesura);
300  virtual FunctorCode VisitControlElement(ControlElement *controlElement);
301  virtual FunctorCode VisitControlElementEnd(ControlElement *controlElement);
302  virtual FunctorCode VisitCpMark(CpMark *cpMark);
303  virtual FunctorCode VisitCpMarkEnd(CpMark *cpMark);
304  virtual FunctorCode VisitDir(Dir *dir);
305  virtual FunctorCode VisitDirEnd(Dir *dir);
306  virtual FunctorCode VisitDynam(Dynam *dynam);
307  virtual FunctorCode VisitDynamEnd(Dynam *dynam);
308  virtual FunctorCode VisitFermata(Fermata *fermata);
309  virtual FunctorCode VisitFermataEnd(Fermata *fermata);
310  virtual FunctorCode VisitFing(Fing *fing);
311  virtual FunctorCode VisitFingEnd(Fing *fing);
312  virtual FunctorCode VisitGliss(Gliss *gliss);
313  virtual FunctorCode VisitGlissEnd(Gliss *gliss);
314  virtual FunctorCode VisitHairpin(Hairpin *hairpin);
315  virtual FunctorCode VisitHairpinEnd(Hairpin *hairpin);
316  virtual FunctorCode VisitHarm(Harm *harm);
317  virtual FunctorCode VisitHarmEnd(Harm *harm);
318  virtual FunctorCode VisitLv(Lv *lv);
319  virtual FunctorCode VisitLvEnd(Lv *lv);
320  virtual FunctorCode VisitMordent(Mordent *mordent);
321  virtual FunctorCode VisitMordentEnd(Mordent *mordent);
322  virtual FunctorCode VisitOctave(Octave *octave);
323  virtual FunctorCode VisitOctaveEnd(Octave *octave);
324  virtual FunctorCode VisitOrnam(Ornam *ornam);
325  virtual FunctorCode VisitOrnamEnd(Ornam *ornam);
326  virtual FunctorCode VisitPedal(Pedal *pedal);
327  virtual FunctorCode VisitPedalEnd(Pedal *pedal);
328  virtual FunctorCode VisitPhrase(Phrase *phrase);
329  virtual FunctorCode VisitPhraseEnd(Phrase *phrase);
330  virtual FunctorCode VisitPitchInflection(PitchInflection *pitchInflection);
331  virtual FunctorCode VisitPitchInflectionEnd(PitchInflection *pitchInflection);
332  virtual FunctorCode VisitReh(Reh *reh);
333  virtual FunctorCode VisitRehEnd(Reh *reh);
334  virtual FunctorCode VisitRepeatMark(RepeatMark *repeatMark);
335  virtual FunctorCode VisitRepeatMarkEnd(RepeatMark *repeatMark);
336  virtual FunctorCode VisitSlur(Slur *slur);
337  virtual FunctorCode VisitSlurEnd(Slur *slur);
338  virtual FunctorCode VisitTempo(Tempo *tempo);
339  virtual FunctorCode VisitTempoEnd(Tempo *tempo);
340  virtual FunctorCode VisitTie(Tie *tie);
341  virtual FunctorCode VisitTieEnd(Tie *tie);
342  virtual FunctorCode VisitTrill(Trill *trill);
343  virtual FunctorCode VisitTrillEnd(Trill *trill);
344  virtual FunctorCode VisitTurn(Turn *turn);
345  virtual FunctorCode VisitTurnEnd(Turn *turn);
347 
352  virtual FunctorCode VisitAccid(Accid *accid);
353  virtual FunctorCode VisitAccidEnd(Accid *accid);
354  virtual FunctorCode VisitArtic(Artic *artic);
355  virtual FunctorCode VisitArticEnd(Artic *artic);
356  virtual FunctorCode VisitBarLine(BarLine *barLine);
357  virtual FunctorCode VisitBarLineEnd(BarLine *barLine);
358  virtual FunctorCode VisitBeam(Beam *beam);
359  virtual FunctorCode VisitBeamEnd(Beam *beam);
360  virtual FunctorCode VisitBeatRpt(BeatRpt *beatRpt);
361  virtual FunctorCode VisitBeatRptEnd(BeatRpt *beatRpt);
362  virtual FunctorCode VisitBTrem(BTrem *bTrem);
363  virtual FunctorCode VisitBTremEnd(BTrem *bTrem);
364  virtual FunctorCode VisitChord(Chord *chord);
365  virtual FunctorCode VisitChordEnd(Chord *chord);
366  virtual FunctorCode VisitClef(Clef *clef);
367  virtual FunctorCode VisitClefEnd(Clef *clef);
368  virtual FunctorCode VisitCustos(Custos *custos);
369  virtual FunctorCode VisitCustosEnd(Custos *custos);
370  virtual FunctorCode VisitDot(Dot *dot);
371  virtual FunctorCode VisitDotEnd(Dot *dot);
372  virtual FunctorCode VisitDots(Dots *dots);
373  virtual FunctorCode VisitDotsEnd(Dots *dots);
374  virtual FunctorCode VisitFlag(Flag *flag);
375  virtual FunctorCode VisitFlagEnd(Flag *flag);
376  virtual FunctorCode VisitFTrem(FTrem *fTrem);
377  virtual FunctorCode VisitFTremEnd(FTrem *fTrem);
378  virtual FunctorCode VisitGenericLayerElement(GenericLayerElement *genericLayerElement);
379  virtual FunctorCode VisitGenericLayerElementEnd(GenericLayerElement *genericLayerElement);
380  virtual FunctorCode VisitGraceGrp(GraceGrp *graceGrp);
381  virtual FunctorCode VisitGraceGrpEnd(GraceGrp *graceGrp);
382  virtual FunctorCode VisitHalfmRpt(HalfmRpt *halfmRpt);
383  virtual FunctorCode VisitHalfmRptEnd(HalfmRpt *halfmRpt);
384  virtual FunctorCode VisitKeyAccid(KeyAccid *keyAccid);
385  virtual FunctorCode VisitKeyAccidEnd(KeyAccid *keyAccid);
386  virtual FunctorCode VisitKeySig(KeySig *keySig);
387  virtual FunctorCode VisitKeySigEnd(KeySig *keySig);
388  virtual FunctorCode VisitLayerElement(LayerElement *layerElement);
389  virtual FunctorCode VisitLayerElementEnd(LayerElement *layerElement);
390  virtual FunctorCode VisitLigature(Ligature *ligature);
391  virtual FunctorCode VisitLigatureEnd(Ligature *ligature);
392  virtual FunctorCode VisitMensur(Mensur *mensur);
393  virtual FunctorCode VisitMensurEnd(Mensur *mensur);
394  virtual FunctorCode VisitMeterSig(MeterSig *meterSig);
395  virtual FunctorCode VisitMeterSigEnd(MeterSig *meterSig);
396  virtual FunctorCode VisitMeterSigGrp(MeterSigGrp *meterSigGrp);
397  virtual FunctorCode VisitMeterSigGrpEnd(MeterSigGrp *meterSigGrp);
398  virtual FunctorCode VisitMRest(MRest *mRest);
399  virtual FunctorCode VisitMRestEnd(MRest *mRest);
400  virtual FunctorCode VisitMRpt(MRpt *mRpt);
401  virtual FunctorCode VisitMRptEnd(MRpt *mRpt);
402  virtual FunctorCode VisitMRpt2(MRpt2 *mRpt2);
403  virtual FunctorCode VisitMRpt2End(MRpt2 *mRpt2);
404  virtual FunctorCode VisitMSpace(MSpace *mSpace);
405  virtual FunctorCode VisitMSpaceEnd(MSpace *mSpace);
406  virtual FunctorCode VisitMultiRest(MultiRest *multiRest);
407  virtual FunctorCode VisitMultiRestEnd(MultiRest *multiRest);
408  virtual FunctorCode VisitMultiRpt(MultiRpt *multiRpt);
409  virtual FunctorCode VisitMultiRptEnd(MultiRpt *multiRpt);
410  virtual FunctorCode VisitNc(Nc *nc);
411  virtual FunctorCode VisitNcEnd(Nc *nc);
412  virtual FunctorCode VisitNeume(Neume *neume);
413  virtual FunctorCode VisitNeumeEnd(Neume *neume);
414  virtual FunctorCode VisitNote(Note *note);
415  virtual FunctorCode VisitNoteEnd(Note *note);
416  virtual FunctorCode VisitPlica(Plica *plica);
417  virtual FunctorCode VisitPlicaEnd(Plica *plica);
418  virtual FunctorCode VisitProport(Proport *proport);
419  virtual FunctorCode VisitProportEnd(Proport *proport);
420  virtual FunctorCode VisitRest(Rest *rest);
421  virtual FunctorCode VisitRestEnd(Rest *rest);
422  virtual FunctorCode VisitSpace(Space *space);
423  virtual FunctorCode VisitSpaceEnd(Space *space);
424  virtual FunctorCode VisitStem(Stem *stem);
425  virtual FunctorCode VisitStemEnd(Stem *stem);
426  virtual FunctorCode VisitSyl(Syl *syl);
427  virtual FunctorCode VisitSylEnd(Syl *syl);
428  virtual FunctorCode VisitSyllable(Syllable *syllable);
429  virtual FunctorCode VisitSyllableEnd(Syllable *syllable);
430  virtual FunctorCode VisitTabDurSym(TabDurSym *tabDurSym);
431  virtual FunctorCode VisitTabDurSymEnd(TabDurSym *tabDurSym);
432  virtual FunctorCode VisitTabGrp(TabGrp *tabGrp);
433  virtual FunctorCode VisitTabGrpEnd(TabGrp *tabGrp);
434  virtual FunctorCode VisitTimestamp(TimestampAttr *timestamp);
435  virtual FunctorCode VisitTimestampEnd(TimestampAttr *timestamp);
436  virtual FunctorCode VisitTuplet(Tuplet *tuplet);
437  virtual FunctorCode VisitTupletEnd(Tuplet *tuplet);
438  virtual FunctorCode VisitTupletBracket(TupletBracket *tupletBracket);
439  virtual FunctorCode VisitTupletBracketEnd(TupletBracket *tupletBracket);
440  virtual FunctorCode VisitTupletNum(TupletNum *tupletNum);
441  virtual FunctorCode VisitTupletNumEnd(TupletNum *tupletNum);
442  virtual FunctorCode VisitVerse(Verse *verse);
443  virtual FunctorCode VisitVerseEnd(Verse *verse);
445 
450  virtual FunctorCode VisitF(F *f);
451  virtual FunctorCode VisitFEnd(F *f);
452  virtual FunctorCode VisitFb(Fb *fb);
453  virtual FunctorCode VisitFbEnd(Fb *fb);
454  virtual FunctorCode VisitFig(Fig *fig);
455  virtual FunctorCode VisitFigEnd(Fig *fig);
456  virtual FunctorCode VisitLb(Lb *lb);
457  virtual FunctorCode VisitLbEnd(Lb *lb);
458  virtual FunctorCode VisitMNum(MNum *mNum);
459  virtual FunctorCode VisitMNumEnd(MNum *mNum);
460  virtual FunctorCode VisitNum(Num *num);
461  virtual FunctorCode VisitNumEnd(Num *num);
462  virtual FunctorCode VisitRend(Rend *rend);
463  virtual FunctorCode VisitRendEnd(Rend *rend);
464  virtual FunctorCode VisitSvg(Svg *svg);
465  virtual FunctorCode VisitSvgEnd(Svg *svg);
466  virtual FunctorCode VisitSymbol(Symbol *symbol);
467  virtual FunctorCode VisitSymbolEnd(Symbol *symbol);
468  virtual FunctorCode VisitText(Text *text);
469  virtual FunctorCode VisitTextEnd(Text *text);
470  virtual FunctorCode VisitTextElement(TextElement *textElement);
471  virtual FunctorCode VisitTextElementEnd(TextElement *textElement);
473 
478  virtual FunctorCode VisitFacsimile(Facsimile *facsimile);
479  virtual FunctorCode VisitFacsimileEnd(Facsimile *facsimile);
480  virtual FunctorCode VisitGraphic(Graphic *graphic);
481  virtual FunctorCode VisitGraphicEnd(Graphic *graphic);
482  virtual FunctorCode VisitSurface(Surface *surface);
483  virtual FunctorCode VisitSurfaceEnd(Surface *surface);
484  virtual FunctorCode VisitZone(Zone *zone);
485  virtual FunctorCode VisitZoneEnd(Zone *zone);
487 
492  virtual FunctorCode VisitAlignment(Alignment *alignment);
493  virtual FunctorCode VisitAlignmentEnd(Alignment *alignment);
494  virtual FunctorCode VisitAlignmentReference(AlignmentReference *alignmentReference);
495  virtual FunctorCode VisitAlignmentReferenceEnd(AlignmentReference *alignmentReference);
496  virtual FunctorCode VisitHorizontalAligner(HorizontalAligner *horizontalAligner);
497  virtual FunctorCode VisitHorizontalAlignerEnd(HorizontalAligner *horizontalAligner);
498  virtual FunctorCode VisitMeasureAligner(MeasureAligner *measureAligner);
499  virtual FunctorCode VisitMeasureAlignerEnd(MeasureAligner *measureAligner);
500  virtual FunctorCode VisitGraceAligner(GraceAligner *graceAligner);
501  virtual FunctorCode VisitGraceAlignerEnd(GraceAligner *graceAligner);
502  virtual FunctorCode VisitTimestampAligner(TimestampAligner *timestampAligner);
503  virtual FunctorCode VisitTimestampAlignerEnd(TimestampAligner *timestampAligner);
505 
510  virtual FunctorCode VisitSystemAligner(SystemAligner *systemAligner);
511  virtual FunctorCode VisitSystemAlignerEnd(SystemAligner *systemAligner);
512  virtual FunctorCode VisitStaffAlignment(StaffAlignment *staffAlignment);
513  virtual FunctorCode VisitStaffAlignmentEnd(StaffAlignment *staffAlignment);
515 
520  virtual FunctorCode VisitFloatingObject(FloatingObject *floatingObject);
521  virtual FunctorCode VisitFloatingObjectEnd(FloatingObject *floatingObject);
523 
524 private:
525  //
526 public:
527  //
528 private:
529  //
530 };
531 
532 //----------------------------------------------------------------------------
533 // ConstFunctorInterface
534 //----------------------------------------------------------------------------
535 
540 class ConstFunctorInterface {
541 public:
546  ConstFunctorInterface() {}
547  virtual ~ConstFunctorInterface() = default;
549 
554  virtual FunctorCode VisitObject(const Object *) { return FUNCTOR_CONTINUE; }
555  virtual FunctorCode VisitObjectEnd(const Object *) { return FUNCTOR_CONTINUE; }
556  virtual FunctorCode VisitDoc(const Doc *doc);
557  virtual FunctorCode VisitDocEnd(const Doc *doc);
559 
564  virtual FunctorCode VisitCourse(const Course *course);
565  virtual FunctorCode VisitCourseEnd(const Course *course);
566  virtual FunctorCode VisitGrpSym(const GrpSym *grpSym);
567  virtual FunctorCode VisitGrpSymEnd(const GrpSym *grpSym);
568  virtual FunctorCode VisitInstrDef(const InstrDef *instrDef);
569  virtual FunctorCode VisitInstrDefEnd(const InstrDef *instrDef);
570  virtual FunctorCode VisitLabel(const Label *label);
571  virtual FunctorCode VisitLabelEnd(const Label *label);
572  virtual FunctorCode VisitLabelAbbr(const LabelAbbr *labelAbbr);
573  virtual FunctorCode VisitLabelAbbrEnd(const LabelAbbr *labelAbbr);
574  virtual FunctorCode VisitLayer(const Layer *layer);
575  virtual FunctorCode VisitLayerEnd(const Layer *layer);
576  virtual FunctorCode VisitLayerDef(const LayerDef *layerDef);
577  virtual FunctorCode VisitLayerDefEnd(const LayerDef *layerDef);
578  virtual FunctorCode VisitMeasure(const Measure *measure);
579  virtual FunctorCode VisitMeasureEnd(const Measure *measure);
580  virtual FunctorCode VisitOssia(const Ossia *ossia);
581  virtual FunctorCode VisitOssiaEnd(const Ossia *ossia);
582  virtual FunctorCode VisitPage(const Page *page);
583  virtual FunctorCode VisitPageEnd(const Page *page);
584  virtual FunctorCode VisitPages(const Pages *pages);
585  virtual FunctorCode VisitPagesEnd(const Pages *pages);
586  virtual FunctorCode VisitPb(const Pb *pb);
587  virtual FunctorCode VisitPbEnd(const Pb *pb);
588  virtual FunctorCode VisitSb(const Sb *sb);
589  virtual FunctorCode VisitSbEnd(const Sb *sb);
590  virtual FunctorCode VisitScoreDef(const ScoreDef *scoreDef);
591  virtual FunctorCode VisitScoreDefEnd(const ScoreDef *scoreDef);
592  virtual FunctorCode VisitScoreDefElement(const ScoreDefElement *scoreDefElement);
593  virtual FunctorCode VisitScoreDefElementEnd(const ScoreDefElement *scoreDefElement);
594  virtual FunctorCode VisitStaff(const Staff *staff);
595  virtual FunctorCode VisitStaffEnd(const Staff *staff);
596  virtual FunctorCode VisitStaffDef(const StaffDef *staffDef);
597  virtual FunctorCode VisitStaffDefEnd(const StaffDef *staffDef);
598  virtual FunctorCode VisitStaffGrp(const StaffGrp *staffGrp);
599  virtual FunctorCode VisitStaffGrpEnd(const StaffGrp *staffGrp);
600  virtual FunctorCode VisitSystem(const System *system);
601  virtual FunctorCode VisitSystemEnd(const System *system);
602  virtual FunctorCode VisitTuning(const Tuning *tuning);
603  virtual FunctorCode VisitTuningEnd(const Tuning *tuning);
605 
611  virtual FunctorCode VisitEditorialElement(const EditorialElement *editorialElement);
612  virtual FunctorCode VisitEditorialElementEnd(const EditorialElement *editorialElement);
614 
619  virtual FunctorCode VisitDiv(const Div *div);
620  virtual FunctorCode VisitDivEnd(const Div *div);
621  virtual FunctorCode VisitRunningElement(const RunningElement *runningElement);
622  virtual FunctorCode VisitRunningElementEnd(const RunningElement *runningElement);
623  virtual FunctorCode VisitPgFoot(const PgFoot *pgFoot);
624  virtual FunctorCode VisitPgFootEnd(const PgFoot *pgFoot);
625  virtual FunctorCode VisitPgHead(const PgHead *pgHead);
626  virtual FunctorCode VisitPgHeadEnd(const PgHead *pgHead);
627  virtual FunctorCode VisitTextLayoutElement(const TextLayoutElement *textLayoutElement);
628  virtual FunctorCode VisitTextLayoutElementEnd(const TextLayoutElement *textLayoutElement);
630 
635  virtual FunctorCode VisitEnding(const Ending *ending);
636  virtual FunctorCode VisitEndingEnd(const Ending *ending);
637  virtual FunctorCode VisitExpansion(const Expansion *expansion);
638  virtual FunctorCode VisitExpansionEnd(const Expansion *expansion);
639  virtual FunctorCode VisitSection(const Section *section);
640  virtual FunctorCode VisitSectionEnd(const Section *section);
641  virtual FunctorCode VisitSystemElement(const SystemElement *systemElement);
642  virtual FunctorCode VisitSystemElementEnd(const SystemElement *systemElement);
643  virtual FunctorCode VisitSystemMilestone(const SystemMilestoneEnd *systemMilestoneEnd);
644  virtual FunctorCode VisitSystemMilestoneEnd(const SystemMilestoneEnd *systemMilestoneEnd);
646 
651  virtual FunctorCode VisitMdiv(const Mdiv *mdiv);
652  virtual FunctorCode VisitMdivEnd(const Mdiv *mdiv);
653  virtual FunctorCode VisitPageElement(const PageElement *pageElement);
654  virtual FunctorCode VisitPageElementEnd(const PageElement *pageElement);
655  virtual FunctorCode VisitPageMilestone(const PageMilestoneEnd *pageMilestoneEnd);
656  virtual FunctorCode VisitPageMilestoneEnd(const PageMilestoneEnd *pageMilestoneEnd);
657  virtual FunctorCode VisitScore(const Score *score);
658  virtual FunctorCode VisitScoreEnd(const Score *score);
660 
665  virtual FunctorCode VisitAnchoredText(const AnchoredText *anchoredText);
666  virtual FunctorCode VisitAnchoredTextEnd(const AnchoredText *anchoredText);
667  virtual FunctorCode VisitAnnotScore(const AnnotScore *annotScore);
668  virtual FunctorCode VisitAnnotScoreEnd(const AnnotScore *annotScore);
669  virtual FunctorCode VisitArpeg(const Arpeg *arpeg);
670  virtual FunctorCode VisitArpegEnd(const Arpeg *arpeg);
671  virtual FunctorCode VisitBeamSpan(const BeamSpan *beamSpan);
672  virtual FunctorCode VisitBeamSpanEnd(const BeamSpan *beamSpan);
673  virtual FunctorCode VisitBracketSpan(const BracketSpan *bracketSpan);
674  virtual FunctorCode VisitBracketSpanEnd(const BracketSpan *bracketSpan);
675  virtual FunctorCode VisitBreath(const Breath *breath);
676  virtual FunctorCode VisitBreathEnd(const Breath *breath);
677  virtual FunctorCode VisitCaesura(const Caesura *caesura);
678  virtual FunctorCode VisitCaesuraEnd(const Caesura *caesura);
679  virtual FunctorCode VisitControlElement(const ControlElement *controlElement);
680  virtual FunctorCode VisitControlElementEnd(const ControlElement *controlElement);
681  virtual FunctorCode VisitCpMark(const CpMark *cpMark);
682  virtual FunctorCode VisitCpMarkEnd(const CpMark *cpMark);
683  virtual FunctorCode VisitDir(const Dir *dir);
684  virtual FunctorCode VisitDirEnd(const Dir *dir);
685  virtual FunctorCode VisitDynam(const Dynam *dynam);
686  virtual FunctorCode VisitDynamEnd(const Dynam *dynam);
687  virtual FunctorCode VisitFermata(const Fermata *fermata);
688  virtual FunctorCode VisitFermataEnd(const Fermata *fermata);
689  virtual FunctorCode VisitFing(const Fing *fing);
690  virtual FunctorCode VisitFingEnd(const Fing *fing);
691  virtual FunctorCode VisitGliss(const Gliss *gliss);
692  virtual FunctorCode VisitGlissEnd(const Gliss *gliss);
693  virtual FunctorCode VisitHairpin(const Hairpin *hairpin);
694  virtual FunctorCode VisitHairpinEnd(const Hairpin *hairpin);
695  virtual FunctorCode VisitHarm(const Harm *harm);
696  virtual FunctorCode VisitHarmEnd(const Harm *harm);
697  virtual FunctorCode VisitLv(const Lv *lv);
698  virtual FunctorCode VisitLvEnd(const Lv *lv);
699  virtual FunctorCode VisitMordent(const Mordent *mordent);
700  virtual FunctorCode VisitMordentEnd(const Mordent *mordent);
701  virtual FunctorCode VisitOctave(const Octave *octave);
702  virtual FunctorCode VisitOctaveEnd(const Octave *octave);
703  virtual FunctorCode VisitOrnam(const Ornam *ornam);
704  virtual FunctorCode VisitOrnamEnd(const Ornam *ornam);
705  virtual FunctorCode VisitPedal(const Pedal *pedal);
706  virtual FunctorCode VisitPedalEnd(const Pedal *pedal);
707  virtual FunctorCode VisitPhrase(const Phrase *phrase);
708  virtual FunctorCode VisitPhraseEnd(const Phrase *phrase);
709  virtual FunctorCode VisitPitchInflection(const PitchInflection *pitchInflection);
710  virtual FunctorCode VisitPitchInflectionEnd(const PitchInflection *pitchInflection);
711  virtual FunctorCode VisitReh(const Reh *reh);
712  virtual FunctorCode VisitRehEnd(const Reh *reh);
713  virtual FunctorCode VisitRepeatMark(const RepeatMark *repeatMark);
714  virtual FunctorCode VisitRepeatMarkEnd(const RepeatMark *repeatMark);
715  virtual FunctorCode VisitSlur(const Slur *slur);
716  virtual FunctorCode VisitSlurEnd(const Slur *slur);
717  virtual FunctorCode VisitTempo(const Tempo *tempo);
718  virtual FunctorCode VisitTempoEnd(const Tempo *tempo);
719  virtual FunctorCode VisitTie(const Tie *tie);
720  virtual FunctorCode VisitTieEnd(const Tie *tie);
721  virtual FunctorCode VisitTrill(const Trill *trill);
722  virtual FunctorCode VisitTrillEnd(const Trill *trill);
723  virtual FunctorCode VisitTurn(const Turn *turn);
724  virtual FunctorCode VisitTurnEnd(const Turn *turn);
726 
731  virtual FunctorCode VisitAccid(const Accid *accid);
732  virtual FunctorCode VisitAccidEnd(const Accid *accid);
733  virtual FunctorCode VisitArtic(const Artic *artic);
734  virtual FunctorCode VisitArticEnd(const Artic *artic);
735  virtual FunctorCode VisitBarLine(const BarLine *barLine);
736  virtual FunctorCode VisitBarLineEnd(const BarLine *barLine);
737  virtual FunctorCode VisitBeam(const Beam *beam);
738  virtual FunctorCode VisitBeamEnd(const Beam *beam);
739  virtual FunctorCode VisitBeatRpt(const BeatRpt *beatRpt);
740  virtual FunctorCode VisitBeatRptEnd(const BeatRpt *beatRpt);
741  virtual FunctorCode VisitBTrem(const BTrem *bTrem);
742  virtual FunctorCode VisitBTremEnd(const BTrem *bTrem);
743  virtual FunctorCode VisitChord(const Chord *chord);
744  virtual FunctorCode VisitChordEnd(const Chord *chord);
745  virtual FunctorCode VisitClef(const Clef *clef);
746  virtual FunctorCode VisitClefEnd(const Clef *clef);
747  virtual FunctorCode VisitCustos(const Custos *custos);
748  virtual FunctorCode VisitCustosEnd(const Custos *custos);
749  virtual FunctorCode VisitDot(const Dot *dot);
750  virtual FunctorCode VisitDotEnd(const Dot *dot);
751  virtual FunctorCode VisitDots(const Dots *dots);
752  virtual FunctorCode VisitDotsEnd(const Dots *dots);
753  virtual FunctorCode VisitFlag(const Flag *flag);
754  virtual FunctorCode VisitFlagEnd(const Flag *flag);
755  virtual FunctorCode VisitFTrem(const FTrem *fTrem);
756  virtual FunctorCode VisitFTremEnd(const FTrem *fTrem);
757  virtual FunctorCode VisitGenericLayerElement(const GenericLayerElement *genericLayerElement);
758  virtual FunctorCode VisitGenericLayerElementEnd(const GenericLayerElement *genericLayerElement);
759  virtual FunctorCode VisitGraceGrp(const GraceGrp *graceGrp);
760  virtual FunctorCode VisitGraceGrpEnd(const GraceGrp *graceGrp);
761  virtual FunctorCode VisitHalfmRpt(const HalfmRpt *halfmRpt);
762  virtual FunctorCode VisitHalfmRptEnd(const HalfmRpt *halfmRpt);
763  virtual FunctorCode VisitKeyAccid(const KeyAccid *keyAccid);
764  virtual FunctorCode VisitKeyAccidEnd(const KeyAccid *keyAccid);
765  virtual FunctorCode VisitKeySig(const KeySig *keySig);
766  virtual FunctorCode VisitKeySigEnd(const KeySig *keySig);
767  virtual FunctorCode VisitLayerElement(const LayerElement *layerElement);
768  virtual FunctorCode VisitLayerElementEnd(const LayerElement *layerElement);
769  virtual FunctorCode VisitLigature(const Ligature *ligature);
770  virtual FunctorCode VisitLigatureEnd(const Ligature *ligature);
771  virtual FunctorCode VisitMensur(const Mensur *mensur);
772  virtual FunctorCode VisitMensurEnd(const Mensur *mensur);
773  virtual FunctorCode VisitMeterSig(const MeterSig *meterSig);
774  virtual FunctorCode VisitMeterSigEnd(const MeterSig *meterSig);
775  virtual FunctorCode VisitMeterSigGrp(const MeterSigGrp *meterSigGrp);
776  virtual FunctorCode VisitMeterSigGrpEnd(const MeterSigGrp *meterSigGrp);
777  virtual FunctorCode VisitMRest(const MRest *mRest);
778  virtual FunctorCode VisitMRestEnd(const MRest *mRest);
779  virtual FunctorCode VisitMRpt(const MRpt *mRpt);
780  virtual FunctorCode VisitMRptEnd(const MRpt *mRpt);
781  virtual FunctorCode VisitMRpt2(const MRpt2 *mRpt2);
782  virtual FunctorCode VisitMRpt2End(const MRpt2 *mRpt2);
783  virtual FunctorCode VisitMSpace(const MSpace *mSpace);
784  virtual FunctorCode VisitMSpaceEnd(const MSpace *mSpace);
785  virtual FunctorCode VisitMultiRest(const MultiRest *multiRest);
786  virtual FunctorCode VisitMultiRestEnd(const MultiRest *multiRest);
787  virtual FunctorCode VisitMultiRpt(const MultiRpt *multiRpt);
788  virtual FunctorCode VisitMultiRptEnd(const MultiRpt *multiRpt);
789  virtual FunctorCode VisitNc(const Nc *nc);
790  virtual FunctorCode VisitNcEnd(const Nc *nc);
791  virtual FunctorCode VisitNeume(const Neume *neume);
792  virtual FunctorCode VisitNeumeEnd(const Neume *neume);
793  virtual FunctorCode VisitNote(const Note *note);
794  virtual FunctorCode VisitNoteEnd(const Note *note);
795  virtual FunctorCode VisitPlica(const Plica *plica);
796  virtual FunctorCode VisitPlicaEnd(const Plica *plica);
797  virtual FunctorCode VisitProport(const Proport *proport);
798  virtual FunctorCode VisitProportEnd(const Proport *proport);
799  virtual FunctorCode VisitRest(const Rest *rest);
800  virtual FunctorCode VisitRestEnd(const Rest *rest);
801  virtual FunctorCode VisitSpace(const Space *space);
802  virtual FunctorCode VisitSpaceEnd(const Space *space);
803  virtual FunctorCode VisitStem(const Stem *stem);
804  virtual FunctorCode VisitStemEnd(const Stem *stem);
805  virtual FunctorCode VisitSyl(const Syl *syl);
806  virtual FunctorCode VisitSylEnd(const Syl *syl);
807  virtual FunctorCode VisitSyllable(const Syllable *syllable);
808  virtual FunctorCode VisitSyllableEnd(const Syllable *syllable);
809  virtual FunctorCode VisitTabDurSym(const TabDurSym *tabDurSym);
810  virtual FunctorCode VisitTabDurSymEnd(const TabDurSym *tabDurSym);
811  virtual FunctorCode VisitTabGrp(const TabGrp *tabGrp);
812  virtual FunctorCode VisitTabGrpEnd(const TabGrp *tabGrp);
813  virtual FunctorCode VisitTimestamp(const TimestampAttr *timestamp);
814  virtual FunctorCode VisitTimestampEnd(const TimestampAttr *timestamp);
815  virtual FunctorCode VisitTuplet(const Tuplet *tuplet);
816  virtual FunctorCode VisitTupletEnd(const Tuplet *tuplet);
817  virtual FunctorCode VisitTupletBracket(const TupletBracket *tupletBracket);
818  virtual FunctorCode VisitTupletBracketEnd(const TupletBracket *tupletBracket);
819  virtual FunctorCode VisitTupletNum(const TupletNum *tupletNum);
820  virtual FunctorCode VisitTupletNumEnd(const TupletNum *tupletNum);
821  virtual FunctorCode VisitVerse(const Verse *verse);
822  virtual FunctorCode VisitVerseEnd(const Verse *verse);
824 
829  virtual FunctorCode VisitF(const F *f);
830  virtual FunctorCode VisitFEnd(const F *f);
831  virtual FunctorCode VisitFb(const Fb *fb);
832  virtual FunctorCode VisitFbEnd(const Fb *fb);
833  virtual FunctorCode VisitFig(const Fig *fig);
834  virtual FunctorCode VisitFigEnd(const Fig *fig);
835  virtual FunctorCode VisitLb(const Lb *lb);
836  virtual FunctorCode VisitLbEnd(const Lb *lb);
837  virtual FunctorCode VisitMNum(const MNum *mNum);
838  virtual FunctorCode VisitMNumEnd(const MNum *mNum);
839  virtual FunctorCode VisitNum(const Num *num);
840  virtual FunctorCode VisitNumEnd(const Num *num);
841  virtual FunctorCode VisitRend(const Rend *rend);
842  virtual FunctorCode VisitRendEnd(const Rend *rend);
843  virtual FunctorCode VisitSvg(const Svg *svg);
844  virtual FunctorCode VisitSvgEnd(const Svg *svg);
845  virtual FunctorCode VisitSymbol(const Symbol *symbol);
846  virtual FunctorCode VisitSymbolEnd(const Symbol *symbol);
847  virtual FunctorCode VisitText(const Text *text);
848  virtual FunctorCode VisitTextEnd(const Text *text);
849  virtual FunctorCode VisitTextElement(const TextElement *textElement);
850  virtual FunctorCode VisitTextElementEnd(const TextElement *textElement);
852 
857  virtual FunctorCode VisitFacsimile(const Facsimile *facsimile);
858  virtual FunctorCode VisitFacsimileEnd(const Facsimile *facsimile);
859  virtual FunctorCode VisitGraphic(const Graphic *graphic);
860  virtual FunctorCode VisitGraphicEnd(const Graphic *graphic);
861  virtual FunctorCode VisitSurface(const Surface *surface);
862  virtual FunctorCode VisitSurfaceEnd(const Surface *surface);
863  virtual FunctorCode VisitZone(const Zone *zone);
864  virtual FunctorCode VisitZoneEnd(const Zone *zone);
866 
871  virtual FunctorCode VisitAlignment(const Alignment *alignment);
872  virtual FunctorCode VisitAlignmentEnd(const Alignment *alignment);
873  virtual FunctorCode VisitAlignmentReference(const AlignmentReference *alignmentReference);
874  virtual FunctorCode VisitAlignmentReferenceEnd(const AlignmentReference *alignmentReference);
875  virtual FunctorCode VisitHorizontalAligner(const HorizontalAligner *horizontalAligner);
876  virtual FunctorCode VisitHorizontalAlignerEnd(const HorizontalAligner *horizontalAligner);
877  virtual FunctorCode VisitMeasureAligner(const MeasureAligner *measureAligner);
878  virtual FunctorCode VisitMeasureAlignerEnd(const MeasureAligner *measureAligner);
879  virtual FunctorCode VisitGraceAligner(const GraceAligner *graceAligner);
880  virtual FunctorCode VisitGraceAlignerEnd(const GraceAligner *graceAligner);
881  virtual FunctorCode VisitTimestampAligner(const TimestampAligner *timestampAligner);
882  virtual FunctorCode VisitTimestampAlignerEnd(const TimestampAligner *timestampAligner);
884 
889  virtual FunctorCode VisitSystemAligner(const SystemAligner *systemAligner);
890  virtual FunctorCode VisitSystemAlignerEnd(const SystemAligner *systemAligner);
891  virtual FunctorCode VisitStaffAlignment(const StaffAlignment *staffAlignment);
892  virtual FunctorCode VisitStaffAlignmentEnd(const StaffAlignment *staffAlignment);
894 
899  virtual FunctorCode VisitFloatingObject(const FloatingObject *floatingObject);
900  virtual FunctorCode VisitFloatingObjectEnd(const FloatingObject *floatingObject);
902 
903 private:
904  //
905 public:
906  //
907 private:
908  //
909 };
910 
911 } // namespace vrv
912 
913 #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:75
vrv::AlignmentReference
This class stores a references of LayerElements for a staff.
Definition: horizontalaligner.h:292
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:540
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::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:161
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:572
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:364
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:52
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:39
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::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:427
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:64
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::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:42
vrv::ScoreDef
This class represents a MEI scoreDef.
Definition: scoredef.h:135
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:172
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:31
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:666
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:249
vrv::Turn
This class models the MEI <turn> element.
Definition: turn.h:33
vrv::Verse
Definition: verse.h:28
vrv::Zone
Implements the zone element in MEI.
Definition: zone.h:30