cms/util/ReferenceManager.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.refman;

//---IMPORTS---
import org.omg.CORBA.ORB;
import org.omg.CosNaming.*;
import org.omg.PortableServer.*;
import uk.ac.ukc.iscream.core.*;

/**
 * This class returns references for global system objects.
 * This class is used to create and return references to objects
 * that are required throughout the system.  Most of which
 * are CORBA based.  It also handles ORB initialisation.
 *
 * It is a singleton object with a static method to obtain a
 * reference to it.  This removes the need for passing
 * references to all the objects it contains throughout 
 * a component.
 *
 * @author  $Author: tdb1 $
 * @version $Id: TemplateClass.java,v 1.5 2000/11/13 18:20:09 tdb1 Exp $
 */
public class ReferenceManager {

//---FINAL ATTRIBUTES---
   
    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.5 $";
    
//---STATIC METHODS---

    /**
     * This essentially formats the toString() source for an
     * object wanting to make a log entry.
     *
     * @param source the source of the call
     * @param rev the CVS revision number of the caller
     *
     * @return the formatted string
    
    public static String logString(Object source, String rev) {
        if (_instance == null) {
            return "unamed{" + source.getClass().getName() + "}(" + rev.substring(11, rev.length() - 2) + ")";
        }
        return getInstance().getName() + "{" + source.getClass().getName() + "}(" + rev.substring(11, rev.length() - 2) + ")";
    }
`    */

    /**
     * This creates the single instance of the ReferenceManager by
     * calling the private constructor.  If it is called twice, 
     * it detects an instance already exits and throws an exception.
     *
     * @param args the args to be passed to the ORB
     * @param name the name of the component that will use this singleton
     *
     * @return a reference to the ReferenceManager
     *
     * @throws AlreadyInitialisedException if this method has already been called
     */
    public static ReferenceManager init(String[] args, String name) throws AlreadyInitialisedException {
        if (_instance != null) {
            throw new AlreadyInitialisedException("init has already been called");
        }
        _instance = new ReferenceManager(args, name);
        return _instance;
    }
    
    /**
     * This returns a reference to the single instance of the
     * ReferenceManager.
     *
     * @return a reference to the ReferenceManager
     *
     * @throws NotInitialisedException if the reference manager has not been initialised
     */
    public static ReferenceManager getInstance() throws NotInitialisedException {
        if (_instance == null) {
            throw new NotInitialisedException("attempt to obtain reference when not initialised");
        }
        return _instance;
    }

//---CONSTRUCTORS---

    /**
     * This is a private constructor
     * This ensures that the system performs according to a Singleton design pattern
     *
     * @param args the args to be passed to the ORB
     * @param name the name of the component that will use this singleton
     */
    private ReferenceManager(String[] args, String name) {
        _orb = ORB.init(args, null);
        _name = name;
        getLogger().write(toString(), Logger.SYSINIT, "created");
    }

//---PUBLIC METHODS---

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return getName() + "{" + getClass().getName() + "}(" + REVISION.substring(11, REVISION.length() - 2) + ")";
    }

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---

    /**
     * Returns a reference to the ORB
     *
     * @return the reference this class holds
     */
    public ORB getORB() {
        return _orb;
    }

    /**
     * Returns a reference to the Root POA
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public POA getRootPOA() {
        if (_rootPOA == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getORB().resolve_initial_references("RootPOA");
            } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
                throw new RuntimeException("CRITICAL:Unable to resolve reference to the RootPOA!\n" + 
                                           "         This indicates an error with your ORB.");
            }
            _rootPOA = POAHelper.narrow(objRef);
        }
        return _rootPOA;
    }
    
    /**
     * Returns a reference to the Naming Service
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public NamingContextExt getNS() {
        if (_ns == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getORB().resolve_initial_references("NameService");
            } catch (org.omg.CORBA.ORBPackage.InvalidName e) {
                throw new RuntimeException("CRITICAL:Unable to resolve reference to the Naming Service!\n" +
                                           "         Please check with your CORBA naming service provider.");
            }
            _ns = NamingContextExtHelper.narrow(objRef);
        }
        return _ns;
    }
    
    /**
     * Returns a reference to the configuration manager
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public ConfigurationManager getCM() {
        if (_cm == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getNS().resolve(getNS().to_name("iscream.ConfigurationManager"));
            } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
                throw new RuntimeException("CRITICAL:Cannot Proceed - when resolving reference to iscream.ConfigurationManager!\n" + 
                                           "         This indicates an error with your ORB.");
            } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
                throw new RuntimeException("CRITICAL:Invalid Name - when resolving reference to iscream.ConfigurationManager!\n" + 
                                           "         This indicates an error with your ORB.");
            } catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
                throw new RuntimeException("CRITICAL:Not Found - when resolving reference to iscream.ConfigurationManager!\n" + 
                                           "         Please check that this component is running.");
            }
            _cm = ConfigurationManagerHelper.narrow(objRef);
        }
        return _cm;
    }

    /**
     * Returns a reference to the logger
     * This will throw a RuntimeException if there is an error
     *
     * @return the reference this class holds
     */
    public Logger getLogger() {
        if (_logger == null) {
            org.omg.CORBA.Object objRef = null;
            try {
                objRef = getNS().resolve(getNS().to_name("iscream.Logger"));
            } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
                throw new RuntimeException("CRITICAL:Cannot Proceed - when resolving reference to iscream.Logger!\n" + 
                                           "         This indicates an error with your ORB.");
            } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
                throw new RuntimeException("CRITICAL:Invalid Name - when resolving reference to iscream.Logger!\n" + 
                                           "         This indicates an error with your ORB.");
            } catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
                throw new RuntimeException("CRITICAL:Not Found - when resolving reference to iscream.Logger!\n" + 
                                           "         Please check that this component is running.");
            }
            _logger = LoggerHelper.narrow(objRef);
        }
        return _logger;
    }
    
    /**
     * Returns a reference to the name
     *
     * @return the reference this class holds
     */
    public String getName() {
        return _name;
    }

