openaz-xacml-pap-admin/src/main/java/org/apache/openaz/xacml/admin/model/PolicyContainer.java

/*
 *  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.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBElement;

import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.ApplyType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeSelectorType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.ConditionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.FunctionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionsType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableDefinitionType;
import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableReferenceType;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.apache.openaz.xacml.util.XACMLPolicyScanner;
import org.apache.openaz.xacml.util.XACMLPolicyScanner.CallbackResult;
import com.google.gwt.thirdparty.guava.common.base.Splitter;
import com.vaadin.data.Container;
import com.vaadin.data.Item;
import com.vaadin.data.Property;
import com.vaadin.data.util.MethodProperty;
import com.vaadin.server.Resource;
import com.vaadin.server.ThemeResource;
import com.vaadin.ui.Table;

public class PolicyContainer extends ItemSetChangeNotifier implements Container.Hierarchical, Container.Ordered, Container.ItemSetChangeNotifier {
	private static final long serialVersionUID = 1L;
	private static Log logger	= LogFactory.getLog(PolicyContainer.class);
	private final PolicyContainer self = this;
	
    /**
     * String identifier of a file's "name" property.
     */
    public static String PROPERTY_NAME = "Name";

    /**
     * String identifier of a file's "id" property.
     */
    public static String PROPERTY_ID = "Id";

    /**
     * String identifier of a file's "short ID" property.
     */
    public static String PROPERTY_SHORTID = "ShortId";

    /**
     * String identifier of a file's "Algorithm" property.
     */
    public static String PROPERTY_ALGORITHM = "Algorithm";

    /**
     * String identifier of a file's "ShortAlgorithm" property.
     */
    public static String PROPERTY_SHORTALGORITHM = "ShortAlgorithm";

    /**
     * String identifier of a file's "Description" property.
     */
    public static String PROPERTY_DESCRIPTION = "Description";

    /**
     * String identifier of a file's "icon" property.
     */
    public static String PROPERTY_ICON = "Icon";

    /**
     * String identifier of a file's "Status" property.
     */
    public static String PROPERTY_STATUS = "Status";

    /**
     * String identifier of a file's "Attributes" property.
     */
    public static String PROPERTY_ATTRIBUTES = "Attributes";

    /**
     * List of the string identifiers for the available properties.
     */
    public static Collection<String> POLICY_PROPERTIES;

    private final static Method POLICYITEM_NAME;
    
    private final static Method POLICYITEM_ID;

    private final static Method POLICYITEM_SHORTID;

    private final static Method POLICYITEM_ALGORITHM;

    private final static Method POLICYITEM_SHORTALGORITHM;

    private final static Method POLICYITEM_DESCRIPTION;

    private final static Method POLICYITEM_ICON;
    
    private final static Method POLICYITEM_STATUS;
    
    private final static Method POLICYITEM_ATTRIBUTES;
    
    static {

    	POLICY_PROPERTIES = new ArrayList<String>();
    	POLICY_PROPERTIES.add(PROPERTY_NAME);
    	POLICY_PROPERTIES.add(PROPERTY_ID);
    	POLICY_PROPERTIES.add(PROPERTY_SHORTID);
    	POLICY_PROPERTIES.add(PROPERTY_ALGORITHM);
    	POLICY_PROPERTIES.add(PROPERTY_SHORTALGORITHM);
    	POLICY_PROPERTIES.add(PROPERTY_DESCRIPTION);
    	POLICY_PROPERTIES.add(PROPERTY_ICON);
    	POLICY_PROPERTIES.add(PROPERTY_STATUS);
    	POLICY_PROPERTIES.add(PROPERTY_ATTRIBUTES);
    	POLICY_PROPERTIES = Collections.unmodifiableCollection(POLICY_PROPERTIES);
        try {
        	POLICYITEM_NAME = PolicyItem.class.getMethod("getName", new Class[]{});
        	POLICYITEM_ID = PolicyItem.class.getMethod("getId", new Class[]{});
        	POLICYITEM_SHORTID = PolicyItem.class.getMethod("getShortId", new Class[]{});
        	POLICYITEM_ALGORITHM = PolicyItem.class.getMethod("getAlgorithm", new Class[] {});
        	POLICYITEM_SHORTALGORITHM = PolicyItem.class.getMethod("getShortAlgorithm", new Class[] {});
            POLICYITEM_DESCRIPTION = PolicyItem.class.getMethod("getDescription", new Class[] {});
            POLICYITEM_ICON = PolicyItem.class.getMethod("getIcon", new Class[] {});
            POLICYITEM_STATUS = PolicyItem.class.getMethod("getStatus", new Class[] {});
            POLICYITEM_ATTRIBUTES = PolicyItem.class.getMethod("getAttributes", new Class[] {});
        } catch (final NoSuchMethodException e) {
            throw new RuntimeException(
                    "Internal error finding methods in PolicyContainer");
        }
    }
    
    private final File file;
    private Object root;
    
    private Map<PolicySetType, PolicySetType> policySets = new HashMap<PolicySetType, PolicySetType>();
    private Map<PolicyType, PolicySetType> policies = new HashMap<PolicyType, PolicySetType>();
    private Map<RuleType, PolicyType> rules = new HashMap<RuleType, PolicyType>();
    private Map<TargetType, Object> targets = new HashMap<TargetType, Object>();
    private Map<AnyOfType, TargetType> anyofs = new HashMap<AnyOfType, TargetType>();
    private Map<AllOfType, AnyOfType> allofs = new HashMap<AllOfType, AnyOfType>();
    private Map<MatchType, AllOfType> matches = new HashMap<MatchType, AllOfType>();
    private Map<ObligationExpressionType, Object> obligations = new HashMap<ObligationExpressionType, Object>();
    private Map<AdviceExpressionType, Object> advice = new HashMap<AdviceExpressionType, Object>();
    private Map<ConditionType, RuleType> conditions = new HashMap<ConditionType, RuleType>();
    private Map<VariableDefinitionType, PolicyType> variables = new HashMap<VariableDefinitionType, PolicyType>();
        
	public PolicyContainer(File file) throws IOException {
		super();
		this.setContainer(this);
		this.file = file;
		this.readData();
		if (logger.isTraceEnabled()) {
			logger.trace("New Policy Container: " + this.file.getName());
		}
	}
	
	private void readData() throws IOException {
		Object data = null;
		try (InputStream is = Files.newInputStream(Paths.get(this.file.getAbsolutePath()))) {
			data = XACMLPolicyScanner.readPolicy(is);
		} catch (IOException e) {
			logger.error("Failed to load policy.");
		}
		XACMLPolicyScanner scanner = null;
		if (data instanceof PolicySetType) {
			this.root = data;
			scanner = new XACMLPolicyScanner((PolicySetType) this.root);
		} else if (data instanceof PolicyType) {
			this.root = data;
			scanner = new XACMLPolicyScanner((PolicyType) this.root);
		} else {
			if (data != null) {
				logger.error("invalid root object: " + data.getClass().getCanonicalName());
			} else {
				logger.error("could not parse the file");
			}
			throw new IOException("Invalid Xacml Policy File");
		}
		scanner.scan(new XACMLPolicyScanner.SimpleCallback() {
			
			@Override
			public CallbackResult onPreVisitRule(PolicyType parent, RuleType rule) {
				self.addRule(parent, rule, false);
				return CallbackResult.CONTINUE;
			}
			
			@Override
			public CallbackResult onPreVisitPolicySet(PolicySetType parent,
					PolicySetType policySet) {
				self.addPolicySet(parent, policySet, false);
				return CallbackResult.CONTINUE;
			}
			
			@Override
			public CallbackResult onPreVisitPolicy(PolicySetType parent,
					PolicyType policy) {
				self.addPolicy(parent, policy, false);
				return CallbackResult.CONTINUE;
			}
			
		});
	}
	
   private boolean	isObjectSupported(Object itemId) {
       if (!(itemId instanceof PolicySetType) &&
           	!(itemId instanceof PolicyType) &&
           	!(itemId instanceof RuleType) &&
           	!(itemId instanceof TargetType) &&
           	!(itemId instanceof ObligationExpressionType) &&
           	!(itemId instanceof AdviceExpressionType) &&
           	!(itemId instanceof AnyOfType) &&
           	!(itemId instanceof AllOfType) &&
           	!(itemId instanceof MatchType) &&
           	!(itemId instanceof ConditionType) &&
           	!(itemId instanceof VariableDefinitionType)) {
               return false;
           }
	   return true;
   }

	@Override
	public Item getItem(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("getItem: " + itemId);
		}
        if (this.isObjectSupported(itemId) == false) {
            return null;
        }
		return new PolicyItem(itemId);
	}
	
	public Item updateItem(Object itemId) {
        if (this.isObjectSupported(itemId) == false) {
            return null;
        }

        this.fireItemSetChange();
        
        return new PolicyItem(itemId);
	}
	
	public Map<VariableDefinitionType, PolicyType>	getVariables() {
		return Collections.unmodifiableMap(this.variables);
	}

	@Override
	public Collection<?> getContainerPropertyIds() {
		return POLICY_PROPERTIES;
	}

	@Override
	public Collection<?> getItemIds() {
		XACMLPolicyScanner scanner = null;
		final Collection<Object> items = new ArrayList<Object>();
		if (this.root instanceof PolicyType) {
			scanner = new XACMLPolicyScanner((PolicyType) this.root);
		} else if (this.root instanceof PolicySetType) {
			scanner = new XACMLPolicyScanner((PolicySetType) this.root);
		} else {
			return Collections.unmodifiableCollection(items);
		}
		
		scanner.scan(new XACMLPolicyScanner.SimpleCallback() {
			
			@Override
			public CallbackResult onPreVisitRule(PolicyType parent, RuleType rule) {
				items.add(rule);
				if (rule.getTarget() != null) {
					items.add(rule.getTarget());
				}
				if (rule.getCondition() != null) {
					items.add(rule.getCondition());
				}
				if (rule.getObligationExpressions() != null) {
					items.addAll(rule.getObligationExpressions().getObligationExpression());
				}
				if (rule.getAdviceExpressions() != null) {
					items.addAll(rule.getAdviceExpressions().getAdviceExpression());
				}
				return CallbackResult.CONTINUE;
			}
			
			@Override
			public CallbackResult onPreVisitPolicySet(PolicySetType parent, PolicySetType policySet) {
				items.add(policySet);
				if (policySet.getTarget() != null) {
					items.add(policySet.getTarget());
				}
				if (policySet.getObligationExpressions() != null) {
					items.addAll(policySet.getObligationExpressions().getObligationExpression());
				}
				if (policySet.getAdviceExpressions() != null) {
					items.addAll(policySet.getAdviceExpressions().getAdviceExpression());
				}
				return CallbackResult.CONTINUE;
			}
			
			@Override
			public CallbackResult onPreVisitPolicy(PolicySetType parent, PolicyType policy) {
				items.add(policy);
				if (policy.getTarget() != null) {
					items.add(policy.getTarget());
				}
				if (policy.getObligationExpressions() != null) {
					items.addAll(policy.getObligationExpressions().getObligationExpression());
				}
				if (policy.getAdviceExpressions() != null) {
					items.addAll(policy.getAdviceExpressions().getAdviceExpression());
				}
				return CallbackResult.CONTINUE;
			}
			
		});
		if (logger.isTraceEnabled()) {
			logger.trace("getItemIds: (" + items.size() + "):" + items);
		}
		return Collections.unmodifiableCollection(items);		
	}

	@Override
	public Property<?> getContainerProperty(Object itemId, Object propertyId) {
        if (this.isObjectSupported(itemId) == false) {
            return null;
        }

        if (propertyId.equals(PROPERTY_NAME)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_NAME, null);
        }

        if (propertyId.equals(PROPERTY_ID)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_ID, null);
        }

        if (propertyId.equals(PROPERTY_SHORTID)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_SHORTID, null);
        }

        if (propertyId.equals(PROPERTY_ICON)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_ICON, null);
        }

        if (propertyId.equals(PROPERTY_ALGORITHM)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_ALGORITHM, null);
        }

        if (propertyId.equals(PROPERTY_SHORTALGORITHM)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_SHORTALGORITHM, null);
        }

         if (propertyId.equals(PROPERTY_DESCRIPTION)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_DESCRIPTION, null);
        }

        if (propertyId.equals(PROPERTY_STATUS)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_STATUS, null);
        }

        if (propertyId.equals(PROPERTY_ATTRIBUTES)) {
            return new MethodProperty<Object>(getType(propertyId),
                    new PolicyItem(itemId), POLICYITEM_ATTRIBUTES, null);
        }

        return null;
	}

	@Override
	public Class<?> getType(Object propertyId) {
		
        if (propertyId.equals(PROPERTY_NAME)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_ID)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_SHORTID)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_ICON)) {
            return Resource.class;
        }
        if (propertyId.equals(PROPERTY_DESCRIPTION)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_ALGORITHM)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_SHORTALGORITHM)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_STATUS)) {
            return String.class;
        }
        if (propertyId.equals(PROPERTY_ATTRIBUTES)) {
            return Table.class;
        }
		return null;
	}

	@Override
	public int size() {
		int size = 0;
		size += this.policySets.size();
		size += this.policies.size();
		size += this.rules.size();
		size += this.targets.size();
		size += this.obligations.size();
		size += this.advice.size();
		size += this.anyofs.size();
		size += this.allofs.size();
		size += this.matches.size();
		size += this.conditions.size();
		size += this.variables.size();
		
		return size;
	}

	@Override
	public boolean containsId(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("containsId: " + itemId);
		}
		if (itemId instanceof PolicySetType) {
			if (this.root instanceof PolicySetType && ((PolicySetType) itemId).getPolicySetId().equals(((PolicySetType) this.root).getPolicySetId())) {
				return true;
			}
			return this.policySets.containsKey(itemId);
		}
		if (itemId instanceof PolicyType) {
			if (this.root instanceof PolicyType && ((PolicyType) itemId).getPolicyId().equals(((PolicyType) this.root).getPolicyId())) {
				return true;
			}
			return this.policies.containsKey(itemId);
		}
		if (itemId instanceof RuleType) {
			return this.rules.containsKey(itemId);
		}
		if (itemId instanceof TargetType) {
			return this.targets.containsKey(itemId);
		}
		if (itemId instanceof ObligationExpressionType) {
			return this.obligations.containsKey(itemId);
		}
		if (itemId instanceof AdviceExpressionType) {
			return this.advice.containsKey(itemId);
		}
		if (itemId instanceof AnyOfType) {
			return this.anyofs.containsKey(itemId);
		}
		if (itemId instanceof AllOfType) {
			return this.allofs.containsKey(itemId);
		}
		if (itemId instanceof MatchType) {
			return this.matches.containsKey(itemId);
		}
		if (itemId instanceof ConditionType) {
			return this.conditions.containsKey(itemId);
		}
		if (itemId instanceof VariableDefinitionType) {
			return this.variables.containsKey(itemId);
		}
		return false;
	}

	@Override
	public Item addItem(Object itemId) throws UnsupportedOperationException {
		throw new UnsupportedOperationException("Please use the addItem(Object, Object) method instead.");
	}

	/**
	 * Add's the new Policy object under the parent. This method appends the item to the end
	 * of the parent's list if applicable. If you want to add an item within a list, use the
	 * addItemAfter() method instead.
	 * 
	 * @param itemId
	 * @param parent
	 * @return
	 * @throws UnsupportedOperationException
	 */
	public Item addItem(Object itemId, Object parent) throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("addItem: " + itemId);
		}
		if (itemId instanceof PolicySetType && parent instanceof PolicySetType) {
			this.addPolicySet((PolicySetType) parent, (PolicySetType) itemId, true);
		} else if (itemId instanceof PolicyType && parent instanceof PolicySetType) {
			this.addPolicy((PolicySetType) parent, (PolicyType) itemId, true);
		} else if (itemId instanceof RuleType && parent instanceof PolicyType) {
			this.addRule((PolicyType) parent, (RuleType) itemId, true);
		} else if (itemId instanceof TargetType && 
				(parent instanceof PolicyType || 
				parent instanceof PolicySetType || 
				parent instanceof RuleType)) {
			this.addTarget(parent, (TargetType) itemId, true);
		} else if (itemId instanceof ObligationExpressionType ||
					itemId instanceof ObligationExpressionsType) {
			if (parent instanceof PolicyType || 
				parent instanceof PolicySetType || 
				parent instanceof RuleType ||
				parent instanceof ObligationExpressionsType) {
				if (itemId instanceof ObligationExpressionType) {
					this.addObligation(parent, (ObligationExpressionType) itemId, true);
				} else {
					this.addObligations(parent, (ObligationExpressionsType) itemId, true);
				}
			}
		} else if (itemId instanceof AdviceExpressionType ||
					itemId instanceof AdviceExpressionsType) {
			if (parent instanceof PolicyType || 
				parent instanceof PolicySetType || 
				parent instanceof RuleType ||
				parent instanceof AdviceExpressionsType) {
				if (itemId instanceof AdviceExpressionType) {
					this.addAdvice(parent, (AdviceExpressionType) itemId, true);
				} else {
					this.addAdvice(parent, (AdviceExpressionsType) itemId, true);
				}
			}
		} else if (itemId instanceof AnyOfType && parent instanceof TargetType) {
			this.addAnyOf((TargetType) parent, (AnyOfType) itemId, true);
		} else if (itemId instanceof AllOfType && parent instanceof AnyOfType) {
			this.addAllOf((AnyOfType) parent, (AllOfType) itemId, true);
		} else if (itemId instanceof MatchType && parent instanceof AllOfType) {
			this.addMatch((AllOfType) parent, (MatchType) itemId, true);
		} else if (itemId instanceof ConditionType && parent instanceof RuleType) {
			this.addCondition((RuleType) parent, (ConditionType) itemId, true);
		} else if (itemId instanceof VariableDefinitionType && parent instanceof PolicyType) {
			this.addVariable((PolicyType) parent, (VariableDefinitionType) itemId, true);
		} else {
			throw new UnsupportedOperationException("Unknown itemid or parent type: " + itemId.getClass().getCanonicalName() + " " + parent.getClass().getCanonicalName());
		}
		//
		// Fire update event
		//
		this.fireItemSetChange();
		//
		// Create a new item
		//
		return new PolicyItem(itemId);
	}
	
	private void addVariable(PolicyType policy, VariableDefinitionType variable, boolean add) {
		if (add) {
			if (policy == null) {
				throw new NullPointerException();
			}
			policy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(variable);
		}
		this.variables.put(variable, policy);
	}

	private void addCondition(RuleType rule, ConditionType condition, boolean add) {
		if (add) {
			if (rule == null) {
				throw new NullPointerException();
			}
			rule.setCondition(condition);
		}
		this.conditions.put(condition, rule);
	}

	private void addPolicySet(PolicySetType parent, PolicySetType policySet, boolean add) {
		if (policySet == null) {
			throw new NullPointerException();
		}
		if (parent == null && this.isRoot(policySet) == false) {
			logger.warn("adding a non-root policy set with no parent");
			return;
		}
		if (add) {
			if (parent == null) {
				throw new NullPointerException();
			}
			parent.getPolicySetOrPolicyOrPolicySetIdReference().add(new ObjectFactory().createPolicySet(policySet));
		}
		this.policySets.put(policySet, parent);
		this.addTarget(policySet, policySet.getTarget(), false);
		this.addObligations(policySet, policySet.getObligationExpressions(), false);
		this.addAdvice(policySet, policySet.getAdviceExpressions(), false);
	}
	
	private void addPolicy(PolicySetType parent, PolicyType policy, boolean add) {
		if (policy == null) {
			throw new NullPointerException();
		}
		if (parent == null && this.isRoot(policy) == false) {
			logger.warn("adding a non-root policy with no parent");
			return;
		}
		if (add) {
			if (parent == null) {
				throw new NullPointerException();
			}
			parent.getPolicySetOrPolicyOrPolicySetIdReference().add(new ObjectFactory().createPolicy(policy));
		}
		this.policies.put(policy, parent);
		this.addTarget(policy, policy.getTarget(), false);
		this.addObligations(policy, policy.getObligationExpressions(), false);
		this.addAdvice(policy, policy.getAdviceExpressions(), false);
		for (Object obj : policy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition()) {
			if (obj instanceof VariableDefinitionType) {
				this.addVariable(policy, (VariableDefinitionType) obj, false);
			}
		}
	}
	
	private void addRule(PolicyType parent, RuleType rule, boolean add) {
		if (rule == null) {
			throw new NullPointerException("Rule can't be null");
		}
		if (parent == null) {
			throw new NullPointerException("Parent policy can't be null");
		}
		if (this.isRoot(parent) == false && this.policies.get(parent) == null) {
			logger.warn("Could NOT find parent as root or in map: " + parent);
			return;
		}
		if (add) {
			parent.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule);
		}
		this.rules.put(rule, parent);
		this.addTarget(rule, rule.getTarget(), false);
		this.addObligations(rule, rule.getObligationExpressions(), false);
		this.addAdvice(rule, rule.getAdviceExpressions(), false);
		this.addCondition(rule, rule.getCondition(), add);
	}
	
	private void addTarget(Object parent, TargetType target, boolean add) {
		if (target == null) {
			logger.error("TargetType is NULL");
			return;
		}
		if (add) {
			if (parent == null) {
				throw new NullPointerException();
			}
			if (parent instanceof PolicySetType) {
				((PolicySetType) parent).setTarget(target);
			} else if (parent instanceof PolicyType) {
				((PolicyType) parent).setTarget(target);
			} else if (parent instanceof RuleType) {
				((RuleType) parent).setTarget(target);
			} else {
				logger.error("Adding target to unknown class: " + parent.getClass().getCanonicalName());
			}
		}
		this.targets.put(target, parent);
		this.addAnyOfs(target);
	}
	
	private void addAnyOfs(TargetType target) {
		for (AnyOfType anyof : target.getAnyOf()) {
			this.anyofs.put(anyof, target);
			this.addAllOfs(anyof);
		}
	}
	
	private void addAnyOf(TargetType target, AnyOfType anyof, boolean add) {
		if (add) {
			target.getAnyOf().add(anyof);
		}
		this.anyofs.put(anyof, target);
	}
	
	private void addAllOfs(AnyOfType anyof) {
		for (AllOfType allof : anyof.getAllOf()) {
			this.allofs.put(allof, anyof);
			this.addMatches(allof);
		}
	}
	
	private void addAllOf(AnyOfType anyof, AllOfType allof, boolean add) {
		if (add) {
			anyof.getAllOf().add(allof);
		}
		this.allofs.put(allof, anyof);
	}
	
	private void addMatches(AllOfType allofs) {
		for (MatchType match : allofs.getMatch()) {
			this.matches.put(match, allofs);
		}
	}

	private void addMatch(AllOfType allofs, MatchType match, boolean add) {
		if (add) {
			allofs.getMatch().add(match);
		}
		this.matches.put(match, allofs);
	}

	private void addObligations(Object parent, ObligationExpressionsType expressions, boolean bAdd) {
		if (expressions == null || expressions.getObligationExpression() == null) {
			return;
		}
		if (bAdd) {
			if (parent instanceof PolicySetType) {
				((PolicySetType) parent).setObligationExpressions(expressions);
			} else if (parent instanceof PolicyType) {
				((PolicyType) parent).setObligationExpressions(expressions);
			} else if (parent instanceof RuleType) {
				((RuleType) parent).setObligationExpressions(expressions);
			}
		}
		for (ObligationExpressionType expression : expressions.getObligationExpression()) {
			this.obligations.put(expression, parent);
		}
	}
	
	private void addObligation(Object parent, ObligationExpressionType expression, boolean bAdd) {
		ObligationExpressionsType expressions = null;
		if (parent instanceof PolicySetType) {
			expressions = ((PolicySetType) parent).getObligationExpressions();
			if (expressions == null) {
				expressions = new ObligationExpressionsType();
				((PolicySetType) parent).setObligationExpressions(expressions);
			}
		} else if (parent instanceof PolicyType) {
			expressions = ((PolicyType) parent).getObligationExpressions();
			if (expressions == null) {
				expressions = new ObligationExpressionsType();
				((PolicyType) parent).setObligationExpressions(expressions);
			}
		} else if (parent instanceof RuleType) {
			expressions = ((RuleType) parent).getObligationExpressions();
			if (expressions == null) {
				expressions = new ObligationExpressionsType();
				((RuleType) parent).setObligationExpressions(expressions);
			}
		} else if (parent instanceof ObligationExpressionsType) {
			expressions = (ObligationExpressionsType) parent;
			if (bAdd) {
				expressions.getObligationExpression().add(expression);
			}
			parent = this.getParent(expressions);
			this.obligations.put(expression, parent);
			return;
		}
		if (bAdd) {
			expressions.getObligationExpression().add(expression);
		}
		this.obligations.put(expression, parent);
	}
	
	private void addAdvice(Object parent, AdviceExpressionsType expressions, boolean bAdd) {
		if (expressions == null || expressions.getAdviceExpression() == null) {
			return;
		}
		if (bAdd) {
			if (parent instanceof PolicySetType) {
				((PolicySetType) parent).setAdviceExpressions(expressions);
			} else if (parent instanceof PolicyType) {
				((PolicyType) parent).setAdviceExpressions(expressions);
			} else if (parent instanceof RuleType) {
				((RuleType) parent).setAdviceExpressions(expressions);
			}
		}
		for (AdviceExpressionType expression : expressions.getAdviceExpression()) {
			this.advice.put(expression, parent);
		}
	}
	
	private void addAdvice(Object parent, AdviceExpressionType expression, boolean bAdd) {
		AdviceExpressionsType expressions = null;
		if (parent instanceof PolicySetType) {
			expressions = ((PolicySetType) parent).getAdviceExpressions();
			if (expressions == null) {
				expressions = new AdviceExpressionsType();
				((PolicySetType) parent).setAdviceExpressions(expressions);
			}
		} else if (parent instanceof PolicyType) {
			expressions = ((PolicyType) parent).getAdviceExpressions();
			if (expressions == null) {
				expressions = new AdviceExpressionsType();
				((PolicyType) parent).setAdviceExpressions(expressions);
			}
		} else if (parent instanceof RuleType) {
			expressions = ((RuleType) parent).getAdviceExpressions();
			if (expressions == null) {
				expressions = new AdviceExpressionsType();
				((RuleType) parent).setAdviceExpressions(expressions);
			}
		} else if (parent instanceof AdviceExpressionsType) {
			expressions = (AdviceExpressionsType) parent;
			if (bAdd) {
				expressions.getAdviceExpression().add(expression);
			}
			parent = this.getParent(expressions);
			this.advice.put(expression, parent);
			return;
		}
		if (bAdd) {
			expressions.getAdviceExpression().add(expression);
		}
		this.advice.put(expression, parent);
	}
	
	@Override
	public Object addItem() throws UnsupportedOperationException {
		throw new UnsupportedOperationException("Policy Container cannot add an unknown item.");
	}

	@Override
	public boolean addContainerProperty(Object propertyId, Class<?> type,
			Object defaultValue) throws UnsupportedOperationException {
		return false;
	}

	@Override
	public boolean removeContainerProperty(Object propertyId)
			throws UnsupportedOperationException {
		return false;
	}

	@Override
	public boolean removeAllItems() throws UnsupportedOperationException {
		throw new UnsupportedOperationException("Policy Container cannot remove all items. You must have a base Policy or Policy Set.");
	}

	@Override
	public Collection<?> getChildren(Object itemId) {
		final Collection<Object> items = new ArrayList<Object>();
		
		if (itemId instanceof PolicySetType) {
			PolicySetType policySet = (PolicySetType) itemId;
			if (policySet.getTarget() != null) {
				items.add(policySet.getTarget());
			}
			if (policySet.getObligationExpressions() != null) {
				items.addAll(policySet.getObligationExpressions().getObligationExpression());
			}
			if (policySet.getAdviceExpressions() != null) {
				items.addAll(policySet.getAdviceExpressions().getAdviceExpression());
			}
			List<JAXBElement<?>> children = policySet.getPolicySetOrPolicyOrPolicySetIdReference();
			for (JAXBElement<?> element : children) {
				if (element.getName().getLocalPart().equals("PolicySet")) {
					items.add(element.getValue());
				} else if (element.getName().getLocalPart().equals("Policy")) {
					items.add(element.getValue());
				}
			}
		} else if (itemId instanceof PolicyType) {
			PolicyType policy = (PolicyType) itemId;
			if (policy.getTarget() != null) {
				items.add(policy.getTarget());
			}
			List<Object> objs = policy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition();
			for (Object obj : objs) {
				if (obj instanceof VariableDefinitionType) {
					items.add(obj);
				} else if (obj instanceof RuleType) {
					items.add(obj);
				}
			}
			if (policy.getObligationExpressions() != null) {
				items.addAll(policy.getObligationExpressions().getObligationExpression());
			}
			if (policy.getAdviceExpressions() != null) {
				items.addAll(policy.getAdviceExpressions().getAdviceExpression());
			}
		} else if (itemId instanceof RuleType) {
			RuleType rule = (RuleType) itemId;
			if (rule.getTarget() != null) {
				items.add(rule.getTarget());
			}
			if (rule.getCondition() != null) {
				items.add(rule.getCondition());
			}
			if (rule.getObligationExpressions() != null) {
				items.addAll(((RuleType) itemId).getObligationExpressions().getObligationExpression());
			}
			if (rule.getAdviceExpressions() != null) {
				items.addAll(rule.getAdviceExpressions().getAdviceExpression());
			}
		} else if (itemId instanceof TargetType) {
			for (AnyOfType anyof : ((TargetType) itemId).getAnyOf()) {
				items.add(anyof);
			}
		} else if (itemId instanceof AnyOfType) {
			for (AllOfType allof : ((AnyOfType) itemId).getAllOf()) {
				items.add(allof);
			}
		} else if (itemId instanceof AllOfType) {
			for (MatchType match : ((AllOfType) itemId).getMatch()) {
				items.add(match);
			}
		}
		if (logger.isTraceEnabled()) {
			logger.trace("getChildren: " + itemId + "(" + items.size() + ") " + items);
		}
		return Collections.unmodifiableCollection(items);
	}

	@Override
	public Object getParent(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("getParent: " + itemId);
		}
		assert itemId != null;
		if (itemId == null) {
			logger.fatal("getParent called with NULL object");
			return null;
		}
		if (itemId.equals(this.root)) {
			if (logger.isTraceEnabled()) {
				logger.trace("getParent is the root");
			}
			return null;
		}
		if (itemId instanceof PolicySetType) {
			return this.policySets.get(itemId);
		}
		if (itemId instanceof PolicyType) {
			return this.policies.get(itemId);
		}
		if (itemId instanceof RuleType) {
			return this.rules.get(itemId);
		}
		if (itemId instanceof TargetType) {
			return this.targets.get(itemId);
		}
		if (itemId instanceof ObligationExpressionType) {
			return this.obligations.get(itemId);
		}
		if (itemId instanceof AdviceExpressionType) {
			return this.advice.get(itemId);
		}
		if (itemId instanceof AllOfType) {
			return this.allofs.get(itemId);
		}
		if (itemId instanceof AnyOfType) {
			return this.anyofs.get(itemId);
		}
		if (itemId instanceof MatchType) {
			return this.matches.get(itemId);
		}
		if (itemId instanceof ConditionType) {
			return this.conditions.get(itemId);
		}
		if (itemId instanceof VariableDefinitionType) {
			return this.variables.get(itemId);
		}
		return null;
	}

	@Override
	public Collection<?> rootItemIds() {
		final Collection<Object> items = new ArrayList<Object>();
		items.add(this.root);
		if (logger.isTraceEnabled()) {
			logger.trace("rootItemIds: " + items);
		}
		return Collections.unmodifiableCollection(items);
	}
	
	@Override
	public boolean setParent(Object itemId, Object newParentId) throws UnsupportedOperationException {
		boolean result = this.setItemParent(itemId, newParentId);
		if (result == true) {
			if (logger.isTraceEnabled()) {
				logger.trace("setParent: " + itemId + " " + newParentId + " succeeded.");
			}
			this.fireItemSetChange();
		}
		return result;
	}

	protected boolean setItemParent(Object itemId, Object newParentId) throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("setItemParent: " + itemId + " " + newParentId);
		}
		if (newParentId instanceof PolicySetType) {
			return this.moveItemToPolicySet(itemId, (PolicySetType) newParentId);
		}
		if (newParentId instanceof PolicyType) {
			return this.moveItemToPolicy(itemId, (PolicyType) newParentId);
		}
		if (newParentId instanceof RuleType) {
			return this.moveItemToRule(itemId, (RuleType) newParentId);
		}
		if (newParentId instanceof TargetType) {
			return this.moveItemToTarget(itemId, (TargetType) newParentId);
		}
		if (newParentId instanceof AnyOfType) {
			return this.moveItemToAnyOf(itemId, (AnyOfType) newParentId);
		}
		if (newParentId instanceof AllOfType) {
			return this.moveItemToAllOf(itemId, (AllOfType) newParentId);
		}
		return false;
	}
	
	protected boolean moveItemToPolicySet(Object itemId, PolicySetType policySet) {
		if (itemId instanceof PolicySetType) {
			
			if (this.doRemoveItem(itemId)) {
				this.addPolicySet(policySet, (PolicySetType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof PolicyType) {
			if (this.doRemoveItem(itemId)) {
				this.addPolicy(policySet, (PolicyType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof TargetType) {
			if (this.doRemoveItem(itemId)) {
				this.addTarget(policySet, (TargetType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof ObligationExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addObligation(policySet, (ObligationExpressionType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof AdviceExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addAdvice(policySet, (AdviceExpressionType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to Policy Set: " + itemId.getClass().getCanonicalName());
		return false;
	}
	
	protected boolean moveItemToPolicy(Object itemId, PolicyType policy) {
		if (itemId instanceof RuleType) {
			if (this.doRemoveItem(itemId)) {
				this.addRule(policy, (RuleType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof TargetType) {
			if (this.doRemoveItem(itemId)) {
				this.addTarget(policy, (TargetType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof ObligationExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addObligation(policy, (ObligationExpressionType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof AdviceExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addAdvice(policy, (AdviceExpressionType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof VariableDefinitionType) {
			if (this.doRemoveItem(itemId)) {
				this.addVariable(policy, (VariableDefinitionType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to Policy: " + itemId.getClass().getCanonicalName());
		return false;
	}
	
	protected boolean moveItemToRule(Object itemId, RuleType rule) {
		if (itemId instanceof TargetType) {
			if (this.doRemoveItem(itemId)) {
				this.addTarget(rule, (TargetType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof ObligationExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addObligation(rule, (ObligationExpressionType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof AdviceExpressionType) {
			if (this.doRemoveItem(itemId)) {
				this.addAdvice(rule, (AdviceExpressionsType) itemId, true);
				return true;
			}
			return false;
		} else if (itemId instanceof ConditionType) {
			if (this.doRemoveItem(itemId)) {
				this.addCondition(rule, (ConditionType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to Rule: " + itemId.getClass().getCanonicalName());
		return false;
	}
	
	protected boolean moveItemToTarget(Object itemId, TargetType target) {
		if (itemId instanceof AnyOfType) {
			if (this.doRemoveItem(itemId)) {
				this.addAnyOf(target, (AnyOfType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to target: " + itemId.getClass().getCanonicalName());
		return false;
	}
	
	protected boolean moveItemToAnyOf(Object itemId, AnyOfType anyOf) {
		if (itemId instanceof AllOfType) {
			if (this.doRemoveItem(itemId)) {
				this.addAllOf(anyOf, (AllOfType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to anyOf: " + itemId.getClass().getCanonicalName());
		return false;
	}
	
	protected boolean moveItemToAllOf(Object itemId, AllOfType allOf) {
		if (itemId instanceof MatchType) {
			if (this.doRemoveItem(itemId)) {
				this.addMatch(allOf, (MatchType) itemId, true);
				return true;
			}
			return false;
		}
		logger.warn("Can't move this item to allOf: " + itemId.getClass().getCanonicalName());
		return false;
	}

	@Override
	public boolean areChildrenAllowed(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("areChildrenAllowed: " + itemId);
		}
		if (itemId instanceof MatchType ||
			itemId instanceof ObligationExpressionType ||
			itemId instanceof AdviceExpressionType ||
			itemId instanceof ConditionType ||
			itemId instanceof VariableDefinitionType) {
			return false;
		}
		return true;
	}

	@Override
	public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed)
			throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("setChildrenAllowed: " + itemId + " " + areChildrenAllowed);
		}
		if (itemId instanceof MatchType ||
			itemId instanceof ObligationExpressionType ||
			itemId instanceof AdviceExpressionType ||
			itemId instanceof ConditionType ||
			itemId instanceof VariableDefinitionType) {
			if (areChildrenAllowed == true) {
				return false;
			}
			return true;
		}
		if (areChildrenAllowed == false) {
			return false;
		}
		return true;
	}

	@Override
	public boolean isRoot(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("isRoot: " + itemId);
		}
		assert itemId != null;
		if (itemId == null) {
			//
			// This usually means the container's map's are screwed up.
			//
			logger.error("NULL isRoot item");
			return false;
		}
		if (itemId instanceof PolicyType && this.root instanceof PolicyType && itemId.equals(this.root)) {
			return true;
		} else if (itemId instanceof PolicySetType && this.root instanceof PolicySetType && itemId.equals(this.root)) {
			return true;
		}
		return false;
	}

	@Override
	public boolean hasChildren(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("hasChildren: " + itemId);
		}
		if (itemId instanceof MatchType ||
			itemId instanceof ObligationExpressionType ||
			itemId instanceof AdviceExpressionType ||
			itemId instanceof ConditionType ||
			itemId instanceof VariableDefinitionType) {
			return false;
		}
		return true;
	}

	@Override
	public boolean removeItem(Object itemId) throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("removeItem: " + itemId);
		}
		boolean result = this.doRemoveItem(itemId);
		if (result) {
			this.fireItemSetChange();
		}
		return result;
	}
	
	protected boolean doRemoveItem(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("doRemoveItem: " + itemId);
		}
		if (itemId instanceof PolicySetType) {
			PolicySetType parent = this.policySets.get(itemId);
			if (parent == null) {
				logger.error("policy set not found in map");
				assert false;
				return false;
			}
			return this.removePolicySetFromPolicySet(parent, (PolicySetType) itemId);
		} else if (itemId instanceof PolicyType) {
			PolicySetType parent = this.policies.get(itemId);
			if (parent == null) {
				logger.error("policy not found in map");
				assert false;
				return false;
			}
			return this.removePolicyFromPolicySet(parent, (PolicyType) itemId);
		} else if (itemId instanceof RuleType) {
			PolicyType parent = this.rules.get(itemId);
			if (parent == null) {
				logger.error("rule not found in map");
				assert false;
				return false;
			}
			if (parent.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().remove(itemId)) {
				this.removeRule((RuleType) itemId);
				return true;
			}
			logger.error("Failed to remove rule from parent policy");
			assert false;
			return false;
		} else if (itemId instanceof TargetType) {
			throw new UnsupportedOperationException("Cannot remove TargetType directly - please remove it via PolicySet/Policy/Rule");
		} else if (itemId instanceof ObligationExpressionType) {
			Object parent = this.obligations.get(itemId);
			if (parent == null) {
				logger.error("obligation not found in map");
				assert false;
				return false;
			}
			if (parent instanceof PolicySetType) {
				if (((PolicySetType) parent).getObligationExpressions() != null) {
					if (((PolicySetType) parent).getObligationExpressions().getObligationExpression().remove(itemId) == false) {
						logger.error("Failed to remove obligation expression from policy set");
						assert false;
						return false;
					}
				} else {
					logger.error("policy set does not contain obligation expressions, cannot remove");
					assert false;
					return false;
				}
			} else if (parent instanceof PolicyType) {
				if (((PolicyType) parent).getObligationExpressions() != null) {
					if (((PolicyType) parent).getObligationExpressions().getObligationExpression().remove(itemId) == false) {
						logger.error("Failed to remove obligation expression from policy");
						assert false;
						return false;
					}
				} else {
					logger.error("policy does not contain obligation expressions, cannot remove");
					assert false;
					return false;
				}
			} else if (parent instanceof RuleType) {
				if (((RuleType) parent).getObligationExpressions() != null) {
					if (((RuleType) parent).getObligationExpressions().getObligationExpression().remove(itemId) == false) {
						logger.error("Failed to remove obligation expression from policy set");
						assert false;
						return false;
					}
				} else {
					logger.error("rule does not contain obligation expressions, cannot remove");
					assert false;
					return false;
				}
			} else {
				logger.error("Unknown parent for obligation: " + parent.getClass().getCanonicalName());
				assert false;
				return false;
			}
			if (this.obligations.remove(itemId) == null) {
				logger.error("obligation map does not contain itemId");
				assert false;
			}
			return true;
		} else if (itemId instanceof AdviceExpressionType) {
			Object parent = this.advice.get(itemId);
			if (parent == null) {
				logger.error("advice not found in map");
				assert false;
				return false;
			}
			if (parent instanceof PolicySetType) {
				if (((PolicySetType) parent).getAdviceExpressions() != null) {
					if (((PolicySetType) parent).getAdviceExpressions().getAdviceExpression().remove(itemId) == false) {
						logger.error("Failed to remove advice expression from policy set");
						assert false;
						return false;
					}
				} else {
					logger.error("policy set does not contain advice expressions, cannot remove");
					assert false;
					return false;
				}
			} else if (parent instanceof PolicyType) {
				if (((PolicyType) parent).getAdviceExpressions() != null) {
					if (((PolicyType) parent).getAdviceExpressions().getAdviceExpression().remove(itemId) == false) {
						logger.error("Failed to remove advice expression from policy");
						assert false;
						return false;
					}
				} else {
					logger.error("policy does not contain advice expressions, cannot remove");
					assert false;
					return false;
				}
			} else if (parent instanceof RuleType) {
				if (((RuleType) parent).getAdviceExpressions() != null) {
					if (((RuleType) parent).getAdviceExpressions().getAdviceExpression().remove(itemId) == false) {
						logger.error("Failed to remove advice expression from rule");
						assert false;
						return false;
					}
				} else {
					logger.error("rule does not contain advice expressions, cannot remove");
					assert false;
					return false;
				}
			} else {
				logger.error("Unknown parent for advice: " + parent.getClass().getCanonicalName());
				assert false;
				return false;
			}
			if (this.advice.remove((AdviceExpressionType) itemId) == null) {
				logger.error("obligation map does not contain itemId");
				assert false;
			}
			return true;
		} else if (itemId instanceof AnyOfType) {
			TargetType parent = this.anyofs.get(itemId);
			if (parent == null) {
				logger.error("anyof not found in map");
				assert false;
				return false;
			}
			if (parent.getAnyOf().remove(itemId)) {
				this.removeAnyOf((AnyOfType) itemId);
				return true;
			} else {
				logger.error("Failed to remove itemId from target");
				assert false;
				return false;
			}
		} else if (itemId instanceof AllOfType) {
			AnyOfType parent = this.allofs.get(itemId);
			if (parent == null) {
				logger.error("allof not found in map");
				assert false;
				return false;
			}
			if (parent.getAllOf().remove(itemId)) {
				this.removeAllOf((AllOfType) itemId);
				return true;
			} else {
				logger.error("Failed to remove itemId from anyOf");
				assert false;
				return false;
			}
		} else if (itemId instanceof MatchType) {
			AllOfType parent = this.matches.get(itemId);
			if (parent == null) {
				logger.error("match not found in map");
				assert false;
				return false;
			}
			if (parent.getMatch().remove(itemId)) {
				this.removeMatch((MatchType) itemId);
				return true;
			} else {
				logger.error("Failed to remove itemId from allOf");
				assert false;
				return false;
			}
		} else if (itemId instanceof ConditionType) {
			RuleType rule = this.conditions.get(itemId);
			if (rule != null) {
				rule.setCondition(null);
				if (this.conditions.remove(itemId) == null) {
					logger.error("Failed to remove condition from map");
					assert false;
					return false;
				}
				return true;
			} else {
				logger.error("condition not found in map");
				assert false;
				return false;
			}
		} else if (itemId instanceof VariableDefinitionType) {
			PolicyType policy = this.variables.get(itemId);
			if (policy != null) {
				if (policy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().remove(itemId)) {
					if (this.variables.remove(itemId) == null) {
						logger.error("failed to remove variable from map");
						assert false;
						return false;
					}
					return true;
				} else {
					logger.error("failed to remove variable from policy");
					assert false;
					return false;
				}
			} else {
				logger.error("variable not found in map");
				assert false;
				return false;
			}
		}
		logger.error("Failed to remove policy set from policy set, not found.");
		return false;
	}
	
	protected boolean removePolicyFromPolicySet(PolicySetType parent, PolicyType policy) {
		for (JAXBElement<?> element : parent.getPolicySetOrPolicyOrPolicySetIdReference()) {
			if (PolicyType.class.isAssignableFrom(element.getDeclaredType()) &&
						((PolicyType) element.getValue()).getPolicyId().equals(policy.getPolicyId())) {
				if (parent.getPolicySetOrPolicyOrPolicySetIdReference().remove(element)) {
					this.removePolicy(policy);
					return true;
				}
				logger.error("Failed to remove policy from parent policy set");
				assert false;
				return false;
			}
		}
		logger.error("Failed to remove policy from policy set, not found.");
		return false;
	}

	protected boolean removePolicySetFromPolicySet(PolicySetType parent, PolicySetType policySet) {
		for (JAXBElement<?> element : parent.getPolicySetOrPolicyOrPolicySetIdReference()) {
			if (PolicySetType.class.isAssignableFrom(element.getDeclaredType())) {
				logger.info(element);
				if (((PolicySetType) element.getValue()).getPolicySetId().equals(policySet.getPolicySetId())) {
					if (parent.getPolicySetOrPolicyOrPolicySetIdReference().remove(element)) {
						this.removePolicySet(policySet);
						return true;
					}
					logger.error("Failed to remove policy set from parent policy set");
					assert false;
					return false;
				}
			}
		}
		return false;
	}
	
	protected void removePolicySet(PolicySetType policySet) {
		if (this.policySets.remove(policySet) == null) {
			logger.warn("Failed to remove policy set from map: " + policySet);
			return;
		}
		//
		// Remove its objects from the other maps
		//
		this.removeTarget(policySet.getTarget());
		this.removeObligations(policySet.getObligationExpressions());
		this.removeAdvice(policySet.getAdviceExpressions());
	}
	
	protected void removePolicy(PolicyType policy) {
		if (this.policies.remove(policy) == null) {
			logger.warn("Failed to remove policy from map: " + policy);
			return;
		}
		//
		// Remove its objects from the other maps
		//
		this.removeTarget(policy.getTarget());
		this.removeObligations(policy.getObligationExpressions());
		this.removeAdvice(policy.getAdviceExpressions());
		this.removeVariables(policy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition());
	}
	
	protected void removeVariables(List<Object> combinerParametersOrRuleCombinerParametersOrVariableDefinition) {
		for (Object object : combinerParametersOrRuleCombinerParametersOrVariableDefinition) {
			if (object instanceof VariableDefinitionType) {
				this.variables.remove(object);
			}
		}
	}

	protected void removeRule(RuleType rule) {
		if (this.rules.remove(rule) == null) {
			logger.warn("Failed to remove rule from map: " + rule);
			return;
		}
		//
		// Remove its objects from the other maps
		//
		this.removeTarget(rule.getTarget());
		this.removeObligations(rule.getObligationExpressions());
		this.removeAdvice(rule.getAdviceExpressions());
		if (rule.getCondition() != null) {
			this.conditions.remove(rule.getCondition());
		}
	}
	
	protected void removeObligations(ObligationExpressionsType expressions) {
		if (expressions == null) {
			return;
		}
		for (ObligationExpressionType expression : expressions.getObligationExpression()) {
			if (this.obligations.remove(expression) == null) {
				logger.warn("Failed to remove obligation expression: " + expression);
			}
		}
	}
	
	protected void removeAdvice(AdviceExpressionsType expressions) {
		if (expressions == null) {
			return;
		}
		for (AdviceExpressionType expression : expressions.getAdviceExpression()) {
			if (this.advice.remove(expression) == null) {
				logger.warn("Failed to remove advice expression: " + expression);
			}
		}
	}
	
	protected void removeTarget(TargetType target) {
		if (this.targets.remove(target) == null) {
			logger.warn("Failed to remove target from map: " + target);
			return;
		}
		for (AnyOfType anyof : target.getAnyOf()) {
			this.removeAnyOf(anyof);
		}
	}
	
	protected void removeAnyOf(AnyOfType anyof) {
		if (this.anyofs.remove(anyof) == null) {
			logger.warn("failed to remove anyof from map: " + anyof);
			return;
		}
		for (AllOfType allof : anyof.getAllOf()) {
			this.removeAllOf(allof);
		}
	}
	
	protected void removeAllOf(AllOfType allof) {
		if (this.allofs.remove(allof) == null) {
			logger.warn("failed to remove allof from map: " + allof);
			return;
		}
		for (MatchType match : allof.getMatch()) {
			this.removeMatch(match);
		}
	}
	
	protected void removeMatch(MatchType match) {
		if (this.matches.remove(match) == null) {
			logger.warn("failed to remove match from map: " + match);
			return;
		}
	}

	@Override
	public Object nextItemId(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("nextItemId: " + itemId);
		}
		return null;
	}

	@Override
	public Object prevItemId(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("prevItemId: " + itemId);
		}
		return null;
	}

	@Override
	public Object firstItemId() {
		if (logger.isTraceEnabled()) {
			logger.trace("firstItemId: ");
		}
		return this.root;
	}

	@Override
	public Object lastItemId() {
		if (logger.isTraceEnabled()) {
			logger.trace("lastItemId: ");
		}
		return null;
	}

	@Override
	public boolean isFirstId(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("isFirstId: " + itemId);
		}
		//
		// The Oasis classes do not have equals implemented. So I am
		// not too sure that using equals works.
		//
		if (this.root != null && itemId != null) {
			return this.root.equals(itemId);
		}
		if (logger.isTraceEnabled()) {
			logger.trace("item is NOT the first ID" +  itemId);
		}
		return false;
	}

	@Override
	public boolean isLastId(Object itemId) {
		if (logger.isTraceEnabled()) {
			logger.trace("isLastId: " + itemId);
		}
		return false;
	}

	@Override
	public Object addItemAfter(Object previousItemId) throws UnsupportedOperationException {
		throw new UnsupportedOperationException("Need to know what you want added. Please use addItemAfter(Object, Object) instead.");
	}

	@Override
	public Item addItemAfter(Object previousItemId, Object newItemId) throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("addItemAfter: " + previousItemId + " new " + newItemId);
		}
		/*
		if (newItemId instanceof PolicySetType) {
			
		}
		//
		// Get our parents
		//
		Object parentPreviousItem = this.getParent(previousItemId);
		*/
		return null;
	}
	
	public Item moveAfterSibling(Object itemId, Object siblingId) throws UnsupportedOperationException {
		if (logger.isTraceEnabled()) {
			logger.trace("moveAfterSibling: " + itemId + " sibling " + siblingId);
		}
		//
		// Get the parents, which should be the same
		//
		/*
		Object itemParent = this.getParent(itemId);
		Object siblingParent = this.getParent(siblingId);
		if (itemParent == null) {
			logger.error("can't move the root element");
			return null;
		}
		if (itemParent != siblingParent) {
			logger.error("parents are not the same");
			return null;
		}
		if (itemId instanceof PolicySetType) {
			assert(itemParent instanceof PolicySetType);
			if (itemParent instanceof PolicySetType) {
				if (siblingId instanceof PolicySetType || siblingId instanceof PolicyType) {
					int index = ((PolicySetType) itemParent).getPolicySetOrPolicyOrPolicySetIdReference().indexOf(siblingId);
					
				}				
			}
		}
		*/
		return null;
	}

	/**
	 * This class is returned to caller's to display the properties
	 * for each policy object.
	 * 
	 * @author pameladragosh
	 *
	 */
	public class PolicyItem implements Item {
		private static final long serialVersionUID = 1L;
		private final Object data;
		
		public PolicyItem(Object data) {
			this.data = data;
		}

		public String getName() {
			if (this.data instanceof RuleType) {
				return "Rule";
			}
			if (this.data instanceof PolicyType) {
				return "Policy";
			}
			if (this.data instanceof PolicySetType) {
				return "Policy Set";
			}
			if (this.data instanceof TargetType) {
				return "Target";
			}
			if (this.data instanceof AnyOfType) {
				return "Any Of";
			}
			if (this.data instanceof AllOfType) {
				return "All Of";
			}
			if (this.data instanceof MatchType) {
				return "Match";
			}
			if (this.data instanceof ObligationExpressionType) {
				return "Obligation";
			}
			if (this.data instanceof AdviceExpressionType) {
				return "Advice";
			}
			if (this.data instanceof ConditionType) {
				return "Condition";
			}
			if (this.data instanceof VariableDefinitionType) {
				return "Variable";
			}
			return null;
		}
		
		public String getId() {
			if (this.data instanceof RuleType) {
				return ((RuleType) this.data).getRuleId();
			} 
			if (this.data instanceof PolicyType) {
				return ((PolicyType) this.data).getPolicyId();
			}
			if (this.data instanceof PolicySetType) {
				return ((PolicySetType) this.data).getPolicySetId();
			}
			if (this.data instanceof ObligationExpressionType) {
				return ((ObligationExpressionType) this.data).getObligationId();
			}
			if (this.data instanceof AdviceExpressionType) {
				return ((AdviceExpressionType) this.data).getAdviceId();
			}
			/*
			if (this.data instanceof TargetType) {
				return this.data.toString();
			}
			if (this.data instanceof AnyOfType) {
				return this.data.toString();
			}
			if (this.data instanceof AllOfType) {
				return this.data.toString();
			}
			if (this.data instanceof MatchType) {
				((MatchType) this.data).getMatchId();
			}
			*/
			if (this.data instanceof VariableDefinitionType) {
				((VariableDefinitionType) this.data).getVariableId();
			}
			return null;
		}
		
		public String getShortId() {
			String id = this.getId();
			if (id == null) {
				return null;
			}
			String[] parts = id.split("[:]");
			
			if (parts != null && parts.length > 0) {
				return parts[parts.length - 1];
			}
			
			return null;
		}
		
		public String getDescription() {
			if (this.data instanceof RuleType) {
				return ((RuleType) this.data).getDescription();
			} else if (this.data instanceof PolicyType) {
				return ((PolicyType) this.data).getDescription();
			} else if (this.data instanceof PolicySetType) {
				return ((PolicySetType) this.data).getDescription();
			} else if (this.data instanceof MatchType) {
				StringBuilder builder = new StringBuilder();
				AttributeValueType value = ((MatchType) this.data).getAttributeValue();
				if (value != null) {
					builder.append(value.getContent());
					builder.append(" ");
				}
				String alg = this.getShortAlgorithm();
				if (alg != null && alg.length() > 0) {
					builder.append(alg);
					builder.append(" ");
				}
				if (((MatchType) this.data).getAttributeDesignator() != null) {
					builder.append(((MatchType) this.data).getAttributeDesignator().getAttributeId());
				} else if (((MatchType) this.data).getAttributeSelector() != null) {
					builder.append(((MatchType) this.data).getAttributeSelector().getContextSelectorId());
				}
				return builder.toString();
			}
			return null;
		}
		
		public String getAlgorithm() {
			if (this.data instanceof PolicyType) {
				return ((PolicyType) this.data).getRuleCombiningAlgId();
			}
			if (this.data instanceof PolicySetType) {
				return ((PolicySetType) this.data).getPolicyCombiningAlgId();
			}
			if (this.data instanceof RuleType) {
				return ((RuleType) this.data).getEffect().toString();
			}
			if (this.data instanceof MatchType) {
				return ((MatchType) this.data).getMatchId();
			}
			if (this.data instanceof ObligationExpressionType) {
				return ((ObligationExpressionType) this.data).getFulfillOn().toString();
			}
			if (this.data instanceof AdviceExpressionType) {
				return ((AdviceExpressionType) this.data).getAppliesTo().toString();
			}
			if (this.data instanceof ConditionType) {
				return this.getRootExpressionFunction(((ConditionType) this.data).getExpression());
			}
			if (this.data instanceof VariableDefinitionType) {
				//return this.getRootExpressionFunction(((VariableDefinitionType) this.data).getExpression());
				return ((VariableDefinitionType) this.data).getVariableId();
			}
			return null;
		}
		
		public String getShortAlgorithm() {
			String algorithm = null;
			if (this.data instanceof PolicyType) {
				algorithm = ((PolicyType) this.data).getRuleCombiningAlgId();
			}
			if (this.data instanceof PolicySetType) {
				algorithm = ((PolicySetType) this.data).getPolicyCombiningAlgId();
			}
			if (this.data instanceof RuleType) {
				return ((RuleType) this.data).getEffect().toString();
			}
			if (this.data instanceof ObligationExpressionType) {
				return ((ObligationExpressionType) this.data).getFulfillOn().toString();
			}
			if (this.data instanceof AdviceExpressionType) {
				return ((AdviceExpressionType) this.data).getAppliesTo().toString();
			}
			if (this.data instanceof MatchType) {
				algorithm = ((MatchType) this.data).getMatchId();
			}
			if (this.data instanceof ConditionType) {
				algorithm = this.getRootExpressionFunction(((ConditionType) this.data).getExpression());
				if (algorithm.startsWith("http")) {
					return algorithm;
				}
			}
			if (this.data instanceof VariableDefinitionType) {
				//algorithm = this.getRootExpressionFunction(((VariableDefinitionType) this.data).getExpression());
				return ((VariableDefinitionType) this.data).getVariableId();
			}
			if (algorithm != null) {
				Iterable<String> fields = Splitter.on(':').trimResults().omitEmptyStrings().split(algorithm);
				if (fields != null) {
					String lastId = null;
					for (String id : fields) {
						lastId = id;
					}
					return lastId;
				}
			}
			return null;
		}
		
        public Resource getIcon() {
			if (this.data instanceof PolicySetType) {
				return new ThemeResource("../runo/icons/16/folder.png");
			}
			if (this.data instanceof RuleType) {
				if (((RuleType) this.data).getEffect() == null) {
					logger.warn("Rule has a null Effect");
					return new ThemeResource("icons/deny-16.png");
				}
				if (((RuleType) this.data).getEffect() == EffectType.DENY) {
					return new ThemeResource("icons/deny-16.png");
				}
				return new ThemeResource("icons/permit-16.png");
			}
			if (this.data instanceof PolicyType) {
				return new ThemeResource("../runo/icons/16/document-txt.png");
			}
			if (this.data instanceof TargetType) {
				return new ThemeResource("icons/target-green-16.png");
			}
			if (this.data instanceof ObligationExpressionType) {
				return new ThemeResource("icons/obligation-16.png");
			}
			if (this.data instanceof AdviceExpressionType) {
				return new ThemeResource("icons/advice-16.png");
			}
			if (this.data instanceof ConditionType) {
				return new ThemeResource("icons/condition-16.png");
			}
			if (this.data instanceof VariableDefinitionType) {
				return new ThemeResource("icons/variable-16.png");
			}
			return null;
        }
        
        public String getStatus() {
        	StringBuffer buffer = new StringBuffer();
        	String a = this.getAlgorithm();
        	//String id = this.getId();
			if (this.data instanceof RuleType) {
				RuleType rule = ((RuleType) this.data);
				buffer.append("Rule");
				EffectType effect = rule.getEffect();
				if (effect == null) {
					rule.setEffect(EffectType.PERMIT);
				}
				if (rule.getEffect() == EffectType.PERMIT) {
					buffer.append(" (PERMIT)");
				} else if (rule.getEffect() == EffectType.DENY) {
					buffer.append(" (DENY)");
				}
			} else if (this.data instanceof PolicyType) {
				buffer.append("Policy");
			} else if (this.data instanceof PolicySetType) {
				buffer.append("Policy Set");
			}
			/*
			if (id != null) {
				String[] ids = id.split("[:]");
				if (ids.length > 0) {
					buffer.append(" " + ids[ids.length - 1]);
				}
			}
			*/
			if (a != null) {
				String[] algs = a.split("[:]");
				if (algs.length > 0) {
					buffer.append(" (" + algs[algs.length - 1] + ")");
				}
			}
			/*
			String d = this.getDescription();
			if (d != null) {
				buffer.append(" " + d);
			}
			*/
			return buffer.toString();
        }
        
        public Table getAttributes() {
        	/*
        	if (this.data instanceof MatchType) {
        		
        	}
        	*/
        	return null;
        }
        
        protected	String	getRootExpressionFunction(JAXBElement<?> element) {
        	if (element == null || element.getValue() == null) {
        		return null;
        	}
        	Object value = element.getValue();
        	if (value instanceof ApplyType) {
        		return ((ApplyType) value).getFunctionId();
        	}
        	if (value instanceof AttributeValueType) {
        		return ((AttributeValueType) value).getDataType();
        	}
        	if (value instanceof AttributeDesignatorType) {
        		return ((AttributeDesignatorType) value).getAttributeId();
        	}
        	if (value instanceof AttributeSelectorType) {
        		return ((AttributeSelectorType) value).getContextSelectorId();
        	}
        	if (value instanceof VariableReferenceType) {
        		return "Variable=" + ((VariableReferenceType) value).getVariableId();
        	}
        	if (value instanceof FunctionType) {
        		return ((FunctionType) value).getFunctionId();
        	}
        	return null;
        }
        
		@Override
		public Property<?> getItemProperty(Object id) {
            return getContainerProperty(data, id);
		}

		@Override
		public Collection<?> getItemPropertyIds() {
            return getContainerPropertyIds();
		}

		@SuppressWarnings("rawtypes")
		@Override
		public boolean addItemProperty(Object id, Property property) throws UnsupportedOperationException {
            throw new UnsupportedOperationException("Policy container does not support adding new properties");
		}

		@Override
		public boolean removeItemProperty(Object id) throws UnsupportedOperationException {
            throw new UnsupportedOperationException("Policy container does not support property removal");
		}

		@Override
		public String toString() {
			return this.getName();
		}
		
	}
}