示例#1
1
  /**
   * Reads the payload of a tag, given the name and type.
   *
   * @param type The type.
   * @param name The name.
   * @param depth The depth.
   * @return The tag.
   * @throws IOException if an I/O error occurs.
   */
  private Tag readTagPayload(int type, String name, int depth) throws IOException {
    switch (type) {
      case NBTConstants.TYPE_END:
        if (depth == 0) {
          throw new IOException("TAG_End found without a TAG_Compound/TAG_List tag preceding it.");
        } else {
          return new EndTag();
        }
      case NBTConstants.TYPE_BYTE:
        return new ByteTag(name, is.readByte());
      case NBTConstants.TYPE_SHORT:
        return new ShortTag(name, is.readShort());
      case NBTConstants.TYPE_INT:
        return new IntTag(name, is.readInt());
      case NBTConstants.TYPE_LONG:
        return new LongTag(name, is.readLong());
      case NBTConstants.TYPE_FLOAT:
        return new FloatTag(name, is.readFloat());
      case NBTConstants.TYPE_DOUBLE:
        return new DoubleTag(name, is.readDouble());
      case NBTConstants.TYPE_BYTE_ARRAY:
        int length = is.readInt();
        byte[] bytes = new byte[length];
        is.readFully(bytes);
        return new ByteArrayTag(name, bytes);
      case NBTConstants.TYPE_STRING:
        length = is.readShort();
        bytes = new byte[length];
        is.readFully(bytes);
        return new StringTag(name, new String(bytes, NBTConstants.CHARSET));
      case NBTConstants.TYPE_LIST:
        int childType = is.readByte();
        length = is.readInt();

        List<Tag> tagList = new ArrayList<Tag>();
        for (int i = 0; i < length; i++) {
          Tag tag = readTagPayload(childType, "", depth + 1);
          if (tag instanceof EndTag) {
            throw new IOException("TAG_End not permitted in a list.");
          }
          tagList.add(tag);
        }

        return new ListTag(name, NBTUtils.getTypeClass(childType), tagList);
      case NBTConstants.TYPE_COMPOUND:
        Map<String, Tag> tagMap = new HashMap<String, Tag>();
        while (true) {
          Tag tag = readTag(depth + 1);
          if (tag instanceof EndTag) {
            break;
          } else {
            tagMap.put(tag.getName(), tag);
          }
        }

        return new CompoundTag(name, tagMap);
      default:
        throw new IOException("Invalid tag type: " + type + ".");
    }
  }
示例#2
0
 // save
 // tag/////////////////////////////////////////////////////////////////////////////////////////
 public static int saveTag(Tag tag) {
   int insertId = -1;
   if (BuildConfig.DEBUG) {
     if (BuildConfig.DEBUG) Log.d("CoCoin", "recordManager.saveTag: " + tag.toString());
   }
   boolean duplicatedName = false;
   for (Tag t : TAGS) {
     if (t.getName().equals(tag.getName())) {
       duplicatedName = true;
       break;
     }
   }
   if (duplicatedName) {
     return SAVE_TAG_ERROR_DUPLICATED_NAME;
   }
   insertId = db.saveTag(tag);
   if (insertId == -1) {
     if (BuildConfig.DEBUG) {
       if (BuildConfig.DEBUG) Log.d("CoCoin", "Save the above tag FAIL!");
       return SAVE_TAG_ERROR_DATABASE_ERROR;
     }
   } else {
     if (BuildConfig.DEBUG) {
       if (BuildConfig.DEBUG) Log.d("CoCoin", "Save the above tag SUCCESSFULLY!");
     }
     TAGS.add(tag);
     TAG_NAMES.put(tag.getId(), tag.getName());
     sortTAGS();
   }
   return insertId;
 }
