Source code: com/aendvari/cerberus/component/descriptor/parser/DefinitionParser.java

   /*
    * DefinitionParser.java
    *
    * Copyright (c) 2001, 2002 Aendvari, Ltd. All Rights Reserved.
    *
    * See the file LICENSE for terms of use.
    *
    */
   
  package com.aendvari.cerberus.component.descriptor.parser;
  
  import java.io.InputStream;
  import java.io.IOException;
  
  import java.util.ArrayList;
  import java.util.Collection;
  
  import com.aendvari.common.model.*;
  import com.aendvari.common.model.osm.*;
  
  import com.aendvari.cerberus.component.descriptor.*;
  
  /**
   * <p>Constructs a {@link ComponentDefinition} from the content of a {@link ModelNode}.</p>
   *
   * <p>The {@link ModelNode} contains the definition of a single component.</p>
   *
   * <p>This class only reads the content of the {@link ModelNode}, it does not attempt to verify
   * the definition.</p>
   *
   * @author  Trevor Milne
   *
   */
  
  public class DefinitionParser extends DescriptorParser
  {
    /* Constants. */
  
  
    /** Constants for descriptor element names. */
    private interface NodeNames
    {
      public static String Definition      = "definition";
  
      public static String Name        = "name";
      public static String Description    = "description";
      public static String Class        = "class";
      public static String Extends      = "extends";
  
      public static String Access        = "access";
      public static String Public        = "public";
      public static String Private      = "private";
  
      public static String Attribute      = "attribute";
      public static String Required      = "required";
      public static String Value        = "value";
  
      public static String Message      = "message";
      public static String Type        = "type";
      public static String Send        = "send";
      public static String Receive      = "receive";
  
      public static String Topic        = "topic";
      public static String Map        = "map";
  
      public static String Signature      = "signature";
      public static String Property      = "property";
  
      public static String Component      = "component";
    }
  
  
    /* Constructors. */
  
  
    /**
     * Constructs a <code>DefinitionParser</code> instance.
     *
     */
  
    public DefinitionParser()
    {
    }
  
  
    /* Parsing. */
  
  
    /**
     * Parses an attribute of a component definition.
     *
     * @param    objectNode          The {@link ModelNode} containing the attribute.
     *
     * @return                  A {@link ComponentAttribute} containing the attribute information.
     *
     */
  
    private ComponentAttribute parseAttribute(ModelNode objectNode)
    {
     // create a attribute
     ComponentAttribute attribute = new ComponentAttribute();
 
     ModelNode node = objectNode.getFirstChild();
 
     while (node != null)
     {
       String nodeName = node.getNodeName();
 
       // process node types
       if (nodeName.equals(NodeNames.Name))
       {
         attribute.setName(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Description))
       {
         attribute.setDescription(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Access))
       {
         String type = node.getNodeValue();
 
         if (type.equalsIgnoreCase(NodeNames.Public))
           attribute.setAccess(ComponentAttribute.Access.Public);
         else
         if (type.equalsIgnoreCase(NodeNames.Private))
           attribute.setAccess(ComponentAttribute.Access.Private);
       }
       else
       if (nodeName.equals(NodeNames.Required))
       {
         attribute.setRequired(node.getNodeValue().equalsIgnoreCase("true"));
       }
       else
       if (nodeName.equals(NodeNames.Value))
       {
         MultiPartValue value = attribute.getValue();
         parseMultiPartValue(node, value);
       }
 
       // get next child node
       node = node.getNextSibling();
     }
 
     return attribute;
   }
 
   /**
    * Parses a property of a signature.
    *
    * @param    objectNode          The {@link ModelNode} containing the property.
    *
    * @return                  A {@link SignatureProperty} containing the property information.
    *
    */
 
   private SignatureProperty parseSignatureProperty(ModelNode objectNode)
   {
     // create a property
     SignatureProperty property = new SignatureProperty();
 
     ModelNode node = objectNode.getFirstChild();
 
     while (node != null)
     {
       String nodeName = node.getNodeName();
 
       // process node types
       if (nodeName.equals(NodeNames.Name))
       {
         property.setName(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Description))
       {
         property.setDescription(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Required))
       {
         property.setRequired(node.getNodeValue().equalsIgnoreCase("true"));
       }
       else
       if (nodeName.equals(NodeNames.Type))
       {
         property.setType(node.getNodeValue());
       }
 
       // get next child node
       node = node.getNextSibling();
     }
 
     return property;
   }
 
   /**
    * Parses a signature of a message.
    *
    * @param    objectNode          The {@link ModelNode} containing the signature.
    * @param    signature          The {@link MessageSignature} for the message.
    *
    */
 
   private void parseMessageSignature(ModelNode objectNode, MessageSignature signature)
   {
     // parse the properties of the signature
     ModelNode node = objectNode.getFirstChild();
 
     while (node != null)
     {
       String nodeName = node.getNodeName();
 
       // process node types
       if (nodeName.equals(NodeNames.Property))
       {
         SignatureProperty property = parseSignatureProperty(node);
         signature.addProperty(property);
       }
 
       // get next child node
       node = node.getNextSibling();
     }
   }
 
   /**
    * Parses a message of a component definition.
    *
    * @param    objectNode          The {@link ModelNode} containing the message.
    *
    * @return                  A {@link ComponentMessage} containing the message information.
    *
    */
 
   private ComponentMessage parseMessage(ModelNode objectNode)
   {
     // create a message
     ComponentMessage message = new ComponentMessage();
 
     ModelNode node = objectNode.getFirstChild();
 
     while (node != null)
     {
       String nodeName = node.getNodeName();
 
       // process node types
       if (nodeName.equals(NodeNames.Name))
       {
         message.setName(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Description))
       {
         message.setDescription(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Type))
       {
         String type = node.getNodeValue();
 
         if (type.equalsIgnoreCase(NodeNames.Send))
           message.setType(ComponentMessage.Type.Send);
         else
         if (type.equalsIgnoreCase(NodeNames.Receive))
           message.setType(ComponentMessage.Type.Receive);
         else
           message.setType(ComponentMessage.Type.Undefined);
       }
       else
       if (nodeName.equals(NodeNames.Required))
       {
         message.setRequired(node.getNodeValue().equalsIgnoreCase("true"));
       }
       else
       if (nodeName.equals(NodeNames.Access))
       {
         String type = node.getNodeValue();
 
         if (type.equalsIgnoreCase(NodeNames.Public))
           message.setAccess(ComponentMessage.Access.Public);
         else
         if (type.equalsIgnoreCase(NodeNames.Private))
           message.setAccess(ComponentMessage.Access.Private);
       }
       else
       if (nodeName.equals(NodeNames.Topic))
       {
         MultiPartValue topic = message.getTopic();
         parseMultiPartValue(node, topic);
       }
       else
       if (nodeName.equals(NodeNames.Map))
       {
         // place mapped message name as 'topic' of message
         message.setMapped(true);
 
         MultiPartValue name = message.getTopic();
         name.addLiteral(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Signature))
       {
         MessageSignature signature = message.getSignature();
         parseMessageSignature(node, signature);
       }
 
       // get next child node
       node = node.getNextSibling();
     }
 
     return message;
   }
 
   /**
    * Parses the given {@link ModelNode} containing a component definition. The {@link ModelNode}
    * must be the <definition> element.
    *
    * @param    definitionNode        A {@link ModelNode} containing a component definition.
    *
    * @return                  A {@link ComponentDefinition} containing the information in the node.
    *
    */
 
   public ComponentDefinition parse(ModelNode definitionNode)
   {
     ComponentDefinition definition = new ComponentDefinition();
 
     ModelNode node = definitionNode.getFirstChild();
 
     while (node != null)
     {
       String nodeName = node.getNodeName();
 
       // process node types
       if (nodeName.equals(NodeNames.Name))
       {
         definition.setName(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Description))
       {
         definition.setDescription(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Class))
       {
         definition.setBackingClass(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Extends))
       {
         definition.addParent(node.getNodeValue());
       }
       else
       if (nodeName.equals(NodeNames.Attribute))
       {
         definition.addAttribute(parseAttribute(node));
       }
       else
       if (nodeName.equals(NodeNames.Message))
       {
         definition.addMessage(parseMessage(node));
       }
       else
       if (nodeName.equals(NodeNames.Component))
       {
         InstanceParser instanceParser = new InstanceParser();
         ComponentInstance instance = instanceParser.parse(node);
 
         definition.addComponent(instance);
       }
 
       // get next child node
       node = node.getNextSibling();
     }
 
     return definition;
   }
 
   /**
    * Parses the content of the given <code>InputStream</code> as a component definition.
    *
    * @param    inputStream            The <code>InputStream</code> containing
    *                        the component definition.
    *
    * @return                    A {@link ComponentDefinition} containing the
    *                        information in the stream.
    *
    * @exception  ParserException          The input stream could not be parsed.
    *
    */
 
   public ComponentDefinition parse(InputStream inputStream)
     throws ParserException
   {
     ModelTree modelTree = new OsmModelTree();
 
     try
     {
       // read the content of the stream
       modelTree.loadFromStream(inputStream);
     }
     catch (ModelParserException exception)
     {
       throw new ParserException(exception);
     }
 
     // parse the tree, ignore the "OsmRoot" node
     ModelNode node = modelTree.getRootNode().getFirstChild();
     ComponentDefinition definition = parse(node);
 
     return definition;
   }
 }