[
{
"path": ".gitignore",
"content": "*.orig\n\n# Maven\ntarget/\n*.releaseBackup\nrelease.properties\n\n# IntelliJ\n*.iml\n.idea/\n\n# Eclipse\n.settings/\n*.project\n*.classpath\n*.springBeans\n\n# Vaadin\nsamples/*-sample*/src/main/webapp/VAADIN/themes/*.css\nsamples/*-sample*/src/main/webapp/VAADIN/themes/**/*.css\nsamples/*-sample*/src/main/webapp/VAADIN/widgetsets/\nsamples/*-sample*/src/main/resources/VAADIN/widgetsets/\nsamples/*-sample*/src/main/resources/VAADIN/themes/**/*.css\n\n# JRebel\nrebel.xml\n"
},
{
"path": "LICENSE.txt",
"content": "\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "README.md",
"content": "Vaadin4Spring\n=============\n\nThis project started as a prototype of an official Vaadin Spring add-on, back in the day when Vaadin 8 was new.\nThat was many years ago and a lot has happened since that time. Now we have Vaadin 14 and I have deleted almost all\nof the extensions and addons since it did not make sense to port them to Vaadin 14.\n \nAll that remains is the event bus that is kept by popular demand. **Please note, however, that the event bus has a\ndesign flaw that can lead to potentially serious security problems if used in the wrong way.** Check the \n[README](eventbus/README.md) for more information."
},
{
"path": "eventbus/README.md",
"content": "The Vaadin4Spring Event Bus\n===========================\n\n**Do not use this event bus in new projects.** This version is published to make it easier to port existing\napplications that use Vaadin4Spring from Vaadin 8 to Vaadin 14.\n\n## Security Issue with the Application Scoped Event Bus\n\nYou can run into serious security problems with the application scoped event bus if you are not careful. Events are\ndispatched synchronously to all listeners in the thread that originally fired the event. This means that **all\nevent listeners will run within the security context of the user that fired the event**. \n\nBecause of this I seriously discourage developers from using the application scoped event bus in their projects.\nI can't fix this issue either since that would break existing software that relies on the events being dispatched\nin this way. \n\nThere are discussions of creating a completely new event bus for Vaadin 14+ that would not have this design flaw.\n "
},
{
"path": "eventbus/pom.xml",
"content": "\n\n 4.0.0\n \n org.vaadin.spring\n parent-pom\n 14.0.1-SNAPSHOT\n ../\n \n\n org.vaadin.spring.addons\n vaadin-spring-addon-eventbus\n jar\n\n Vaadin4Spring Event Bus\n\n \n \n com.vaadin\n vaadin-spring\n \n\n \n org.mockito\n mockito-core\n test\n \n \n org.junit.jupiter\n junit-jupiter-engine\n test\n \n \n org.springframework\n spring-test\n test\n \n \n com.vaadin\n vaadin-spring-boot-starter\n test\n \n \n\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/Event.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\nimport java.io.Serializable;\n\n/**\n * A class that represents an event that has been published on an {@link org.vaadin.spring.events.EventBus}.\n *\n * @author Petter Holmström (petter@vaadin.com)\n * @see EventBus#publish(Object, Object)\n */\npublic class Event implements Serializable {\n\n private static final long serialVersionUID = 4818820872533486223L;\n\n private final EventBus eventBus;\n\n private final Object source;\n\n private final String topic;\n \n private final long timestamp;\n\n private final T payload;\n\n public Event(EventBus eventBus, Object source, T payload) {\n \tthis(eventBus, source, payload, \"\");\n }\n\n public Event(EventBus eventBus, Object source, T payload, String topic) {\n this.eventBus = eventBus;\n this.source = source;\n this.payload = payload;\n this.topic = topic != null ? topic : \"\";\n this.timestamp = System.currentTimeMillis();\n }\n\n /**\n * Gets the event bus on which the event was originally published.\n *\n * @return the event bus, never {@code null}.\n */\n public EventBus getEventBus() {\n return eventBus;\n }\n\n /**\n * Gets the scope of the event.\n *\n * @return the scope, never {@code null}.\n */\n public EventScope getScope() {\n return eventBus.getScope();\n }\n\n /**\n * Gets the object that published the event on the event bus.\n *\n * @return the source of the event, never {@code null}.\n */\n public Object getSource() {\n return source;\n }\n\n /**\n * Gets the string which specifies the topic of the event on the event bus.\n * \n * @return the topic of the event, never {@code null}.\n */\n public String getTopic() {\n\t\treturn topic;\n\t}\n \n /**\n * Gets the timestamp when the event was published on the event bus.\n *\n * @return the timestamp.\n */\n public long getTimestamp() {\n return timestamp;\n }\n\n /**\n * Gets the payload of the event.\n *\n * @return the payload, never {@code null}.\n */\n public T getPayload() {\n return payload;\n }\n\n @Override\n public String toString() {\n return String.format(\"%s[scope=%s, eventBus=%s, ts=%d, source=[%s], payload=[%s]]\",\n getClass().getSimpleName(), getScope(), getEventBus(), getTimestamp(), getSource(), getPayload());\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/EventBus.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n * Interface defining an event bus. This event bus infrastructure complements the\n * {@link org.springframework.context.ApplicationEventPublisher} in the following ways:\n *
\n *
Events propagate from parent buses to children
\n *
Events are scoped
\n *
\n *
\n * There are three event scopes, and therefore three event bus types (each with their own sub interface):\n *
\n *
{@link EventScope#APPLICATION} events are published to the entire application.
\n *
{@link EventScope#SESSION} events are published to the current session.
\n *
{@link EventScope#UI} events are published to the current UI.
\n * \n *
\n * The event buses are chained in the following way:\n *
\n *
Application events are propagated to the session event bus.
\n *
Session events are propagated to the UI event bus.
\n *
\n * Furthermore, {@link org.springframework.context.ApplicationEventPublisher} events can be propagated to any event bus\n * by using {@link org.vaadin.spring.events.support.ApplicationContextEventBroker}.\n *
\n * You select which {@code EventBus} implementation to inject by using the corresponding interface. For example, to\n * inject the UI-scoped event bus, you would use:\n * \n * @Autowired UIEventBus myUIScopedEventBus;\n * \n * With this implementation, you can subscribe to and publish events of the application, session and UI scopes (see\n * {@link #publish(EventScope, Object, Object)}).\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\npublic interface EventBus {\n\n /**\n * Publishes the specified payload on the event bus, using the scope of this particular event bus.\n *\n * @param sender the object that published the event, never {@code null}.\n * @param payload the payload of the event to publish, never {@code null}.\n * @param the type of the payload.\n * @see #getScope()\n */\n void publish(Object sender, T payload);\n\n /**\n * Publishes the specified payload on the event bus, using the scope of this particular event bus.\n * The topic specifies which listeners will be notified.\n *\n * @param topic the topic of the event to publish, never {@code null}.\n * @param sender the object that published the event, never {@code null}.\n * @param payload the payload of the event to publish, never {@code null}.\n * @param the type of the payload.\n * @see #getScope()\n */\n void publish(String topic, Object sender, T payload);\n\n /**\n * Publishes the specified payload on the event bus, or any of its parent buses, depending on the event scope.\n *\n * @param scope the scope of the event, never {@code null}.\n * @param sender the object that published the event, never {@code null}.\n * @param payload the payload of the event to publish, never {@code null}.\n * @param the type of the payload;\n * @throws UnsupportedOperationException if the payload could not be published with the specified scope.\n * @see #publish(Object, Object)\n */\n void publish(EventScope scope, Object sender, T payload) throws UnsupportedOperationException;\n\n /**\n * Publishes the specified payload on the event bus, or any of its parent buses, depending on the event scope.\n * The topic specifies which listeners will be notified.\n *\n * @param scope the scope of the event, never {@code null}.\n * @param topic the topic of the event to publish, never {@code null}.\n * @param sender the object that published the event, never {@code null}.\n * @param payload the payload of the event to publish, never {@code null}.\n * @param the type of the payload;\n * @throws UnsupportedOperationException if the payload could not be published with the specified scope.\n * @see #publish(Object, Object)\n */\n void publish(EventScope scope, String topic, Object sender, T payload) throws UnsupportedOperationException;\n\n /**\n * Gets the scope of the events published on this event bus.\n *\n * @return the event scope, never {@code null}.\n * @see org.vaadin.spring.events.Event#getScope()\n */\n EventScope getScope();\n\n /**\n * Subscribes the specified listener to the event bus, including propagated events from parent event buses.\n * The event bus will analyse the payload type of the listener to determine which events it is interested in\n * receiving.\n * This is the same as calling {@link #subscribe(EventBusListener, boolean) subscribe(listener, true)}.\n *\n * @param listener the listener to subscribe, never {@code null}.\n * @param the type of payload the listener is interested in.\n * @see #unsubscribe(EventBusListener)\n * @see #subscribeWithWeakReference(EventBusListener)\n */\n void subscribe(EventBusListener listener);\n\n /**\n * Same as {@link #subscribe(EventBusListener)}, but uses a weak reference to store the listener internally.\n */\n void subscribeWithWeakReference(EventBusListener listener);\n\n /**\n * Subscribes the topic interested listener to the event bus, including propagated events from parent event buses.\n * The event bus will analyse the payload type and topic of the listener to determine which events it is interested\n * in receiving.\n * @param listener the listener to subscribe, never {@code null}\n * @param topic the topic of listener interest\n *\n * @param the type of payload the listener is interested in\n */\n void subscribe(EventBusListener listener, String topic);\n\n /**\n * Same as {@link #subscribe(EventBusListener, String)}, but uses a weak reference to store the listener\n * internally.\n */\n void subscribeWithWeakReference(EventBusListener listener, String topic);\n\n /**\n * Subscribes the specified listener to the event bus. The event bus will analyse the\n * payload type of the listener to determine which events it is interested in receiving.\n *\n * @param listener the listener to subscribe, never {@code null}.\n * @param includingPropagatingEvents true to notify the listener of events that have propagated from the chain of\n * parent event buses, false to only notify the listeners of events that are directly published on this event\n * bus.\n * @param the type of payload the listener is interested in.\n * @see #unsubscribe(EventBusListener)\n * @see #subscribeWithWeakReference(EventBusListener, boolean)\n */\n void subscribe(EventBusListener listener, boolean includingPropagatingEvents);\n\n /**\n * Same as {@link #subscribe(EventBusListener, boolean)}, but uses a weak reference to store the listener\n * internally.\n */\n void subscribeWithWeakReference(EventBusListener listener, boolean includingPropagatingEvents);\n\n /**\n * Subscribes the specified listener to the event bus. The listener need not implement the\n * {@link org.vaadin.spring.events.EventBusListener} interface,\n * but must contain one or more methods that are annotated with the\n * {@link org.vaadin.spring.events.annotation.EventBusListenerMethod} interface and conform to one of these method\n * signatures: myMethodName(Event<MyPayloadType>) or myMethodName(MyPayloadType).\n * The event bus will analyse the payload type of the listener methods to determine\n * which events the different methods are interested in receiving. This is the same as calling\n * {@link #subscribe(Object, boolean) subscribe(listener, true)}.\n *\n * @param listener the listener to subscribe, never {@code null}.\n * @see #subscribeWithWeakReference(Object)\n */\n void subscribe(Object listener);\n\n /**\n * Same as {@link #subscribe(Object)}, but uses a weak reference to store the listener internally.\n */\n void subscribeWithWeakReference(Object listener);\n\n /**\n * Subscribes the topic interested listener to the event bus. The listener need not implement the\n * {@link org.vaadin.spring.events.EventBusListener} interface,\n * but must contain one or more methods that are annotated with the\n * {@link org.vaadin.spring.events.annotation.EventBusListenerMethod} interface and conform to one of these method\n * signatures: myMethodName(Event<MyPayloadType>) or myMethodName(MyPayloadType).\n * The event bus will analyse the payload type of the listener methods to determine\n * which events the different methods are interested in receiving.\n *
\n * Example:\n * subscribe(Listener.this, \"/news\");\n * @param listener the listener to subscribe, never {@code null}.\n * @param topic the topic of listener interest\n * @see #subscribeWithWeakReference(Object, String)\n */\n void subscribe(Object listener, String topic);\n\n /**\n * Same as {@link #subscribe(Object, String)}, but uses a weak reference to store the listener internally.\n */\n void subscribeWithWeakReference(Object listener, String topic);\n\n /**\n * Subscribes the specified listener to the event bus. The listener need not implement the\n * {@link org.vaadin.spring.events.EventBusListener} interface,\n * but must contain one or more methods that are annotated with the\n * {@link org.vaadin.spring.events.annotation.EventBusListenerMethod} interface and conform to one of these method\n * signatures: myMethodName(Event<MyPayloadType>) or myMethodName(MyPayloadType).\n * The event bus will analyse the payload type of the listener methods to determine\n * which events the different methods are interested in receiving.\n *\n * @param listener the listener to subscribe, never {@code null}.\n * @param includingPropagatingEvents true to notify the listener of events that have propagated from the chain of\n * parent event buses, false to only notify the listeners of events that are directly published on this event\n * bus.\n * @see #unsubscribe(Object)\n * @see #subscribeWithWeakReference(Object, boolean)\n */\n void subscribe(Object listener, boolean includingPropagatingEvents);\n\n /**\n * Same as {@link #subscribe(Object, boolean)}, but uses a weak reference to store the listener internally.\n */\n void subscribeWithWeakReference(Object listener, boolean includingPropagatingEvents);\n\n /**\n * Unsubscribes the specified listener from the event bus. Also works for listeners stored with weak references.\n *\n * @param listener the listener to unsubscribe, never {@code null}.\n * @param the type of the payload.\n * @see #subscribe(EventBusListener)\n * @see #subscribe(EventBusListener, boolean)\n */\n void unsubscribe(EventBusListener listener);\n\n /**\n * Unsubscribes the specified listener (and all its listener methods) from the event bus. Also works for listeners\n * stored with weak references.\n *\n * @param listener the listener to unsubscribe, never {@code null}.\n * @see #subscribe(Object)\n * @see #subscribe(Object, boolean)\n */\n void unsubscribe(Object listener);\n\n /**\n * Interface implemented by the application scoped event bus.\n *\n * @see org.vaadin.spring.events.EventScope#APPLICATION\n */\n interface ApplicationEventBus extends EventBus {\n }\n\n /**\n * Interface implemented by the session scoped event bus.\n *\n * @see org.vaadin.spring.events.EventScope#SESSION\n */\n interface SessionEventBus extends EventBus {\n }\n\n /**\n * Interface implemented by the UI scoped event bus.\n *\n * @see org.vaadin.spring.events.EventScope#UI\n */\n interface UIEventBus extends EventBus {\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/EventBusAware.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\nimport org.springframework.beans.factory.Aware;\n\n/**\n * Marker super interface for beans that want to get notified of a specific type of event bus.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\npublic interface EventBusAware extends Aware {\n\n /**\n * Interface to be implemented by beans that want to get notified of the\n * application event bus.\n */\n interface ApplicationEventBusAware extends EventBusAware {\n /**\n * Sets the application scoped event bus.\n */\n void setApplicationEventBus(EventBus.ApplicationEventBus applicationEventBus);\n }\n\n /**\n * Interface to be implemented by beans that want to get notified of the\n * session event bus.\n */\n interface SessionEventBusAware extends EventBusAware {\n /**\n * Sets the session scoped event bus.\n */\n void setSessionEventBus(EventBus.SessionEventBus sessionEventBus);\n }\n\n /**\n * Interface to be implemented by beans that want to get notified of the\n * UI event bus.\n */\n interface UIEventBusAware extends EventBusAware {\n /**\n * Sets the UI scoped event bus.\n */\n void setUIEventBus(EventBus.UIEventBus uiEventBus);\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/EventBusListener.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\nimport java.io.Serializable;\n\n/**\n * Interface to be implemented by listeners that want to subscribe to an {@link org.vaadin.spring.events.EventBus}.\n *\n * @param type of event payloads that the listener is interested in receiving.\n * @author Petter Holmström (petter@vaadin.com)\n */\npublic interface EventBusListener extends Serializable {\n\n /**\n * Called when an event has been received.\n *\n * @param event the event, never {@code null}.\n */\n void onEvent(Event event);\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/EventBusListenerMethodFilter.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n *
\n * A method annotated with @EventBusListenerMethod will be invoked if it is\n * subscribed to the EventBus that published the Event\n * (or Object payload). That method will oftentimes employ filtering code\n * in the method internals, because of the possibility that multiple annotated methods\n * might listen to same the Event.\n *
\n *
\n * As a convenience, an implementation of this filter may be defined in\n * {@link org.vaadin.spring.events.annotation.EventBusListenerMethod#filter()}\n * and stand in place of such filtering code.\n *
\n * @author Chris Phillipson (fastnsilver@gmail.com)\n *\n */\npublic interface EventBusListenerMethodFilter {\n\n /**\n * Criteria used to influence when an @EventBusListenerMethod\n * annotated method with this filter defined will execute\n * @param event EventBus event\n * @return true if filtering condition met; false otherwise\n */\n boolean filter(Event event);\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/EventScope.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n * Enumeration of event scopes.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\npublic enum EventScope {\n /**\n * The event is application wide.\n */\n APPLICATION,\n\n /**\n * The event is specific to the current (Vaadin) session.\n */\n SESSION,\n\n /**\n * The event is specific to the current UI.\n */\n UI,\n\n /**\n * Undefined event scope. An internal event scope used only when no scope has been explicitly defined.\n *\n * @see org.vaadin.spring.events.annotation.EventBusListenerMethod#scope()\n */\n UNDEFINED\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/ExactTopicFilter.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n * An implementation of {@link org.vaadin.spring.events.TopicFilter}\n * which validates the topics with an exact match (equals).\n * \n * @author Marco Luthardt (marco.luthardt@iandme.net)\n */\npublic class ExactTopicFilter implements TopicFilter {\n\n @Override\n public boolean validTopic(String eventTopic, String listenerTopic) {\n return eventTopic.equals(listenerTopic);\n }\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/HierachyTopicFilter.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n * An implementation of {@link org.vaadin.spring.events.TopicFilter}\n * which validates the topics hierarchical. This means, that the\n * listener filter will be checked as prefixed substring against\n * the event topic.\n * \n * \n *
match: eventTopic = \"foo.bar\" and listenerTopic = \"foo\"
\n *
no match: eventTopic = \"foo\" and listenerTopic = \"foo.bar\"
\n *
no match: eventTopic = \"foo.bar\" and listenerTopic = \"foo.not\"
\n * \n * \n * @author Marco Luthardt (marco.luthardt@iandme.net)\n */\npublic class HierachyTopicFilter implements TopicFilter {\n\n @Override\n public boolean validTopic(String eventTopic, String listenerTopic) {\n return eventTopic.startsWith(listenerTopic);\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/NoEventBusListenerMethodFilter.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n\n/**\n * A default filter implementation which always returns true.\n * @author Chris Phillipson (fastnsilver@gmail.com)\n * @see org.vaadin.spring.events.annotation.EventBusListenerMethod#scope()\n */\npublic class NoEventBusListenerMethodFilter implements EventBusListenerMethodFilter {\n\n @Override\n public boolean filter(Event event) {\n return true;\n }\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/TopicFilter.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events;\n\n/**\n * The interface defines a method to validate a given event topic\n * an listener topic. The event topic is provided when publishing\n * an event and the listener topic by the {@link org.vaadin.spring.events.annotation.EventBusListenerTopic} \n * annotation. An implementation of this interface can be used as \n * parameter of this annotation.\n * \n * @author Marco Luthardt (marco.luthardt@iandme.net)\n * @see org.vaadin.spring.events.annotation.EventBusListenerTopic\n */\npublic interface TopicFilter {\n\n /**\n * Validates the given event topic against the listener topic.\n * \n * @param eventTopic the topic provided by while publishing an event, never {@code null}\n * @param listenerTopic the topic of the listener method, never {@code null}\n * \n * @return true true if the event topic matches the listener topic, otherwise false\n */\n boolean validTopic(String eventTopic, String listenerTopic);\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/annotation/EnableEventBus.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.annotation;\n\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.RetentionPolicy;\nimport java.lang.annotation.Target;\n\nimport org.springframework.context.annotation.Import;\nimport org.vaadin.spring.events.config.EventBusConfiguration;\n\n@Target(ElementType.TYPE)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\n@Import(EventBusConfiguration.class)\npublic @interface EnableEventBus {\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/annotation/EventBusListenerMethod.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.annotation;\n\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.RetentionPolicy;\nimport java.lang.annotation.Target;\n\nimport org.vaadin.spring.events.EventBus;\nimport org.vaadin.spring.events.EventBusListener;\nimport org.vaadin.spring.events.EventBusListenerMethodFilter;\nimport org.vaadin.spring.events.EventScope;\nimport org.vaadin.spring.events.NoEventBusListenerMethodFilter;\n\n/**\n * Annotation to be placed on event bus listener methods. A listener method must always conform to one of the following method signatures:\n * \n *
\n * \n * A listener method can have any visibility and any return type.\n *\n * @author Petter Holmström (petter@vaadin.com)\n * @see org.vaadin.spring.events.EventBusListener\n * @see EventBus#subscribe(Object)\n * @see EventBus#subscribe(Object, boolean)\n */\n@Target(ElementType.METHOD)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface EventBusListenerMethod {\n\n /**\n * The default scope of a listener method is EventScope.UNDEFINED\n * This means that listener will listen for any {@link EventScope} if {@link EventBus#subscribe(EventBusListener, boolean)} is set to propagate event\n */\n EventScope scope() default EventScope.UNDEFINED;\n\n Class filter() default NoEventBusListenerMethodFilter.class;\n \n /**\n * Filter by source class \n */\n Class[] source() default {};\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/annotation/EventBusListenerTopic.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.annotation;\n\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.RetentionPolicy;\nimport java.lang.annotation.Target;\n\nimport org.vaadin.spring.events.ExactTopicFilter;\nimport org.vaadin.spring.events.TopicFilter;\n\n/**\n * Annotation to be placed on event bus listener methods, additional to\n * the {@link org.vaadin.spring.events.annotation.EventBusListenerMethod} annotation.\n * A topic is specified as string which will be defined when publishing an event.\n * Each method annotated with this annotation and the corresponding topic will be\n * called as listener.\n * \n * Topics can be filtered with implementations of the {@link org.vaadin.spring.events.TopicFilter} interface.\n * \n * @author Marco Luthardt (marco.luthardt@iandme.net)\n * @see org.vaadin.spring.events.annotation.EventBusListenerMethod\n * @see org.vaadin.spring.events.TopicFilter\n */\n@Target(ElementType.METHOD)\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface EventBusListenerTopic {\n\n /**\n * A topic is a string which can be specified while publishing an event. The\n * method will only called when the topic matches the given String in the\n * published method.\n */\n String topic() default \"\";\n\n /**\n * The filter to be used to validate the published and listener topic.\n * \n * @return an implementation of the {@link org.vaadin.spring.events.TopicFilter} interface.\n */\n Class filter() default ExactTopicFilter.class;\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/annotation/EventBusProxy.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.annotation;\n\nimport org.springframework.beans.factory.annotation.Qualifier;\n\nimport java.lang.annotation.Documented;\nimport java.lang.annotation.ElementType;\nimport java.lang.annotation.Inherited;\nimport java.lang.annotation.Retention;\nimport java.lang.annotation.RetentionPolicy;\nimport java.lang.annotation.Target;\n\n/**\n * Qualifier to be used to indicate that a proxy of an {@link org.vaadin.spring.events.EventBus} should be injected.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\n@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE})\n@Retention(RetentionPolicy.RUNTIME)\n@Inherited\n@Documented\n@Qualifier\npublic @interface EventBusProxy {\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/config/EventBusConfiguration.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.config;\n\nimport com.vaadin.flow.spring.scopes.VaadinSessionScope;\nimport com.vaadin.flow.spring.scopes.VaadinUIScope;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.context.annotation.Primary;\nimport org.springframework.context.annotation.Scope;\nimport org.springframework.context.annotation.ScopedProxyMode;\nimport org.vaadin.spring.events.EventBus;\nimport org.vaadin.spring.events.annotation.EventBusProxy;\nimport org.vaadin.spring.events.internal.ScopedEventBus;\nimport org.vaadin.spring.events.support.VaadinEventBusAwareProcessor;\n\n/**\n * Configuration class to configure the Spring Vaadin Eventbus\n *\n * @author Gert-Jan Timmer (gjr.timmer@gmail.com)\n */\n@Configuration\npublic class EventBusConfiguration {\n\n @Bean\n VaadinEventBusAwareProcessor vaadinEventBusProcessor() {\n return new VaadinEventBusAwareProcessor();\n }\n\n @Bean\n EventBus.ApplicationEventBus applicationEventBus() {\n return new ScopedEventBus.DefaultApplicationEventBus();\n }\n\n @Bean\n @Scope(value = VaadinSessionScope.VAADIN_SESSION_SCOPE_NAME, proxyMode = ScopedProxyMode.INTERFACES)\n @EventBusProxy\n EventBus.SessionEventBus proxiedSessionEventBus() {\n return sessionEventBus();\n }\n\n @Bean\n @Scope(value = VaadinSessionScope.VAADIN_SESSION_SCOPE_NAME, proxyMode = ScopedProxyMode.NO)\n @Primary\n EventBus.SessionEventBus sessionEventBus() {\n return new ScopedEventBus.DefaultSessionEventBus(applicationEventBus());\n }\n\n @Bean\n @Scope(value = VaadinUIScope.VAADIN_UI_SCOPE_NAME, proxyMode = ScopedProxyMode.INTERFACES)\n @EventBusProxy\n EventBus.UIEventBus proxiedUiEventBus() {\n return uiEventBus();\n }\n\n @Bean\n @Scope(value = VaadinUIScope.VAADIN_UI_SCOPE_NAME, proxyMode = ScopedProxyMode.NO)\n @Primary\n EventBus.UIEventBus uiEventBus() {\n return new ScopedEventBus.DefaultUIEventBus(sessionEventBus());\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/AbstractListenerWrapper.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\nimport org.vaadin.spring.events.Event;\nimport org.vaadin.spring.events.EventBus;\n\n/**\n * Base implementation of {@link org.vaadin.spring.events.internal.ListenerCollection.Listener} that implements\n * the {@link #supports(org.vaadin.spring.events.Event)} method. An event is supported if:\n *
\n *
The payload type of the listener is either the same type as, or a supertype of, the payload type of the event
\n *
The listener allows propagating events, or the event was originally published on event bus that the listener was subscribed to
\n *
\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\nabstract class AbstractListenerWrapper implements ListenerCollection.Listener {\n\n private static final long serialVersionUID = 6211420845165980671L;\n\n private final EventBus owningEventBus;\n\n private final Object listenerTarget;\n\n private final boolean includingPropagatingEvents;\n\n private final String topic;\n\n AbstractListenerWrapper(EventBus owningEventBus, Object listenerTarget, String topic, boolean includingPropagatingEvents) {\n this.owningEventBus = owningEventBus;\n this.topic = topic;\n this.listenerTarget = listenerTarget;\n this.includingPropagatingEvents = includingPropagatingEvents;\n }\n\n /**\n * Gets the payload type of the listener.\n */\n protected abstract Class getPayloadType();\n\n /**\n * Gets the target object that this listener is wrapping.\n */\n public Object getListenerTarget() {\n return listenerTarget;\n }\n\n @Override\n public boolean supports(Event event) {\n final Class eventPayloadType = event.getPayload().getClass();\n return (event.getTopic().equals(topic) || topic == null) &&\n getPayloadType().isAssignableFrom(eventPayloadType) &&\n (includingPropagatingEvents || event.getEventBus().equals(owningEventBus));\n }\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/ClassUtils.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\n/**\n * Utility methods for working with classes and class members.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\nfinal class ClassUtils {\n\n private ClassUtils() {\n }\n\n /**\n * Visitor interface used with {@link ClassUtils#visitClassHierarchy(ClassUtils.ClassVisitor, Class)}.\n */\n public interface ClassVisitor {\n void visit(Class clazz);\n }\n\n /**\n * Visits the entire class hierarchy from {@code subClass} to {@code Object}.\n *\n * @param visitor the visitor to use, must not be {@code null}.\n * @param subClass the class whose hierarchy is to be visited, must not be {@code null}.\n */\n static void visitClassHierarchy(ClassVisitor visitor, Class subClass) {\n Class visitedClass = subClass;\n while (visitedClass.getSuperclass() != null) {\n visitor.visit(visitedClass);\n visitedClass = visitedClass.getSuperclass();\n }\n }\n}"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/EventBusListenerWrapper.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\nimport org.springframework.core.GenericTypeResolver;\nimport org.springframework.util.Assert;\nimport org.vaadin.spring.events.Event;\nimport org.vaadin.spring.events.EventBus;\nimport org.vaadin.spring.events.EventBusListener;\n\n/**\n * Implementation of {@link org.vaadin.spring.events.internal.AbstractListenerWrapper} that wraps a single\n * {@link org.vaadin.spring.events.EventBusListener} instance.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\nclass EventBusListenerWrapper extends AbstractListenerWrapper {\n\n private static final long serialVersionUID = 8964309195124823892L;\n private final Class payloadType;\n\n EventBusListenerWrapper(EventBus owningEventBus, EventBusListener listenerTarget, String topic, boolean includingPropagatingEvents) {\n super(owningEventBus, listenerTarget, topic, includingPropagatingEvents);\n payloadType = GenericTypeResolver.resolveTypeArgument(listenerTarget.getClass(), EventBusListener.class);\n Assert.notNull(payloadType, \"Could not resolve payload type\");\n }\n\n @Override\n @SuppressWarnings(\"rawtypes\")\n public EventBusListener getListenerTarget() {\n return (EventBusListener) super.getListenerTarget();\n }\n\n @Override\n protected Class getPayloadType() {\n return payloadType;\n }\n\n @Override\n @SuppressWarnings(\"unchecked\")\n public void publish(Event event) {\n getListenerTarget().onEvent(event);\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/ListenerCollection.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\nimport java.io.Serializable;\nimport java.util.*;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.vaadin.spring.events.Event;\n\n/**\n * A collection of listeners. Intended only for internal use by the framework.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\nclass ListenerCollection implements Serializable {\n\n private static final long serialVersionUID = -6237902400879667320L;\n private final Logger logger = LoggerFactory.getLogger(getClass());\n private final Set listeners = new HashSet();\n private final Set weakListeners = Collections.newSetFromMap(new WeakHashMap());\n\n /**\n * Interface defining a listener.\n */\n public interface Listener extends Serializable {\n\n /**\n * Checks if this listener supports the specified event.\n *\n * @param event the event to check, never {@code null}.\n * @return true if the event is supported, false otherwise.\n */\n boolean supports(Event event);\n\n /**\n * Publishes the event to the listener.\n *\n * @param event the event to publish, never {@code null}.\n */\n void publish(Event event);\n }\n\n /**\n * Interface defining a listener filter.\n */\n public interface ListenerFilter {\n /**\n * Checks if the specified listener passes the filter.\n *\n * @param listener the listener to check, never {@code null}.\n * @return true if the listener passes the filter, false otherwise.\n */\n boolean passes(Listener listener);\n }\n\n /**\n * Adds the specified {@link org.vaadin.spring.events.internal.ListenerCollection.Listener} to the listener\n * collection.\n *\n * @param listener the listener to add, never {@code null}.\n * @see #remove(org.vaadin.spring.events.internal.ListenerCollection.Listener)\n */\n void add(Listener listener) {\n logger.trace(\"Adding listener [{}]\", listener);\n synchronized (listeners) {\n listeners.add(listener);\n }\n }\n\n /**\n * Adds the specified {@link org.vaadin.spring.events.internal.ListenerCollection.Listener} to the listener\n * collection,\n * using a weak reference. This means the listener does not need to be removed to be eligible for garbage\n * collection.\n *\n * @param listener the listener to add, never {@code null}.\n */\n void addWithWeakReference(Listener listener) {\n logger.trace(\"Adding listener [{}] using a weak reference\", listener);\n synchronized (weakListeners) {\n weakListeners.add(listener);\n }\n }\n\n /**\n * Removes a {@link org.vaadin.spring.events.internal.ListenerCollection.Listener} previously added by \n * {@link #add(org.vaadin.spring.events.internal.ListenerCollection.Listener)}.\n * If no listener definition is found in the collection, nothing happens.\n *\n * @param listener the listener to remove, never {@code null}.\n * @see #add(org.vaadin.spring.events.internal.ListenerCollection.Listener)\n */\n void remove(Listener listener) {\n logger.trace(\"Removing listener [{}]\", listener);\n synchronized (listeners) {\n listeners.remove(listener);\n }\n synchronized (weakListeners) {\n weakListeners.remove(listener);\n }\n }\n\n /**\n * Removes all {@link org.vaadin.spring.events.internal.ListenerCollection.Listener}s that pass the specified filter\n * and that were previously added by\n * {@link #add(org.vaadin.spring.events.internal.ListenerCollection.Listener)}.\n *\n * @param filter the filter that specifies which listeners to remove, never {@code null}.\n */\n void removeAll(ListenerFilter filter) {\n synchronized (listeners) {\n removeFilteredListenersFromSet(filter, listeners);\n }\n synchronized (weakListeners) {\n removeFilteredListenersFromSet(filter, weakListeners);\n }\n }\n\n /**\n * Removes all {@link org.vaadin.spring.events.internal.ListenerCollection.Listener}s from the collection.\n */\n void clear() {\n synchronized (listeners) {\n listeners.clear();\n }\n synchronized (weakListeners) {\n weakListeners.clear();\n }\n }\n\n /**\n * Publishes the specified {@code event} to all\n * {@link org.vaadin.spring.events.internal.ListenerCollection.Listener}s that support it.\n *\n * @param event the event to publish, never {@code null}.\n * @see org.vaadin.spring.events.internal.ListenerCollection.Listener#publish(org.vaadin.spring.events.Event)\n * @see org.vaadin.spring.events.internal.ListenerCollection.Listener#supports(org.vaadin.spring.events.Event)\n */\n public void publish(Event event) {\n Set interestedListeners = new HashSet();\n synchronized (listeners) {\n addSupportedListenersToSet(listeners, interestedListeners, event);\n }\n synchronized (weakListeners) {\n addSupportedListenersToSet(weakListeners, interestedListeners, event);\n }\n if (interestedListeners.isEmpty()) {\n logger.debug(\"No listeners supported event [{}]\", event);\n } else {\n for (Listener listener : interestedListeners) {\n logger.trace(\"Publishing event [{}] to listener [{}]\", event, listener);\n listener.publish(event);\n }\n }\n }\n\n private void addSupportedListenersToSet(Set candidateListeners, Set selectedListeners,\n Event event) {\n for (Listener candidateListener : candidateListeners) {\n if (candidateListener.supports(event)) {\n logger.trace(\"Listener [{}] supports event [{}]\", candidateListener, event);\n selectedListeners.add(candidateListener);\n }\n }\n }\n\n private void removeFilteredListenersFromSet(ListenerFilter filter, Set listenerSet) {\n for (Iterator it = listenerSet.iterator(); it.hasNext();) {\n Listener listener = it.next();\n if (filter.passes(listener)) {\n logger.trace(\"Removing listener [{}]\", listener);\n it.remove();\n }\n }\n }\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/MethodListenerWrapper.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\nimport org.vaadin.spring.events.*;\nimport org.vaadin.spring.events.annotation.EventBusListenerMethod;\nimport org.vaadin.spring.events.annotation.EventBusListenerTopic;\n\nimport java.io.IOException;\nimport java.io.ObjectInputStream;\nimport java.io.ObjectOutputStream;\nimport java.lang.reflect.InvocationTargetException;\nimport java.lang.reflect.Method;\nimport java.lang.reflect.ParameterizedType;\n\n/**\n * Implementation of {@link org.vaadin.spring.events.internal.AbstractListenerWrapper} that wraps an object\n * that contains a method annotated with {@link org.vaadin.spring.events.annotation.EventBusListenerMethod}. If the object\n * contains multiple listener methods, multiple instances of this class should be created.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\nclass MethodListenerWrapper extends AbstractListenerWrapper {\n\n private static final long serialVersionUID = -3624543380547361337L;\n private final Class payloadType;\n private final boolean payloadMethod;\n private transient Method listenerMethod;\n private final String topic;\n\n MethodListenerWrapper(EventBus owningEventBus, Object listenerTarget, String topic, boolean includingPropagatingEvents, Method listenerMethod) {\n super(owningEventBus, listenerTarget, topic, includingPropagatingEvents);\n this.topic = topic;\n if (listenerMethod.getParameterTypes()[0] == Event.class) {\n ParameterizedType type = (ParameterizedType) listenerMethod.getGenericParameterTypes()[0];\n payloadType = (Class) type.getActualTypeArguments()[0];\n payloadMethod = false;\n } else {\n payloadType = listenerMethod.getParameterTypes()[0];\n payloadMethod = true;\n }\n this.listenerMethod = listenerMethod;\n }\n\n private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {\n ois.defaultReadObject();\n // TODO Read listener method info and look up method\n }\n\n private void writeObject(ObjectOutputStream oos) throws IOException {\n oos.defaultWriteObject();\n // TODO Write listener method info\n }\n\n @Override\n public Class getPayloadType() {\n return payloadType;\n }\n\n @Override\n public void publish(Event event) {\n listenerMethod.setAccessible(true);\n try {\n if (payloadMethod) {\n listenerMethod.invoke(getListenerTarget(), event.getPayload());\n } else {\n listenerMethod.invoke(getListenerTarget(), event);\n }\n } catch (IllegalAccessException e) {\n throw new RuntimeException(\"Could not access listener method \" + listenerMethod.getName());\n } catch (InvocationTargetException e) {\n Throwable targetException = e.getTargetException();\n if (targetException instanceof RuntimeException) {\n throw (RuntimeException) targetException;\n } else {\n throw new RuntimeException(\"A checked exception occurred while invoking listener method \" + listenerMethod.getName(), targetException);\n }\n }\n }\n\n @Override\n public boolean supports(Event event) {\n boolean supports = super.supports(event);\n try {\n if (listenerMethod.isAnnotationPresent(EventBusListenerMethod.class)) {\n supports = supports && isInterestedListenerMethod(event);\n }\n\n if (topic != null) {\n return supports;\n }\n\n if (listenerMethod.isAnnotationPresent(EventBusListenerTopic.class) && supports) {\n supports = isInTopic(event);\n } else if (!event.getTopic().isEmpty()) {\n supports = false;\n }\n } catch (Exception e) {\n throw new RuntimeException(\"A checked exception occurred while invoking listener method \" + listenerMethod.getName(), e);\n }\n return supports;\n }\n\n private boolean isInterestedListenerMethod(Event event) throws InstantiationException, IllegalAccessException {\n EventBusListenerMethod annotation = listenerMethod.getAnnotation(EventBusListenerMethod.class);\n EventBusListenerMethodFilter filter = annotation.filter().newInstance();\n EventScope scope = annotation.scope();\n if (scope.equals(EventScope.UNDEFINED)) {\n scope = event.getScope();\n }\n return filter.filter(event)\n && event.getScope().equals(scope) && isFromSource(event, annotation.source());\n }\n\n private boolean isFromSource(Event event, Class[] sources) {\n if (sources.length == 0) {\n return true;\n }\n\n boolean result = false;\n\n for (int i = 0; i < sources.length && !result; i++) {\n result |= sources[i].isAssignableFrom(event.getSource().getClass());\n }\n\n return result;\n }\n\n private boolean isInTopic(Event event) throws InstantiationException, IllegalAccessException {\n EventBusListenerTopic annotation = listenerMethod.getAnnotation(EventBusListenerTopic.class);\n TopicFilter filter = annotation.filter().newInstance();\n return filter.validTopic(event.getTopic(), annotation.topic());\n }\n\n}\n"
},
{
"path": "eventbus/src/main/java/org/vaadin/spring/events/internal/ScopedEventBus.java",
"content": "/*\n * Copyright 2015 The original authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage org.vaadin.spring.events.internal;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\nimport org.springframework.aop.framework.Advised;\nimport org.springframework.aop.support.AopUtils;\nimport org.vaadin.spring.events.Event;\nimport org.vaadin.spring.events.EventBus;\nimport org.vaadin.spring.events.EventBusListener;\nimport org.vaadin.spring.events.EventScope;\nimport org.vaadin.spring.events.annotation.EventBusListenerMethod;\n\nimport javax.annotation.PreDestroy;\nimport java.io.Serializable;\nimport java.lang.reflect.Method;\n\n/**\n * Implementation of {@link org.vaadin.spring.events.EventBus} that publishes events with one specific\n * {@link org.vaadin.spring.events.EventScope}.\n * A scoped event bus can also have a parent event bus, in which case all events published on the parent bus will\n * propagate to the scoped event bus as well.\n *\n * @author Petter Holmström (petter@vaadin.com)\n */\npublic abstract class ScopedEventBus implements EventBus, Serializable {\n\n private static final long serialVersionUID = -582697574672947883L;\n private final Logger logger = LoggerFactory.getLogger(getClass());\n private final EventScope eventScope;\n\n private final ListenerCollection listeners = new ListenerCollection();\n\n private EventBus parentEventBus;\n private EventBusListener