示例#3
0
  @Override
  @Secured
  public TestExecution updateTestExecution(TestExecution testExecution) throws ServiceException {
    TestExecution execEntity = testExecutionDAO.get(testExecution.getId());
    if (execEntity == null) {
      throw new ServiceException("serviceException.testExecutionNotFound", testExecution.getName());
    }
    // this is what can be updated here
    execEntity.setName(testExecution.getName());
    execEntity.setStarted(testExecution.getStarted());
    execEntity.setComment(testExecution.getComment());
    execEntity.setTags(new ArrayList<>());

    for (Tag tag : testExecution.getTags()) {
      Tag tagEntity = tagDAO.findByName(tag.getName());
      if (tagEntity == null) {
        Tag newTag = new Tag();
        newTag.setName(tag.getName());
        tagEntity = tagDAO.create(newTag);
      }

      Collection<TestExecution> tagTestExecutions = tagEntity.getTestExecutions();
      if (tagTestExecutions == null) {
        tagEntity.setTestExecutions(new ArrayList<>());
      }

      tagEntity.getTestExecutions().add(execEntity);
      execEntity.getTags().add(tagEntity);
    }
    TestExecution execClone = cloneAndFetch(execEntity, true, true, true, true, true);
    return execClone;
  }
        @Override
        public int compare(Tag tag, Tag tag2) {
          if (!TextUtils.equals(tag.getCategory(), tag2.getCategory())) {
            return Config.Tags.CATEGORY_DISPLAY_ORDERS.get(tag.getCategory())
                - Config.Tags.CATEGORY_DISPLAY_ORDERS.get(tag2.getCategory());
          } else if (tag.getOrderInCategory() != tag2.getOrderInCategory()) {
            return tag.getOrderInCategory() - tag2.getOrderInCategory();
          }

          return tag.getName().compareTo(tag2.getName());
        }
  /**
   * Perform the action of the plugin.
   *
   * @param document the current document.
   */
  public boolean perform(Document document) throws IOException {
    // Interact with the user to get the layer tag/

    Tag layerTag = getLayerTagFromUser(document);
    if (layerTag == null) return false; // User cancled.
    Tag endTag = new Tag(layerTag.getName(), false);
    // Get the output stream to hold the new document text.
    PrintWriter out = new PrintWriter(document.getOutput());
    // Create a lexical stream to tokenize the old document text.
    LexicalStream in = new LexicalStream(new SelectedHTMLReader(document.getInput(), out));
    for (; ; ) {
      // Get the next token of the document.
      Token token = in.next();
      if (token == null) break; //  Null means we've finished the document.
      else if (token instanceof Comment) {
        Comment comment = (Comment) token;
        if (comment.isSelectionStart()) {
          out.print(layerTag);
        } else if (comment.isSelectionEnd()) {
          out.print(comment);
          out.print(endTag);
          continue; // So comment isn't printed twice.
        }
      }
      out.print(token);
    }
    out.close();
    return true;
  }
示例#6
0
  /**
   * Writes all exemplar of this tag and all his nodes recursively to files. One file to exemplar
   * (exemplar is text, representing tag with attribute - fn, replaced by fn value)
   *
   * @param tag - written tag
   */
  public void writeAllXml(Tag tag, String prefix, boolean toOutStream) {
    // initialise path in begin of export
    path = new ArrayList<>();
    XMLStreamWriter current;
    int n = tag.attrSizes();
    String extension = tag.getName();

    // if tag size > m, _trim it_
    if (limit >= 0 && limit < n) {
      n = limit;
    }

    // if tag size > WARNING_QUANTITY, ask user.
    // This tag is root tag of export, so quantity of files equals to its size
    if (n > WARNING_QUANTITY) {
      System.out.println("Write " + n + " files? y/n");
      try {
        int yn = System.in.read();
        if (yn != yCharCode) {
          System.out.println("Writing canceled\n Exit");
          System.exit(0);
        }
      } catch (IOException e) {
        Util.handleException(e);
      }
    }

    // if must be one file, export it
    if (n <= 1) {
      // if to out, print
      if (toOutStream) {
        writeExemplarXML(getXmlStreamWriter(null), tag, 0, 0);
      } else {
        // if to file, export
        current = getXmlStreamWriter(prefix + "." + extension);
        writeExemplarXML(current, tag, 0, 0);
        writeVersion(current);
      }
      // if files many,
    } else {
      // if to out,print all
      if (toOutStream) {
        for (int i = 0; i < n; i++) {
          writeExemplarXML(getXmlStreamWriter(null), tag, i, 0);
        }
      } else {
        // if to files, export all appended with __[№]
        for (int i = 0; i < n; i++) {
          current =
              getXmlStreamWriter(
                  prefix + "__(" + tag.getNameWithAttr(i).replace(" ", "_") + ")." + extension);
          writeExemplarXML(current, tag, i, 0);
          writeVersion(current);
        }
      }
    }

    // delete path in end of exort
    path = null;
  }