//---ATTRIBUTES---
    
    /**
     * The ORB
     */
    private ORB _orb;
    
    /**
     * The Naming Service
     */
    private NamingContextExt _ns;
    
    /**
     * The Root POA
     */
    private POA _rootPOA;

    /**
     * The configuration manager
     */
    private ConfigurationManager _cm;

    /**
     * The logger
     */
    private Logger _logger;
    
    /**
     * The name
     */
    private String _name;

//---STATIC ATTRIBUTES---
    
    /**
     * A reference to the single instance of this class
     */
    private static ReferenceManager _instance; 
}
Revision:	1.1
Committed:	Thu Nov 30 00:54:27 2000 UTC (23 years, 5 months ago) by ajm
Branch:	MAIN
Log Message:	initial checkin
#	User	Rev	Content
1	ajm	1.1	//---PACKAGE DECLARATION---
2			package uk.ac.ukc.iscream.refman;
3
4			//---IMPORTS---
5			import org.omg.CORBA.ORB;
6			import org.omg.CosNaming.*;
7			import org.omg.PortableServer.*;
8			import uk.ac.ukc.iscream.core.*;
9
10			/**
11			* This class returns references for global system objects.
12			* This class is used to create and return references to objects
13			* that are required throughout the system. Most of which
14			* are CORBA based. It also handles ORB initialisation.
15			*
16			* It is a singleton object with a static method to obtain a
17			* reference to it. This removes the need for passing
18			* references to all the objects it contains throughout
19			* a component.
20			*
21			* @author $Author: tdb1 $
22			* @version $Id: TemplateClass.java,v 1.5 2000/11/13 18:20:09 tdb1 Exp $
23			*/
24			public class ReferenceManager {
25
26			//---FINAL ATTRIBUTES---
27
28			/**
29			* The current CVS revision of this class
30			*/
31			public final String REVISION = "$Revision: 1.5 $";
32
33			//---STATIC METHODS---
34
35			/**
36			* This essentially formats the toString() source for an
37			* object wanting to make a log entry.
38			*
39			* @param source the source of the call
40			* @param rev the CVS revision number of the caller
41			*
42			* @return the formatted string
43
44			public static String logString(Object source, String rev) {
45			if (_instance == null) {
46			return "unamed{" + source.getClass().getName() + "}(" + rev.substring(11, rev.length() - 2) + ")";
47			}
48			return getInstance().getName() + "{" + source.getClass().getName() + "}(" + rev.substring(11, rev.length() - 2) + ")";
49			}
50			` */
51
52			/**
53			* This creates the single instance of the ReferenceManager by
54			* calling the private constructor. If it is called twice,
55			* it detects an instance already exits and throws an exception.
56			*
57			* @param args the args to be passed to the ORB
58			* @param name the name of the component that will use this singleton
59			*
60			* @return a reference to the ReferenceManager
61			*
62			* @throws AlreadyInitialisedException if this method has already been called
63			*/
64			public static ReferenceManager init(String[] args, String name) throws AlreadyInitialisedException {
65			if (_instance != null) {
66			throw new AlreadyInitialisedException("init has already been called");
67			}
68			_instance = new ReferenceManager(args, name);
69			return _instance;
70			}
71
72			/**
73			* This returns a reference to the single instance of the
74			* ReferenceManager.
75			*
76			* @return a reference to the ReferenceManager
77			*
78			* @throws NotInitialisedException if the reference manager has not been initialised
79			*/
80			public static ReferenceManager getInstance() throws NotInitialisedException {
81			if (_instance == null) {
82			throw new NotInitialisedException("attempt to obtain reference when not initialised");
83			}
84			return _instance;
85			}
86
87			//---CONSTRUCTORS---
88
89			/**
90			* This is a private constructor
91			* This ensures that the system performs according to a Singleton design pattern
92			*
93			* @param args the args to be passed to the ORB
94			* @param name the name of the component that will use this singleton
95			*/
96			private ReferenceManager(String[] args, String name) {
97			_orb = ORB.init(args, null);
98			_name = name;
99			getLogger().write(toString(), Logger.SYSINIT, "created");
100			}
101
102			//---PUBLIC METHODS---
103
104			/**
105			* Overrides the {@link java.lang.Object#toString() Object.toString()}
106			* method to provide clean logging (every class should have this).
107			*
108			* @return the name of this class and its CVS revision
109			*/
110			public String toString() {
111			return getName() + "{" + getClass().getName() + "}(" + REVISION.substring(11, REVISION.length() - 2) + ")";
112			}
113
114			//---PRIVATE METHODS---
115
116			//---ACCESSOR/MUTATOR METHODS---
117
118			/**
119			* Returns a reference to the ORB
120			*
121			* @return the reference this class holds
122			*/
123			public ORB getORB() {
124			return _orb;
125			}
126
127			/**
128			* Returns a reference to the Root POA
129			* This will throw a RuntimeException if there is an error
130			*
131			* @return the reference this class holds
132			*/
133			public POA getRootPOA() {
134			if (_rootPOA == null) {
135			org.omg.CORBA.Object objRef = null;
136			try {
137			objRef = getORB().resolve_initial_references("RootPOA");
138			} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
139			throw new RuntimeException("CRITICAL:Unable to resolve reference to the RootPOA!\n" +
140			" This indicates an error with your ORB.");
141			}
142			_rootPOA = POAHelper.narrow(objRef);
143			}
144			return _rootPOA;
145			}
146
147			/**
148			* Returns a reference to the Naming Service
149			* This will throw a RuntimeException if there is an error
150			*
151			* @return the reference this class holds
152			*/
153			public NamingContextExt getNS() {
154			if (_ns == null) {
155			org.omg.CORBA.Object objRef = null;
156			try {
157			objRef = getORB().resolve_initial_references("NameService");
158			} catch (org.omg.CORBA.ORBPackage.InvalidName e) {
159			throw new RuntimeException("CRITICAL:Unable to resolve reference to the Naming Service!\n" +
160			" Please check with your CORBA naming service provider.");
161			}
162			_ns = NamingContextExtHelper.narrow(objRef);
163			}
164			return _ns;
165			}
166
167			/**
168			* Returns a reference to the configuration manager
169			* This will throw a RuntimeException if there is an error
170			*
171			* @return the reference this class holds
172			*/
173			public ConfigurationManager getCM() {
174			if (_cm == null) {
175			org.omg.CORBA.Object objRef = null;
176			try {
177			objRef = getNS().resolve(getNS().to_name("iscream.ConfigurationManager"));
178			} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
179			throw new RuntimeException("CRITICAL:Cannot Proceed - when resolving reference to iscream.ConfigurationManager!\n" +
180			" This indicates an error with your ORB.");
181			} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
182			throw new RuntimeException("CRITICAL:Invalid Name - when resolving reference to iscream.ConfigurationManager!\n" +
183			" This indicates an error with your ORB.");
184			} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
185			throw new RuntimeException("CRITICAL:Not Found - when resolving reference to iscream.ConfigurationManager!\n" +
186			" Please check that this component is running.");
187			}
188			_cm = ConfigurationManagerHelper.narrow(objRef);
189			}
190			return _cm;
191			}
192
193			/**
194			* Returns a reference to the logger
195			* This will throw a RuntimeException if there is an error
196			*
197			* @return the reference this class holds
198			*/
199			public Logger getLogger() {
200			if (_logger == null) {
201			org.omg.CORBA.Object objRef = null;
202			try {
203			objRef = getNS().resolve(getNS().to_name("iscream.Logger"));
204			} catch (org.omg.CosNaming.NamingContextPackage.CannotProceed e) {
205			throw new RuntimeException("CRITICAL:Cannot Proceed - when resolving reference to iscream.Logger!\n" +
206			" This indicates an error with your ORB.");
207			} catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {
208			throw new RuntimeException("CRITICAL:Invalid Name - when resolving reference to iscream.Logger!\n" +
209			" This indicates an error with your ORB.");
210			} catch (org.omg.CosNaming.NamingContextPackage.NotFound e) {
211			throw new RuntimeException("CRITICAL:Not Found - when resolving reference to iscream.Logger!\n" +
212			" Please check that this component is running.");
213			}
214			_logger = LoggerHelper.narrow(objRef);
215			}
216			return _logger;
217			}
218
219			/**
220			* Returns a reference to the name
221			*
222			* @return the reference this class holds
223			*/
224			public String getName() {
225			return _name;
226			}
227
228			//---ATTRIBUTES---
229
230			/**
231			* The ORB
232			*/
233			private ORB _orb;
234
235			/**
236			* The Naming Service
237			*/
238			private NamingContextExt _ns;
239
240			/**
241			* The Root POA
242			*/
243			private POA _rootPOA;
244
245			/**
246			* The configuration manager
247			*/
248			private ConfigurationManager _cm;
249
250			/**
251			* The logger
252			*/
253			private Logger _logger;
254
255			/**
256			* The name
257			*/
258			private String _name;
259
260			//---STATIC ATTRIBUTES---
261
262			/**
263			* A reference to the single instance of this class
264			*/
265			private static ReferenceManager _instance;
266			}