001    /*
002     *  Licensed to the Apache Software Foundation (ASF) under one
003     *  or more contributor license agreements.  See the NOTICE file
004     *  distributed with this work for additional information
005     *  regarding copyright ownership.  The ASF licenses this file
006     *  to you under the Apache License, Version 2.0 (the
007     *  "License"); you may not use this file except in compliance
008     *  with 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,
013     *  software distributed under the License is distributed on an
014     *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015     *  KIND, either express or implied.  See the License for the
016     *  specific language governing permissions and limitations
017     *  under the License. 
018     *  
019     */
020    package org.apache.directory.shared.ldap.schema.registries;
021    
022    
023    import java.util.HashMap;
024    import java.util.Iterator;
025    import java.util.Map;
026    
027    import org.apache.directory.shared.i18n.I18n;
028    import org.apache.directory.shared.ldap.exception.LdapException;
029    import org.apache.directory.shared.ldap.schema.DITStructureRule;
030    import org.apache.directory.shared.ldap.schema.SchemaObject;
031    import org.apache.directory.shared.ldap.schema.SchemaObjectType;
032    import org.slf4j.Logger;
033    import org.slf4j.LoggerFactory;
034    
035    
036    /**
037     * A DITStructureRule registry's service default implementation.
038     *
039     * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
040     * @version $Rev: 828111 $
041     */
042    public class DefaultDITStructureRuleRegistry extends DefaultSchemaObjectRegistry<DITStructureRule>
043        implements DITStructureRuleRegistry
044    {
045        /** static class logger */
046        private static final Logger LOG = LoggerFactory.getLogger( DefaultDITStructureRuleRegistry.class );
047    
048        /** A speedup for debug */
049        private static final boolean DEBUG = LOG.isDebugEnabled();
050        
051        /** a map of DITStructureRule looked up by RuleId */
052        protected Map<Integer, DITStructureRule> byRuleId;
053        
054        /**
055         * Creates a new default NormalizerRegistry instance.
056         */
057        public DefaultDITStructureRuleRegistry()
058        {
059            super( SchemaObjectType.DIT_STRUCTURE_RULE, new OidRegistry() );
060            byRuleId = new HashMap<Integer, DITStructureRule>();
061        }
062    
063    
064        /**
065         * {@inheritDoc}
066         */
067        public boolean contains( int ruleId )
068        {
069            return byRuleId.containsKey( ruleId );
070        }
071    
072        
073        /**
074         * {@inheritDoc}
075         */
076        public Iterator<DITStructureRule> iterator()
077        {
078            return byRuleId.values().iterator();
079        }
080        
081        
082        /**
083         * {@inheritDoc}
084         */
085        public Iterator<Integer> ruleIdIterator()
086        {
087            return byRuleId.keySet().iterator();
088        }
089        
090        
091        /**
092         * {@inheritDoc}
093         */
094        public String getSchemaName( int ruleId ) throws LdapException
095        {
096            DITStructureRule ditStructureRule = byRuleId.get( ruleId );
097    
098            if ( ditStructureRule != null )
099            {
100                return ditStructureRule.getSchemaName();
101            }
102            
103            String msg = I18n.err( I18n.ERR_04263, ruleId );
104            LOG.warn( msg );
105            throw new LdapException( msg );
106        }
107    
108        
109        /**
110         * {@inheritDoc}
111         */
112        public void register( DITStructureRule ditStructureRule ) throws LdapException
113        {
114            int ruleId = ditStructureRule.getRuleId();
115            
116            if ( byRuleId.containsKey( ruleId ) )
117            {
118                String msg = I18n.err( I18n.ERR_04264, ruleId );
119                LOG.warn( msg );
120                throw new LdapException( msg );
121            }
122    
123            byRuleId.put( ruleId, ditStructureRule );
124            
125            if ( LOG.isDebugEnabled() )
126            {
127                LOG.debug( "registered {} for OID {}", ditStructureRule, ruleId );
128            }
129        }
130    
131        
132        /**
133         * {@inheritDoc}
134         */
135        public DITStructureRule lookup( int ruleId ) throws LdapException
136        {
137            DITStructureRule ditStructureRule = byRuleId.get( ruleId );
138    
139            if ( ditStructureRule == null )
140            {
141                String msg = I18n.err( I18n.ERR_04265, ruleId );
142                LOG.debug( msg );
143                throw new LdapException( msg );
144            }
145    
146            if ( DEBUG )
147            {
148                LOG.debug( "Found {} with ruleId: {}", ditStructureRule, ruleId );
149            }
150            
151            return ditStructureRule;
152        }
153    
154    
155        /**
156         * {@inheritDoc}
157         */
158        public void unregister( int ruleId ) throws LdapException
159        {
160            DITStructureRule ditStructureRule = byRuleId.remove( ruleId );
161            
162            if ( DEBUG )
163            {
164                LOG.debug( "Removed {} with ruleId {} from the registry", ditStructureRule, ruleId );
165            }
166        }
167        
168        
169        /**
170         * {@inheritDoc}
171         */
172        public void unregisterSchemaElements( String schemaName )
173        {
174            if ( schemaName == null )
175            {
176                return;
177            }
178            
179            // Loop on all the SchemaObjects stored and remove those associated
180            // with the give schemaName
181            for ( DITStructureRule ditStructureRule : this )
182            {
183                if ( schemaName.equalsIgnoreCase( ditStructureRule.getSchemaName() ) )
184                {
185                    int ruleId = ditStructureRule.getRuleId();
186                    SchemaObject removed = byRuleId.remove( ruleId );
187                    
188                    if ( DEBUG )
189                    {
190                        LOG.debug( "Removed {} with ruleId {} from the registry", removed, ruleId );
191                    }
192                }
193            }
194        }
195    
196        
197        /**
198         * {@inheritDoc}
199         */
200        public void renameSchema( String originalSchemaName, String newSchemaName )
201        {
202            // Loop on all the SchemaObjects stored and remove those associated
203            // with the give schemaName
204            for ( DITStructureRule ditStructureRule : this )
205            {
206                if ( originalSchemaName.equalsIgnoreCase( ditStructureRule.getSchemaName() ) )
207                {
208                    ditStructureRule.setSchemaName( newSchemaName );
209    
210                    if ( DEBUG )
211                    {
212                        LOG.debug( "Renamed {} schemaName to {}", ditStructureRule, newSchemaName );
213                    }
214                }
215            }
216        }
217        
218        
219        /**
220         * {@inheritDoc}
221         */
222        public DefaultDITStructureRuleRegistry copy()
223        {
224            DefaultDITStructureRuleRegistry copy = new DefaultDITStructureRuleRegistry();
225            
226            // Copy the base data
227            copy.copy( this );
228            
229            return copy;
230        }
231    }