示例#7
0
  // getInstance//////////////////////////////////////////////////////////////////////////////////////
  public static synchronized RecordManager getInstance(Context context) {
    if (RECORDS == null
        || TAGS == null
        || TAG_NAMES == null
        || SUM == null
        || recordManager == null) {
      SUM = 0;
      RECORDS = new LinkedList<>();
      TAGS = new LinkedList<>();
      TAG_NAMES = new HashMap<>();
      recordManager = new RecordManager(context);

      db.getData();

      if (BuildConfig.DEBUG) {
        if (BuildConfig.DEBUG) Log.d("CoCoin", "Load " + RECORDS.size() + " records S");
        if (BuildConfig.DEBUG) Log.d("CoCoin", "Load " + TAGS.size() + " tags S");
      }

      TAGS.add(0, new Tag(-1, "Sum Histogram", -4));
      TAGS.add(0, new Tag(-2, "Sum Pie", -5));

      for (Tag tag : TAGS) TAG_NAMES.put(tag.getId(), tag.getName());

      sortTAGS();
    }
    return recordManager;
  }
 void load(DataInput dis) throws IOException {
   tags.clear();
   Tag tag;
   while ((tag = Tag.readNamedTag(dis)).getId() != Tag.TAG_End) {
     tags.put(tag.getName(), tag);
   }
 }
示例#9
0
 public static boolean isTagAndValue(String Name, String Value) {
   for (Tag tag : PiritaProtect.Plugin.Tags) {
     if (tag.getName().equalsIgnoreCase(Name) && tag.getValues().contains(Value.toLowerCase())) {
       return true;
     }
   }
   return false;
 }
示例#10
0
 public static boolean isTag(String Name) {
   for (Tag tag : PiritaProtect.Plugin.Tags) {
     if (tag.getName().equalsIgnoreCase(Name)) {
       return true;
     }
   }
   return false;
 }
示例#11
0
 @Override
 public List<String> getTagsByPrefix(String prefix) {
   List<String> tags = new ArrayList<String>();
   for (Tag tag : tagDAO.findByPrefix(prefix)) {
     tags.add(tag.getName());
   }
   return tags;
 }
  protected void assertTagEquals(
      Tag expected, Tag source, final List<String> ignoreAttr, final List<String> ignoreTag) {
    if (!expected.getName().equals(source.getName())) {
      throw new ComparisonFailure(
          "Tags not equal: ", expected.getName().toString(), source.getName().toString());
    }

    assertAttributesEquals(
        expected.getName(), expected.getAttributes(), source.getAttributes(), ignoreAttr);
    assertAttributesEquals(
        expected.getName(), source.getAttributes(), expected.getAttributes(), ignoreAttr);

    if (!StringUtils.isEmpty(expected.getText()) && !expected.getText().equals(source.getText())) {
      throw new ComparisonFailure("Text not equal: ", expected.getText(), source.getText());
    }

    if (!expected.getTags().isEmpty()) {
      for (Tag expectedTag : expected.getTags()) {
        if (ignoreTag.contains(expectedTag.getName().getLocalPart())
            && expectedTag.getTags().isEmpty()) {
          continue;
        }
        Tag sourceTag = getFromSource(source, expectedTag);
        if (sourceTag == null) {
          throw new AssertionError(
              "\n"
                  + expected.toString()
                  + " is missing in the source file:"
                  + "\n"
                  + source.toString());
        }
        assertTagEquals(expectedTag, sourceTag, ignoreAttr, ignoreTag);
      }
    }
  }
