1 /*
2 MusicXML Library
3 Copyright (C) Grame 2006-2013
4
5 This Source Code Form is subject to the terms of the Mozilla Public
6 License, v. 2.0. If a copy of the MPL was not distributed with this
7 file, You can obtain one at http://mozilla.org/MPL/2.0/.
8
9 Grame Research Laboratory, 11, cours de Verdun Gensoul 69002 Lyon - France
10 research@grame.fr
11 */
12
13 #include <iomanip> // setw, setprecision, ...
14
15 #include "bsrMutualDependencies.h"
16
17 #include "oahOah.h"
18 #include "generalOah.h"
19
20 #include "setTraceOahIfDesired.h"
21 #ifdef TRACE_OAH
22 #include "traceOah.h"
23 #endif
24
25 #include "bsrOah.h"
26 #include "brailleOah.h"
27
28
29 using namespace std;
30
31 namespace MusicXML2
32 {
33
34 //_______________________________________________________________________________
35
create(int inputLineNumber,bsrLineContentsKind lineContentsKind)36 S_bsrLineContents bsrLineContents::create (
37 int inputLineNumber,
38 bsrLineContentsKind lineContentsKind)
39 {
40 bsrLineContents* o =
41 new bsrLineContents (
42 inputLineNumber,
43 lineContentsKind);
44 assert(o!=0);
45 return o;
46 }
47
bsrLineContents(int inputLineNumber,bsrLineContentsKind lineContentsKind)48 bsrLineContents::bsrLineContents (
49 int inputLineNumber,
50 bsrLineContentsKind lineContentsKind)
51 : bsrElement (inputLineNumber)
52 {
53 fLineContentsKind = lineContentsKind;
54 }
55
~bsrLineContents()56 bsrLineContents::~bsrLineContents ()
57 {}
58
createLineNewbornClone()59 S_bsrLineContents bsrLineContents::createLineNewbornClone ()
60 {
61 #ifdef TRACE_OAH
62 if (gBsrOah->fTraceLines) {
63 gLogOstream <<
64 "Creating a newborn clone of line " <<
65 asString () <<
66 endl;
67 }
68 #endif
69
70 S_bsrLineContents
71 newbornClone =
72 bsrLineContents::create (
73 fInputLineNumber,
74 fLineContentsKind);
75
76 return newbornClone;
77 }
78
79 /*
80 void bsrLineContents::setBsrLineUpLink (
81 S_bsrLine bsrLineUpLink)
82 {
83 fBsrLineUpLink = bsrLineUpLink;
84 }
85
86 S_bsrLine bsrLineContents::getBsrLineUpLink () const
87 {
88 return fBsrLineUpLink;
89 }
90 */
91
appendLineElementToLineContents(S_bsrLineElement lineElement)92 void bsrLineContents::appendLineElementToLineContents (
93 S_bsrLineElement lineElement)
94 {
95 fLineContentsElementsList.push_back (lineElement);
96 }
97
insertLineElementBeforeLastElementOfLineContents(S_bsrLineElement lineElement)98 void bsrLineContents::insertLineElementBeforeLastElementOfLineContents (
99 S_bsrLineElement lineElement)
100 {
101 #ifdef TRACE_OAH
102 if (gTraceOah->fTraceTimes || gTraceOah->fTraceMeasures) {
103 gLogOstream <<
104 "Inserting line element '" <<
105 lineElement->asShortString () <<
106 "' before the last element of line contents '" <<
107 asString () <<
108 "'" <<
109 endl;
110 }
111 #endif
112
113 int
114 lineContentsElementsListSize =
115 fLineContentsElementsList.size ();
116
117 if (lineContentsElementsListSize > 0) {
118 list<S_bsrLineElement>::iterator it = fLineContentsElementsList.begin();
119
120 std::advance (it, lineContentsElementsListSize - 1);
121
122 fLineContentsElementsList.insert (it, lineElement);
123 }
124 else {
125 stringstream s;
126
127 s <<
128 "line contents elementslist is empty, cannot insert '" <<
129 lineElement->asShortString () <<
130 "' before its last element";
131
132 bsrInternalError (
133 gOahOah->fInputSourceName,
134 lineElement->getInputLineNumber (),
135 __FILE__, __LINE__,
136 s.str ());
137 }
138 }
139
fetchCellsNumber() const140 int bsrLineContents::fetchCellsNumber () const
141 {
142 int result = 0;
143
144 for (
145 list<S_bsrLineElement>::const_iterator i = fLineContentsElementsList.begin ();
146 i != fLineContentsElementsList.end ();
147 i++
148 ) {
149 S_bsrLineElement lineElement = (*i);
150
151 result += lineElement->fetchCellsNumber ();
152 } // for
153
154 return result;
155 }
156
acceptIn(basevisitor * v)157 void bsrLineContents::acceptIn (basevisitor* v)
158 {
159 #ifdef TRACE_OAH
160 if (gBsrOah->fTraceBsrVisitors) {
161 gLogOstream <<
162 "% ==> bsrLineContents::acceptIn ()" <<
163 endl;
164 }
165 #endif
166
167 if (visitor<S_bsrLineContents>*
168 p =
169 dynamic_cast<visitor<S_bsrLineContents>*> (v)) {
170 S_bsrLineContents elem = this;
171
172 #ifdef TRACE_OAH
173 if (gBsrOah->fTraceBsrVisitors) {
174 gLogOstream <<
175 "% ==> Launching bsrLineContents::visitStart ()" <<
176 endl;
177 }
178 #endif
179 p->visitStart (elem);
180 }
181 }
182
acceptOut(basevisitor * v)183 void bsrLineContents::acceptOut (basevisitor* v)
184 {
185 #ifdef TRACE_OAH
186 if (gBsrOah->fTraceBsrVisitors) {
187 gLogOstream <<
188 "% ==> bsrLineContents::acceptOut ()" <<
189 endl;
190 }
191 #endif
192
193 if (visitor<S_bsrLineContents>*
194 p =
195 dynamic_cast<visitor<S_bsrLineContents>*> (v)) {
196 S_bsrLineContents elem = this;
197
198 #ifdef TRACE_OAH
199 if (gBsrOah->fTraceBsrVisitors) {
200 gLogOstream <<
201 "% ==> Launching bsrLineContents::visitEnd ()" <<
202 endl;
203 }
204 #endif
205 p->visitEnd (elem);
206 }
207 }
208
browseData(basevisitor * v)209 void bsrLineContents::browseData (basevisitor* v)
210 {
211 for (
212 list<S_bsrLineElement>::const_iterator i = fLineContentsElementsList.begin ();
213 i != fLineContentsElementsList.end ();
214 i++ ) {
215 // browse the element
216 bsrBrowser<bsrLineElement> browser (v);
217 browser.browse (*(*i));
218 } // for
219 }
220
lineContentsKindAsString(bsrLineContentsKind lineContentsKind)221 string bsrLineContents::lineContentsKindAsString (
222 bsrLineContentsKind lineContentsKind)
223 {
224 string result;
225
226 switch (lineContentsKind) {
227 case bsrLineContents::kLineContentsRegular:
228 result = "lineContentsRegular";
229 break;
230 case bsrLineContents::kLineContentsContinuation:
231 result = "lineContentsContinuation";
232 break;
233 } // switch
234
235 return result;
236 }
237
asShortString() const238 string bsrLineContents::asShortString () const
239 {
240 /* JMI
241 // this is overriden all in actual elements
242 return "??? bsrLineContents::asString () ???";
243 */
244
245 stringstream s;
246
247 s <<
248 "LineContents" <<
249 ", lineContentsKind: " <<
250 lineContentsKindAsString (fLineContentsKind) <<
251 ", " <<
252 singularOrPlural (
253 fLineContentsElementsList.size (), "lineElement", "lineElements");
254
255 return s.str ();
256 }
257
asString() const258 string bsrLineContents::asString () const
259 {
260 // this can be overriden in actual elements
261 return asShortString ();
262 }
263
print(ostream & os) const264 void bsrLineContents::print (ostream& os) const
265 {
266 int lineElementsListSize = fLineContentsElementsList.size ();
267
268 os <<
269 "LineContents" <<
270 ", lineContentsKind: " <<
271 lineContentsKindAsString (fLineContentsKind) <<
272 ", " <<
273 singularOrPlural (
274 lineElementsListSize, "lineElement", "lineElements") <<
275 endl;
276
277 gIndenter++;
278
279 // print the line numbers
280 const int fieldWidth = 17;
281
282 os << left <<
283 setw (fieldWidth) <<
284 "cellsNumber" << " : " << fetchCellsNumber () <<
285 endl;
286 os << endl;
287
288 // print the line elements if any
289 if (lineElementsListSize || gBsrOah->fDisplayBsrDetails) {
290 os <<
291 // setw (fieldWidth) <<
292 "LineElementsList" <<
293 ", " <<
294 singularOrPlural (
295 lineElementsListSize, "lineElement", "lineElements");
296 if (lineElementsListSize) {
297 os << endl;
298 gIndenter++;
299
300 list<S_bsrLineElement>::const_iterator
301 iBegin = fLineContentsElementsList.begin (),
302 iEnd = fLineContentsElementsList.end (),
303 i = iBegin;
304 for ( ; ; ) {
305 os << (*i);
306 if (++i == iEnd) break;
307 os << endl;
308 } // for
309
310 gIndenter--;
311 }
312 else {
313 os <<
314 " : " << "none" <<
315 endl;
316 }
317 }
318
319 gIndenter--;
320 }
321
operator <<(ostream & os,const S_bsrLineContents & elt)322 ostream& operator<< (ostream& os, const S_bsrLineContents& elt)
323 {
324 elt->print (os);
325 return os;
326 }
327
328 //______________________________________________________________________________
create(int inputLineNumber,int printLineNumber,int cellsPerLine)329 S_bsrLine bsrLine::create (
330 int inputLineNumber,
331 int printLineNumber,
332 int cellsPerLine)
333 {
334 bsrLine* o =
335 new bsrLine (
336 inputLineNumber, printLineNumber, cellsPerLine);
337 assert(o!=0);
338 return o;
339 }
340
bsrLine(int inputLineNumber,int printLineNumber,int cellsPerLine)341 bsrLine::bsrLine (
342 int inputLineNumber,
343 int printLineNumber,
344 int cellsPerLine)
345 : bsrPageElement (inputLineNumber)
346 {
347 fPrintLineNumber = printLineNumber;
348 fBrailleLineNumber = fPrintLineNumber; // will be set by BSR finalizer
349
350 fCellsPerLine = cellsPerLine;
351
352 fLineNumberCellsList = buildLineNumberCellsList ();
353
354 fASpaceIsNeededInLine = true;
355
356 #ifdef TRACE_OAH
357 if (gBsrOah->fTraceLines) {
358 gLogOstream <<
359 "Creating bsrLine '" <<
360 asString () <<
361 "', line " <<
362 fInputLineNumber <<
363 endl;
364 }
365 #endif
366 }
367
~bsrLine()368 bsrLine::~bsrLine ()
369 {}
370
createLineNewbornClone()371 S_bsrLine bsrLine::createLineNewbornClone ()
372 {
373 #ifdef TRACE_OAH
374 if (gBsrOah->fTraceLines) {
375 gLogOstream <<
376 "Creating a newborn clone of line " <<
377 asString () <<
378 endl;
379 }
380 #endif
381
382 S_bsrLine
383 newbornClone =
384 bsrLine::create (
385 fInputLineNumber,
386 fPrintLineNumber,
387 fCellsPerLine);
388
389 // braille line number
390 newbornClone->fBrailleLineNumber =
391 fBrailleLineNumber;
392
393 return newbornClone;
394 }
395
appendLineElementToLine(S_bsrLineElement lineElement)396 void bsrLine::appendLineElementToLine (S_bsrLineElement lineElement)
397 {
398 S_bsrLineContents
399 lineContentsToAppendTo;
400
401 if (! fLineContentsList.size ()) {
402 // first insertion in this line: create the first, regular line contents
403 lineContentsToAppendTo =
404 bsrLineContents::create (
405 lineElement->getInputLineNumber (),
406 bsrLineContents::kLineContentsRegular);
407
408 // set lineElement's spacesAfter value if needed
409 switch (lineContentsToAppendTo->getLineContentsKind ()) {
410 case bsrLineContents::kLineContentsRegular:
411 // leave it as 0
412 break;
413 case bsrLineContents::kLineContentsContinuation:
414 // JMI lineElement->setSpacesBefore (2);
415 break;
416 } // switch
417
418 // append it to the line contents list
419 fLineContentsList.push_back (lineContentsToAppendTo);
420 }
421 else {
422 lineContentsToAppendTo = fLineContentsList.back ();
423
424 // set lineElement's spacesAfter value
425 // JMI lineElement->setSpacesBefore (1);
426 }
427
428 if (fASpaceIsNeededInLine) {
429 // append a space to the line elements list // JMI appendSpacesToLine ???
430 lineContentsToAppendTo->
431 appendLineElementToLineContents (
432 bsrSpaces::create (
433 fInputLineNumber, 1));
434
435 fASpaceIsNeededInLine = false;
436 }
437
438 lineContentsToAppendTo->
439 appendLineElementToLineContents (lineElement);
440 }
441
insertElementBeforeLastElementOfLine(S_bsrLineElement lineElement)442 void bsrLine::insertElementBeforeLastElementOfLine (
443 S_bsrLineElement lineElement)
444 {
445 S_bsrLineContents
446 lineContentsToAppendTo;
447
448 if (! fLineContentsList.size ()) {
449 // first insertion in this line: create the first, regular line contents
450 lineContentsToAppendTo =
451 bsrLineContents::create (
452 lineElement->getInputLineNumber (),
453 bsrLineContents::kLineContentsRegular);
454
455 // append it to the line contents list
456 fLineContentsList.push_back (lineContentsToAppendTo);
457 }
458 else {
459 lineContentsToAppendTo = fLineContentsList.back ();
460 }
461
462 lineContentsToAppendTo->
463 insertLineElementBeforeLastElementOfLineContents (lineElement);
464 }
465
appendSpacesToLine(S_bsrSpaces spaces)466 void bsrLine::appendSpacesToLine (S_bsrSpaces spaces)
467 {
468 #ifdef TRACE_OAH
469 if (gBsrOah->fTraceSpaces || gBsrOah->fTraceLines) {
470 gLogOstream <<
471 "Appending spaces '" <<
472 spaces->asShortString () <<
473 "' to line '" <<
474 asString () <<
475 "'" <<
476 endl;
477 }
478 #endif
479
480 appendLineElementToLine (spaces);
481 }
482
appendKeyToLine(S_bsrKey key)483 void bsrLine::appendKeyToLine (S_bsrKey key)
484 {
485 #ifdef TRACE_OAH
486 if (gTraceOah->fTraceKeys || gTraceOah->fTraceMeasures) {
487 gLogOstream <<
488 "Appending key '" <<
489 key->asShortString () <<
490 "' to line '" <<
491 asString () <<
492 "'" <<
493 endl;
494 }
495 #endif
496
497 appendLineElementToLine (key);
498 fASpaceIsNeededInLine = true;
499 }
500
appendTimeToLine(S_bsrTime time)501 void bsrLine::appendTimeToLine (S_bsrTime time)
502 {
503 #ifdef TRACE_OAH
504 if (gTraceOah->fTraceTimes || gTraceOah->fTraceMeasures) {
505 gLogOstream <<
506 "Appending time '" <<
507 time->asShortString () <<
508 "' to line '" <<
509 asString () <<
510 "'" <<
511 endl;
512 }
513 #endif
514
515 appendLineElementToLine (time);
516 fASpaceIsNeededInLine = true;
517 }
518
insertTimeBeforeLastElementOfLine(S_bsrTime time)519 void bsrLine::insertTimeBeforeLastElementOfLine (S_bsrTime time)
520 {
521 #ifdef TRACE_OAH
522 if (gTraceOah->fTraceTimes || gTraceOah->fTraceMeasures) {
523 gLogOstream <<
524 "Inserting time '" <<
525 time->asShortString () <<
526 "' before the last element of line '" <<
527 asString () <<
528 "'" <<
529 endl;
530 }
531 #endif
532
533 insertElementBeforeLastElementOfLine (time);
534 fASpaceIsNeededInLine = true;
535 }
536
appendTempoToLine(S_bsrTempo tempo)537 void bsrLine::appendTempoToLine (S_bsrTempo tempo)
538 {
539 #ifdef TRACE_OAH
540 if (gTraceOah->fTraceTempos || gTraceOah->fTraceMeasures) {
541 gLogOstream <<
542 "Appending tempo '" <<
543 tempo->asShortString () <<
544 "' to line '" <<
545 asString () <<
546 "'" <<
547 endl;
548 }
549 #endif
550
551 appendLineElementToLine (tempo);
552 fASpaceIsNeededInLine = true;
553 }
554
appendMeasureToLine(S_bsrMeasure measure)555 void bsrLine::appendMeasureToLine (S_bsrMeasure measure)
556 {
557 #ifdef TRACE_OAH
558 if (gTraceOah->fTraceMeasures || gBsrOah->fTraceLines) {
559 gLogOstream <<
560 "Appending line '" <<
561 measure->asShortString () <<
562 "' to line '" <<
563 asString () <<
564 "'" <<
565 endl;
566 }
567 #endif
568
569 appendLineElementToLine (measure);
570 fASpaceIsNeededInLine = true;
571 }
572
appendLineElementToLastMeasureOfLine(S_bsrLineElement lineElement)573 void bsrLine::appendLineElementToLastMeasureOfLine (
574 S_bsrLineElement lineElement)
575 {
576 S_bsrLineContents
577 lineContentsToAppendTo;
578
579 if (! fLineContentsList.size ()) {
580 // first insertion in this line: create the first, regular line contents
581 lineContentsToAppendTo =
582 bsrLineContents::create (
583 lineElement->getInputLineNumber (),
584 bsrLineContents::kLineContentsRegular);
585
586 // set lineElement's spacesAfter value if needed
587 switch (lineContentsToAppendTo->getLineContentsKind ()) {
588 case bsrLineContents::kLineContentsRegular:
589 // leave it as 0
590 break;
591 case bsrLineContents::kLineContentsContinuation:
592 // JMI lineElement->setSpacesBefore (2);
593 break;
594 } // switch
595
596 // append it to the line contents list
597 fLineContentsList.push_back (lineContentsToAppendTo);
598 }
599 else {
600 lineContentsToAppendTo = fLineContentsList.back ();
601
602 // set lineElement's spacesAfter value
603 // JMI lineElement->setSpacesBefore (1);
604 }
605
606 if (fASpaceIsNeededInLine) {
607 // append a space to the line elements list // JMI appendSpacesToLine ???
608 lineContentsToAppendTo->
609 appendLineElementToLineContents (
610 bsrSpaces::create (
611 fInputLineNumber, 1));
612
613 fASpaceIsNeededInLine = false;
614 }
615
616 lineContentsToAppendTo->
617 appendLineElementToLineContents (lineElement);
618 }
619
appendNoteToLine(S_bsrNote note)620 void bsrLine::appendNoteToLine (S_bsrNote note)
621 {
622 #ifdef TRACE_OAH
623 if (gTraceOah->fTraceNotes || gTraceOah->fTraceMeasures) {
624 gLogOstream <<
625 "Appending note '" <<
626 note->asShortString () <<
627 "' to line '" <<
628 asString () <<
629 "'" <<
630 endl;
631 }
632 #endif
633
634 appendLineElementToLastMeasureOfLine (note); // last measure? JMI
635 }
636
buildLineNumberCellsList() const637 S_bsrCellsList bsrLine::buildLineNumberCellsList () const
638 {
639 S_bsrCellsList
640 result =
641 bsrCellsList::create (fInputLineNumber);
642
643 if (! gBsrOah->fNoLineNumbers) {
644 // create the print line number
645 S_bsrNumber
646 printLineNumber =
647 bsrNumber::create (
648 fInputLineNumber,
649 fPrintLineNumber,
650 bsrNumber::kNumberSignIsNeededYes);
651
652 // append it to result
653 result->appendCellsListToCellsList (
654 printLineNumber->fetchCellsList ());
655
656 if (fBrailleLineNumber != fPrintLineNumber) { // JMI
657 // create the braille line number
658 S_bsrNumber
659 brailleLineNumber =
660 bsrNumber::create (
661 fInputLineNumber,
662 fBrailleLineNumber,
663 bsrNumber::kNumberSignIsNeededYes);
664
665 // append it to result
666 result->appendCellsListToCellsList (
667 brailleLineNumber->fetchCellsList ());
668 }
669 }
670
671 return result;
672 }
673
fetchCellsNumber() const674 int bsrLine::fetchCellsNumber () const
675 {
676 int result = 0;
677
678 for (
679 list<S_bsrLineContents>::const_iterator i = fLineContentsList.begin ();
680 i != fLineContentsList.end ();
681 i++ ) {
682 result += (*i)->fetchCellsNumber ();
683 } // for
684
685 return result;
686 }
687
acceptIn(basevisitor * v)688 void bsrLine::acceptIn (basevisitor* v)
689 {
690 #ifdef TRACE_OAH
691 if (gBsrOah->fTraceBsrVisitors) {
692 gLogOstream <<
693 "% ==> bsrLine::acceptIn ()" <<
694 endl;
695 }
696 #endif
697
698 if (visitor<S_bsrLine>*
699 p =
700 dynamic_cast<visitor<S_bsrLine>*> (v)) {
701 S_bsrLine elem = this;
702
703 #ifdef TRACE_OAH
704 if (gBsrOah->fTraceBsrVisitors) {
705 gLogOstream <<
706 "% ==> Launching bsrLine::visitStart ()" <<
707 endl;
708 }
709 #endif
710 p->visitStart (elem);
711 }
712 }
713
acceptOut(basevisitor * v)714 void bsrLine::acceptOut (basevisitor* v)
715 {
716 #ifdef TRACE_OAH
717 if (gBsrOah->fTraceBsrVisitors) {
718 gLogOstream <<
719 "% ==> bsrLine::acceptOut ()" <<
720 endl;
721 }
722 #endif
723
724 if (visitor<S_bsrLine>*
725 p =
726 dynamic_cast<visitor<S_bsrLine>*> (v)) {
727 S_bsrLine elem = this;
728
729 #ifdef TRACE_OAH
730 if (gBsrOah->fTraceBsrVisitors) {
731 gLogOstream <<
732 "% ==> Launching bsrLine::visitEnd ()" <<
733 endl;
734 }
735 #endif
736 p->visitEnd (elem);
737 }
738 }
739
browseData(basevisitor * v)740 void bsrLine::browseData (basevisitor* v)
741 {
742 for (
743 list<S_bsrLineContents>::const_iterator i = fLineContentsList.begin ();
744 i != fLineContentsList.end ();
745 i++ ) {
746 // browse the element
747 bsrBrowser<bsrLineContents> browser (v);
748 browser.browse (*(*i));
749 } // for
750 }
751
asString() const752 string bsrLine::asString () const
753 {
754 stringstream s;
755
756 s <<
757 "Line" <<
758 ", printLineNumber" << " : " << fPrintLineNumber <<
759 ", brailleLineNumber" << " : " << fBrailleLineNumber <<
760 ", cellsPerLine" << " : " << fCellsPerLine <<
761 ", lineContents: " << fLineContentsList.size () <<
762 ", cellsNumber" << " : " << fetchCellsNumber () <<
763 ", line " << fInputLineNumber;
764
765 return s.str ();
766 }
767
print(ostream & os) const768 void bsrLine::print (ostream& os) const
769 {
770 int lineContentsListSize = fLineContentsList.size ();
771
772 os <<
773 "Line" <<
774 ", printLineNumber: " << fPrintLineNumber <<
775 ", " <<
776 singularOrPlural (
777 lineContentsListSize, "lineContent", "lineContents") <<
778 endl;
779
780 gIndenter++;
781
782 // print the line numbers
783 const int fieldWidth = 20;
784
785 os << left <<
786 /* JMI
787 setw (fieldWidth) <<
788 "printLineNumber" << " : " << fPrintLineNumber <<
789 endl <<
790 */
791 setw (fieldWidth) <<
792 "brailleLineNumber" << " : " << fBrailleLineNumber <<
793 endl <<
794 setw (fieldWidth) <<
795 "cellsPerLine" << " : " << fCellsPerLine <<
796 endl <<
797 setw (fieldWidth) <<
798 "lineNumberCellsList" << " : " << buildLineNumberCellsList () <<
799 endl <<
800 setw (fieldWidth) <<
801 "cellsNumber" << " : " << fetchCellsNumber () <<
802 endl;
803 os << endl;
804
805 // print the line contents if any
806 if (lineContentsListSize || gBsrOah->fDisplayBsrDetails) {
807 os <<
808 // setw (fieldWidth) <<
809 "LineContentsList" <<
810 ", " <<
811 singularOrPlural (
812 lineContentsListSize, "lineContent", "lineContents");
813 if (lineContentsListSize) {
814 os << endl;
815 gIndenter++;
816
817 list<S_bsrLineContents>::const_iterator
818 iBegin = fLineContentsList.begin (),
819 iEnd = fLineContentsList.end (),
820 i = iBegin;
821 for ( ; ; ) {
822 os << (*i);
823 if (++i == iEnd) break;
824 os << endl;
825 } // for
826
827 gIndenter--;
828 }
829 else {
830 os <<
831 " : " << "none" <<
832 endl;
833 }
834 }
835
836 gIndenter--;
837 }
838
operator <<(ostream & os,const S_bsrLine & elt)839 ostream& operator<< (ostream& os, const S_bsrLine& elt)
840 {
841 elt->print (os);
842 return os;
843 }
844
845
846 }
847