Ejemplo n.º 1
0
  /**
   * Render the given Item as XML using an XMLStreamWriter
   *
   * @param writer to XMLStreamWriter to write to
   * @param item the Item to render
   */
  public static void renderImpl(XMLStreamWriter writer, Item item) {
    try {
      writer.writeStartElement("item");
      if (item.getIdentifier() != null) {
        writer.writeAttribute("id", item.getIdentifier());
      }
      writer.writeAttribute("class", item.getClassName() == null ? "" : item.getClassName());

      if (item.getImplementations() != null && !"".equals(item.getImplementations())) {
        writer.writeAttribute("implements", item.getImplementations());
      }
      writer.writeCharacters(ENDL);
      TreeSet<Attribute> attrs = new TreeSet<Attribute>(new RendererComparator());
      attrs.addAll(item.getAttributes());
      for (Attribute attr : attrs) {
        if (!"".equals(attr.getValue())) {
          writer.writeEmptyElement("attribute");
          writer.writeAttribute("name", attr.getName());
          writer.writeAttribute("value", attr.getValue());
          writer.writeCharacters(ENDL);
        }
      }

      TreeSet<Reference> refs = new TreeSet<Reference>(new RendererComparator());
      refs.addAll(item.getReferences());
      for (Reference ref : refs) {
        writer.writeEmptyElement("reference");
        writer.writeAttribute("name", ref.getName());
        writer.writeAttribute("ref_id", ref.getRefId());
        writer.writeCharacters(ENDL);
      }

      TreeSet<ReferenceList> cols = new TreeSet<ReferenceList>(new RendererComparator());
      cols.addAll(item.getCollections());
      for (ReferenceList refList : cols) {
        writer.writeStartElement("collection");
        writer.writeAttribute("name", refList.getName());

        for (String ref : refList.getRefIds()) {
          writer.writeEmptyElement("reference");
          writer.writeAttribute("ref_id", ref);
        }
        writer.writeEndElement();
        writer.writeCharacters(ENDL);
      }
      writer.writeEndElement();
      writer.writeCharacters(ENDL);
    } catch (XMLStreamException e) {
      throw new RuntimeException("unexpected exception while accessing a XMLStreamWriter", e);
    }
  }
Ejemplo n.º 2
0
  public void close() {
    if (closed) {
      return;
    }
    closed = true;

    // finish off anything
    try {
      xmlw.writeEndElement(); // msRun element

      // declare the index does not exist
      xmlw.writeEmptyElement("indexOffset");
      xmlw.writeAttribute("xsi:nil", "1");

      xmlw.writeEndElement(); // mzXML element

      // close out the xml writer
      xmlw.flush();
      xmlw.close();
    } catch (XMLStreamException e) {
      throw new RuntimeException("Can't write all of XML!", e);
    } finally {
      super.close();
    }
  }