示例#13
0
 private boolean matchInTag(String needle) {
   needle = needle.toLowerCase(Locale.US);
   for (Tag tag : getTags()) {
     if (tag.getName().toLowerCase(Locale.US).contains(needle)) {
       return true;
     }
   }
   return false;
 }
 public AtributoAutofocus(Tag tag) {
   this.tag = tag;
   Class c = (Class) tag.getClass();
   if (!AgregadorAtributos.class.isAssignableFrom(c)) {
     type = tag.getName();
   } else {
     AgregadorAtributos temp = (AgregadorAtributos) tag;
     type = temp.getType();
   }
 }
  public boolean assertXmlEquals(
      final File expected, final File source, final List<String> ignoreAttr) throws Exception {
    List<Tag> expectedTags = ToolsStaxUtils.getTags(expected);
    List<Tag> sourceTags = ToolsStaxUtils.getTags(source);

    Iterator<Tag> iterator = sourceTags.iterator();

    for (Tag expectedTag : expectedTags) {
      Tag sourceTag = iterator.next();
      if (!expectedTag.getName().equals(sourceTag.getName())) {
        throw new ComparisonFailure(
            "Tags not equal: ", expectedTag.getName().toString(), sourceTag.getName().toString());
      }
      for (Map.Entry<QName, String> attr : expectedTag.getAttributes().entrySet()) {
        if (ignoreAttr.contains(attr.getKey().getLocalPart())) {
          continue;
        }

        if (sourceTag.getAttributes().containsKey(attr.getKey())) {
          if (!sourceTag.getAttributes().get(attr.getKey()).equals(attr.getValue())) {
            throw new ComparisonFailure(
                "Attributes not equal: ",
                attr.getKey() + ":" + attr.getValue(),
                attr.getKey() + ":" + sourceTag.getAttributes().get(attr.getKey()));
          }
        } else {
          throw new AssertionError("Attribute: " + attr + " is missing in the source file.");
        }
      }

      if (!StringUtils.isEmpty(expectedTag.getText())
          && !expectedTag.getText().equals(sourceTag.getText())) {
        throw new ComparisonFailure("Text not equal: ", expectedTag.getText(), sourceTag.getText());
      }
    }
    return true;
  }
示例#16
0
 private void putTag(final String key, final Tag tag) {
   final String[] parts =
       (String[])
           Iterables.toArray(
               Splitter.on('.').split((CharSequence) this.createRelativeKey(key)),
               (Class) String.class);
   Map<String, Tag> parent = NBTStorage.this.root;
   for (int i = 0; i < parts.length - 1; ++i) {
     if (!parent.containsKey(parts[i]) || !(parent.get(parts[i]) instanceof CompoundTag)) {
       parent.put(parts[i], new CompoundTag(parts[i]));
     }
     parent = parent.get(parts[i]).getValue();
   }
   parent.put(tag.getName(), tag);
 }
示例#17
0
  /**
   * Writes a tag.
   *
   * @param tag The tag to write.
   * @throws IOException if an I/O error occurs.
   */
  public void writeTag(Tag tag) throws IOException {
    int type = NBTUtils.getTypeCode(tag.getClass());
    String name = tag.getName();
    byte[] nameBytes = name.getBytes(NBTConstants.CHARSET);

    os.writeByte(type);
    os.writeShort(nameBytes.length);
    os.write(nameBytes);

    if (type == NBTConstants.TYPE_END) {
      throw new IOException("Named TAG_End not permitted.");
    }

    writeTagPayload(tag);
  }
