Package nexj.core.util.XMLUtil

Examples of nexj.core.util.XMLUtil.ElementHandler


      String sElement = XMLUtil.getReqStringAttr(dstElement, "element");

      XMLMetadataHelper.validateName(sElement);
      m_metadata.addDataSourceTypeElement(sElement, type);

      XMLUtil.withFirstChildElement(dstElement, "Adapters", false, new ElementHandler()
      {
         public void handleElement(Element adaptersElement)
         {
            XMLUtil.forEachChildElement(adaptersElement, "Adapter",
               m_helper.new ElementHandler("adapter")
            {
               public void handleElement(Element adapterElement, String sAdapterName)
               {
                  DataSourceAdapter adapter = new DataSourceAdapter(sAdapterName);
View Full Code Here


      dataSource.setDeletable(XMLUtil.getBooleanAttr(element, "delete", true));
      dataSource.setExecutable(XMLUtil.getBooleanAttr(element, "execute", true));
      dataSource.setJoinable(XMLUtil.getBooleanAttr(element, "join", true));
      dataSource.setReadLimit(XMLUtil.getIntAttr(element, "readLimit", dataSource.getReadLimit()));

      XMLUtil.withFirstChildElement(element, "Properties", false, new ElementHandler()
      {
         public void handleElement(final Element propertiesElement)
         {
            addIOFixup(new ContextFixup(m_helper)
            {
View Full Code Here

   protected void loadChannelTypes(Element chtElement)
   {
      XMLMetadataHelper.verifyRootElement(chtElement, "ChannelTypes");

      XMLUtil.forEachChildElement(chtElement, "ChannelType",
         m_helper.new ElementHandler("channelType")
      {
         public void handleElement(Element element, String sName)
         {
            loadChannelType(element, sName);
         }
View Full Code Here

      {
         throw new MetadataException("err.meta.integration.combine",
            new Object[]{sCombine, channel.getName()});
      }

      XMLUtil.withFirstChildElement(element, "SenderProperties", false, new ElementHandler()
      {
         public void handleElement(final Element propertiesElement)
         {
            addIOFixup(new ContextFixup(m_helper)
            {
               public void fixup()
               {
                  if (channel.getSender() != null)
                  {
                     loadComponentProperties(propertiesElement, channel.getSender());
                  }
               }
            });
         }
      });

      XMLUtil.withFirstChildElement(element, "ReceiverProperties", false, new ElementHandler()
      {
         public void handleElement(final Element propertiesElement)
         {
            addIOFixup(new ContextFixup(m_helper)
            {
               public void fixup()
               {
                  if (channel.getReceiver() != null)
                  {
                     loadComponentProperties(propertiesElement, channel.getReceiver());
                  }
               }
            });
         }
      });

      if (!m_bIntegrationExcluded)
      {
         XMLUtil.withFirstChildElement(element, "ServiceBindings", false, new ElementHandler()
         {
            public void handleElement(final Element bindingsElement)
            {
               addPersistenceMappingFixup(new ContextFixup(m_helper)
               {
                  public void fixup()
                  {
                     XMLUtil.forEachChildElement(bindingsElement, "ServiceBinding", m_helper.new ElementHandler("service")
                     {
                        protected String getName(Element element)
                        {
                           return XMLUtil.getReqStringAttr(element, "service");
                        }

                        public void handleElement(Element bindingElement, String sService)
                        {
                           final Binding binding = new Binding(m_metadata.getService(sService), channel);
                           String sOutput = XMLUtil.getStringAttr(bindingElement, "output");

                           if (sOutput != null)
                           {
                              binding.setOutput(m_metadata.getChannel(sOutput));
                           }

                           XMLUtil.withFirstChildElement(bindingElement, "Arguments", false, new ElementHandler()
                           {
                              public void handleElement(Element argumentsElement)
                              {
                                 XMLUtil.forEachChildElement(argumentsElement, "Argument", m_helper.new ElementHandler("argument")
                                 {
                                    public void handleElement(Element argumentElement, String sArgument)
                                    {
                                       String sChannel = XMLUtil.getStringAttr(argumentElement, "channel");
View Full Code Here

   {
      final Set connectionSet = new HashHolder();

      if (connectionsElement != null)
      {
         XMLUtil.withFirstChildElement(connectionsElement, "DataSourceConnections", false, new ElementHandler()
         {
            public void handleElement(Element connectionsElement)
            {
               XMLUtil.forEachChildElement(connectionsElement, null,
                  m_helper.new ElementHandler("dataSource")
               {
                  protected String getName(Element element)
                  {
                     return XMLUtil.getReqStringAttr(element, "dataSource");
                  }

                  public void handleElement(Element connectionElement, String sDataSource)
                  {
                     DataSource source = m_metadata.getDataSource(sDataSource);
                     String sExpectedElement = m_metadata.getDataSourceTypeElement(source.getType()) + "Connection";

                     if (!sExpectedElement.equals(connectionElement.getNodeName()))
                     {
                        throw new MetadataException("err.meta.dataSourceConnectionElement",
                           new Object[]{connectionElement.getNodeName(), source.getName(),
                           sConnectionsName, sExpectedElement});
                     }

                     if (!connectionSet.add(source))
                     {
                        throw new MetadataException("err.meta.dupDataSourceConnection", new Object[]{sDataSource});
                     }

                     String sAdapter = XMLUtil.getStringAttr(connectionElement, "adapter");

                     if (sAdapter != null)
                     {
                        source.setAdapter(source.getType().getAdapter(sAdapter));
                     }

                     source.setReadLimit(XMLUtil.getIntAttr(connectionElement, "readLimit", source.getReadLimit()));

                     //Load DataSource-specific attributes.
                     ((XMLPersistenceMetadataLoader)m_helper.getClassInstance(source.getType().getLoader()))
                        .loadConnection(connectionElement, source, XMLMetadataLoader.this);
                  }
               });
            }
         });
      }

      //Call loadConnection to initialize DataSources with no entry in the .connections file.
      for (Iterator itr = m_metadata.getDataSourceIterator(); itr.hasNext();)
      {
         DataSource source = (DataSource)itr.next();

         if (!connectionSet.contains(source))
         {
            int nCookie = getHelper().pushMarker(MetadataValidationException.TYPE_NAME, "DataSourceConnection");
            getHelper().pushMarker("dataSourceConnection", source.getName());

            try
            {
               ((XMLPersistenceMetadataLoader)m_helper.getClassInstance(source.getType().getLoader()))
                  .loadConnection(null, source, XMLMetadataLoader.this);
            }
            catch (MetadataException e)
            {
               m_helper.addException(e);
            }
            finally
            {
               m_helper.restoreMarker(nCookie);
            }
         }
      }

      if (connectionsElement != null && !m_bIntegrationExcluded)
      {
         XMLUtil.withFirstChildElement(connectionsElement, "ChannelConnections", false, new ElementHandler()
         {
            public void handleElement(Element connectionsElement)
            {
               XMLUtil.forEachChildElement(connectionsElement, null,
                  m_helper.new ElementHandler("channel")
               {
                  protected String getName(Element element)
                  {
                     return XMLUtil.getReqStringAttr(element, "channel");
                  }
View Full Code Here

    */
   protected void loadSecurityDescriptor(final Element descriptorElement)
   {
      XMLMetadataHelper.verifyRootElement(descriptorElement, "SecurityDescriptor");

      XMLUtil.withFirstChildElement(descriptorElement, "Privileges", false, new ElementHandler()
      {
         public void handleElement(Element privilegesElement)
         {
            XMLUtil.forEachChildElement(privilegesElement, "Privilege",
               m_helper.new ElementHandler("privilege")
            {
               public void handleElement(Element privilegeElement, String sPrivilegeName)
               {
                  Privilege privilege = new PrimitivePrivilege(sPrivilegeName);

                  m_metadata.addPrivilege(privilege);
                  privilege.setCaption(XMLUtil.getStringAttr(privilegeElement,
                     "caption", privilege.getCaption()));
               }
            });
         }
      });

      XMLUtil.withFirstChildElement(descriptorElement, "PrivilegeGroups", false, new ElementHandler()
      {
         public void handleElement(Element privilegeGroupsElement)
         {
            XMLUtil.forEachChildElement(privilegeGroupsElement, "PrivilegeGroup",
               m_helper.new ElementHandler("privilegeGroup")
            {
               public void handleElement(Element privilegeGroupElement, String sPrivilegeSetName)
               {
                  final PrivilegeGroup privilegeGroup = new PrivilegeGroup(sPrivilegeSetName);

                  m_metadata.addPrivilege(privilegeGroup);
                  privilegeGroup.setCaption(XMLUtil.getStringAttr(privilegeGroupElement,
                     "caption", privilegeGroup.getCaption()));

                  XMLUtil.withFirstChildElement(privilegeGroupElement, "Privileges", false, new ElementHandler()
                  {
                     public void handleElement(Element privilegesElement)
                     {
                        XMLUtil.forEachChildElement(privilegesElement, "Privilege",
                           m_helper.new ElementHandler("privilege")
                        {
                           public void handleElement(Element privilegeElement, final String sPrivilegeName)
                           {
                              m_privilegeFixupList.add(new ContextFixup(m_helper)
                              {
View Full Code Here

            {
               metaclass.addAspectOverride(m_metadata.defineClassAspect(sName, metaclass), bInclusive);
            }
         });

      XMLUtil.withFirstChildElement(classElement, "Attributes", false, new ElementHandler()
      {
         public void handleElement(Element attributesElement)
         {
            XMLUtil.forEachChildElement(attributesElement, "Attribute",
               m_helper.new ElementHandler("attribute")
            {
               public void handleElement(Element attributeElement, String sAttributeName)
               {
                  XMLMetadataHelper.validateName(sAttributeName);

                  Attribute attribute = new Attribute(sAttributeName);

                  attribute.setMetaclass(metaclass);
                  attribute.setDeclarator(metaclass);
                  loadAttribute(attributeElement, attribute);
                  metaclass.addAttribute(attribute);
               }
            });
         }
      });

      XMLUtil.withFirstChildElement(classElement, "Events", false, new ElementHandler()
      {
         public void handleElement(Element eventsElement)
         {
            XMLUtil.forEachChildElement(eventsElement, "Event",
               m_helper.new ElementHandler("event")
            {
               public void handleElement(Element eventElement, String sEventName)
               {
                  XMLMetadataHelper.validateName(sEventName);
View Full Code Here

         });
      }

      // Queue for second pass only if a persistence mapping element is present

      XMLUtil.withFirstChildElement(classElement, "PersistenceMapping", false, new ElementHandler()
      {
         public void handleElement(Element element)
         {
            final String sResourceName = m_helper.getCurResourceName();
            final Element clone = (Element)m_tmpDocument.importNode(element, true);
View Full Code Here

            {
               aspect.addPointcutPattern(sPattern, bInclusive);
            }
         });

      XMLUtil.withFirstChildElement(aspectElement, "PersistenceMappings", false, new ElementHandler()
      {
         public void handleElement(Element persistenceMappingsElement)
         {
            XMLUtil.forEachChildElement(persistenceMappingsElement, "PersistenceMapping", new ElementHandler()
            {
               public void handleElement(Element persistenceMappingElement)
               {
                  final String sResourceName = m_helper.getCurResourceName();
                  final Element clone = (Element)m_tmpDocument.importNode(persistenceMappingElement, true);
View Full Code Here

      event.setPrivilege(getPrivilege(eventElement, "privilege"));
      event.setTransactionMode(parseTransactionMode(XMLUtil.getStringAttr(eventElement, "transaction"), Event.TX_DEFAULT));
      event.setAudited(XMLUtil.getBooleanObjAttr(eventElement, "audit"));
      event.setVarArg(XMLUtil.getBooleanAttr(eventElement, "vararg", false));

      XMLUtil.withFirstChildElement(eventElement, "Result", false, new ElementHandler()
      {
         public void handleElement(Element resultElement)
         {
            event.setResult(loadArgument(resultElement, null));
         }
      });

      String sArgList = XMLUtil.getStringAttr(eventElement, "args");
      final Lookup/*<String, Argument>*/ argMap = new HashTab/*<String, Argument>*/();

      XMLUtil.withFirstChildElement(eventElement, "Arguments", false, new ElementHandler()
      {
         public void handleElement(Element argsElement)
         {
            XMLUtil.forEachChildElement(argsElement, "Argument",
               m_helper.new ElementHandler("argument")
            {
               protected void handleElement(Element argElement, String sArgName)
               {
                  argMap.put(sArgName, loadArgument(argElement, sArgName));
               }
            });
         }
      });

      if (sArgList != null)
      {
         for (StringTokenizer tokenizer = new StringTokenizer(sArgList); tokenizer.hasMoreTokens();)
         {
            String sArgName = tokenizer.nextToken();
            Argument arg = (Argument)argMap.remove(sArgName);

            XMLMetadataHelper.validateName(sArgName);
            event.addArgument((arg == null) ? new Argument(sArgName) : arg);
         }
      }

      MetadataCompoundValidationException e = null;

      for (Iterator/*<Argument>*/ itr = argMap.valueIterator(); itr.hasNext();)
      {
         if (e == null)
         {
            e = new MetadataCompoundValidationException();
         }

         e.addException(
            new MetadataException("err.meta.argLookup", new Object[]{itr.next(), event}));
      }

      if (e != null)
      {
         throw e;
      }

      event.addVariables((Pair)m_helper.parse(XMLUtil.getStringAttr(eventElement, "variables"), true, null, null, m_metadata.getGlobalEnvironment()));

      final String sAccessAttributeName = XMLUtil.getStringAttr(eventElement, "access");

      if (sAccessAttributeName != null)
      {
         m_attributeFixupList.add(new ContextFixup(m_helper)
         {
            public void fixup()
            {
               event.setAccessAttribute(event.getMetaclass().getAttribute(sAccessAttributeName));
            }
         });
      }

      XMLUtil.withFirstChildElement(eventElement, "Actions", false, new ElementHandler()
      {
         public void handleElement(Element actionsElement)
         {
            XMLUtil.forEachChildElement(actionsElement, "Action",
               m_helper.new ElementHandler("action")
            {
               public void handleElement(Element actionElement, String sActionName)
               {
                  String sGroupName = null;
                  int i = sActionName.indexOf(':');
View Full Code Here

TOP

Related Classes of nexj.core.util.XMLUtil.ElementHandler

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.