Ejemplo n.º 3
0
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws Exception {
    try {
      String fileName = null;
      try {
        if (args[0].equals("-f")) {
          fileName = args[1];
        } else {
          printUsage();
          return;
        }
      } catch (Exception ex) {
        printUsage();
        return;
      }

      XMLOutputFactory xof = XMLOutputFactory.newInstance();
      XMLStreamWriter xtw = null;
      xtw = xof.createXMLStreamWriter(new FileOutputStream(fileName), "utf-8");
      xtw.writeStartDocument("utf-8", "1.0");
      xtw.writeComment("StAX Sample: writer.HelloWorld");
      xtw.writeStartElement("hello");
      xtw.writeDefaultNamespace("http://samples");
      xtw.writeCharacters("this crazy");
      xtw.writeEmptyElement("world");
      xtw.writeEndElement();
      xtw.writeEndDocument();
      xtw.flush();
      xtw.close();
    } catch (Exception ex) {
      ex.printStackTrace();
      System.err.println("Exception occurred while running Hello World samples");
    }
    System.out.println("Done");
  }
  @Override
  public void marshallAsElement(ModelNode resourceModel, XMLStreamWriter writer)
      throws XMLStreamException {
    if (resourceModel.hasDefined(getName()) && resourceModel.asInt() > 0) {
      final ModelNode modules = resourceModel.get(getName());
      for (ModelNode module : modules.asList()) {
        writer.writeStartElement(getXmlName());
        writer.writeAttribute(Attribute.CODE.getLocalName(), module.get(CODE).asString());
        if (module.hasDefined(Constants.LOGIN_MODULE_STACK_REF)) {
          writer.writeAttribute(
              Attribute.LOGIN_MODULE_STACK_REF.getLocalName(),
              module.get(Constants.LOGIN_MODULE_STACK_REF).asString());
        }

        if (module.hasDefined(Constants.MODULE_OPTIONS)) {
          for (ModelNode option : module.get(Constants.MODULE_OPTIONS).asList()) {
            writer.writeEmptyElement(Element.MODULE_OPTION.getLocalName());
            writer.writeAttribute(Attribute.NAME.getLocalName(), option.asProperty().getName());
            writer.writeAttribute(
                Attribute.VALUE.getLocalName(), option.asProperty().getValue().asString());
          }
        }
        writer.writeEndElement();
      }
    }
  }
  private void appendKey(final XMLStreamWriter writer, final EdmEntityType entityType)
      throws XMLStreamException {
    List<EdmKeyPropertyRef> keyPropertyRefs = entityType.getKeyPropertyRefs();
    if (keyPropertyRefs != null && !keyPropertyRefs.isEmpty()) {
      // Resolve Base Type key as it is shown in derived type
      EdmEntityType baseType = entityType.getBaseType();
      if (baseType != null
          && baseType.getKeyPropertyRefs() != null
          && !(baseType.getKeyPropertyRefs().isEmpty())) {
        return;
      }

      writer.writeStartElement(XML_KEY);
      for (EdmKeyPropertyRef keyRef : keyPropertyRefs) {
        writer.writeEmptyElement(XML_PROPERTY_REF);

        writer.writeAttribute(XML_NAME, keyRef.getName());

        if (keyRef.getAlias() != null) {
          writer.writeAttribute(XML_ALIAS, keyRef.getAlias());
        }
      }
      writer.writeEndElement();
    }
  }
 @Override
 public void marshallAsElement(ModelNode resourceModel, XMLStreamWriter writer)
     throws XMLStreamException {
   if (isMarshallable(resourceModel)) {
     writer.writeEmptyElement(getXmlName());
     writer.writeAttribute(attribute.getLocalName(), resourceModel.get(getName()).asString());
   }
 }
 private void writeOnlineResource(final XMLStreamWriter writer, final String url)
     throws XMLStreamException {
   if (url != null) {
     writer.writeEmptyElement("OnlineResource");
     writer.writeNamespace(XLINK_PREFIX, XLNNS);
     writer.writeAttribute(XLNNS, "type", "simple");
     writer.writeAttribute(XLNNS, "href", url);
   }
 }
 private void writeTransactional(TransactionalDef transactionDef) throws XMLStreamException {
   if (transactionDef != null) {
     writer.writeCharacters("    ");
     writer.writeEmptyElement("tx", "transaction", NS_TX);
     writer.writeAttribute("method", transactionDef.getMethod());
     writer.writeAttribute("value", transactionDef.getType());
     writer.writeCharacters("\n");
   }
 }
 private void writeServiceRef(OsgiServiceBean serviceBean) throws XMLStreamException {
   writer.writeEmptyElement("reference");
   writer.writeAttribute("id", serviceBean.id);
   writer.writeAttribute("interface", serviceBean.clazz.getName());
   if (serviceBean.filter != null && !"".equals(serviceBean.filter)) {
     writer.writeAttribute("filter", serviceBean.filter);
   }
   writer.writeCharacters("\n");
 }
Ejemplo n.º 10
0
 @Override
 public void writeXML(XMLStreamWriter writer) throws XMLStreamException {
   writer.writeEmptyElement("geofence");
   writer.writeAttribute("name", nameTextField.getValue());
   writer.writeAttribute("operator", getOperator());
   writer.writeAttribute("longitude", longitudeTextField.getValue());
   writer.writeAttribute("latitude", latitudeTextField.getValue());
   writer.writeAttribute("radius", radiusTextField.getValue());
 }
 void writeObject(Object object) throws XMLStreamException {
   if (object == null) {
     writer.writeEmptyElement("null");
   } else if (object instanceof Iterable) {
     writeIterable((Iterable) object);
   } else {
     writer.writeCharacters(object.toString());
   }
 }