示例#18
0
 private static boolean renameWorld(String worldname, String newname) {
   if (isLoaded(worldname)) return false;
   Tag t = getData(worldname);
   if (t == null) return false;
   t = t.findTagByName("Data");
   if (t == null || t.getType() != Type.TAG_Compound) return false;
   int i = 0;
   for (Tag tt : (Tag[]) t.getValue()) {
     if (tt.getName().equals("LevelName")) {
       t.removeTag(i);
       t.insertTag(new Tag(Type.TAG_String, "LevelName", newname), i);
       break;
     }
     i++;
   }
   return setData(worldname, t);
 }
示例#19
0
  public String getTagsString() {
    if (getTags().isEmpty()) {
      return "ไม่มีป้ายกำกับ";
    }

    String tgs = "";
    String splitor = ", ";
    for (Tag tag : getTags()) {
      tgs = tgs + splitor + tag.getName();
    }

    if (tgs.startsWith(splitor)) {
      return tgs.substring(splitor.length());
    }

    return tgs;
  }
 @Override
 @SuppressWarnings("unchecked")
 public void loadTag(T entity, Tag tag) {
   String name = tag.getName();
   if (name.equals("Dir")) {
     entity.setDirection(((ByteTag) tag).getValue());
   } else if (name.equals("Motive")) {
     entity.setArt(((StringTag) tag).getValue());
   } else if (name.equals("TileX")) {
     entity.getBlockCoordinates().setX(((IntTag) tag).getValue());
   } else if (name.equals("TileY")) {
     entity.getBlockCoordinates().setY(((IntTag) tag).getValue());
   } else if (name.equals("TileZ")) {
     entity.getBlockCoordinates().setZ(((IntTag) tag).getValue());
   } else {
     super.loadTag(entity, tag);
   }
 }
示例#21
0
  @Override
  public void removeTagsFromTestExecutions(
      Collection<String> tags, Collection<TestExecution> testExecutions) {
    for (TestExecution testExecutionItem : testExecutions) {
      TestExecution testExecution = testExecutionDAO.get(testExecutionItem.getId());
      if (testExecution == null) {
        continue;
      }

      for (Tag tag : testExecution.getTags()) {
        if (tags.contains(tag.getName())) {
          testExecution.getTags().remove(tag);
        }
      }

      testExecutionDAO.update(testExecution);
    }
  }
 @Override
 public View getChildView(
     int groupPosition,
     int childPosition,
     boolean isLastChild,
     View convertView,
     ViewGroup parent) {
   if (convertView == null) {
     convertView = layoutInflater.inflate(R.layout.item_expandble_list, parent, false);
   }
   TagsCategory category = (TagsCategory) getGroup(groupPosition);
   TextView tagName = (TextView) convertView.findViewById(R.id.elementsItemName);
   Tag tag = category.get(childPosition);
   tagName.setText(tag.getName());
   if (search.isChosen(tag)) {
     convertView.setBackgroundColor(Color.GRAY);
   } else {
     convertView.setBackgroundColor(Color.LTGRAY);
   }
   return convertView;
 }
