    001    /* $Id: ObjectCreateRule.java 729106 2008-12-23 20:48:09Z rahul $
    002     *
    003     * Licensed to the Apache Software Foundation (ASF) under one or more
    004     * contributor license agreements.  See the NOTICE file distributed with
    005     * this work for additional information regarding copyright ownership.
    006     * The ASF licenses this file to You under the Apache License, Version 2.0
    007     * (the "License"); you may not use this file except in compliance with
    008     * the License.  You may obtain a copy of the License at
    009     *
    010     *      http://www.apache.org/licenses/LICENSE-2.0
    011     *
    012     * Unless required by applicable law or agreed to in writing, software
    013     * distributed under the License is distributed on an "AS IS" BASIS,
    014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    015     * See the License for the specific language governing permissions and
    016     * limitations under the License.
    017     */
    018
    019
    020    package org.apache.commons.digester;
    021
    022
    023    import org.xml.sax.Attributes;
    024
    025
    026    /**
    027     * Rule implementation that creates a new object and pushes it
    028     * onto the object stack.  When the element is complete, the
    029     * object will be popped
    030     */
    031
    032    public class ObjectCreateRule extends Rule {
    033
    034
    035        // ----------------------------------------------------------- Constructors
    036
    037
    038        /**
    039         * Construct an object create rule with the specified class name.
    040         *
    041         * @param digester The associated Digester
    042         * @param className Java class name of the object to be created
    043         *
    044         * @deprecated The digester instance is now set in the {@link Digester#addRule} method.
    045         * Use {@link #ObjectCreateRule(String className)} instead.
    046         */
    047        public ObjectCreateRule(Digester digester, String className) {
    048
    049            this(className);
    050
    051        }
    052
    053
    054        /**
    055         * Construct an object create rule with the specified class.
    056         *
    057         * @param digester The associated Digester
    058         * @param clazz Java class name of the object to be created
    059         *
    060         * @deprecated The digester instance is now set in the {@link Digester#addRule} method.
    061         * Use {@link #ObjectCreateRule(Class clazz)} instead.
    062         */
    063        public ObjectCreateRule(Digester digester, Class<?> clazz) {
    064
    065            this(clazz);
    066
    067        }
    068
    069
    070        /**
    071         * Construct an object create rule with the specified class name and an
    072         * optional attribute name containing an override.
    073         *
    074         * @param digester The associated Digester
    075         * @param className Java class name of the object to be created
    076         * @param attributeName Attribute name which, if present, contains an
    077         *  override of the class name to create
    078         *
    079         * @deprecated The digester instance is now set in the {@link Digester#addRule} method.
    080         * Use {@link #ObjectCreateRule(String className, String attributeName)} instead.
    081         */
    082        public ObjectCreateRule(Digester digester, String className,
    083                                String attributeName) {
    084
    085            this (className, attributeName);
    086
    087        }
    088
    089
    090        /**
    091         * Construct an object create rule with the specified class and an
    092         * optional attribute name containing an override.
    093         *
    094         * @param digester The associated Digester
    095         * @param attributeName Attribute name which, if present, contains an
    096         * @param clazz Java class name of the object to be created
    097         *  override of the class name to create
    098         *
    099         * @deprecated The digester instance is now set in the {@link Digester#addRule} method.
    100         * Use {@link #ObjectCreateRule(String attributeName, Class clazz)} instead.
    101         */
    102        public ObjectCreateRule(Digester digester,
    103                                String attributeName,
    104                                Class<?> clazz) {
    105
    106            this(attributeName, clazz);
    107
    108        }
    109
    110        /**
    111         * Construct an object create rule with the specified class name.
    112         *
    113         * @param className Java class name of the object to be created
    114         */
    115        public ObjectCreateRule(String className) {
    116
    117            this(className, (String) null);
    118
    119        }
    120
    121
    122        /**
    123         * Construct an object create rule with the specified class.
    124         *
    125         * @param clazz Java class name of the object to be created
    126         */
    127        public ObjectCreateRule(Class<?> clazz) {
    128
    129            this(clazz.getName(), (String) null);
    130
    131        }
    132
    133
    134        /**
    135         * Construct an object create rule with the specified class name and an
    136         * optional attribute name containing an override.
    137         *
    138         * @param className Java class name of the object to be created
    139         * @param attributeName Attribute name which, if present, contains an
    140         *  override of the class name to create
    141         */
    142        public ObjectCreateRule(String className,
    143                                String attributeName) {
    144
    145            this.className = className;
    146            this.attributeName = attributeName;
    147
    148        }
    149
    150
    151        /**
    152         * Construct an object create rule with the specified class and an
    153         * optional attribute name containing an override.
    154         *
    155         * @param attributeName Attribute name which, if present, contains an
    156         * @param clazz Java class name of the object to be created
    157         *  override of the class name to create
    158         */
    159        public ObjectCreateRule(String attributeName,
    160                                Class<?> clazz) {
    161
    162            this(clazz.getName(), attributeName);
    163
    164        }
    165
    166        // ----------------------------------------------------- Instance Variables
    167
    168
    169        /**
    170         * The attribute containing an override class name if it is present.
    171         */
    172        protected String attributeName = null;
    173
    174
    175        /**
    176         * The Java class name of the object to be created.
    177         */
    178        protected String className = null;
    179
    180
    181        // --------------------------------------------------------- Public Methods
    182
    183
    184        /**
    185         * Process the beginning of this element.
    186         *
    187         * @param attributes The attribute list of this element
    188         */
    189        public void begin(Attributes attributes) throws Exception {
    190
    191            // Identify the name of the class to instantiate
    192            String realClassName = className;
    193            if (attributeName != null) {
    194                String value = attributes.getValue(attributeName);
    195                if (value != null) {
    196                    realClassName = value;
    197                }
    198            }
    199            if (digester.log.isDebugEnabled()) {
    200                digester.log.debug("[ObjectCreateRule]{" + digester.match +
    201                        "}New " + realClassName);
    202            }
    203
    204            // Instantiate the new object and push it on the context stack
    205            Class<?> clazz = digester.getClassLoader().loadClass(realClassName);
    206            Object instance = clazz.newInstance();
    207            digester.push(instance);
    208
    209        }
    210
    211
    212        /**
    213         * Process the end of this element.
    214         */
    215        public void end() throws Exception {
    216
    217            Object top = digester.pop();
    218            if (digester.log.isDebugEnabled()) {
    219                digester.log.debug("[ObjectCreateRule]{" + digester.match +
    220                        "} Pop " + top.getClass().getName());
    221            }
    222
    223        }
    224
    225
    226        /**
    227         * Render a printable version of this Rule.
    228         */
    229        public String toString() {
    230
    231            StringBuffer sb = new StringBuffer("ObjectCreateRule[");
    232            sb.append("className=");
    233            sb.append(className);
    234            sb.append(", attributeName=");
    235            sb.append(attributeName);
    236            sb.append("]");
    237            return (sb.toString());
    238
    239        }
    240
    241
    242    }