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    import com.liferay.registry.collections.ServiceRegistrationMapImpl;
028    
029    import java.util.Collection;
030    import java.util.List;
031    import java.util.Map;
032    import java.util.concurrent.ConcurrentHashMap;
033    
034    /**
035     * Provides a utility facade to the staged model data handler registry
036     * framework.
037     *
038     * @author Mate Thurzo
039     * @author Brian Wing Shun Chan
040     * @since  6.2
041     */
042    @ProviderType
043    public class StagedModelDataHandlerRegistryUtil {
044    
045            /**
046             * Returns the registered staged model data handler with the class name.
047             *
048             * @param  className the name of the staged model class
049             * @return the registered staged model data handler with the class name, or
050             *         <code>null</code> if none are registered with the class name
051             */
052            public static StagedModelDataHandler<?> getStagedModelDataHandler(
053                    String className) {
054    
055                    return _instance._getStagedModelDataHandler(className);
056            }
057    
058            /**
059             * Returns all the registered staged model data handlers.
060             *
061             * @return the registered staged model data handlers
062             */
063            public static List<StagedModelDataHandler<?>> getStagedModelDataHandlers() {
064                    return _instance._getStagedModelDataHandlers();
065            }
066    
067            /**
068             * Registers the staged model data handler.
069             *
070             * @param stagedModelDataHandler the staged model data handler to register
071             */
072            public static void register(
073                    StagedModelDataHandler<?> stagedModelDataHandler) {
074    
075                    _instance._register(stagedModelDataHandler);
076            }
077    
078            /**
079             * Unregisters the staged model data handlers.
080             *
081             * @param stagedModelDataHandlers the staged model data handlers to
082             *        unregister
083             */
084            public static void unregister(
085                    List<StagedModelDataHandler<?>> stagedModelDataHandlers) {
086    
087                    for (StagedModelDataHandler<?> stagedModelDataHandler :
088                                    stagedModelDataHandlers) {
089    
090                            unregister(stagedModelDataHandler);
091                    }
092            }
093    
094            /**
095             * Unregisters the staged model data handler.
096             *
097             * @param stagedModelDataHandler the staged model data handler to unregister
098             */
099            public static void unregister(
100                    StagedModelDataHandler<?> stagedModelDataHandler) {
101    
102                    _instance._unregister(stagedModelDataHandler);
103            }
104    
105            private StagedModelDataHandlerRegistryUtil() {
106                    Registry registry = RegistryUtil.getRegistry();
107    
108                    _serviceTracker = registry.trackServices(
109                            (Class<StagedModelDataHandler<?>>)(Class<?>)
110                                    StagedModelDataHandler.class,
111                            new StagedModelDataHandlerServiceTrackerCustomizer());
112    
113                    _serviceTracker.open();
114            }
115    
116            private StagedModelDataHandler<?> _getStagedModelDataHandler(
117                    String className) {
118    
119                    return _stagedModelDataHandlers.get(className);
120            }
121    
122            private List<StagedModelDataHandler<?>> _getStagedModelDataHandlers() {
123                    Collection<StagedModelDataHandler<?>> values =
124                            _stagedModelDataHandlers.values();
125    
126                    return ListUtil.fromCollection(values);
127            }
128    
129            private void _register(StagedModelDataHandler<?> stagedModelDataHandler) {
130                    Registry registry = RegistryUtil.getRegistry();
131    
132                    ServiceRegistration<StagedModelDataHandler<?>> serviceRegistration =
133                            registry.registerService(
134                                    (Class<StagedModelDataHandler<?>>)(Class<?>)
135                                            StagedModelDataHandler.class, stagedModelDataHandler);
136    
137                    _serviceRegistrations.put(stagedModelDataHandler, serviceRegistration);
138            }
139    
140            private void _unregister(StagedModelDataHandler<?> stagedModelDataHandler) {
141                    ServiceRegistration<StagedModelDataHandler<?>> serviceRegistration =
142                            _serviceRegistrations.remove(stagedModelDataHandler);
143    
144                    if (serviceRegistration != null) {
145                            serviceRegistration.unregister();
146                    }
147            }
148    
149            private static final StagedModelDataHandlerRegistryUtil _instance =
150                    new StagedModelDataHandlerRegistryUtil();
151    
152            private final ServiceRegistrationMap<StagedModelDataHandler<?>>
153                    _serviceRegistrations = new ServiceRegistrationMapImpl<>();
154            private final
155                    ServiceTracker<StagedModelDataHandler<?>, StagedModelDataHandler<?>>
156                            _serviceTracker;
157            private final Map<String, StagedModelDataHandler<?>>
158                    _stagedModelDataHandlers = new ConcurrentHashMap<>();
159    
160            private class StagedModelDataHandlerServiceTrackerCustomizer
161                    implements ServiceTrackerCustomizer
162                            <StagedModelDataHandler<?>, StagedModelDataHandler<?>> {
163    
164                    @Override
165                    public StagedModelDataHandler<?> addingService(
166                            ServiceReference<StagedModelDataHandler<?>> serviceReference) {
167    
168                            Registry registry = RegistryUtil.getRegistry();
169    
170                            StagedModelDataHandler<?> stagedModelDataHandler =
171                                    registry.getService(serviceReference);
172    
173                            for (String className : stagedModelDataHandler.getClassNames()) {
174                                    _stagedModelDataHandlers.put(className, stagedModelDataHandler);
175                            }
176    
177                            return stagedModelDataHandler;
178                    }
179    
180                    @Override
181                    public void modifiedService(
182                            ServiceReference<StagedModelDataHandler<?>> serviceReference,
183                            StagedModelDataHandler<?> stagedModelDataHandler) {
184                    }
185    
186                    @Override
187                    public void removedService(
188                            ServiceReference<StagedModelDataHandler<?>> serviceReference,
189                            StagedModelDataHandler<?> stagedModelDataHandler) {
190    
191                            Registry registry = RegistryUtil.getRegistry();
192    
193                            registry.ungetService(serviceReference);
194    
195                            for (String className : stagedModelDataHandler.getClassNames()) {
196                                    _stagedModelDataHandlers.remove(className);
197                            }
198                    }
199    
200            }
201    
202    }