示例#23
0
  @Override
  @Secured
  public TestExecution createTestExecution(TestExecution testExecution) throws ServiceException {
    // The test referred by test execution has to be an existing test
    Test test = testDAO.get(testExecution.getTest().getId());
    testExecution.setTest(test);
    TestExecution storedTestExecution = testExecutionDAO.create(testExecution);
    // execution params
    if (testExecution.getParameters() != null && testExecution.getParameters().size() > 0) {
      for (TestExecutionParameter param : testExecution.getParameters()) {
        param.setTestExecution(storedTestExecution);
        testExecutionParameterDAO.create(param);
      }
    }
    // tags
    if (testExecution.getTags() != null && testExecution.getTags().size() > 0) {
      for (Tag teg : testExecution.getTags()) {
        Tag tag = tagDAO.findByName(teg.getName());
        if (tag == null) {
          tag = tagDAO.create(teg);
        }

        Collection<TestExecution> tagTestExecutions = tag.getTestExecutions();
        if (tagTestExecutions == null) {
          tag.setTestExecutions(new ArrayList<>());
        }

        tag.getTestExecutions().add(storedTestExecution);
      }
    }
    // values
    if (testExecution.getValues() != null && !testExecution.getValues().isEmpty()) {
      for (Value value : testExecution.getValues()) {
        value.setTestExecution(storedTestExecution);
        if (value.getMetricName() == null) {
          throw new IllegalArgumentException("Metric name is mandatory");
        }
        Metric metric =
            test.getMetrics()
                .stream()
                .filter(m -> m.getName().equals(value.getMetricName()))
                .findFirst()
                .get();
        if (metric == null) {
          throw new ServiceException(
              "serviceException.metricNotInTest",
              test.getName(),
              test.getId().toString(),
              value.getMetricName());
        }
        value.setMetric(metric);
        valueDAO.create(value);
        if (value.getParameters() != null && value.getParameters().size() > 0) {
          for (ValueParameter vp : value.getParameters()) {
            vp.setValue(value);
            valueParameterDAO.create(vp);
          }
        }
      }
    }

    TestExecution clone = cloneAndFetch(storedTestExecution, true, true, true, true, true);
    log.debug("Created new test execution " + clone.getId());

    alertingService.processAlerts(clone);

    return clone;
  }
  /** Builds the document header of the swagger model */
  private void overview() {
    Info info = swagger.getInfo();
    this.markupDocBuilder.documentTitle(info.getTitle());
    this.markupDocBuilder.sectionTitleLevel1(OVERVIEW);
    if (isNotBlank(info.getDescription())) {
      this.markupDocBuilder.textLine(info.getDescription());
    }
    if (isNotBlank(info.getVersion())) {
      this.markupDocBuilder.sectionTitleLevel2(CURRENT_VERSION);
      this.markupDocBuilder.textLine(VERSION + info.getVersion());
    }
    Contact contact = info.getContact();
    if (contact != null) {
      this.markupDocBuilder.sectionTitleLevel2(CONTACT_INFORMATION);
      if (isNotBlank(contact.getName())) {
        this.markupDocBuilder.textLine(CONTACT_NAME + contact.getName());
      }
      if (isNotBlank(contact.getEmail())) {
        this.markupDocBuilder.textLine(CONTACT_EMAIL + contact.getEmail());
      }
    }

    License license = info.getLicense();
    if (license != null && (isNotBlank(license.getName()) || isNotBlank(license.getUrl()))) {
      this.markupDocBuilder.sectionTitleLevel2(LICENSE_INFORMATION);
      if (isNotBlank(license.getName())) {
        this.markupDocBuilder.textLine(LICENSE + license.getName());
      }
      if (isNotBlank(license.getUrl())) {
        this.markupDocBuilder.textLine(LICENSE_URL + license.getUrl());
      }
    }
    if (isNotBlank(info.getTermsOfService())) {
      this.markupDocBuilder.textLine(TERMS_OF_SERVICE + info.getTermsOfService());
    }

    if (isNotBlank(swagger.getHost())
        || isNotBlank(swagger.getBasePath())
        || isNotEmpty(swagger.getSchemes())) {
      this.markupDocBuilder.sectionTitleLevel2(URI_SCHEME);
      if (isNotBlank(swagger.getHost())) {
        this.markupDocBuilder.textLine(HOST + swagger.getHost());
      }
      if (isNotBlank(swagger.getBasePath())) {
        this.markupDocBuilder.textLine(BASE_PATH + swagger.getBasePath());
      }
      if (isNotEmpty(swagger.getSchemes())) {
        List<String> schemes = new ArrayList<>();
        for (Scheme scheme : swagger.getSchemes()) {
          schemes.add(scheme.toString());
        }
        this.markupDocBuilder.textLine(SCHEMES + join(schemes, ", "));
      }
    }

    if (isNotEmpty(swagger.getTags())) {
      this.markupDocBuilder.sectionTitleLevel2(TAGS);
      List<String> tags = new ArrayList<>();
      for (Tag tag : swagger.getTags()) {
        String name = tag.getName();
        String description = tag.getDescription();
        if (isNoneBlank(description)) {
          tags.add(name + ": " + description);
        } else {
          tags.add(name);
        }
      }
      this.markupDocBuilder.unorderedList(tags);
    }

    if (isNotEmpty(swagger.getConsumes())) {
      this.markupDocBuilder.sectionTitleLevel2(CONSUMES);
      this.markupDocBuilder.unorderedList(swagger.getConsumes());
    }

    if (isNotEmpty(swagger.getProduces())) {
      this.markupDocBuilder.sectionTitleLevel2(PRODUCES);
      this.markupDocBuilder.unorderedList(swagger.getProduces());
    }
  }
