001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.exportimport.lar;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.util.ListUtil;
020    import com.liferay.registry.Registry;
021    import com.liferay.registry.RegistryUtil;
022    import com.liferay.registry.ServiceReference;
023    import com.liferay.registry.ServiceRegistration;
024    import com.liferay.registry.ServiceTracker;
025    import com.liferay.registry.ServiceTrackerCustomizer;
026    import com.liferay.registry.collections.ServiceRegistrationMap;
027    
028    import java.util.Collection;
029    import java.util.List;
030    import java.util.Map;
031    import java.util.concurrent.ConcurrentHashMap;
032    
033    /**
034     * Provides a utility facade to the staged model data handler registry
035     * framework.
036     *
037     * @author Mate Thurzo
038     * @author Brian Wing Shun Chan
039     * @since  6.2
040     */
041    @ProviderType
042    public class StagedModelDataHandlerRegistryUtil {
043    
044            /**
045             * Returns the registered staged model data handler with the class name.
046             *
047             * @param  className the name of the staged model class
048             * @return the registered staged model data handler with the class name, or
049             *         <code>null</code> if none are registered with the class name
050             */
051            public static StagedModelDataHandler<?> getStagedModelDataHandler(
052                    String className) {
053    
054                    return _instance._getStagedModelDataHandler(className);
055            }
056    
057            /**
058             * Returns all the registered staged model data handlers.
059             *
060             * @return the registered staged model data handlers
061             */
062            public static List<StagedModelDataHandler<?>> getStagedModelDataHandlers() {
063                    return _instance._getStagedModelDataHandlers();
064            }
065    
066            /**
067             * Registers the staged model data handler.
068             *
069             * @param stagedModelDataHandler the staged model data handler to register
070             */
071            public static void register(
072                    StagedModelDataHandler<?> stagedModelDataHandler) {
073    
074                    _instance._register(stagedModelDataHandler);
075            }
076    
077            /**
078             * Unregisters the staged model data handlers.
079             *
080             * @param stagedModelDataHandlers the staged model data handlers to
081             *        unregister
082             */
083            public static void unregister(
084                    List<StagedModelDataHandler<?>> stagedModelDataHandlers) {
085    
086                    for (StagedModelDataHandler<?> stagedModelDataHandler :
087                                    stagedModelDataHandlers) {
088    
089                            unregister(stagedModelDataHandler);
090                    }
091            }
092    
093            /**
094             * Unregisters the staged model data handler.
095             *
096             * @param stagedModelDataHandler the staged model data handler to unregister
097             */
098            public static void unregister(
099                    StagedModelDataHandler<?> stagedModelDataHandler) {
100    
101                    _instance._unregister(stagedModelDataHandler);
102            }
103    
104            private StagedModelDataHandlerRegistryUtil() {
105                    Registry registry = RegistryUtil.getRegistry();
106    
107                    _serviceTracker = registry.trackServices(
108                            (Class<StagedModelDataHandler<?>>)(Class<?>)
109                                    StagedModelDataHandler.class,
110                            new StagedModelDataHandlerServiceTrackerCustomizer());
111    
112                    _serviceTracker.open();
113            }
114    
115            private StagedModelDataHandler<?> _getStagedModelDataHandler(
116                    String className) {
117    
118                    return _stagedModelDataHandlers.get(className);
119            }
120    
121            private List<StagedModelDataHandler<?>> _getStagedModelDataHandlers() {
122                    Collection<StagedModelDataHandler<?>> values =
123                            _stagedModelDataHandlers.values();
124    
125                    return ListUtil.fromCollection(values);
126            }
127    
128            private void _register(StagedModelDataHandler<?> stagedModelDataHandler) {
129                    Registry registry = RegistryUtil.getRegistry();
130    
131                    ServiceRegistration<StagedModelDataHandler<?>> serviceRegistration =
132                            registry.registerService(
133                                    (Class<StagedModelDataHandler<?>>)(Class<?>)
134                                            StagedModelDataHandler.class, stagedModelDataHandler);
135    
136                    _serviceRegistrations.put(stagedModelDataHandler, serviceRegistration);
137            }
138    
139            private void _unregister(StagedModelDataHandler<?> stagedModelDataHandler) {
140                    ServiceRegistration<StagedModelDataHandler<?>> serviceRegistration =
141                            _serviceRegistrations.remove(stagedModelDataHandler);
142    
143                    if (serviceRegistration != null) {
144                            serviceRegistration.unregister();
145                    }
146            }
147    
148            private static final StagedModelDataHandlerRegistryUtil _instance =
149                    new StagedModelDataHandlerRegistryUtil();
150    
151            private final ServiceRegistrationMap<StagedModelDataHandler<?>>
152                    _serviceRegistrations = new ServiceRegistrationMap<>();
153            private final
154                    ServiceTracker<StagedModelDataHandler<?>, StagedModelDataHandler<?>>
155                            _serviceTracker;
156            private final Map<String, StagedModelDataHandler<?>>
157                    _stagedModelDataHandlers = new ConcurrentHashMap<>();
158    
159            private class StagedModelDataHandlerServiceTrackerCustomizer
160                    implements ServiceTrackerCustomizer
161                            <StagedModelDataHandler<?>, StagedModelDataHandler<?>> {
162    
163                    @Override
164                    public StagedModelDataHandler<?> addingService(
165                            ServiceReference<StagedModelDataHandler<?>> serviceReference) {
166    
167                            Registry registry = RegistryUtil.getRegistry();
168    
169                            StagedModelDataHandler<?> stagedModelDataHandler =
170                                    registry.getService(serviceReference);
171    
172                            for (String className : stagedModelDataHandler.getClassNames()) {
173                                    _stagedModelDataHandlers.put(className, stagedModelDataHandler);
174                            }
175    
176                            return stagedModelDataHandler;
177                    }
178    
179                    @Override
180                    public void modifiedService(
181                            ServiceReference<StagedModelDataHandler<?>> serviceReference,
182                            StagedModelDataHandler<?> stagedModelDataHandler) {
183                    }
184    
185                    @Override
186                    public void removedService(
187                            ServiceReference<StagedModelDataHandler<?>> serviceReference,
188                            StagedModelDataHandler<?> stagedModelDataHandler) {
189    
190                            Registry registry = RegistryUtil.getRegistry();
191    
192                            registry.ungetService(serviceReference);
193    
194                            for (String className : stagedModelDataHandler.getClassNames()) {
195                                    _stagedModelDataHandlers.remove(className);
196                            }
197                    }
198    
199            }
200    
201    }