1/*
2 * Copyright (C) 2007 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.eventbus;
18
19import static com.google.common.base.Preconditions.checkNotNull;
20
21import com.google.common.base.Preconditions;
22
23import java.lang.reflect.InvocationTargetException;
24import java.lang.reflect.Method;
25
26import javax.annotation.Nullable;
27
28/**
29 * Wraps a single-argument subscriber method on a specific object.
30 *
31 * <p>This class only verifies the suitability of the method and event type if
32 * something fails.  Callers are expected to verify their uses of this class.
33 *
34 * <p>Two EventSubscribers are equivalent when they refer to the same method on the
35 * same object (not class).   This property is used to ensure that no subscriber
36 * method is registered more than once.
37 *
38 * @author Cliff Biffle
39 */
40class EventSubscriber {
41
42  /** Object sporting the subscriber method. */
43  private final Object target;
44  /** Subscriber method. */
45  private final Method method;
46
47  /**
48   * Creates a new EventSubscriber to wrap {@code method} on @{code target}.
49   *
50   * @param target  object to which the method applies.
51   * @param method  subscriber method.
52   */
53  EventSubscriber(Object target, Method method) {
54    Preconditions.checkNotNull(target,
55        "EventSubscriber target cannot be null.");
56    Preconditions.checkNotNull(method, "EventSubscriber method cannot be null.");
57
58    this.target = target;
59    this.method = method;
60    method.setAccessible(true);
61  }
62
63  /**
64   * Invokes the wrapped subscriber method to handle {@code event}.
65   *
66   * @param event  event to handle
67   * @throws InvocationTargetException  if the wrapped method throws any
68   *     {@link Throwable} that is not an {@link Error} ({@code Error} instances are
69   *     propagated as-is).
70   */
71  public void handleEvent(Object event) throws InvocationTargetException {
72    checkNotNull(event);
73    try {
74      method.invoke(target, new Object[] { event });
75    } catch (IllegalArgumentException e) {
76      throw new Error("Method rejected target/argument: " + event, e);
77    } catch (IllegalAccessException e) {
78      throw new Error("Method became inaccessible: " + event, e);
79    } catch (InvocationTargetException e) {
80      if (e.getCause() instanceof Error) {
81        throw (Error) e.getCause();
82      }
83      throw e;
84    }
85  }
86
87  @Override public String toString() {
88    return "[wrapper " + method + "]";
89  }
90
91  @Override public int hashCode() {
92    final int PRIME = 31;
93    return (PRIME + method.hashCode()) * PRIME
94        + System.identityHashCode(target);
95  }
96
97  @Override public boolean equals(@Nullable Object obj) {
98    if (obj instanceof EventSubscriber) {
99      EventSubscriber that = (EventSubscriber) obj;
100      // Use == so that different equal instances will still receive events.
101      // We only guard against the case that the same object is registered
102      // multiple times
103      return target == that.target && method.equals(that.method);
104    }
105    return false;
106  }
107
108  public Object getSubscriber() {
109    return target;
110  }
111
112  public Method getMethod() {
113    return method;
114  }
115}
116