aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java')
-rw-r--r--gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java472
1 files changed, 472 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java b/gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java
new file mode 100644
index 000000000..e0ce16a14
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/gnu/CORBA/Interceptor/Registrator.java
@@ -0,0 +1,472 @@
+/* Registrator.java --
+ Copyright (C) 2005 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.CORBA.Interceptor;
+
+import gnu.CORBA.Poa.ORB_1_4;
+import gnu.CORBA.ObjectCreator;
+import gnu.CORBA.gnuCodecFactory;
+
+import org.omg.CORBA.BAD_INV_ORDER;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.LocalObject;
+import org.omg.CORBA.Object;
+import org.omg.IOP.CodecFactory;
+import org.omg.PortableInterceptor.ClientRequestInterceptor;
+import org.omg.PortableInterceptor.IORInterceptor;
+import org.omg.PortableInterceptor.Interceptor;
+import org.omg.PortableInterceptor.ORBInitInfo;
+import org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName;
+import org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName;
+import org.omg.PortableInterceptor.ORBInitializer;
+import org.omg.PortableInterceptor.ORBInitializerOperations;
+import org.omg.PortableInterceptor.PolicyFactory;
+import org.omg.PortableInterceptor.ServerRequestInterceptor;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+
+/**
+ * Collects interceptors, references and factories into arrays during
+ * registration. As the class is security sensitive, the most of the fields are
+ * private.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class Registrator extends LocalObject implements ORBInitInfo
+{
+ /**
+ * Use serialVersionUID for interoperability.
+ */
+ private static final long serialVersionUID = 1;
+
+ /**
+ * The agreed properties prefix.
+ */
+ public static final String m_prefix =
+ "org.omg.PortableInterceptor.ORBInitializerClass.";
+
+ /**
+ * The initialization - time server request interceptors.
+ */
+ private ArrayList m_server = new ArrayList();
+
+ /**
+ * The initialization - time client request interceptors.
+ */
+ private ArrayList m_client = new ArrayList();
+
+ /**
+ * The initialization - time ior interceptors.
+ */
+ private ArrayList m_ior = new ArrayList();
+
+ /**
+ * The policy factories.
+ */
+ public Hashtable m_policyFactories = new Hashtable();
+
+ /**
+ * The registered references. To avoid exposing the ORB's references map, the
+ * are added by ORB from inside the ORB code. The ORB is responsible for
+ * taking them from this field between pre_init and post_init.
+ */
+ public TreeMap m_references = new TreeMap();
+
+ /**
+ * The initializers.
+ */
+ public ArrayList m_initializers = new ArrayList();
+
+ /**
+ * The ORB being intialised.
+ */
+ final ORB_1_4 orb;
+
+ /**
+ * The argument string array, passed to ORB.init.
+ */
+ final String[] m_args;
+
+ /**
+ * The codec factory.
+ */
+ final gnuCodecFactory m_codecFactory;
+
+ /**
+ * Create the interceptor collection from the given properties, using the
+ * agreed naming convention.
+ *
+ * @param an_orb the ORB being initialised.
+ * @param props the cumulated set of properties where the orb initializer
+ * pattern is searched.
+ * @param an_args the argument string array, passed to ORB.init.
+ */
+ public Registrator(ORB_1_4 an_orb, Properties props, String[] an_args)
+ {
+ orb = an_orb;
+ m_args = an_args;
+ m_codecFactory = new gnuCodecFactory(orb);
+ checkProperties(props);
+ checkProperties(System.getProperties());
+ checkFile("user.home", null);
+ checkFile("java.home", "lib");
+ }
+
+ /**
+ * Scan the given properties for the possible interceptors.
+ */
+ private void checkProperties(Properties props)
+ {
+ if (props == null)
+ {
+ return;
+ }
+
+ Enumeration names = props.propertyNames();
+ java.lang.Object key;
+ String sk;
+
+ while (names.hasMoreElements())
+ {
+ key = names.nextElement();
+ if (key != null)
+ {
+ sk = key.toString();
+ if (sk.startsWith(m_prefix))
+ {
+ try
+ {
+ String cn = sk.substring(m_prefix.length());
+ Class iClass = ObjectCreator.forName(cn);
+
+ ORBInitializer initializer =
+ (ORBInitializer) iClass.newInstance();
+ m_initializers.add(initializer);
+ }
+ catch (Exception exc)
+ {
+ // OMG states we should not throw an exception, but
+ // this will help the user to detect his error
+ // in initialiser properties. Should never print during
+ // normal run.
+ System.err.println(sk + " failed");
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Check if the property is defined in the existsting file orb.properties.
+ */
+ private void checkFile(String dir, String subdir)
+ {
+ try
+ {
+ File f = new File(dir);
+ if (!f.exists())
+ {
+ return;
+ }
+
+ if (subdir != null)
+ {
+ f = new File(f, subdir);
+ }
+ f = new File(f, "orb.properties");
+
+ if (!f.exists())
+ {
+ return;
+ }
+
+ Properties p = new Properties();
+ p.load(new BufferedInputStream(new FileInputStream(f)));
+
+ checkProperties(p);
+ }
+ catch (IOException ex)
+ {
+ }
+ }
+
+ /**
+ * Called by ORB as a pre_init for all initializers.
+ */
+ public void pre_init()
+ {
+ Iterator iter = m_initializers.iterator();
+ while (iter.hasNext())
+ {
+ ORBInitializerOperations initializer =
+ (ORBInitializerOperations) iter.next();
+ initializer.pre_init(this);
+ }
+ }
+
+ /**
+ * Get the map of the registered references. The ORB calls this method to
+ * import the references into its references map.
+ */
+ public Map getRegisteredReferences()
+ {
+ return m_references;
+ }
+
+ /**
+ * Called by ORB as a post-init for all initializers. After this call, the
+ * interceptor sets are fixed and redundant information is discarded.
+ */
+ public void post_init()
+ {
+ Iterator iter = m_initializers.iterator();
+ while (iter.hasNext())
+ {
+ ORBInitializerOperations initializer =
+ (ORBInitializerOperations) iter.next();
+ initializer.post_init(this);
+ }
+ }
+
+ public ServerRequestInterceptor[] getServerRequestInterceptors()
+ {
+ ServerRequestInterceptor[] iServer =
+ new ServerRequestInterceptor[ m_server.size() ];
+ for (int i = 0; i < iServer.length; i++)
+ {
+ iServer [ i ] = (ServerRequestInterceptor) m_server.get(i);
+ }
+ return iServer;
+ }
+
+ public ClientRequestInterceptor[] getClientRequestInterceptors()
+ {
+ ClientRequestInterceptor[] iClient =
+ new ClientRequestInterceptor[ m_client.size() ];
+ for (int i = 0; i < iClient.length; i++)
+ {
+ iClient [ i ] = (ClientRequestInterceptor) m_client.get(i);
+ }
+ return iClient;
+ }
+
+ public IORInterceptor[] getIORInterceptors()
+ {
+ IORInterceptor[] iIor = new IORInterceptor[ m_ior.size() ];
+ for (int i = 0; i < iIor.length; i++)
+ {
+ iIor [ i ] = (IORInterceptor) m_ior.get(i);
+ }
+ return iIor;
+ }
+
+ public void add_client_request_interceptor(
+ ClientRequestInterceptor interceptor
+ ) throws DuplicateName
+ {
+ add(m_client, interceptor);
+ }
+
+ public void add_ior_interceptor(IORInterceptor interceptor)
+ throws DuplicateName
+ {
+ add(m_ior, interceptor);
+ }
+
+ public void add_server_request_interceptor(
+ ServerRequestInterceptor interceptor
+ ) throws DuplicateName
+ {
+ add(m_server, interceptor);
+ }
+
+ /**
+ * Allocate a new slot for request - specific records.
+ */
+ public int allocate_slot_id()
+ {
+ return orb.icSlotSize++;
+ }
+
+ /**
+ * Add the interceptor to the given collection.
+ *
+ * @param list the collection to add.
+ * @param interceptor the interceptor to add.
+ */
+ private void add(ArrayList list, Interceptor interceptor)
+ throws DuplicateName
+ {
+ if (interceptor.name().length() > 0)
+ {
+ Iterator iter = list.iterator();
+ Interceptor ic;
+
+ while (iter.hasNext())
+ {
+ ic = (Interceptor) iter.next();
+ if (ic.name().equals(interceptor.name()))
+ {
+ throw new DuplicateName(interceptor.name());
+ }
+ }
+ }
+ list.add(interceptor);
+ }
+
+ /**
+ * Get string array, passed to ORB.init.
+ */
+ public String[] arguments()
+ {
+ return m_args;
+ }
+
+ /**
+ * Get the codec factory.
+ */
+ public CodecFactory codec_factory()
+ {
+ return m_codecFactory;
+ }
+
+ /**
+ * Get the ORB's id, currently using .toString.
+ */
+ public String orb_id()
+ {
+ return "orb_" + orb;
+ }
+
+ /**
+ * Register reference.
+ */
+ public void register_initial_reference(String object_name, Object object)
+ throws InvalidName
+ {
+ if (object_name == null)
+ {
+ throw new InvalidName("null");
+ }
+ else if (object_name.length() == 0)
+ {
+ throw new InvalidName("Empty string");
+ }
+ else if (m_references.containsKey(object_name))
+ {
+ throw new InvalidName(object_name);
+ }
+ else
+ {
+ m_references.put(object_name, object);
+ }
+ }
+
+ /**
+ * Accumulates the policy factory map.
+ */
+ public void register_policy_factory(int policy_type,
+ PolicyFactory policy_factory
+ )
+ {
+ Integer it = new Integer(policy_type);
+ if (m_policyFactories.containsKey(it))
+ {
+ throw new BAD_INV_ORDER(
+ "Repetetive registration of the policy factory for type " +
+ policy_type,
+ 16,
+ CompletionStatus.COMPLETED_NO
+ );
+ }
+ m_policyFactories.put(it, policy_factory);
+ }
+
+ /**
+ * Delegates to ORB.
+ */
+ public org.omg.CORBA.Object resolve_initial_references(String object_name)
+ throws InvalidName
+ {
+ try
+ {
+ return orb.resolve_initial_references(object_name);
+ }
+ catch (org.omg.CORBA.ORBPackage.InvalidName e)
+ {
+ InvalidName in = new InvalidName(e.getMessage());
+ in.initCause(e);
+ throw in;
+ }
+ }
+
+ /**
+ * Check if any interceptors of this type were registered.
+ */
+ public boolean hasClientRequestInterceptors()
+ {
+ return m_client.size() > 0;
+ }
+
+ /**
+ * Check if any interceptors of this type were registered.
+ */
+ public boolean hasServerRequestInterceptors()
+ {
+ return m_server.size() > 0;
+ }
+
+ /**
+ * Check if any interceptors of this type were registered.
+ */
+ public boolean hasIorInterceptors()
+ {
+ return m_ior.size() > 0;
+ }
+} \ No newline at end of file