Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  // Copyright 2006, 2007, 2008, 2009, 2010 The Apache Software Foundation
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package org.apache.tapestry5.internal.model;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 public final class MutableComponentModelImpl implements MutableComponentModel
 {
     private final ComponentModel parentModel;
 
     private final Resource baseResource;
 
     private final String componentClassName;
 
     private final IdAllocator persistentFieldNameAllocator = new IdAllocator();
 
     private final Logger logger;
 
     private Map<StringParameterModelparameters;
 
     private Map<StringEmbeddedComponentModelembeddedComponents;

    
Maps from field name to strategy.
 
     private Map<StringStringpersistentFields;
 
     private List<StringmixinClassNames;
 
     private Map<StringString[]> mixinOrders;
 
     private boolean informalParametersSupported;
 
     private boolean mixinAfter;
 
     private Map<StringStringmetaData;
 
     private Set<ClasshandledRenderPhases;
 
     private Map<StringBooleanhandledEvents;
 
     public MutableComponentModelImpl(String componentClassNameLogger logger,
             Resource baseResourceComponentModel parentModel)
     {
         this. = componentClassName;
         this. = logger;
         this. = baseResource;
         this. = parentModel;
 
         // Pre-allocate names from the parent, to avoid name collisions.
 
         if (this. != null)
         {
             for (String name : this..getPersistentFieldNames())
             {
                 .allocateId(name);
             }
         }
     }
 
     @Override
     public String toString()
     {
         return String.format("ComponentModel[%s]");
     }
 
     public Logger getLogger()
     {
         return ;
    }
    public Resource getBaseResource()
    {
        return ;
    }
    public String getComponentClassName()
    {
        return ;
    }
    public void addParameter(String nameboolean requiredboolean allowNull,
            String defaultBindingPrefixboolean cached)
    {
        assert InternalUtils.isNonBlank(name);
        assert InternalUtils.isNonBlank(defaultBindingPrefix);
        if ( == null)
             = CollectionFactory.newCaseInsensitiveMap();
        if (.containsKey(name))
            throw new IllegalArgumentException(ModelMessages.duplicateParameter(name,
                    ));
        .put(namenew ParameterModelImpl(namerequiredallowNull,
                defaultBindingPrefixcached));
    }
    public void addParameter(String nameboolean requiredboolean allowNull,
            String defaultBindingPrefix)
    {
        // assume /false/ for the default because:
        // if the parameter is actually cached, the only effect will be to reduce that optimization
        // in certain
        // scenarios (mixin BindParameter). But if the value is NOT cached but we say it is,
        // we'll get incorrect behavior.
        addParameter(namerequiredallowNulldefaultBindingPrefixfalse);
    }
    public ParameterModel getParameterModel(String parameterName)
    {
        ParameterModel result = InternalUtils.get(parameterName.toLowerCase());
        if (result == null &&  != null)
            result = .getParameterModel(parameterName);
        return result;
    }
    
    public boolean isFormalParameter(String parameterName)
    {
        return getParameterModel(parameterName) != null;
    }
    public List<StringgetParameterNames()
    {
        List<Stringnames = CollectionFactory.newList();
        if ( != null)
            names.addAll(.keySet());
        if ( != null)
            names.addAll(.getParameterNames());
        Collections.sort(names);
        return names;
    }
    {
        return InternalUtils.sortedKeys();
    }
            String componentClassNameboolean inheritInformalParametersLocation location)
    {
        // TODO: Parent compent model? Or would we simply override the parent?
        if ( == null)
             = CollectionFactory.newCaseInsensitiveMap();
        else if (.containsKey(id))
            throw new IllegalArgumentException(ModelMessages.duplicateComponentId(id,
                    this.));
        MutableEmbeddedComponentModel embedded = new MutableEmbeddedComponentModelImpl(idtype,
                componentClassNamethis.inheritInformalParameterslocation);
        .put(idembedded);
        return embedded// So that parameters can be filled in
    }
    {
        List<Stringresult = CollectionFactory.newList();
        if ( != null)
            result.addAll(.keySet());
        if ( != null)
            result.addAll(.getEmbeddedComponentIds());
        Collections.sort(result);
        return result;
    }
    {
        EmbeddedComponentModel result = InternalUtils.get(componentId);
        if (result == null &&  != null)
            result = .getEmbeddedComponentModel(componentId);
        return result;
    }
    public String getFieldPersistenceStrategy(String fieldName)
    {
        String result = InternalUtils.get(fieldName);
        if (result == null &&  != null)
            result = .getFieldPersistenceStrategy(fieldName);
        if (result == null)
            throw new IllegalArgumentException(ModelMessages.missingPersistentField(fieldName));
        return result;
    }
    {
    }
    public String setFieldPersistenceStrategy(String fieldNameString strategy)
    {
        String logicalFieldName = .allocateId(fieldName);
        if ( == null)
             = CollectionFactory.newMap();
        .put(logicalFieldNamestrategy);
        return logicalFieldName;
    }
    public boolean isRootClass()
    {
        return  == null;
    }
    public void addMixinClassName(String mixinClassNameString... order)
    {
        if ( == null)
             = CollectionFactory.newList();
        .add(mixinClassName);
        if (order != null && order.length > 0)
        {
            if ( == null)
                 = CollectionFactory.newCaseInsensitiveMap();
            .put(mixinClassNameorder);
        }
    }
    public List<StringgetMixinClassNames()
    {
        List<Stringresult = CollectionFactory.newList();
        if ( != null)
            result.addAll();
        if ( != null)
            result.addAll(.getMixinClassNames());
        Collections.sort(result);
        return result;
    }
    public void enableSupportsInformalParameters()
    {
         = true;
    }
    public boolean getSupportsInformalParameters()
    {
        return ;
    }
    {
        return ;
    }
    public boolean isMixinAfter()
    {
        return ;
    }
    public void setMixinAfter(boolean mixinAfter)
    {
        this. = mixinAfter;
    }
    public void setMeta(String keyString value)
    {
        assert InternalUtils.isNonBlank(key);
        assert InternalUtils.isNonBlank(value);
        if ( == null)
             = CollectionFactory.newCaseInsensitiveMap();
        // TODO: Error if duplicate?
        .put(keyvalue);
    }
    public void addRenderPhase(Class renderPhase)
    {
        assert renderPhase != null;
        if ( == null)
             = CollectionFactory.newSet();
        .add(renderPhase);
    }
    public void addEventHandler(String eventType)
    {
        if ( == null)
             = CollectionFactory.newCaseInsensitiveMap();
        .put(eventTypetrue);
    }
    public String getMeta(String key)
    {
        String result = InternalUtils.get(key);
        if (result == null &&  != null)
            result = .getMeta(key);
        return result;
    }
    public Set<ClassgetHandledRenderPhases()
    {
        Set<Classresult = CollectionFactory.newSet();
        if ( != null)
            result.addAll(.getHandledRenderPhases());
        if ( != null)
            result.addAll();
        return result;
    }
    public boolean handlesEvent(String eventType)
    {
        if (InternalUtils.get(eventType) != null)
            return true;
        return  == null ? false : .handlesEvent(eventType);
    }
    public String[] getOrderForMixin(String mixinClassName)
    {
        return InternalUtils.get(mixinClassName);
    }
New to GrepCode? Check out our FAQ X