10

I am trying to write an iterator for a hierarchy of classes that collectively make up the components of a song. All classes are implementations of the abstract MusicComponent base class and inherit a getChildren() function. The abstract MusicTime subclass knows the actual note/chord to play, and all its implementations (e.g. quaver, crotchet) return null for getChildren().

The other components are MusicComponent which holds a collection of MusicTimes e.g. a bar at a time, and Section which holds the MusicComponents. Song holds the Sections that make up the song e.g. verses, choruses, sections with different tempos/time signatures.

What I need is an iterator that will iterate through all Sections in a Song, then all MusicComponents in the Section and only when it finds a MusicTime descendant, play the note for the length of time based on its note type, and the time signature and tempo of its containing Section.

Sorry if too much info, but was the only way I could explain what I'm trying to do. So do I need to handle this with a stack, recording which MusicComponents I've visted or is there a way to do this just using recursion?

Improve this question

3 Answers 3

Reset to default
5

You can write an iterator which "concatenates" the iterators of its children, even lazily. Calling next() on a Song's iterator would then drill down through the Section and MusicComponent iterators and finally deliver the next MusicTime.

Guava makes this easy. Make MusicComponent an Iterable<MusicTime> and implement iterator() as:

@Override
public Iterator<MusicTime> iterator() {
    return Iterables.concat(getChildren()).iterator();
}

Since all children are MusicComponents and thus implement Iterable<MusicTime> themselves, Song's iterator will be a concatenation of Section iterators, which are themselves concatenations of MusicTime iterators.

This last iterator is a special case. A MusicTime iterator should only return itself once:

@Override
public Iterator<MusicTime> iterator() {
    return Iterators.singletonIterator(this);
}

Alternatively, Section's iterator could be replaced with:

@Override
public Iterator<MusicTime> iterator() {
    return getChildren().iterator();
}

With this, iterating becomes as easy as:

for (MusicTime time : song) {
    player.play(time);
}

You can now do any kind of operation (playing, counting the total duration,...) without re-implementing the recursion.

There are alternative solutions for your problem though, but it all comes down to design choices. For example, you could have a play method on MusicComponent which Song and Section would implement by calling play on all of their children. This is a straightforward recursive implementation, but you must repeat the recursion for all operations you intend to add on MusicComponent (such as play, getTotalDuration, ...).

If you need more flexibility, you could use the Visitor design pattern and make your play operation a visitor (e.g. PlayVisitor). This has the advantage that you can decide to control the iteration order from within the visitor, but makes it harder to add new MusicComponent implementations.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Thank you, that seems to be exactly what I need, and is very straightforward. However, I'm getting an error. I've downloaded Guava and added it as an external library, and implemented Iterable on MusicComponent but I get a java.lang.NoClassDefFoundError: com.google.common.collect.Iterables on the concat line. Any ideas what could be causing this?
Have fixed that error, so now is working fine...but I have one more question. The iterator returns a MusicTime as the first result, but is it possible to also get the Section that holds it? So when the client iterates through the components it can decide how to handle them. Can I do that using the Iterables?
Nevermind my previous comment, that would've been a bad way of handling what I needed to so found a better way. All sorted now and working like an absolute charm, many thanks!
@CrazyHorse In that case, you'd be better off with a visitor. A Section's accept(Visitor) method could then call both visitSection as well as visitMusicTime for all its children. However, you then lose the "transparency" that an iterator gives you: a visitor needs to know about Sections and MusicTimes whereas a class using an iterator only needs to know about MusicTimes. Either way, you solved it, so that's great. :-)
I solved this by setting references to the containing object at each level, so I can navigate back up the tree to find the Section` for each MusicTime. Not sure if this is the best approach, but seems to be working fine. I will look into the visitor pattern though as I think I may end up needing the flexibility.
|
0

You'll need to keep your own stack. An iterator has to return the next value when it finds it. If you could write it recursively, say with recursiveMethod calling itself, and then calling itself again, and then inside the third time it's called, it finds out what value to return, the call stack would look something like

recursiveMethod
recursiveMethod
recursiveMethod
theIterator.next
the client that's using the iterator

When the innermost recursiveMethod returns, it has to return the value to the client, and then the client has to keep running. That means that the top four entries on the call stack have to be popped. Then, when the client wants the next value, and it calls theIterator.next() again, the above three recursiveMethod entries on the call stack would have to be reconstructed so that the process could continue. Java doesn't have a way to do that (at least through Java 7; if Java 8 does this, I wouldn't know about it since I'm not familiar with all the new features).

The only way that I know of to have multiple call stacks is to have multiple threads. I wouldn't recommend using threads for this purpose, but perhaps others have had successes with it.

You might want to read the Wikipedia article on coroutines.

Improve this answer

Comments

0

Since all of the components inherit from the same abstract class MusicComponent, I would implement the default method play() in that class. Assuming that MusicComponent class also has the property protected List<MusicComponent> children it would look like this:

public void play(){

    for(MusicComponent component: children){
        component.play();
    }

}

In the MusicTime class, I would override the play() method to actually play the music like below:

@Override
public void play(){

    //music playing logic
}

It should not be necessary to override this method in the other classes since they are just composite classes that can't play music.

After you've created your full component tree. To play all the music, you would need to run the play() method on the topmost component which is Song:

song.play()

It will iterate through all the children eventually reaching the bottommost MusicTime objects where the music will be played. This answer is based on my interpretation of your problem and my understanding of the Composite Design Pattern which I think is a viable way to solve your problem.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.