Ejemplo n.º 12
0
 private void writePersistenceUnit(Field field) throws XMLStreamException {
   PersistenceUnit persistenceUnit = field.getAnnotation(PersistenceUnit.class);
   if (persistenceUnit != null) {
     writer.writeCharacters("    ");
     writer.writeEmptyElement("jpa", "context", NS_JPA);
     writer.writeAttribute("unitname", persistenceUnit.unitName());
     writer.writeAttribute("property", field.getName());
     writer.writeCharacters("\n");
   }
 }
 private void appendNavigationPropertyBindings(
     final XMLStreamWriter writer, final EdmBindingTarget bindingTarget)
     throws XMLStreamException {
   if (bindingTarget.getNavigationPropertyBindings() != null) {
     for (EdmNavigationPropertyBinding binding : bindingTarget.getNavigationPropertyBindings()) {
       writer.writeEmptyElement(XML_NAVIGATION_PROPERTY_BINDING);
       writer.writeAttribute(XML_PATH, binding.getPath());
       writer.writeAttribute(XML_TARGET, binding.getTarget());
     }
   }
 }
 @Override
 public void marshallAsElement(
     AttributeDefinition attribute,
     ModelNode resourceModel,
     boolean marshallDefault,
     XMLStreamWriter writer)
     throws XMLStreamException {
   writer.writeEmptyElement(Element.HOST.getLocalName());
   writer.writeAttribute(
       Attribute.NAME.getLocalName(), resourceModel.asString());
 }
Ejemplo n.º 15
0
 protected void writeEmptyElementWithNS(String namespaceURI, String localname)
     throws XMLStreamException {
   if (namespaceURI == null || namespaceURI.length() == 0) {
     writer.writeEmptyElement(localname);
   } else {
     if (writer.getNamespaceContext().getPrefix(namespaceURI) == null) {
       String prefix = nsToPrefix.get(namespaceURI);
       if (prefix != null) {
         writer.writeEmptyElement(prefix, localname, namespaceURI);
         writer.writeNamespace(prefix, namespaceURI);
       } else {
         LOG.warn(
             "No prefix for namespace '{}' configured. Depending on XMLStream auto-repairing.",
             namespaceURI);
         writer.writeEmptyElement(namespaceURI, localname);
       }
     } else {
       writer.writeEmptyElement(namespaceURI, localname);
     }
   }
 }
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   Object result = null;
   Throwable error = null;
   try {
     result = method.invoke(target, args);
   } catch (InvocationTargetException e) {
     error = e.getTargetException();
   } catch (Throwable e) {
     // Proxy not allowed to throw exception
   }
   if (method.getDeclaringClass() != Object.class) {
     try {
       StringWriter stringWriter = new StringWriter();
       this.writer = XMLOutputFactory.newInstance().createXMLStreamWriter(stringWriter);
       writer.writeStartElement("invoke");
       writer.writeAttribute("timestamp", Long.valueOf(System.currentTimeMillis()).toString());
       writer.writeAttribute("class", target.getClass().getName());
       writer.writeAttribute("name", method.getName());
       if (args != null && args.length != 0) {
         writer.writeStartElement("arguments");
         for (int i = 0; i < args.length; i++) {
           writer.writeStartElement("argument");
           writeObject(args[i]);
           writer.writeEndElement();
         }
         writer.writeEndElement();
       } else {
         writer.writeEmptyElement("arguments");
       }
       if (method.getReturnType() != void.class && error == null) {
         writer.writeStartElement("return");
         writeObject(result);
         writer.writeEndElement();
       } else if (error != null) {
         writer.writeStartElement("thrown");
         writer.writeCharacters(error.toString());
         writer.writeEndElement();
       }
       writer.writeEndElement();
       writer.flush();
       initialWriter.write(stringWriter.toString() + System.lineSeparator());
     } catch (Exception e) {
       // Proxy not allowed to throw exceptions
     }
   }
   if (error != null) {
     throw error;
   }
   return result;
 }
