com.sun.tools.xjc.reader.Ring Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxb-xjc Show documentation
The newest version!
/*
 * Copyright (c) 1997, 2022 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0, which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package com.sun.tools.xjc.reader;

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

import com.sun.tools.xjc.ErrorReceiver;
import com.sun.tools.xjc.model.Model;

/**
 * Holds all the binding related singleton components in a "ring",
 * and let you access those components, creating them as necessary.
 *
 * 
 * A {@link Ring} is local to a thread,
 * and only one instanceof {@link Ring} can be active at any given time.
 *
 * Use {@link #begin()} and {@link #end(Ring)} to start/end a ring scope.
 * Inside a scope, use {@link #get()} to obtain the instance.
 *
 * 

 * When a {@link Model} is built by the reader, an active {@link Ring} scope
 * is assumed.
 *
 *
 * 
Components in Ring
 * 
 * Depending on the schema language we are dealing with, different
 * components are in the model. But at least the following components
 * are in the ring.
 *
 * 

 *  {@link ErrorReceiver}
 * 
 *
 * @author Kohsuke Kawaguchi
 */
public final class Ring {

    private final Map,Object> components = new HashMap<>();

    private static final ThreadLocal instances = new ThreadLocal<>();

    private Ring() {}

    public static  void add( Class clazz, T instance ) {
        assert !get().components.containsKey(clazz);
        get().components.put(clazz,instance);
    }

    @SuppressWarnings({"unchecked"})
    public static  void add( T o ) {
        add((Class)o.getClass(),o);
    }

    public static  T get( Class key ) {
        @SuppressWarnings({"unchecked"})
        T t = (T)get().components.get(key);
        if(t==null) {
            try {
                Constructor c = key.getDeclaredConstructor();
                c.setAccessible(true);
                t = c.newInstance();
                if(!get().components.containsKey(key))
                    // many components register themselves.
                    add(key,t);
            } catch (ReflectiveOperationException e) {
                throw new Error(e);
            }
        }

        assert t!=null;
        return t;
    }

    /**
     * An instance is associated with a thread.
     */
    public static Ring get() {
        return instances.get();
    }

    /**
     * Starts a new scope.
     */
    public static Ring begin() {
        Ring r = null;
        synchronized (instances) {
            r = instances.get();
            instances.set(new Ring());
        }
        return r;
    }

    /**
     * Ends a scope.
     */
    public static void end(Ring old) {
        synchronized (instances) {
            instances.remove();
            instances.set(old);
        }
    }
}