Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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.openaz.xacml.admin.model; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Properties; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.openaz.xacml.admin.jpa.PIPConfiguration; import org.apache.openaz.xacml.admin.jpa.PIPResolver; import org.apache.openaz.xacml.api.pap.PDP; import org.apache.openaz.xacml.api.pap.PDPGroup; import org.apache.openaz.xacml.api.pap.PDPPIPConfig; import org.apache.openaz.xacml.api.pip.PIPException; import com.vaadin.data.Container; import com.vaadin.data.Item; import com.vaadin.data.Property; import com.vaadin.data.util.MethodProperty; public class PDPPIPContainer extends ItemSetChangeNotifier implements Container.Hierarchical, Container.ItemSetChangeNotifier { private static final long serialVersionUID = 1L; private static Log logger = LogFactory.getLog(PDPPIPContainer.class); /** * String identifier of a file's "Id" property. */ public static String PROPERTY_ID = "Id"; /** * String identifier of a file's "name" property. */ public static String PROPERTY_NAME = "Name"; /** * String identifier of a file's "Description" property. */ public static String PROPERTY_DESCRIPTION = "Description"; /** * List of the string identifiers for the available properties. */ public static Collection<String> PDPPIP_PROPERTIES; private final static Method PDPPIPITEM_ID; private final static Method PDPPIPITEM_NAME; private final static Method PDPPIPITEM_DESCRIPTION; static { PDPPIP_PROPERTIES = new ArrayList<String>(); PDPPIP_PROPERTIES.add(PROPERTY_ID); PDPPIP_PROPERTIES.add(PROPERTY_NAME); PDPPIP_PROPERTIES.add(PROPERTY_DESCRIPTION); PDPPIP_PROPERTIES = Collections.unmodifiableCollection(PDPPIP_PROPERTIES); try { PDPPIPITEM_ID = PDPPIPItem.class.getMethod("getId", new Class[] {}); PDPPIPITEM_NAME = PDPPIPItem.class.getMethod("getName", new Class[] {}); PDPPIPITEM_DESCRIPTION = PDPPIPItem.class.getMethod("getDescription", new Class[] {}); } catch (final NoSuchMethodException e) { throw new RuntimeException("Internal error finding methods in PDPPIPContainer"); } } private final Object data; List<PIPConfiguration> configurations = new ArrayList<PIPConfiguration>(); public PDPPIPContainer(Object data) { super(); setContainer(this); // // Save our object // this.data = data; // // Is it supported? // if (this.isPDPGroup() == false && this.isPDP() == false) { throw new IllegalArgumentException("This container only supported PDPGroup and PDP objects."); } // // Initialize our internal structures // initialize(); } private boolean isSupported(Object itemId) { if (this.isConfiguration(itemId) || this.isResolver(itemId)) { return true; } return false; } private boolean isPDPGroup() { return this.data instanceof PDPGroup; } private boolean isPDP() { return this.data instanceof PDP; } private boolean isConfiguration(Object itemId) { return itemId instanceof PIPConfiguration; } private boolean isResolver(Object itemId) { return itemId instanceof PIPResolver; } private void initialize() { assert this.data != null; // // Get the list of configurations // Set<PDPPIPConfig> configs = null; if (this.isPDPGroup()) { configs = ((PDPGroup) this.data).getPipConfigs(); } else if (this.isPDP()) { configs = ((PDP) this.data).getPipConfigs(); } else { throw new IllegalArgumentException("This container only supported PDPGroup and PDP objects."); } // // Map these to a list of PIPConfiguration objects. That // way we can match them up to the database. // for (PDPPIPConfig config : configs) { Properties properties = new Properties(); properties.putAll(config.getConfiguration()); try { PIPConfiguration pipConfig = new PIPConfiguration(config.getId(), properties); if (logger.isDebugEnabled()) { logger.debug("Found config: " + pipConfig); } this.configurations.add(pipConfig); } catch (PIPException e) { logger.error("Failed to create PIPConfiguration: " + e.getLocalizedMessage()); } } } public void refresh() { this.configurations.clear(); this.initialize(); this.fireItemSetChange(); } @Override public Item getItem(Object itemId) { if (this.isSupported(itemId)) { return new PDPPIPItem(itemId); } return null; } @Override public Collection<?> getContainerPropertyIds() { return PDPPIP_PROPERTIES; } @Override public Collection<?> getItemIds() { final Collection<Object> items = new ArrayList<Object>(); for (PIPConfiguration config : this.configurations) { items.add(config); /* for (PIPResolver resolver : config.getPipresolvers()) { items.add(resolver); } */ } return Collections.unmodifiableCollection(items); } @Override public Property<?> getContainerProperty(Object itemId, Object propertyId) { if (this.isSupported(itemId) == false) { return null; } if (propertyId.equals(PROPERTY_ID)) { return new MethodProperty<Object>(getType(propertyId), new PDPPIPItem(itemId), PDPPIPITEM_ID, null); } if (propertyId.equals(PROPERTY_NAME)) { return new MethodProperty<Object>(getType(propertyId), new PDPPIPItem(itemId), PDPPIPITEM_NAME, null); } if (propertyId.equals(PROPERTY_DESCRIPTION)) { return new MethodProperty<Object>(getType(propertyId), new PDPPIPItem(itemId), PDPPIPITEM_DESCRIPTION, null); } return null; } @Override public Class<?> getType(Object propertyId) { if (propertyId.equals(PROPERTY_ID)) { return String.class; } if (propertyId.equals(PROPERTY_NAME)) { return String.class; } if (propertyId.equals(PROPERTY_DESCRIPTION)) { return String.class; } return null; } @Override public int size() { /* int size = 0; for (PIPConfiguration config : this.configurations) { size++; size += config.getPipresolvers().size(); } return size; */ return this.configurations.size(); } @Override public boolean containsId(Object itemId) { // // Let's try this by using the Id // for (PIPConfiguration config : this.configurations) { if (this.isConfiguration(itemId)) { if (((PIPConfiguration) itemId).getId() == config.getId()) { return true; } } else if (this.isResolver(itemId)) { for (PIPResolver resolver : config.getPipresolvers()) { if (((PIPResolver) itemId).getId() == resolver.getId()) { return true; } } } else { throw new IllegalArgumentException( "This container only supports pip configuration and resolvers objects."); } } return false; } @Override public Item addItem(Object itemId) throws UnsupportedOperationException { if (this.isConfiguration(itemId)) { this.configurations.add((PIPConfiguration) itemId); // } else if (this.isResolver(itemId)) { } throw new UnsupportedOperationException("Cannot add unsupported object."); } @Override public Object addItem() throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot add unknown object."); } @Override public boolean addContainerProperty(Object propertyId, Class<?> type, Object defaultValue) throws UnsupportedOperationException { throw new UnsupportedOperationException("Adding properties not supported."); } @Override public boolean removeContainerProperty(Object propertyId) throws UnsupportedOperationException { throw new UnsupportedOperationException("Removing properties not supported."); } @Override public boolean removeAllItems() throws UnsupportedOperationException { // // Remove everything // this.configurations.clear(); return true; } @Override public Collection<?> getChildren(Object itemId) { if (this.isConfiguration(itemId)) { Collection<Object> children = new ArrayList<Object>(); for (PIPConfiguration config : this.configurations) { if (config.getId() == ((PIPConfiguration) itemId).getId()) { /* * Not for this release * children.addAll(config.getPipresolvers()); */ break; } } return Collections.unmodifiableCollection(children); } return Collections.emptyList(); } @Override public Object getParent(Object itemId) { if (this.isResolver(itemId)) { return ((PIPResolver) itemId).getPipconfiguration(); } return null; } @Override public Collection<?> rootItemIds() { Collection<Object> roots = new ArrayList<Object>(); roots.addAll(this.configurations); return Collections.unmodifiableCollection(roots); } @Override public boolean setParent(Object itemId, Object newParentId) throws UnsupportedOperationException { throw new UnsupportedOperationException("Not allowed in this implementation."); } @Override public boolean areChildrenAllowed(Object itemId) { if (this.isConfiguration(itemId)) { return true; } return false; } @Override public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed) throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot change which objects can or cannot have children."); } @Override public boolean isRoot(Object itemId) { if (this.isConfiguration(itemId)) { return this.containsId(itemId); } return false; } @Override public boolean hasChildren(Object itemId) { if (this.isConfiguration(itemId)) { //return ((PIPConfiguration) itemId).getPipresolvers().size() > 0; // // Not this implementation return false; } return false; } @Override public boolean removeItem(Object itemId) throws UnsupportedOperationException { throw new UnsupportedOperationException("Not allowed in this implementation."); /* if (this.isConfiguration(itemId)) { return this.configurations.remove(itemId); } if (this.isResolver(itemId)) { ((PIPResolver) itemId).getPipconfiguration().removePipresolver((PIPResolver) itemId); } throw new UnsupportedOperationException("Object not supported by this container."); */ } public class PDPPIPItem implements Item { private static final long serialVersionUID = 1L; private final Object config; public PDPPIPItem(Object config) { this.config = config; } public String getId() { if (this.config instanceof PIPConfiguration) { return Integer.toString(((PIPConfiguration) this.config).getId()); } if (this.config instanceof PIPResolver) { return Integer.toString(((PIPResolver) this.config).getId()); } return null; } public String getName() { if (this.config instanceof PIPConfiguration) { return ((PIPConfiguration) this.config).getName(); } if (this.config instanceof PIPResolver) { return ((PIPResolver) this.config).getName(); } return null; } public String getDescription() { if (this.config instanceof PIPConfiguration) { return ((PIPConfiguration) this.config).getDescription(); } if (this.config instanceof PIPResolver) { return ((PIPResolver) this.config).getDescription(); } return null; } @Override public Property<?> getItemProperty(Object id) { return getContainerProperty(config, id); } @Override public Collection<?> getItemPropertyIds() { return getContainerPropertyIds(); } @Override public boolean addItemProperty(Object id, @SuppressWarnings("rawtypes") Property property) throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot add property."); } @Override public boolean removeItemProperty(Object id) throws UnsupportedOperationException { throw new UnsupportedOperationException("Cannot remove property."); } } }