示例#25
0
  private void writeExemplarXML(XMLStreamWriter xmlStreamWriter, Tag tag, int n, int tabs) {
    String string;
    Map<String, StringFacadeIF> map;

    // add this tag to end of path
    path.add(tag);

    // filtr exemplar by EXIST, EXIST0, ONENODE (and m.b. something else in future)
    if (tag.isExemplarWritten(n)) {
      map = tag.getStringFacadeMap();

      try {
        // "\t" * tabs
        tabs(xmlStreamWriter, tabs);

        // <tag>
        xmlStreamWriter.writeStartElement(tag.getName());

        // replace attr with "..." by same without dots d and vice versa
        // and export it
        for (String s : tag.getAttributeNames()) {
          if (s.endsWith("...")) {
            string = s.replace("...", "");
            if (tag.getAttributeNames().contains(string)) {
              xmlStreamWriter.writeAttribute(string, map.get(s).getValue(null, n));
            } else {
              Util.printErrorAndExit("\"" + s + "\" has not pair. Exit");
            }
          } else {
            string = s.concat("...");
            if (tag.getAttributeNames().contains(string)) {
              xmlStreamWriter.writeAttribute(string, map.get(s).getValue(null, n));
            } else {
              xmlStreamWriter.writeAttribute(s, map.get(s).getValue(null, n));
            }
          }
        }

        // if not <tag></tag>, \n
        if (!tag.isEmpty()) {
          xmlStreamWriter.writeCharacters("\n");
        }

        // export nodes with "\t" * (tabs + 1)
        if (!tag.oneNode()) {
          tag.getNodes().stream().forEach(t -> writeAllXml(xmlStreamWriter, t, tabs + 1));
        } else {
          if (tag.nodeSizes() > -1) {
            tag.getNodes().stream().forEach(t -> writeExemplarXML(xmlStreamWriter, t, n, tabs + 1));
          }
        }

        // text
        if (tag.getText() != null) {
          tabs(xmlStreamWriter, tabs + 1);
          xmlStreamWriter.writeCharacters(tag.getText().getValue(null, n));
          xmlStreamWriter.writeCharacters("\n");
        }

        // if not <tag></tag>, "\t" * (tabs)
        if (!tag.isEmpty()) {
          tabs(xmlStreamWriter, tabs);
        }
        // </tag>
        xmlStreamWriter.writeEndElement();

        // \n
        xmlStreamWriter.writeCharacters("\n");

        // print only exception name, not stackTrace (if catch this exception)
      } catch (XMLStreamException e) {
        Util.handleException(e);
      }
    }

    // remove this tag from path
    getPath().remove(getPath().size() - 1);
  }