Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  // Copyright 2007, 2008, 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.beaneditor;
 
 import java.util.List;
 import java.util.Map;
 
 
 public class BeanModelImpl<T> implements BeanModel<T>
 {
     private final Class<T> beanType;
 
 
     private final TypeCoercer typeCoercer;
 
     private final Messages messages;
 
     private final ObjectLocator locator;
 
     private final Map<StringPropertyModelproperties = CollectionFactory.newCaseInsensitiveMap();
 
     // The list of property names, in desired order (generally not alphabetical order).
 
     private final List<StringpropertyNames = CollectionFactory.newList();
 
     public BeanModelImpl(Class<T> beanTypePropertyConduitSource propertyConduitSourceTypeCoercer typeCoercer,
             Messages messagesObjectLocator locator)
 
     {
         this. = beanType;
         this. = propertyConduitSource;
         this. = typeCoercer;
         this. = messages;
         this. = locator;
     }
 
     public Class<T> getBeanType()
     {
         return ;
     }
 
     public T newInstance()
     {
         return .autobuild("Instantiating new instance of " + .getName(), );
     }
 
     public PropertyModel add(String propertyName)
     {
         PropertyConduit conduit = createConduit(propertyName);
 
         return add(propertyNameconduit);
     }
 
     private void validateNewPropertyName(String propertyName)
     {
         assert InternalUtils.isNonBlank(propertyName);
         if (.containsKey(propertyName))
             throw new RuntimeException(String.format(
                     "Bean editor model for %s already contains a property model for property '%s'.",
                     .getName(), propertyName));
     }
 
     public PropertyModel add(RelativePosition positionString existingPropertyNameString propertyName,
             PropertyConduit conduit)
     {
         assert position != null;
         validateNewPropertyName(propertyName);
 
         // Locate the existing one.
 
         PropertyModel existing = get(existingPropertyName);
 
        // Use the case normalized property name.
        int pos = .indexOf(existing.getPropertyName());
        PropertyModel newModel = new PropertyModelImpl(thispropertyNameconduit);
        .put(propertyNamenewModel);
        int offset = position == . ? 1 : 0;
        .add(pos + offsetpropertyName);
        return newModel;
    }
    public PropertyModel add(RelativePosition positionString existingPropertyNameString propertyName)
    {
        PropertyConduit conduit = createConduit(propertyName);
        return add(positionexistingPropertyNamepropertyNameconduit);
    }
    public PropertyModel add(String propertyNamePropertyConduit conduit)
    {
        validateNewPropertyName(propertyName);
        PropertyModel propertyModel = new PropertyModelImpl(thispropertyNameconduit);
        .put(propertyNamepropertyModel);
        // Remember the order in which the properties were added.
        .add(propertyName);
        return propertyModel;
    }
    private CoercingPropertyConduitWrapper createConduit(String propertyName)
    {
        return new CoercingPropertyConduitWrapper(.create(propertyName), );
    }
    public PropertyModel get(String propertyName)
    {
        PropertyModel propertyModel = .get(propertyName);
        if (propertyModel == null)
            throw new UnknownValueException(String.format(
                    "Bean editor model for %s does not contain a property named '%s'.".getName(),
                    propertyName), new AvailableValues("Defined properties"));
        return propertyModel;
    }
    public PropertyModel getById(String propertyId)
    {
        for (PropertyModel model : .values())
        {
            if (model.getId().equalsIgnoreCase(propertyId))
                return model;
        }
        // Not found, so we throw an exception. A bit of work to set
        // up the exception however.
        List<Stringids = CollectionFactory.newList();
        for (PropertyModel model : .values())
        {
            ids.add(model.getId());
        }
        throw new UnknownValueException(String.format(
                "Bean editor model for %s does not contain a property with id '%s'.".getName(), propertyId),
                new AvailableValues("Defined property ids"ids));
    }
    public List<StringgetPropertyNames()
    {
        return CollectionFactory.newList();
    }
    public BeanModel<T> exclude(String... propertyNames)
    {
        for (String propertyName : propertyNames)
        {
            PropertyModel model = .get(propertyName);
            if (model == null)
                continue;
            // De-referencing from the model is needed because the name provided may not be a
            // case-exact match, so we get the normalized or canonical name from the model because
            // that's the one in propertyNames.
            this..remove(model.getPropertyName());
            .remove(propertyName);
        }
        return this;
    }
    public BeanModel<T> reorder(String... propertyNames)
    {
        List<StringremainingPropertyNames = CollectionFactory.newList(this.);
        List<StringreorderedPropertyNames = CollectionFactory.newList();
        for (String name : propertyNames)
        {
            PropertyModel model = get(name);
            // Get the canonical form (which may differ from name in terms of case)
            String canonical = model.getPropertyName();
            reorderedPropertyNames.add(canonical);
            remainingPropertyNames.remove(canonical);
        }
        this..clear();
        this..addAll(reorderedPropertyNames);
        // Any unspecified names are ordered to the end. Don't want them? Remove them instead.
        this..addAll(remainingPropertyNames);
        return this;
    }
    public BeanModel<T> include(String... propertyNames)
    {
        List<StringreorderedPropertyNames = CollectionFactory.newList();
        Map<StringPropertyModelreduced = CollectionFactory.newCaseInsensitiveMap();
        for (String name : propertyNames)
        {
            PropertyModel model = get(name);
            String canonical = model.getPropertyName();
            reorderedPropertyNames.add(canonical);
            reduced.put(canonicalmodel);
        }
        this..clear();
        this..addAll(reorderedPropertyNames);
        .clear();
        .putAll(reduced);
        return this;
    }
    @Override
    public String toString()
    {
        StringBuilder builder = new StringBuilder("BeanModel[");
        builder.append(ClassFabUtils.toJavaClassName());
        builder.append(" properties:");
        String sep = "";
        for (String name : )
        {
            builder.append(sep);
            builder.append(name);
            sep = ", ";
        }
        builder.append("]");
        return builder.toString();
    }
New to GrepCode? Check out our FAQ X