1 /*
2 * Copyright (C) The JContainer Group. All rights reserved.
3 *
4 * This software is published under the terms of the JContainer
5 * Software License version 1.1, a copy of which has been included
6 * with this distribution in the LICENSE.txt file.
7 */
8 package org.jcontainer.dna.impl;
9
10 import org.jcontainer.dna.Active;
11 import org.jcontainer.dna.Composable;
12 import org.jcontainer.dna.Configurable;
13 import org.jcontainer.dna.Configuration;
14 import org.jcontainer.dna.ConfigurationException;
15 import org.jcontainer.dna.LogEnabled;
16 import org.jcontainer.dna.Logger;
17 import org.jcontainer.dna.MissingResourceException;
18 import org.jcontainer.dna.ParameterException;
19 import org.jcontainer.dna.Parameterizable;
20 import org.jcontainer.dna.Parameters;
21 import org.jcontainer.dna.ResourceLocator;
22
23 /***
24 * Utility class to make it easier to process a object
25 * through its lifecycle stages.
26 *
27 * @version $Revision: 1.4 $ $Date: 2003/09/23 08:10:14 $
28 */
29 public class ContainerUtil
30 {
31 /***
32 * Supply specified object with Logger if it implements the
33 * LogEnabled interface.
34 *
35 * @param object the object to process
36 * @param logger the logger. If null then the specified object must
37 * not implement LogEnabled.
38 * @throws IllegalArgumentException if the object is LogEnabled and
39 * Logger is null
40 */
41 public static void enableLogging( final Object object,
42 final Logger logger )
43 {
44 if( object instanceof LogEnabled )
45 {
46 if( null == logger )
47 {
48 final String message = "Null logger.";
49 throw new IllegalArgumentException( message );
50 }
51 ( (LogEnabled)object ).enableLogging( logger );
52 }
53 }
54
55 /***
56 * Supply specified object with ResourceLocator if it implements the
57 * Composable interface.
58 *
59 * @param object the object to process
60 * @param locator the ResourceLocator. If null then the specified
61 * object must not implement Composable.
62 * @throws IllegalArgumentException if the object is Composable
63 * and locator is null
64 * @throws MissingResourceException if processing lifecycle stage on
65 * object throws exception
66 */
67 public static void compose( final Object object,
68 final ResourceLocator locator )
69 throws MissingResourceException
70 {
71 if( object instanceof Composable )
72 {
73 if( null == locator )
74 {
75 final String message = "Null locator.";
76 throw new IllegalArgumentException( message );
77 }
78 ( (Composable)object ).compose( locator );
79 }
80 }
81
82 /***
83 * Supply specified object with Configuration if it implements the
84 * Configurable interface.
85 *
86 * @param object the object to process
87 * @param configuration the Configuration. If null then the specified
88 * object must not implement Configurable.
89 * @throws IllegalArgumentException if the object is Configurable
90 * and configuration is null
91 * @throws ConfigurationException if processing lifecycle stage on
92 * object throws exception
93 */
94 public static void configure( final Object object,
95 final Configuration configuration )
96 throws ConfigurationException
97 {
98 if( object instanceof Configurable )
99 {
100 if( null == configuration )
101 {
102 final String message = "Null configuration.";
103 throw new IllegalArgumentException( message );
104 }
105 ( (Configurable)object ).configure( configuration );
106 }
107 }
108
109 /***
110 * Supply specified object with Parameters if it implements the
111 * Parameterizable interface.
112 *
113 * @param object the object to process
114 * @param parameters the Parameters. If null then the specified
115 * object must not implement Parameterizable.
116 * @throws IllegalArgumentException if the object is Parameterizable
117 * and parameters is null
118 * @throws ParameterException if processing lifecycle stage on
119 * object throws exception
120 */
121 public static void parameterize( final Object object,
122 final Parameters parameters )
123 throws ParameterException
124 {
125 if( object instanceof Parameterizable )
126 {
127 if( null == parameters )
128 {
129 final String message = "Null parameters.";
130 throw new IllegalArgumentException( message );
131 }
132 ( (Parameterizable)object ).parameterize( parameters );
133 }
134 }
135
136 /***
137 * Initialize specified object if it implements the
138 * Active interface.
139 *
140 * @param object the object to process
141 * @throws Exception if processing lifecycle stage on
142 * object throws exception
143 */
144 public static void initialize( final Object object )
145 throws Exception
146 {
147 if( object instanceof Active )
148 {
149 ( (Active)object ).initialize();
150 }
151 }
152
153 /***
154 * Dispose specified object if it implements the
155 * Active interface.
156 *
157 * @param object the object to process
158 * @throws Exception if processing lifecycle stage on
159 * object throws exception
160 */
161 public static void dispose( final Object object )
162 throws Exception
163 {
164 if( object instanceof Active )
165 {
166 ( (Active)object ).dispose();
167 }
168 }
169 }
This page was automatically generated by Maven