/FileExtraction/Java_unseen/dlitz_resin/modules/extra/src/com/caucho/jcr/base/BaseNodeType.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.jcr.base;

import javax.jcr.PropertyType;
import javax.jcr.Value;
import javax.jcr.nodetype.NodeDefinition;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.PropertyDefinition;
import javax.jcr.version.OnParentVersionAction;
import java.util.ArrayList;

/**
 * Represents a node type.
 */
public class BaseNodeType implements NodeType {
  public static final BaseNodeType MIX_REFERENCEABLE;
  
  public static final BaseNodeType NT_BASE;
  
  public static final BaseNodeType NT_HIERARCHY_NODE;
  public static final BaseNodeType NT_FILE;
  public static final BaseNodeType NT_FOLDER;
  public static final BaseNodeType NT_RESOURCE;
  
  private final String _name;
  
  private final NodeType []_declaredSuperTypes;
  
  private final NodeType []_superTypes;

  private boolean _isMixin;
  
  private boolean _hasOrderableChildNodes;

  private String _primaryItemName;
  
  private ArrayList<PropertyDefinition> _properties
    = new ArrayList<PropertyDefinition>();

  private ArrayList<NodeDefinition> _childNodes
    = new ArrayList<NodeDefinition>();

  public BaseNodeType(String name,
                      NodeType []declaredSuperTypes)
  {
    _name = name;
    _declaredSuperTypes = declaredSuperTypes;

    ArrayList<NodeType> superTypes = new ArrayList<NodeType>();

    for (NodeType type : declaredSuperTypes) {
      if (! superTypes.contains(type))
        superTypes.add(type);

      for (NodeType parentType : type.getSupertypes()) {
        if (! superTypes.contains(parentType))
          superTypes.add(parentType);
      }
    }

    _superTypes = new NodeType[superTypes.size()];
    superTypes.toArray(_superTypes);
  }

  public BaseNodeType(String name, NodeType superType)
  {
    this(name, new NodeType[] { superType });
  }
  
  /**
   * Returns the node type's name.
   */
  public String getName()
  {
    return _name;
  }

  /**
   * Returns true for a mixin node type.
   */
  public boolean isMixin()
  {
    return _isMixin;
  }

  /**
   * Set true for a mixin node type.
   */
  public void setMixin(boolean isMixin)
  {
    _isMixin = isMixin;
  }

  /**
   * Returns true if this node type has orderable children.
   */
  public boolean hasOrderableChildNodes()
  {
    return _hasOrderableChildNodes;
  }

  /**
   * SEt true if this node type has orderable children.
   */
  public void setHasOrderableChildNodes(boolean hasOrder)
  {
    _hasOrderableChildNodes = hasOrder;
  }

  /**
   * Returns the main item name.
   */
  public String getPrimaryItemName()
  {
    return _primaryItemName;
  }

  /**
   * Returns the main item type.
   */
  public void setPrimaryItemName(String name)
  {
    _primaryItemName = name;
  }

  /**
   * Returns all supertypes of the node type.
   */
  public NodeType[] getSupertypes()
  {
    return _superTypes;
  }

  /**
   * Returns the immediate supertypes of the node type.
   */
  public NodeType[] getDeclaredSupertypes()
  {
    return _declaredSuperTypes;
  }

  /**
   * Returns true if the given node type is valid.
   */
  public boolean isNodeType(String nodeTypeName)
  {
    return false;
  }

  /**
   * Returns the properties defined for the node.
   */
  public PropertyDefinition[] getPropertyDefinitions()
  {
    return getDeclaredPropertyDefinitions();
  }
  
  /**
   * Returns the immediate properties defined for the node.
   */
  public PropertyDefinition[] getDeclaredPropertyDefinitions()
  {
    PropertyDefinition []props;

    props = new PropertyDefinition[_properties.size()];
    _properties.toArray(props);
    
    return props;
  }

  /**
   * Adds a property definition.
   */
  public void addProperty(PropertyDefinition prop)
  {
    _properties.add(prop);
  }
  
  /**
   * Returns the allowed children.
   */
  public NodeDefinition[] getChildNodeDefinitions()
  {
    return getDeclaredChildNodeDefinitions();
  }
  
  /**
   * Returns the direct children.
   */
  public NodeDefinition[] getDeclaredChildNodeDefinitions()
  {
    NodeDefinition []children;

    children = new NodeDefinition[_childNodes.size()];
    _childNodes.toArray(children);
    
    return children;
  }

  /**
   * Adds a child node.
   */
  public void addChildNode(NodeDefinition child)
  {
    _childNodes.add(child);
  }

