New(?) pattern looking for a good home

Question

Hi everyone, this is my second post to sun forums about this, I initially asked people for help with the decorator and strategy pattern on the general Java Programming forum not being aware that there was a specific section for design pattern related questions. Since then I refined my solution somewhat and was wondering if anyone here would take a look. Sorry about the length of my post, I know it's best to keep it brief but in this case it just seemed that a fully functional example was more important than keeping it short.
So what I'd like to ask is whether any of you have seen this pattern before and if so, then what is it called. I'm also looking for some fresh eyes on this, this example I wrote seems to work but there are a lot of subtleties to the problem so any help figuring out if I went wrong anywhere is greatly appreciated. Please do tell me if you think this is an insane approach to the problem -- in short, might this pattern have a chance at finding a good home or should it be put down?
The intent of the pattern I am giving below is to modify behavior of an object at runtime through composition. In effect, it is like strategy pattern, except that the effect is achieved by wrapping, and wrapping can be done multiple times so the effect is cumulative. Wrapper class is a subclass of the class whose instance is being wrapped, and the change of behavior is accomplished by overriding methods in the wrapper class. After wrapping, the object "mutates" and starts to behave as if it was an instance of the wrapper class.
Here's the example:
public class Test {
     public static void main(String[] args) {
          double[] data = { 1, 1, 1, 1 };
          ModifiableChannel ch1 = new ModifiableChannel();
          ch1.fill(data);
          // ch2 shifts ch1 down by 1
          ModifiableChannel ch2 = new DownShiftedChannel(ch1, 1);
          // ch3A shifts ch2 down by 1
          ModifiableChannel ch3A = new DownShiftedChannel(ch2, 1);
          // ch3B shifts ch2 up by 1, tests independence from ch3A
          ModifiableChannel ch3B = new UpShiftedChannel(ch2, 1);
          // ch4 shifts ch3A up by 1, data now looks same as ch2
          ModifiableChannel ch4 = new UpShiftedChannel(ch3A, 1);
          // print channels:
          System.out.println("ch1:");
          printChannel(ch1);
          System.out.println("ch2:");
          printChannel(ch2);
          System.out.println("ch3A:");
          printChannel(ch3A);
          System.out.println("ch3B:");
          printChannel(ch3B);
          System.out.println("ch4:");
          printChannel(ch4);
     public static void printChannel(Channel channel) {
          for(int i = 0; i < channel.size(); i++) {
               System.out.println(channel.get(i) + "");
          // Note how channel's getAverage() method "sees"
          // the changes that each wrapper imposes on top
          // of the original object.
          System.out.println("avg=" + channel.getAverage());
* A Channel is a simple container for data that can
* find its average. Think audio channel or any other
* kind of sampled data.
public interface Channel {
     public void fill(double[] data);
     public double get(int i);
     public double getAverage();
     public int size();
public class DefaultChannel implements Channel {
     private double[] data;
     public void fill(double[] data) {
          this.data = new double[data.length];
          for(int i = 0; i < data.length; i++)
               this.data[i] = data;
     public double get(int i) {
          if(i < 0 || i >= data.length)
               throw new IndexOutOfBoundsException("Incorrect index.");
          return data[i];
     public double getAverage() {
          if(data.length == 0) return 0;
          double average = this.get(0);
          for(int i = 1; i < data.length; i++) {
               average = average * i / (i + 1) + this.get(i) / (i + 1);
          return average;
     public int size() {
          return data.length;
public class ModifiableChannel extends DefaultChannel {
     protected ChannelModifier modifier;
     public void fill(double[] data) {
          if (modifier != null) {
               modifier.fill(data);
          } else {
               super.fill(data);
     public void _fill(double[] data) {
          super.fill(data);
     public double get(int i) {
          if(modifier != null)
               return modifier.get(i);
          else
               return super.get(i);
     public double _get(int i) {
          return super.get(i);
     public double getAverage() {
          if (modifier != null) {
               return modifier.getAverage();
          } else {
               return super.getAverage();
     public double _getAverage() {
          return super.getAverage();
public class ChannelModifier extends ModifiableChannel {
     protected ModifiableChannel delegate;
     protected ModifiableChannel root;
     protected ChannelModifier tmpModifier;
     protected boolean doSwap = true;
     private void pre() {
          if(doSwap) { // we only want to swap out modifiers once when the
               // top call in the chain is made, after that we want to
               // proceed without it and finally restore doSwap to original
               // state once ChannelModifier is reached.
               tmpModifier = root.modifier;
               root.modifier = this;
               if(delegate instanceof ChannelModifier)
                    ((ChannelModifier)delegate).doSwap = false;
     private void post() {
          if (doSwap) {
               root.modifier = tmpModifier;
          } else {
               if(delegate instanceof ChannelModifier)
                         ((ChannelModifier)delegate).doSwap = true;
     public ChannelModifier(ModifiableChannel delegate) {
          if(delegate instanceof ChannelModifier)
               this.root = ((ChannelModifier)delegate).root;
          else
               this.root = delegate;
          this.delegate = delegate;
     public void fill(double[] data) {
          pre();
          if(delegate instanceof ChannelModifier)
               delegate.fill(data);
          else
               delegate._fill(data);
          post();
     public double get(int i) {
          pre();
          double result;
          if(delegate instanceof ChannelModifier)
               result = delegate.get(i);
          else
               result = delegate._get(i);
          post();
          return result;
     public double getAverage() {
          pre();
          double result;
          if(delegate instanceof ChannelModifier)
               result = delegate.getAverage();
          else
               result = delegate._getAverage();
          post();
          return result;
     public int size() {
          //for simplicity no support for modifying size()
          return delegate.size();
public class DownShiftedChannel extends ChannelModifier {
     private double shift;
     public DownShiftedChannel(ModifiableChannel channel, final double shift) {
          super(channel);
          this.shift = shift;
     @Override
     public double get(int i) {
          return super.get(i) - shift;
public class UpShiftedChannel extends ChannelModifier {
     private double shift;
     public UpShiftedChannel(ModifiableChannel channel, final double shift) {
          super(channel);
          this.shift = shift;
     @Override
     public double get(int i) {
          return super.get(i) + shift;
Output:ch1:
1.0
1.0
1.0
1.0
avg=1.0
ch2:
0.0
0.0
0.0
0.0
avg=0.0
ch3A:
-1.0
-1.0
-1.0
-1.0
avg=-1.0
ch3B:
1.0
1.0
1.0
1.0
avg=1.0
ch4:
0.0
0.0
0.0
0.0
avg=0.0

Answer 1

jduprez wrote:
Hello,
unless you sell your design better, I deem it is an inferior derivation of the Adapter pattern.
In the Adapter pattern, the adaptee doesn't have to be designed to support adaptation, and the instance doesn't even know at runtime whether it is adapted.
Your design makes the "modifiable" class aware of the modification, and it needs to be explicitly designed to be modifiable (in particular this constrains the implementation hierarchy). Overall DesignPattern are meant to provide flexibility, your version offers less flexibility than Adapter, as it poses more constraint on the modifiable class.
Another sign of this inflexibility is your instanceof checks.
On an unrelated note, I intensely dislike your naming choice of fill() vs _fill()+, I prefer more explicit names (I cannot provide you one as I didn't understand the purpose of this dual method, which a good name would have avoided, by the way).
That being said, I haven't followed your original problem, so I am not aware of the constraints that led you to this design.
Best regards,
J.
Edited by: jduprez on Mar 22, 2010 10:56 PMThank you for your input, I will try to explain my design better. First of all, as I understand it the Adapter pattern is meant to translate one interface into another. This is not at all what I am trying to do here, I am trying to keep the same interface but modify behavior of objects through composition. I started thinking about how to do this when I was trying to apply the Decorator pattern to filter some data. The way I would do that in my example here is to write an AbstractChannelDecorator that delegates all methods to the Channel it wraps:
public abstract class AbstractChannelDecorator implements Channel {
        protected Channel delegate;
...// code ommitted
     public double getAverage() {
          return delegate.getAverage();
...// code ommitted
}and then to filter the data I would extend it with concrete classes and override the appropriate methods like so:
public class DownShiftedChannel extends AbstractChannelDecorator {
     ...// code ommitted
     public double get(int i) {
          return super.get(i) - shift;
       ...// code ommitted
}(I am just shifting the data here to simplify the examples but a more realistic example would be something like a moving average filter to smooth the data).
Unfortunately this doesn't get me what I want, because getAverage() method doesn't use the filtered data unless I override it in the concrete decorator, but that means I will have to re-implement the whole algorithm. So that's pretty much my motivation for this, how do I use what on the surface looks like a Decorator pattern, but in reality works more like inheritance?
Now as to the other points of critique you mentioned:
I understand your dislike for such method names, I'm sorry about that, I had to come up with some way for the ChannelModifier to call ModifiableChannel's super's method equivalents. I needed some way to have the innermost wrapped object to initiate a call to the topmost ChannelModifier, but only do it once -- that was one way to do it. I suppose I could have done it with a flag and another if/else statement in each of the methods, or if you prefer, the naming convention could have been fill() and super_fill(), get() and super_get(), I didn't really think that it was that important. Anyway, those methods are not meant to be used by any other class except ChannelModifier so I probably should have made them protected.
The instanceof checks are necessary because at some point ChannelModifier instance runs into a delegate that isn't a ChannelModifier and I have to somehow detect that, because otherwise instead of calling get() I'd call get() which in ModifiableChannel would take me back up to the topmost wrapper and start the whole call chain again, so we'd be in infinite recursion. But calling get() allows me to prevent that and go straight to the original method of the innermost wrapped object.
I completely agree with you that the example I presented has limited flexibility in supporting multiple implementations. If I had two different Channel implementations I would need two ModifiableChannel classes, two ChannelModifiers, and two sets of concrete implementations -- obviously that's not good. Not to worry though, I found a way around that. Here's what I came up with, it's a modification of my original example with DefaultChannel replaced by ChannelImplementation1,2:
public class ChannelImplementation1 implements Channel { ... }
public class ChannelImplementation2 implements Channel { ... }
// this interface allows implementations to be interchangeable in ChannelModifier
public interface ModifiableChannel {
     public double super_get(int i);
     public double super_getAverage();
     public void setModifier(ChannelModifier modifier);
     public ChannelModifier getModifier();
public class ModifiableChannelImplementation1
          extends ChannelImplementation1
          implements ModifiableChannel {
     ... // see DefaultChannel in my original example
public class ModifiableChannelImplementation2
          extends ChannelImplementation1
          implements ModifiableChannel { ...}
// ChannelModifier is a Channel, but more importantly, it takes a Channel,
// not any specific implementation of it, so in effect the user has complete
// flexibility as to what implementation to use.
public class ChannelModifier implements Channel {
     protected Channel delegate;
     protected Channel root;
     protected ChannelModifier tmpModifier;
     protected boolean doSwap = true;
     public ChannelModifier(Channel delegate) {
          if(delegate instanceof ChannelModifier)
               this.root = ((ChannelModifier)delegate).root;
          else
               this.root = delegate;
          this.delegate = delegate;
     private void pre() {
          if(doSwap) {
               if(root instanceof ModifiableChannel) {
                    ModifiableChannel root = (ModifiableChannel)this.root;
                    tmpModifier = root.getModifier();
                    root.setModifier(this);
               if(delegate instanceof ChannelModifier)
                    ((ChannelModifier)delegate).doSwap = false;
     private void post() {
          if (doSwap) {
               if(root instanceof ModifiableChannel) {
                    ModifiableChannel root = (ModifiableChannel)this.root;
                    root.setModifier(tmpModifier);
          } else {
               if(delegate instanceof ChannelModifier)
                         ((ChannelModifier)delegate).doSwap = true;
     public void fill(double[] data) {
          delegate.fill(data);
     public double get(int i) {
          pre();
          double result;
          if(delegate instanceof ModifiableChannel)
// I've changed the naming convention from _get() to super_get(), I think that may help show the intent of the call
               result = ((ModifiableChannel)delegate).super_get(i);
          else
               result = delegate.get(i);               
          post();
          return result;
     public double getAverage() {
          pre();
          double result;
          if(delegate instanceof ModifiableChannel)
               result = ((ModifiableChannel)delegate).super_getAverage();
          else
               result = delegate.getAverage();
          post();
          return result;
     public int size() {
          return delegate.size();
public class UpShiftedChannel extends ChannelModifier { ...}
public class DownShiftedChannel extends ChannelModifier { ... }