// a wrapper implementation
public class ChattyExecutorWrapper implements Executor, Wrapper<Executor> {
  private final Executor executor;

  public ChattyExecutorWrapper(Executor executor) {
    this.executor = executor;
  }

  @Override
  public void execute(Runnable command) {
    System.out.println("BlaBlaBla...");
    executor.execute(command);
  }

  @Override
  public Executor unwrap_() {
    return executor;
  }
}

// another wrapper implementation
public class LazyExecutorWrapper implements Executor, Wrapper<Executor>, Attachable<String, String> {
  private final Executor executor;

  public LazyExecutorWrapper(Executor executor) {
    this.executor = executor;
  }

  @Override
  public void execute(Runnable command) {
    System.out.println("I'm lazy, sleep before work.");
    sleep();

    executor.execute(command);
  }

  @Override
  public Executor unwrap_() {
    return executor;
  }

  private final Attachable<String, String> attachable = new AttachableDelegate<>();

  @Override
  public void setAttachment_(String key, String value) {
    attachable.setAttachment_(key, value);
  }

  @Override
  public String getAttachment_(String key) {
    return attachable.getAttachment_(key);
  }
}

public class Demo {
  public static void main(String[] args) {
    final Executor executor = buildExecutorChain();

    ////////////////////////////////////////
    // inspect the executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println("Is executor lazy? " +
        containsInstanceTypeOnWrapperChain(executor, LazyExecutorWrapper.class));
    // print true

    String busy = getAttachmentFromWrapperChain(executor, "busy");
    System.out.println("Is executor busy? " + busy);
    // print "very, very busy!"

    ////////////////////////////////////////
    // call executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println();
    executor.execute(() -> System.out.println("I'm working."));
  }

  /**
   * prepare executor instances/wrappers, build the executor/wrapper chain
   **/
  private static Executor buildExecutorChain() {
    final Executor base = Runnable::run;

    final LazyExecutorWrapper lazy = new LazyExecutorWrapper(base);
    lazy.setAttachment_("busy", "very, very busy!");

    return new ChattyExecutorWrapper(lazy);
  }
}

/*
demo output:

Is executor lazy? true
Is executor busy? very, very busy!

BlaBlaBla...
I'm lazy, sleep before work.
I'm working.
 */

public class ExistedExecutorWrapper implements Executor {
  private final Executor executor;

  public ExistedExecutorWrapper(Executor executor) {
    this.executor = executor;
  }

  @Override
  public void execute(Runnable command) {
    System.out.println("I'm existed executor, have nothing to do with ~inspectable~wrappers~.");
    executor.execute(command);
  }
}

public class IntegrationDemo {
  public static void main(String[] args) {
    final Executor executor = buildExecutorChain();

    ////////////////////////////////////////
    // inspect the executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println("Is executor ExistedExecutorWrapper? " +
        containsInstanceTypeOnWrapperChain(executor, ExistedExecutorWrapper.class));
    // print true
    String adaptAttachment = getAttachmentFromWrapperChain(executor, "adapted-existed-executor-wrapper-msg");
    System.out.println("Adapted existed executor wrapper msg: " + adaptAttachment);
    // print "I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~."

    ////////////////////////////////////////
    // call executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println();
    executor.execute(() -> System.out.println("I'm working."));
  }

  private static Executor buildExecutorChain() {
    final Executor base = Runnable::run;
    final ExistedExecutorWrapperAdapter adapter = createExistedExecutorWrapperAdapter(base);
    return new ChattyExecutorWrapper(adapter);
  }

  private static ExistedExecutorWrapperAdapter createExistedExecutorWrapperAdapter(Executor base) {
    final ExistedExecutorWrapper existed = new ExistedExecutorWrapper(base);
    final ExistedExecutorWrapperAdapter adapter = new ExistedExecutorWrapperAdapter(base, existed);
    adapter.setAttachment_("adapted-existed-executor-wrapper-msg", "I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.");
    return adapter;
  }

  /**
   * Adaption an existed wrapper(`ExistedExecutorWrapper`) without modifying it.
   */
  private static class ExistedExecutorWrapperAdapter implements Executor, WrapperAdapter<Executor>, Attachable<String, String> {
    private final Executor base;
    private final Executor adaptee;

    public ExistedExecutorWrapperAdapter(Executor base, Executor adaptee) {
      this.base = base;
      this.adaptee = adaptee;
    }

    @Override
    public Executor unwrap_() {
      return base;
    }

    @Override
    public Executor adaptee_() {
      return adaptee;
    }

    @Override
    public void execute(Runnable command) {
      adaptee.execute(command);
    }

    private final Attachable<String, String> attachable = new AttachableDelegate<>();

    @Override
    public void setAttachment_(String key, String value) {
      attachable.setAttachment_(key, value);
    }

    @Nullable
    @Override
    public String getAttachment_(String key) {
      return attachable.getAttachment_(key);
    }
  }
}

/*
demo output:

Is executor ExistedExecutorWrapper? true
Adapted existed executor wrapper msg: I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.

BlaBlaBla...
I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.
I'm working.
 */

public class IntegrationDemoUsingWrapperAdapterUtils {
  public static void main(String[] args) {
    final Executor executor = buildExecutorChain();

    ////////////////////////////////////////
    // inspect the executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println("Is executor ExistedExecutorWrapper? " +
        containsInstanceTypeOnWrapperChain(executor, ExistedExecutorWrapper.class));
    // print true
    String adaptAttachment = getAttachmentFromWrapperChain(executor, "adapted-existed-executor-wrapper-msg");
    System.out.println("Adapted existed executor wrapper msg: " + adaptAttachment);
    // print "I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~."

    ////////////////////////////////////////
    // call executor(wrapper chain)
    ////////////////////////////////////////

    System.out.println();
    executor.execute(() -> System.out.println("I'm working."));
  }

  private static Executor buildExecutorChain() {
    final Executor base = Runnable::run;
    final Executor adapter = createExistedExecutorWrapperAdapter(base);
    return new ChattyExecutorWrapper(adapter);
  }

  private static Executor createExistedExecutorWrapperAdapter(Executor base) {
    final Executor existed = new ExistedExecutorWrapper(base);

    Attachable<String, String> attachable = new AttachableDelegate<>();
    attachable.setAttachment_("adapted-existed-executor-wrapper-msg", "I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.");

    return WrapperAdapterUtils.createWrapperAdapter(Executor.class, base, existed, attachable);
  }
}

/*
demo output:

Is executor ExistedExecutorWrapper? true
Adapted existed executor wrapper msg: I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.

BlaBlaBla...
I'm an adapter of an existed executor which have nothing to do with ~inspectable~wrappers~.
I'm working.
 */