bridgemethodresolvertests.java

struts+spring 源码 希望能给大家带来帮助

		public Object[] toArray() {
			throw new UnsupportedOperationException();
		}

		public <T>T[] toArray(T[] a) {
			throw new UnsupportedOperationException();
		}

		public boolean add(String o) {
			throw new UnsupportedOperationException();
		}

		public boolean remove(Object o) {
			throw new UnsupportedOperationException();
		}

		public boolean containsAll(Collection<?> c) {
			throw new UnsupportedOperationException();
		}

		public boolean addAll(Collection<? extends String> c) {
			throw new UnsupportedOperationException();
		}

		public boolean addAll(int index, Collection<? extends String> c) {
			throw new UnsupportedOperationException();
		}

		public boolean removeAll(Collection<?> c) {
			throw new UnsupportedOperationException();
		}

		public boolean retainAll(Collection<?> c) {
			throw new UnsupportedOperationException();
		}

		public void clear() {
			throw new UnsupportedOperationException();
		}

		public String get(int index) {
			throw new UnsupportedOperationException();
		}

		public String set(int index, String element) {
			throw new UnsupportedOperationException();
		}

		public void add(int index, String element) {
			throw new UnsupportedOperationException();
		}

		public String remove(int index) {
			throw new UnsupportedOperationException();
		}

		public int indexOf(Object o) {
			throw new UnsupportedOperationException();
		}

		public int lastIndexOf(Object o) {
			throw new UnsupportedOperationException();
		}

		public ListIterator<String> listIterator() {
			throw new UnsupportedOperationException();
		}

		public ListIterator<String> listIterator(int index) {
			throw new UnsupportedOperationException();
		}

		public List<String> subList(int fromIndex, int toIndex) {
			throw new UnsupportedOperationException();
		}
	}


	public interface Event {

		int getPriority();
	}


	public class GenericEvent implements Event {

		private int priority;

		public int getPriority() {
			return priority;
		}

		/**
		 * Constructor that takes an event priority
		 */
		public GenericEvent(int priority) {
			this.priority = priority;
		}

		/**
		 * Default Constructor
		 */
		public GenericEvent() {
		}
	}


	public interface UserInitiatedEvent {

		/**
		 * returns the user who initiator this event
		 * @return
		 */
		//public Session getInitiatorSession();
	}


	public abstract class BaseUserInitiatedEvent extends GenericEvent implements UserInitiatedEvent {

	}


	public class MessageEvent extends BaseUserInitiatedEvent {

	}


	public interface Channel<E extends Event> {

		void send(E event);

		void subscribe(final Receiver<E> receiver, Class<E> event);

		void unsubscribe(final Receiver<E> receiver, Class<E> event);
	}


	public interface Broadcaster {

	}


	public interface EventBroadcaster extends Broadcaster {

		public void subscribe();

		public void unsubscribe();

		public void setChannel(Channel channel);
	}


	public class GenericBroadcasterImpl implements Broadcaster {

	}


	public abstract class GenericEventBroadcasterImpl<T extends Event> extends GenericBroadcasterImpl
					implements EventBroadcaster, BeanNameAware {

		private Class<T>[] subscribingEvents;

		private Channel<T> channel;

		/**
		 * Abstract method to retrieve instance of subclass
		 *
		 * @return receiver instance
		 */
		public abstract Receiver<T> getInstance();

		public void setChannel(Channel channel) {
			this.channel = channel;
		}

		private String beanName;

		public void setBeanName(String name) {
			this.beanName = name;
		}

		public void subscribe() {

		}

		public void unsubscribe() {

		}

		public GenericEventBroadcasterImpl(Class<? extends T>... events) {

		}
	}


	public interface Receiver<E extends Event> {

		void receive(E event);
	}


	public interface MessageBroadcaster extends Receiver<MessageEvent> {

	}


	public class RemovedMessageEvent extends MessageEvent {

	}


	public class NewMessageEvent extends MessageEvent {

	}


	public class ModifiedMessageEvent extends MessageEvent {

	}


	public class MessageBroadcasterImpl extends GenericEventBroadcasterImpl<MessageEvent>
					implements MessageBroadcaster {

		public MessageBroadcasterImpl() {
			super(NewMessageEvent.class);
		}

		public void receive(MessageEvent event) {
			throw new UnsupportedOperationException("should not be called, use subclassed events");
		}

		public void receive(NewMessageEvent event) {
		}

		@Override
		public Receiver<MessageEvent> getInstance() {
			return null;
		}

		public void receive(RemovedMessageEvent event) {
		}

		public void receive(ModifiedMessageEvent event) {
		}
	}

	//-----------------------------
	// SPR-2454 Test Classes
	//-----------------------------

	public interface SimpleGenericRepository<T> {

		public Class<T> getPersistentClass();


		List<T> findByQuery();


		List<T> findAll();


		T refresh(T entity);


		T saveOrUpdate(T entity);


		void delete(Collection<T> entities);
	}


	public interface RepositoryRegistry {

		<T> SimpleGenericRepository<T> getFor(Class<T> entityType);
	}


	public class SettableRepositoryRegistry<R extends SimpleGenericRepository<?>>
					implements RepositoryRegistry, InitializingBean {

		protected void injectInto(R rep) {
		}

		public void register(R rep) {
		}

		public void register(R... reps) {
		}

		public void setRepos(R... reps) {
		}

		public <T> SimpleGenericRepository<T> getFor(Class<T> entityType) {
			return null;
		}

		public void afterPropertiesSet() throws Exception {
		}
	}


	public interface ConvenientGenericRepository<T, ID extends Serializable> extends SimpleGenericRepository<T> {

		T findById(ID id, boolean lock);

		List<T> findByExample(T exampleInstance);

		void delete(ID id);

		void delete(T entity);
	}


	public class GenericHibernateRepository<T, ID extends Serializable> extends HibernateDaoSupport
					implements ConvenientGenericRepository<T, ID> {

		/**
		 * @param c Mandatory. The domain class this repository is responsible for.
		 */
		// Since it is impossible to determine the actual type of a type
		// parameter (!), we resort to requiring the caller to provide the
		// actual type as parameter, too.
		// Not set in a constructor to enable easy CGLIB-proxying (passing
		// constructor arguments to Spring AOP proxies is quite cumbersome).
		public void setPersistentClass(Class<T> c) {
		}

		public Class<T> getPersistentClass() {
			return null;
		}

		public T findById(ID id, boolean lock) {
			return null;
		}

		public List<T> findAll() {
			return null;
		}

		public List<T> findByExample(T exampleInstance) {
			return null;
		}

		public List<T> findByQuery() {
			return null;
		}

		public T saveOrUpdate(T entity) {
			return null;
		}

		public void delete(T entity) {
		}

		public T refresh(T entity) {
			return null;
		}

		public void delete(ID id) {
		}

		public void delete(Collection<T> entities) {
		}
	}


	public class HibernateRepositoryRegistry extends SettableRepositoryRegistry<GenericHibernateRepository<?, ?>> {

		public void injectInto(GenericHibernateRepository<?, ?> rep) {
		}

		public <T> GenericHibernateRepository<T, ?> getFor(Class<T> entityType) {
			return null;
		}
	}

	//-------------------
	// SPR-2603 classes
	//-------------------

	public interface Homer<E> {

		void foo(E e);
	}

	public class MyHomer<T extends Bounded<T>, L extends T> implements Homer<L> {

		public void foo(L t) {
			throw new UnsupportedOperationException();
		}

	}

	public class YourHomer<T extends AbstractBounded<T>, L extends T> extends
					MyHomer<T, L> {

		public void foo(L t) {
			throw new UnsupportedOperationException();
		}

	}

	public interface GenericDao<T> {
		public void saveOrUpdate(T t);
	}

	public interface ConvenienceGenericDao<T> extends GenericDao<T> {

	}

	public class GenericSqlMapDao<T extends Serializable> implements ConvenienceGenericDao<T>{

		public void saveOrUpdate(T t) {
			throw new UnsupportedOperationException();
		}
	}

	public class GenericSqlMapIntegerDao<T extends Integer> extends GenericSqlMapDao<T> {
	  public void saveOrUpdate(T t) {

		}
  }

}