001    // SECTION-START[License Header]
002    // <editor-fold defaultstate="collapsed" desc=" Generated License ">
003    /*
004     *   Java Object Management and Configuration
005     *   Copyright (C) Christian Schulte, 2011-313
006     *   All rights reserved.
007     *
008     *   Redistribution and use in source and binary forms, with or without
009     *   modification, are permitted provided that the following conditions
010     *   are met:
011     *
012     *     o Redistributions of source code must retain the above copyright
013     *       notice, this list of conditions and the following disclaimer.
014     *
015     *     o Redistributions in binary form must reproduce the above copyright
016     *       notice, this list of conditions and the following disclaimer in
017     *       the documentation and/or other materials provided with the
018     *       distribution.
019     *
020     *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
021     *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
022     *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
023     *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
024     *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
025     *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
026     *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
027     *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
028     *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
029     *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
030     *
031     *   $JOMC: RuntimeModelObjects.java 4381 2012-03-04 19:29:29Z schulte2005 $
032     *
033     */
034    // </editor-fold>
035    // SECTION-END
036    package org.jomc.ri.model;
037    
038    import java.lang.ref.Reference;
039    import java.util.HashMap;
040    import java.util.Map;
041    import org.jomc.model.Argument;
042    import org.jomc.model.Arguments;
043    import org.jomc.model.Author;
044    import org.jomc.model.Authors;
045    import org.jomc.model.Dependencies;
046    import org.jomc.model.Dependency;
047    import org.jomc.model.Implementation;
048    import org.jomc.model.ImplementationReference;
049    import org.jomc.model.Implementations;
050    import org.jomc.model.Instance;
051    import org.jomc.model.Instances;
052    import org.jomc.model.Message;
053    import org.jomc.model.MessageReference;
054    import org.jomc.model.Messages;
055    import org.jomc.model.Module;
056    import org.jomc.model.Person;
057    import org.jomc.model.Persons;
058    import org.jomc.model.Properties;
059    import org.jomc.model.Property;
060    import org.jomc.model.PropertyReference;
061    import org.jomc.model.Specification;
062    import org.jomc.model.SpecificationReference;
063    import org.jomc.model.Specifications;
064    import org.jomc.model.Text;
065    import org.jomc.model.Texts;
066    import org.jomc.util.WeakIdentityHashMap;
067    
068    // SECTION-START[Documentation]
069    // <editor-fold defaultstate="collapsed" desc=" Generated Documentation ">
070    /**
071     * Runtime model objects.
072     *
073     * <dl>
074     *   <dt><b>Identifier:</b></dt><dd>org.jomc.ri.model.RuntimeModelObjects</dd>
075     *   <dt><b>Name:</b></dt><dd>JOMC RI</dd>
076     *   <dt><b>Abstract:</b></dt><dd>No</dd>
077     *   <dt><b>Final:</b></dt><dd>No</dd>
078     *   <dt><b>Stateless:</b></dt><dd>No</dd>
079     * </dl>
080     *
081     * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 1.2
082     * @version 1.2
083     */
084    // </editor-fold>
085    // SECTION-END
086    // SECTION-START[Annotations]
087    // <editor-fold defaultstate="collapsed" desc=" Generated Annotations ">
088    @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.2", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.2" )
089    // </editor-fold>
090    // SECTION-END
091    public class RuntimeModelObjects
092    {
093        // SECTION-START[RuntimeModelObjects]
094    
095        /** Classes by class loader any name cache. */
096        static final Map<ClassLoader, Map<String, Reference<Class<?>>>> classesByClassLoaderAndNameCache =
097            new WeakIdentityHashMap<ClassLoader, Map<String, Reference<Class<?>>>>();
098    
099        /** Singleton instance. */
100        private static final RuntimeModelObjects instance = new RuntimeModelObjects();
101    
102        /** Cache key for the bootstrap class loader. */
103        static final ClassLoader BOOTSTRAP_CLASSLOADER_KEY = new ClassLoader()
104        {
105        };
106    
107        /**
108         * Gets the {@code RuntimeModelObjects} singleton instance.
109         *
110         * @return The {@code RuntimeModelObjects} singleton instance.
111         */
112        public static RuntimeModelObjects getInstance()
113        {
114            return instance;
115        }
116    
117        /**
118         * Creates a copy of a given object.
119         *
120         * @param o The object to copy.
121         *
122         * @return {@code new RuntimePropertyReference( o )}
123         */
124        public PropertyReference copyOf( final PropertyReference o )
125        {
126            return new RuntimePropertyReference( o );
127        }
128    
129        /**
130         * Creates a copy of a given object.
131         *
132         * @param o The object to copy.
133         *
134         * @return {@code new RuntimeImplementationReference( o )}
135         */
136        public ImplementationReference copyOf( final ImplementationReference o )
137        {
138            return new RuntimeImplementationReference( o );
139        }
140    
141        /**
142         * Creates a copy of a given object.
143         *
144         * @param o The object to copy.
145         *
146         * @return {@code new RuntimeDependencies( o )}
147         */
148        public Dependencies copyOf( final Dependencies o )
149        {
150            return new RuntimeDependencies( o );
151        }
152    
153        /**
154         * Creates a copy of a given object.
155         *
156         * @param o The object to copy.
157         *
158         * @return {@code new RuntimeInstances( o )}
159         */
160        public Instances copyOf( final Instances o )
161        {
162            return new RuntimeInstances( o );
163        }
164    
165        /**
166         * Creates a copy of a given object.
167         *
168         * @param o The object to copy.
169         *
170         * @return {@code new RuntimeAuthors( o )}
171         */
172        public Authors copyOf( final Authors o )
173        {
174            return new RuntimeAuthors( o );
175        }
176    
177        /**
178         * Creates a copy of a given object.
179         *
180         * @param o The object to copy.
181         *
182         * @return {@code new RuntimeSpecification( o )}
183         */
184        public Specification copyOf( final Specification o )
185        {
186            return new RuntimeSpecification( o );
187        }
188    
189        /**
190         * Creates a copy of a given object.
191         *
192         * @param o The object to copy.
193         *
194         * @return {@code new RuntimeMessage( o )}
195         */
196        public Message copyOf( final Message o )
197        {
198            return new RuntimeMessage( o );
199        }
200    
201        /**
202         * Creates a copy of a given object.
203         *
204         * @param o The object to copy.
205         *
206         * @return {@code new RuntimeInstance( o )}
207         */
208        public Instance copyOf( final Instance o )
209        {
210            return new RuntimeInstance( o );
211        }
212    
213        /**
214         * Creates a copy of a given object.
215         *
216         * @param o The object to copy.
217         *
218         * @return {@code new RuntimeImplementations( o )}
219         */
220        public Implementations copyOf( final Implementations o )
221        {
222            return new RuntimeImplementations( o );
223        }
224    
225        /**
226         * Creates a copy of a given object.
227         *
228         * @param o The object to copy.
229         *
230         * @return {@code new RuntimeTexts( o )}
231         */
232        public Texts copyOf( final Texts o )
233        {
234            return new RuntimeTexts( o );
235        }
236    
237        /**
238         * Creates a copy of a given object.
239         *
240         * @param o The object to copy.
241         *
242         * @return {@code new RuntimeImplementation( o )}
243         */
244        public Implementation copyOf( final Implementation o )
245        {
246            return new RuntimeImplementation( o );
247        }
248    
249        /**
250         * Creates a copy of a given object.
251         *
252         * @param o The object to copy.
253         *
254         * @return {@code new RuntimeModule( o )}
255         */
256        public Module copyOf( final Module o )
257        {
258            return new RuntimeModule( o );
259        }
260    
261        /**
262         * Creates a copy of a given object.
263         *
264         * @param o The object to copy.
265         *
266         * @return {@code new RuntimeArgument( o )}
267         */
268        public Argument copyOf( final Argument o )
269        {
270            return new RuntimeArgument( o );
271        }
272    
273        /**
274         * Creates a copy of a given object.
275         *
276         * @param o The object to copy.
277         *
278         * @return {@code new RuntimeText( o )}
279         */
280        public Text copyOf( final Text o )
281        {
282            return new RuntimeText( o );
283        }
284    
285        /**
286         * Creates a copy of a given object.
287         *
288         * @param o The object to copy.
289         *
290         * @return {@code new RuntimeProperties( o )}
291         */
292        public Properties copyOf( final Properties o )
293        {
294            return new RuntimeProperties( o );
295        }
296    
297        /**
298         * Creates a copy of a given object.
299         *
300         * @param o The object to copy.
301         *
302         * @return {@code new RuntimePerson( o )}
303         */
304        public Person copyOf( final Person o )
305        {
306            return new RuntimePerson( o );
307        }
308    
309        /**
310         * Creates a copy of a given object.
311         *
312         * @param o The object to copy.
313         *
314         * @return {@code new RuntimeSpecificationReference( o )}
315         */
316        public SpecificationReference copyOf( final SpecificationReference o )
317        {
318            return new RuntimeSpecificationReference( o );
319        }
320    
321        /**
322         * Creates a copy of a given object.
323         *
324         * @param o The object to copy.
325         *
326         * @return {@code new RuntimeAuthor( o )}
327         */
328        public Author copyOf( final Author o )
329        {
330            return new RuntimeAuthor( o );
331        }
332    
333        /**
334         * Creates a copy of a given object.
335         *
336         * @param o The object to copy.
337         *
338         * @return {@code new RuntimeProperty( o )}
339         */
340        public Property copyOf( final Property o )
341        {
342            return new RuntimeProperty( o );
343        }
344    
345        /**
346         * Creates a copy of a given object.
347         *
348         * @param o The object to copy.
349         *
350         * @return {@code new RuntimeArguments( o )}
351         */
352        public Arguments copyOf( final Arguments o )
353        {
354            return new RuntimeArguments( o );
355        }
356    
357        /**
358         * Creates a copy of a given object.
359         *
360         * @param o The object to copy.
361         *
362         * @return {@code new RuntimeDependency( o )}
363         */
364        public Dependency copyOf( final Dependency o )
365        {
366            return new RuntimeDependency( o );
367        }
368    
369        /**
370         * Creates a copy of a given object.
371         *
372         * @param o The object to copy.
373         *
374         * @return {@code new RuntimeSpecifications( o )}
375         */
376        public Specifications copyOf( final Specifications o )
377        {
378            return new RuntimeSpecifications( o );
379        }
380    
381        /**
382         * Creates a copy of a given object.
383         *
384         * @param o The object to copy.
385         *
386         * @return {@code new RuntimeMessages( o )}
387         */
388        public Messages copyOf( final Messages o )
389        {
390            return new RuntimeMessages( o );
391        }
392    
393        /**
394         * Creates a copy of a given object.
395         *
396         * @param o The object to copy.
397         *
398         * @return {@code new RuntimePersons( o )}
399         */
400        public Persons copyOf( final Persons o )
401        {
402            return new RuntimePersons( o );
403        }
404    
405        /**
406         * Creates a copy of a given object.
407         *
408         * @param o The object to copy.
409         *
410         * @return {@code new RuntimeMessageReference( o )}
411         */
412        public MessageReference copyOf( final MessageReference o )
413        {
414            return new RuntimeMessageReference( o );
415        }
416    
417        /** Handles shared runtime state. */
418        public void gc()
419        {
420            synchronized ( classesByClassLoaderAndNameCache )
421            {
422                classesByClassLoaderAndNameCache.size();
423            }
424            synchronized ( RuntimeInstance.assignableFlagsByClassLoaderAndInstanceCache )
425            {
426                RuntimeInstance.assignableFlagsByClassLoaderAndInstanceCache.size();
427            }
428            synchronized ( RuntimeInstance.classesByClassLoaderAndInstanceCache )
429            {
430                RuntimeInstance.classesByClassLoaderAndInstanceCache.size();
431            }
432            synchronized ( RuntimeInstance.constructorsByClassLoaderAndInstanceCache )
433            {
434                RuntimeInstance.constructorsByClassLoaderAndInstanceCache.size();
435            }
436            synchronized ( RuntimeInstance.methodsByClassLoaderAndInstanceCache )
437            {
438                RuntimeInstance.methodsByClassLoaderAndInstanceCache.size();
439            }
440            synchronized ( RuntimeInstance.proxyClassesByClassLoaderAndInstanceCache )
441            {
442                RuntimeInstance.proxyClassesByClassLoaderAndInstanceCache.size();
443            }
444        }
445    
446        /**  Clears shared runtime state. */
447        public void clear()
448        {
449            synchronized ( classesByClassLoaderAndNameCache )
450            {
451                classesByClassLoaderAndNameCache.clear();
452            }
453            synchronized ( RuntimeInstance.assignableFlagsByClassLoaderAndInstanceCache )
454            {
455                RuntimeInstance.assignableFlagsByClassLoaderAndInstanceCache.clear();
456            }
457            synchronized ( RuntimeInstance.classesByClassLoaderAndInstanceCache )
458            {
459                RuntimeInstance.classesByClassLoaderAndInstanceCache.clear();
460            }
461            synchronized ( RuntimeInstance.constructorsByClassLoaderAndInstanceCache )
462            {
463                RuntimeInstance.constructorsByClassLoaderAndInstanceCache.clear();
464            }
465            synchronized ( RuntimeInstance.methodsByClassLoaderAndInstanceCache )
466            {
467                RuntimeInstance.methodsByClassLoaderAndInstanceCache.clear();
468            }
469            synchronized ( RuntimeInstance.proxyClassesByClassLoaderAndInstanceCache )
470            {
471                RuntimeInstance.proxyClassesByClassLoaderAndInstanceCache.clear();
472            }
473        }
474    
475        /**
476         * Creates a new {@code Map} instance.
477         *
478         * @param <K> The type of the keys to maintain by the new map.
479         * @param <V> The type of the values to map.
480         *
481         * @return A new {@code Map} instance.
482         */
483        static <K, V> Map<K, V> createMap()
484        {
485            return new HashMap<K, V>( 128 );
486        }
487    
488        // SECTION-END
489        // SECTION-START[Constructors]
490        // <editor-fold defaultstate="collapsed" desc=" Generated Constructors ">
491        /** Creates a new {@code RuntimeModelObjects} instance. */
492        @javax.annotation.Generated( value = "org.jomc.tools.SourceFileProcessor 1.2.2", comments = "See http://jomc.sourceforge.net/jomc/1.2/jomc-tools-1.2.2" )
493        public RuntimeModelObjects()
494        {
495            // SECTION-START[Default Constructor]
496            super();
497            // SECTION-END
498        }
499        // </editor-fold>
500        // SECTION-END
501        // SECTION-START[Dependencies]
502        // SECTION-END
503        // SECTION-START[Properties]
504        // SECTION-END
505        // SECTION-START[Messages]
506        // SECTION-END
507    }