  /**
   * Returns true if the given property can be set with the given value.
   */
  public boolean canSetProperty(String propertyName, Value value)
  {
    return false;
  }
  
  /**
   * Returns true if the given property can be set with the given value.
   */
  public boolean canSetProperty(String propertyName, Value[] values)
  {
    return false;
  }
  
  /**
   * Returns true if this node type can add a child node.
   */
  public boolean canAddChildNode(String childNodeName)
  {
    return false;
  }
  
  /**
   * Returns true if this node type can add a child node with the given type..
   */
  public boolean canAddChildNode(String childNodeName, String nodeTypeName)
  {
    return false;
  }
  
  /**
   * Returns true if this node type can remove an item.
   */
  public boolean canRemoveItem(String itemName)
  {
    return false;
  }

  public int hashCode()
  {
    return getName().hashCode();
  }
  
  public boolean equals(Object o)
  {
    if (this == o)
      return true;
    else if (! (o instanceof BaseNodeType))
      return false;

    BaseNodeType nodeType = (BaseNodeType) o;

    return getName().equals(nodeType.getName());
  }

  public String toString()
  {
    return "BaseNodeType[" + getName() + "]";
  }

  static {
    BasePropertyDefinition prop;
    BaseNodeDefinition child;

    // mix:referenceable
    
    MIX_REFERENCEABLE = new BaseNodeType("mix:referenceable", new NodeType[0]);

    // nt:base

    NT_BASE = new BaseNodeType("nt:base", new NodeType[0]);

    prop = new BasePropertyDefinition("jcr:primaryType", NT_BASE,
                                      PropertyType.NAME);
    prop.setAutoCreated(true);
    prop.setMandatory(true);
    prop.setOnParentVersion(OnParentVersionAction.COMPUTE);
    prop.setProtected(true);
    NT_BASE.addProperty(prop);

    prop = new BasePropertyDefinition("jcr:mixinTypes", NT_BASE,
                                      PropertyType.NAME);
    prop.setOnParentVersion(OnParentVersionAction.COMPUTE);
    prop.setProtected(true);
    prop.setMultiple(true);
    NT_BASE.addProperty(prop);

    // nt:unstructured - XXX: skip

    // nt:hierarchyNode

    NT_HIERARCHY_NODE = new BaseNodeType("nt:hierarchyNode", NT_BASE);

    prop = new BasePropertyDefinition("jcr:created", NT_HIERARCHY_NODE,
                                      PropertyType.DATE);
    prop.setAutoCreated(true);
    prop.setOnParentVersion(OnParentVersionAction.INITIALIZE);
    prop.setProtected(true);
    NT_HIERARCHY_NODE.addProperty(prop);

    // nt:file

    NT_FILE = new BaseNodeType("nt:file", NT_HIERARCHY_NODE);
    NT_FILE.setPrimaryItemName("jcr:content");

    child = new BaseNodeDefinition("jcr:content", NT_FILE);
    child.setRequiredPrimaryTypes(new NodeType[] { NT_BASE });
    child.setMandatory(true);
    NT_FILE.addChildNode(child);

    // nt:linkedFile - XXX: skip

    // nt:folder

    NT_FOLDER = new BaseNodeType("nt:folder", NT_HIERARCHY_NODE);

    child = new BaseNodeDefinition("*", NT_FOLDER);
    child.setRequiredPrimaryTypes(new NodeType[] { NT_HIERARCHY_NODE });
    child.setOnParentVersion(OnParentVersionAction.VERSION);
    
    // nt:resource
    
    NT_RESOURCE = new BaseNodeType("nt:resource",
                                 new NodeType[] { NT_HIERARCHY_NODE,
                                                  MIX_REFERENCEABLE });
    NT_RESOURCE.setPrimaryItemName("jcr:data");

    prop = new BasePropertyDefinition("jcr:encoding", NT_RESOURCE,
                                      PropertyType.STRING);
    NT_FOLDER.addProperty(prop);

    prop = new BasePropertyDefinition("jcr:mimeType", NT_RESOURCE,
                                      PropertyType.STRING);
    prop.setMandatory(true);
    NT_FOLDER.addProperty(prop);

    prop = new BasePropertyDefinition("jcr:data", NT_RESOURCE,
                                      PropertyType.BINARY);
    prop.setMandatory(true);
    NT_FOLDER.addProperty(prop);

    prop = new BasePropertyDefinition("jcr:lastModified", NT_RESOURCE,
                                      PropertyType.DATE);
    prop.setMandatory(true);
    prop.setOnParentVersion(OnParentVersionAction.IGNORE);
    NT_FOLDER.addProperty(prop);
  }
}