Ejemplo n.º 17
0
 @Override
 void writeXML(XMLStreamWriter writer) throws XMLStreamException {
   writer.writeStartElement(
       COMPOSITE_INDEX_TAG.getNamespaceURI(), COMPOSITE_INDEX_TAG.getLocalPart());
   this.writeAttributes(writer, true);
   for (int storageId : this.indexedFields) {
     writer.writeEmptyElement(
         INDEXED_FIELD_TAG.getNamespaceURI(), INDEXED_FIELD_TAG.getLocalPart());
     writer.writeAttribute(
         STORAGE_ID_ATTRIBUTE.getNamespaceURI(),
         STORAGE_ID_ATTRIBUTE.getLocalPart(),
         "" + storageId);
   }
   writer.writeEndElement(); // </CompositeIndex>
 }
  public void generateSchema(XMLStreamWriter out) throws XMLStreamException {
    out.writeStartElement("xsd", "simpleType", XML_SCHEMA_NS);
    out.writeAttribute("name", JAXBUtil.qNameToString(_typeName));

    out.writeStartElement("xsd", "restriction", XML_SCHEMA_NS);
    out.writeAttribute("base", JAXBUtil.qNameToString(_baseName));

    for (String name : _nameMap.values()) {
      out.writeEmptyElement("xsd", "enumeration", XML_SCHEMA_NS);
      out.writeAttribute("value", name);
    }

    out.writeEndElement(); // restriction
    out.writeEndElement(); // simpleType
  }
 @Override
 public void marshallAsElement(
     AttributeDefinition attribute,
     ModelNode resourceModel,
     boolean marshallDefault,
     XMLStreamWriter writer)
     throws XMLStreamException {
   resourceModel = resourceModel.get(attribute.getName());
   if (resourceModel.isDefined()) {
     for (ModelNode property : resourceModel.asList()) {
       writer.writeEmptyElement(REALM_MAPPING);
       writer.writeAttribute(FROM, property.asProperty().getName());
       writer.writeAttribute(TO, property.asProperty().getValue().asString());
     }
   }
 }
Ejemplo n.º 20
0
 @Override
 public void writeProperty(Property property) {
   try {
     writer.writeCharacters("    ");
     writer.writeEmptyElement("property");
     writer.writeAttribute("name", property.name);
     if (property.ref != null) {
       writer.writeAttribute("ref", property.ref);
     } else if (property.value != null) {
       writer.writeAttribute("value", property.value);
     }
     writer.writeCharacters("\n");
   } catch (XMLStreamException e) {
     throw new RuntimeException(e.getMessage(), e);
   }
 }
  private void appendOperationReturnType(final XMLStreamWriter writer, final EdmOperation operation)
      throws XMLStreamException {
    EdmReturnType returnType = operation.getReturnType();
    if (returnType != null) {
      writer.writeEmptyElement(XML_RETURN_TYPE);
      String returnTypeFqnString;
      if (EdmTypeKind.PRIMITIVE.equals(returnType.getType().getKind())) {
        returnTypeFqnString = getFullQualifiedName(returnType.getType(), returnType.isCollection());
      } else {
        returnTypeFqnString =
            getAliasedFullQualifiedName(returnType.getType(), returnType.isCollection());
      }
      writer.writeAttribute(XML_TYPE, returnTypeFqnString);

      appendReturnTypeFacets(writer, returnType);
    }
  }
  private void appendOperationParameters(final XMLStreamWriter writer, final EdmOperation operation)
      throws XMLStreamException {
    for (String parameterName : operation.getParameterNames()) {
      EdmParameter parameter = operation.getParameter(parameterName);
      writer.writeEmptyElement(XML_PARAMETER);
      writer.writeAttribute(XML_NAME, parameterName);
      String typeFqnString;
      if (EdmTypeKind.PRIMITIVE.equals(parameter.getType().getKind())) {
        typeFqnString = getFullQualifiedName(parameter.getType(), parameter.isCollection());
      } else {
        typeFqnString = getAliasedFullQualifiedName(parameter.getType(), parameter.isCollection());
      }
      writer.writeAttribute(XML_TYPE, typeFqnString);

      appendParameterFacets(writer, parameter);
    }
  }
  private void appendProperties(final XMLStreamWriter writer, final EdmStructuredType type)
      throws XMLStreamException {
    List<String> propertyNames = new ArrayList<String>(type.getPropertyNames());
    if (type.getBaseType() != null) {
      propertyNames.removeAll(type.getBaseType().getPropertyNames());
    }
    for (String propertyName : propertyNames) {
      EdmProperty property = type.getStructuralProperty(propertyName);
      writer.writeEmptyElement(XML_PROPERTY);
      writer.writeAttribute(XML_NAME, propertyName);
      String fqnString;
      if (property.isPrimitive()) {
        fqnString = getFullQualifiedName(property.getType(), property.isCollection());
      } else {
        fqnString = getAliasedFullQualifiedName(property.getType(), property.isCollection());
      }
      writer.writeAttribute(XML_TYPE, fqnString);

      // Facets
      if (!property.isNullable()) {
        writer.writeAttribute(XML_NULLABLE, "" + property.isNullable());
      }

      if (!property.isUnicode()) {
        writer.writeAttribute(XML_UNICODE, "" + property.isUnicode());
      }

      if (property.getDefaultValue() != null) {
        writer.writeAttribute(XML_DEFAULT_VALUE, property.getDefaultValue());
      }

      if (property.getMaxLength() != null) {
        writer.writeAttribute(XML_MAX_LENGTH, "" + property.getMaxLength());
      }

      if (property.getPrecision() != null) {
        writer.writeAttribute(XML_PRECISION, "" + property.getPrecision());
      }

      if (property.getScale() != null) {
        writer.writeAttribute(XML_SCALE, "" + property.getScale());
      }
    }
  }
