// Copyright 2007, 2008, 2010, 2011 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 org.apache.tapestry5.PropertyConduit;
import org.apache.tapestry5.beaneditor.BeanModel;
import org.apache.tapestry5.beaneditor.PropertyModel;
import org.apache.tapestry5.beaneditor.RelativePosition;
import org.apache.tapestry5.internal.services.CoercingPropertyConduitWrapper;
import org.apache.tapestry5.ioc.Messages;
import org.apache.tapestry5.ioc.ObjectLocator;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.InternalCommonsUtils;
import org.apache.tapestry5.ioc.services.TypeCoercer;
import org.apache.tapestry5.ioc.util.AvailableValues;
import org.apache.tapestry5.ioc.util.UnknownValueException;
import org.apache.tapestry5.plastic.PlasticUtils;
import org.apache.tapestry5.services.PropertyConduitSource;
import java.util.List;
import java.util.Map;
public class BeanModelImpl<T> implements BeanModel<T>
{
private final Class<T> beanType;
private final PropertyConduitSource propertyConduitSource;
private final TypeCoercer typeCoercer;
private final Messages messages;
private final ObjectLocator locator;
private final Map<String, PropertyModel> properties = CollectionFactory.newCaseInsensitiveMap();
// The list of property names, in desired order (generally not alphabetical order).
private final List<String> propertyNames = CollectionFactory.newList();
private static PropertyConduit NULL_PROPERTY_CONDUIT = null;
public BeanModelImpl(Class<T> beanType, PropertyConduitSource propertyConduitSource, TypeCoercer typeCoercer,
Messages messages, ObjectLocator locator)
{
this.beanType = beanType;
this.propertyConduitSource = propertyConduitSource;
this.typeCoercer = typeCoercer;
this.messages = messages;
this.locator = locator;
}
public Class<T> getBeanType()
{
return beanType;
}
public T newInstance()
{
return locator.autobuild("Instantiating new instance of " + beanType.getName(), beanType);
}
public PropertyModel add(String propertyName)
{
return addExpression(propertyName, propertyName);
}
public PropertyModel addEmpty(String propertyName)
{
return add(propertyName, NULL_PROPERTY_CONDUIT);
}
public PropertyModel addExpression(String propertyName, String expression)
{
PropertyConduit conduit = createConduit(expression);
return add(propertyName, conduit);
}
private void validateNewPropertyName(String propertyName)
{
assert InternalCommonsUtils.isNonBlank(propertyName);
if (properties.containsKey(propertyName))
throw new RuntimeException(String.format(
"Bean editor model for %s already contains a property model for property '%s'.",
beanType.getName(), propertyName));
}
public PropertyModel add(RelativePosition position, String existingPropertyName, String propertyName,
PropertyConduit conduit)
{
assert position != null;
validateNewPropertyName(propertyName);
// Locate the existing one.
PropertyModel existing = get(existingPropertyName);
// Use the case normalized property name.
int pos = propertyNames.indexOf(existing.getPropertyName());
PropertyModel newModel = new PropertyModelImpl(this, propertyName, conduit, messages);
properties.put(propertyName, newModel);
int offset = position == RelativePosition.AFTER ? 1 : 0;
propertyNames.add(pos + offset, propertyName);
return newModel;
}
public PropertyModel add(RelativePosition position, String existingPropertyName, String propertyName)
{
PropertyConduit conduit = createConduit(propertyName);
return add(position, existingPropertyName, propertyName, conduit);
}
public PropertyModel add(String propertyName, PropertyConduit conduit)
{
validateNewPropertyName(propertyName);
PropertyModel propertyModel = new PropertyModelImpl(this, propertyName, conduit, messages);
properties.put(propertyName, propertyModel);
// Remember the order in which the properties were added.
propertyNames.add(propertyName);
return propertyModel;
}
private CoercingPropertyConduitWrapper createConduit(String propertyName)
{
return new CoercingPropertyConduitWrapper(propertyConduitSource.create(beanType, propertyName), typeCoercer);
}
public PropertyModel get(String propertyName)
{
PropertyModel propertyModel = properties.get(propertyName);
if (propertyModel == null)
throw new UnknownValueException(String.format(
"Bean editor model for %s does not contain a property named '%s'.", beanType.getName(),
propertyName), new AvailableValues("Defined properties", propertyNames));
return propertyModel;
}
public PropertyModel getById(String propertyId)
{
for (PropertyModel model : properties.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<String> ids = CollectionFactory.newList();
for (PropertyModel model : properties.values())
{
ids.add(model.getId());
}
throw new UnknownValueException(String.format(
"Bean editor model for %s does not contain a property with id '%s'.", beanType.getName(), propertyId),
new AvailableValues("Defined property ids", ids));
}
public List<String> getPropertyNames()
{
return CollectionFactory.newList(propertyNames);
}
public BeanModel<T> exclude(String... propertyNames)
{
for (String propertyName : propertyNames)
{
PropertyModel model = properties.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.propertyNames.remove(model.getPropertyName());
properties.remove(propertyName);
}
return this;
}
public BeanModel<T> reorder(String... propertyNames)
{
List<String> remainingPropertyNames = CollectionFactory.newList(this.propertyNames);
List<String> reorderedPropertyNames = 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.propertyNames.clear();
this.propertyNames.addAll(reorderedPropertyNames);
// Any unspecified names are ordered to the end. Don't want them? Remove them instead.
this.propertyNames.addAll(remainingPropertyNames);
return this;
}
public BeanModel<T> include(String... propertyNames)
{
List<String> reorderedPropertyNames = CollectionFactory.newList();
Map<String, PropertyModel> reduced = CollectionFactory.newCaseInsensitiveMap();
for (String name : propertyNames)
{
PropertyModel model = get(name);
String canonical = model.getPropertyName();
reorderedPropertyNames.add(canonical);
reduced.put(canonical, model);
}
this.propertyNames.clear();
this.propertyNames.addAll(reorderedPropertyNames);
properties.clear();
properties.putAll(reduced);
return this;
}
@Override
public String toString()
{
StringBuilder builder = new StringBuilder("BeanModel[");
builder.append(PlasticUtils.toTypeName(beanType));
builder.append(" properties:");
String sep = "";
for (String name : propertyNames)
{
builder.append(sep);
builder.append(name);
sep = ", ";
}
builder.append(']');
return builder.toString();
}
}