docs: public static String transformValues(String oldFormat, String newFormat, String value) {
  
          if (!oldFormat.contains(CmsStringUtil.PLACEHOLDER_START)
              || !oldFormat.contains(CmsStringUtil.PLACEHOLDER_END)
              || !newFormat.contains(CmsStringUtil.PLACEHOLDER_START)
              || !newFormat.contains(CmsStringUtil.PLACEHOLDER_END)) {
              // no place holders are set in correct format
              // that is why there is nothing to calculate and the value is the new format
              return newFormat;
          }
          //initialize the arrays with the values where the place holders starts
          ArrayList<Integer> oldValues = new ArrayList<Integer>();
          ArrayList<Integer> newValues = new ArrayList<Integer>();
  
          // count the number of placeholders
          // for example these are three pairs:
          // old format: {.*}<b>{.*}</b>{.*}
          // new format: {}<strong>{}</strong>{}
          // get the number of place holders in the old format
          int oldNumber = 0;
          try {
              int counter = 0;
              Pattern pattern = Pattern.compile("\\{\\.\\*\\}");
              Matcher matcher = pattern.matcher(oldFormat);
              // get the number of matches
              while (matcher.find()) {
                  counter += 1;
              }
              oldValues = new ArrayList<Integer>(counter);
              matcher = pattern.matcher(oldFormat);
              while (matcher.find()) {
                  int start = matcher.start() + 1;
                  oldValues.add(oldNumber, new Integer(start));
                  oldNumber += 1;
              }
          } catch (PatternSyntaxException e) {
              // do nothing
          }
          // get the number of place holders in the new format
          int newNumber = 0;
          try {
              int counter = 0;
              Pattern pattern = Pattern.compile("\\{\\}");
              Matcher matcher = pattern.matcher(newFormat);
              // get the number of matches
              while (matcher.find()) {
                  counter += 1;
              }
              newValues = new ArrayList<Integer>(counter);
              matcher = pattern.matcher(newFormat);
              while (matcher.find()) {
                  int start = matcher.start() + 1;
                  newValues.add(newNumber, new Integer(start));
                  newNumber += 1;
              }
          } catch (PatternSyntaxException e) {
              // do nothing
          }
          // prove the numbers of place holders
          if (oldNumber != newNumber) {
              // not the same number of place holders in the old and in the new format
              return newFormat;
          }
  
          // initialize the arrays with the values between the place holders
          ArrayList<String> oldBetween = new ArrayList<String>(oldNumber + 1);
          ArrayList<String> newBetween = new ArrayList<String>(newNumber + 1);
  
          // get the values between the place holders for the old format
          // for this example with oldFormat: {.*}<b>{.*}</b>{.*}
          // this array is that:
          // ---------
          // | empty |
          // ---------
          // | <b>   |
          // |--------
          // | </b>  |
          // |--------
          // | empty |
          // |--------
          int counter = 0;
          Iterator<Integer> iter = oldValues.iterator();
          while (iter.hasNext()) {
              int start = iter.next().intValue();
              if (counter == 0) {
                  // the first entry
                  if (start == 1) {
                      // the first place holder starts at the beginning of the old format
                      // for example: {.*}<b>...
                      oldBetween.add(counter, "");
                  } else {
                      // the first place holder starts NOT at the beginning of the old format
                      // for example: <a>{.*}<b>...
                      String part = oldFormat.substring(0, start - 1);
                      oldBetween.add(counter, part);
                  }
              } else {
                  // the entries between the first and the last entry
                  int lastStart = oldValues.get(counter - 1).intValue();
                  String part = oldFormat.substring(lastStart + 3, start - 1);
                  oldBetween.add(counter, part);
              }
              counter += 1;
          }
          // the last element
          int lastElstart = oldValues.get(counter - 1).intValue();
          if ((lastElstart + 2) == (oldFormat.length() - 1)) {
              // the last place holder ends at the end of the old format
              // for example: ...</b>{.*}
              oldBetween.add(counter, "");
          } else {
              // the last place holder ends NOT at the end of the old format
              // for example: ...</b>{.*}</a>
              String part = oldFormat.substring(lastElstart + 3);
              oldBetween.add(counter, part);
          }
  
          // get the values between the place holders for the new format
          // for this example with newFormat: {}<strong>{}</strong>{}
          // this array is that:
          // ------------|
          // | empty     |
          // ------------|
          // | <strong>  |
          // |-----------|
          // | </strong> |
          // |-----------|
          // | empty     |
          // |-----------|
          counter = 0;
          iter = newValues.iterator();
          while (iter.hasNext()) {
              int start = iter.next().intValue();
              if (counter == 0) {
                  // the first entry
                  if (start == 1) {
                      // the first place holder starts at the beginning of the new format
                      // for example: {.*}<b>...
                      newBetween.add(counter, "");
                  } else {
                      // the first place holder starts NOT at the beginning of the new format
                      // for example: <a>{.*}<b>...
                      String part = newFormat.substring(0, start - 1);
                      newBetween.add(counter, part);
                  }
              } else {
                  // the entries between the first and the last entry
                  int lastStart = newValues.get(counter - 1).intValue();
                  String part = newFormat.substring(lastStart + 1, start - 1);
                  newBetween.add(counter, part);
              }
              counter += 1;
          }
          // the last element
          lastElstart = newValues.get(counter - 1).intValue();
          if ((lastElstart + 2) == (newFormat.length() - 1)) {
              // the last place holder ends at the end of the old format
              // for example: ...</b>{.*}
              newBetween.add(counter, "");
          } else {
              // the last place holder ends NOT at the end of the old format
              // for example: ...</b>{.*}</a>
              String part = newFormat.substring(lastElstart + 1);
              newBetween.add(counter, part);
          }
  
          // get the values in the place holders
          // for the example with:
          //   oldFormat: {.*}<b>{.*}</b>{.*}
          //   newFormat: {}<strong>{}</strong>{}
          //   value: abc<b>def</b>ghi
          // it is used the array with the old values between the place holders to get the content in the place holders
          // this result array is that:
          // ------|
          // | abc |
          // ------|
          // | def |
          // |-----|
          // | ghi |
          // |-----|
          ArrayList<String> placeHolders = new ArrayList<String>(oldNumber);
          String tmpValue = value;
          // loop over all rows with the old values between the place holders and take the values between them in the
          // current property value
          for (int placeCounter = 0; placeCounter < (oldBetween.size() - 1); placeCounter++) {
              // get the two next values with the old values between the place holders
              String content = oldBetween.get(placeCounter);
              String nextContent = oldBetween.get(placeCounter + 1);
              // check the position of the first of the next values in the current property value
              int contPos = 0;
              int nextContPos = 0;
              if ((placeCounter == 0) && CmsStringUtil.isEmpty(content)) {
                  // the first value in the values between the place holders is empty
                  // for example: {.*}<p>...
                  contPos = 0;
              } else {
                  // the first value in the values between the place holders is NOT empty
                  // for example: bla{.*}<p>...
                  contPos = tmpValue.indexOf(content);
              }
              // check the position of the second of the next values in the current property value
              if (((placeCounter + 1) == (oldBetween.size() - 1)) && CmsStringUtil.isEmpty(nextContent)) {
                  // the last value in the values between the place holders is empty
                  // for example: ...<p>{.*}
                  nextContPos = tmpValue.length();
              } else {
                  // the last value in the values between the place holders is NOT empty
                  // for example: ...<p>{.*}bla
                  nextContPos = tmpValue.indexOf(nextContent);
              }
              // every value must match the current value
              if ((contPos < 0) || (nextContPos < 0)) {
                  return value;
              }
              // get the content of the current place holder
              String placeContent = tmpValue.substring(contPos + content.length(), nextContPos);
              placeHolders.add(placeCounter, placeContent);
              // cut off the currently visited part of the value
              tmpValue = tmpValue.substring(nextContPos);
          }
  
          // build the new format
          // with following vectors from above:
          // old values between the place holders:
          // ---------
          // | empty | (old.1)
          // ---------
          // | <b>   | (old.2)
          // |--------
          // | </b>  | (old.3)
          // |--------
          // | empty | (old.4)
          // |--------
          //
          // new values between the place holders:
          // ------------|
          // | empty     | (new.1)
          // ------------|
          // | <strong>  | (new.2)
          // |-----------|
          // | </strong> | (new.3)
          // |-----------|
          // | empty     | (new.4)
          // |-----------|
          //
          // content of the place holders:
          // ------|
          // | abc | (place.1)
          // ------|
          // | def | (place.2)
          // |-----|
          // | ghi | (place.3)
          // |-----|
          //
          // the result is calculated in that way:
          // new.1 + place.1 + new.2 + place.2 + new.3 + place.3 + new.4
          String newValue = "";
          // take the values between the place holders and add the content of the place holders
          for (int buildCounter = 0; buildCounter < newNumber; buildCounter++) {
              newValue = newValue + newBetween.get(buildCounter) + placeHolders.get(buildCounter);
          }
          newValue = newValue + newBetween.get(newNumber);
          // return the changed value
          return newValue;
      }