Ejemplo n.º 24
0
  public void serialize(XMLStreamWriter writer) throws XMLStreamException {
    QName name = constants.getUserNameToken();
    String localname = name.getLocalPart();
    String namespaceURI = name.getNamespaceURI();

    String prefix = writer.getPrefix(namespaceURI);
    if (prefix == null) {
      prefix = name.getPrefix();
      writer.setPrefix(prefix, namespaceURI);
    }

    // <sp:KeyValueToken
    writer.writeStartElement(prefix, localname, namespaceURI);

    writer.writeNamespace(prefix, namespaceURI);

    String inclusion;

    inclusion = constants.getAttributeValueFromInclusion(getInclusion());

    if (inclusion != null) {
      writer.writeAttribute(prefix, namespaceURI, SPConstants.ATTR_INCLUDE_TOKEN, inclusion);
    }

    if (forceRsaKeyValue) {
      String pPrefix = writer.getPrefix(SPConstants.POLICY.getNamespaceURI());
      if (pPrefix == null) {
        writer.setPrefix(SPConstants.POLICY.getPrefix(), SPConstants.POLICY.getNamespaceURI());
      }

      // <wsp:Policy>
      writer.writeStartElement(
          pPrefix, SPConstants.POLICY.getLocalPart(), SPConstants.POLICY.getNamespaceURI());

      writer.writeEmptyElement(prefix, "RsaKeyValue", namespaceURI);

      // </wsp:Policy>
      writer.writeEndElement();
    }
    writer.writeEndElement();
    // </sp:KeyValueToken>

  }
  private void appendEnumTypes(final XMLStreamWriter writer, final List<EdmEnumType> enumTypes)
      throws XMLStreamException {
    for (EdmEnumType enumType : enumTypes) {
      writer.writeStartElement(XML_ENUM_TYPE);
      writer.writeAttribute(XML_NAME, enumType.getName());
      writer.writeAttribute(XML_IS_FLAGS, Boolean.toString(enumType.isFlags()));
      writer.writeAttribute(
          XML_UNDERLYING_TYPE, getFullQualifiedName(enumType.getUnderlyingType(), false));

      for (String memberName : enumType.getMemberNames()) {
        writer.writeEmptyElement(XML_MEMBER);
        writer.writeAttribute(XML_NAME, memberName);
        final String value = enumType.getMember(memberName).getValue();
        if (value != null) {
          writer.writeAttribute(XML_VALUE, value);
        }
      }

      writer.writeEndElement();
    }
  }
  /** Recursively serialize a single element, appending it to DOM element <code>parent</code>. */
  protected void serializeElement(XMLStreamWriter writer, EventDataElement element)
      throws XMLStreamException {

    if (!element.isNull()) {
      // create a new node for the element and append it to the parent.
      String name = getXMLElementName(element.getName());

      if (element.isEmpty()) {
        writer.writeEmptyElement(name);
        // TODO: remove when stax bug is fixed.
        // this is a workaround for a bug in the 1.2 StAX implementation, where
        // if the only element in your document is empty, the closing "/>" never gets written.
        // any other API call fixes the problem, so here we do a no-op string append to force
        // the element closed.
        writer.writeCharacters(DUMMY_TEXT, 0, 0);
      } else {
        writer.writeStartElement(name);

        // add attributes for properties.
        Iterator<? extends Entry<String, Object>> props = element.iterateProperties();
        while (props.hasNext()) {
          Entry<String, Object> prop = props.next();
          Object value = prop.getValue();
          if (value != null) {
            String propName = getXMLElementName(prop.getKey());
            writer.writeAttribute(propName, value.toString());
          }
        }

        // add text to the element if applicable.
        String text = element.getText();
        if (text != null) writer.writeCharacters(text);

        // add child elements for children.
        Iterator<EventDataElement> children = element.iterateChildren();
        while (children.hasNext()) serializeElement(writer, children.next());
        writer.writeEndElement();
      }
    }
  }
  private void appendNavigationProperties(
      final XMLStreamWriter writer, final EdmStructuredType type) throws XMLStreamException {
    List<String> navigationPropertyNames = new ArrayList<String>(type.getNavigationPropertyNames());
    if (type.getBaseType() != null) {
      navigationPropertyNames.removeAll(type.getBaseType().getNavigationPropertyNames());
    }
    for (String navigationPropertyName : navigationPropertyNames) {
      EdmNavigationProperty navigationProperty = type.getNavigationProperty(navigationPropertyName);

      writer.writeStartElement(XML_NAVIGATION_PROPERTY);
      writer.writeAttribute(XML_NAME, navigationPropertyName);
      writer.writeAttribute(
          XML_TYPE,
          getAliasedFullQualifiedName(
              navigationProperty.getType(), navigationProperty.isCollection()));
      if (!navigationProperty.isNullable()) {
        writer.writeAttribute(XML_NULLABLE, "" + navigationProperty.isNullable());
      }

      if (navigationProperty.getPartner() != null) {
        EdmNavigationProperty partner = navigationProperty.getPartner();
        writer.writeAttribute(XML_PARTNER, partner.getName());
      }

      if (navigationProperty.containsTarget()) {
        writer.writeAttribute(XML_CONTAINS_TARGET, "" + navigationProperty.containsTarget());
      }

      if (navigationProperty.getReferentialConstraints() != null) {
        for (EdmReferentialConstraint constraint : navigationProperty.getReferentialConstraints()) {
          writer.writeEmptyElement("ReferentialConstraint");
          writer.writeAttribute(XML_PROPERTY, constraint.getPropertyName());
          writer.writeAttribute("ReferencedProperty", constraint.getReferencedPropertyName());
        }
      }

      writer.writeEndElement();
    }
  }
  private void appendTypeDefinitions(
      final XMLStreamWriter writer, final List<EdmTypeDefinition> typeDefinitions)
      throws XMLStreamException {
    for (EdmTypeDefinition definition : typeDefinitions) {
      writer.writeEmptyElement(XML_TYPE_DEFINITION);
      writer.writeAttribute(XML_NAME, definition.getName());
      writer.writeAttribute(
          XML_UNDERLYING_TYPE, getFullQualifiedName(definition.getUnderlyingType(), false));

      // Facets
      if (definition.getMaxLength() != null) {
        writer.writeAttribute(XML_MAX_LENGTH, "" + definition.getMaxLength());
      }

      if (definition.getPrecision() != null) {
        writer.writeAttribute(XML_PRECISION, "" + definition.getPrecision());
      }

      if (definition.getScale() != null) {
        writer.writeAttribute(XML_SCALE, "" + definition.getScale());
      }
    }
  }
 @Override
 public void marshallAsElement(
     AttributeDefinition attribute,
     ModelNode resourceModel,
     boolean marshallDefault,
     XMLStreamWriter writer)
     throws XMLStreamException {
   resourceModel = resourceModel.get(attribute.getName());
   if (wrapElement) {
     writer.writeStartElement(wrapperElement == null ? attribute.getName() : wrapperElement);
   }
   for (ModelNode property : resourceModel.asList()) {
     writer.writeEmptyElement(attribute.getXmlName());
     writer.writeAttribute(
         org.jboss.as.controller.parsing.Attribute.NAME.getLocalName(),
         property.asProperty().getName());
     writer.writeAttribute(
         org.jboss.as.controller.parsing.Attribute.VALUE.getLocalName(),
         property.asProperty().getValue().asString());
   }
   if (wrapElement) {
     writer.writeEndElement();
   }
 }
Ejemplo n.º 30
0
 private void writeEmpty(final String name) throws XMLStreamException {
   xmlWriter.writeEmptyElement(name);
 }