import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.openecomp.sdc.be.model.tosca.constraints.ConstraintUtil;
SCALAR_UNIT("scalar-unit"),
SCALAR_UNIT_SIZE("scalar-unit.size"),
SCALAR_UNIT_TIME("scalar-unit.time"),
+ SCALAR_UNIT_BITRATE("scalar-unit.bitrate"),
SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
// @formatter:on
+ private static final String SCALAR_UNIT_BITRATE_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([TtGgMmKk]?i?[Bb]ps)$";
+ private static final String SCALAR_UNIT_TIME_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([mun]?[dhms])$";
+ private static final String SCALAR_UNIT_SIZE_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([TtGgMmKk]?i?[Bb])$";
+ private static final String SCALAR_UNIT_FREQUENCY_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([kMG]?Hz)$";
+ private static final double B_IN_TiB = Math.pow(1024, 4);
+ private static final double B_IN_GiB = Math.pow(1024, 3);
+ private static final double B_IN_MiB = Math.pow(1024, 2);
+ private static final double B_IN_KiB = Math.pow(1024, 1);
+ private static final double B_IN_TB = Math.pow(1000, 4);
+ private static final double B_IN_GB = Math.pow(1000, 3);
+ private static final double B_IN_MB = Math.pow(1000, 2);
+ private static final double B_IN_KB = Math.pow(1000, 1);
+
@Getter
private final String type;
return ToscaPropertyType.MAP.getType().equals(type) || ToscaPropertyType.LIST.getType().equals(type);
}
- public Boolean isValueTypeValid(Object value) {
+ public boolean isValueTypeValid(Object value) {
switch (this) {
case BOOLEAN:
return value.equals(true) || value.equals(false);
case RANGE:
return value instanceof Integer;
case STRING:
- case SCALAR_UNIT:
case SCALAR_UNIT_SIZE:
case SCALAR_UNIT_TIME:
+ case SCALAR_UNIT_BITRATE:
case SCALAR_UNIT_FREQUENCY:
case TIMESTAMP:
case VERSION:
case LIST:
case MAP:
return true;
+ case SCALAR_UNIT:
default:
return false;
}
return isFloat(value);
case INTEGER:
return isInteger(value);
- case STRING:
- case SCALAR_UNIT:
case SCALAR_UNIT_SIZE:
+ return isScalarUnitSize(value);
case SCALAR_UNIT_TIME:
+ return isScalarUnitTime(value);
+ case SCALAR_UNIT_BITRATE:
+ return isScalarUnitBitrate(value);
case SCALAR_UNIT_FREQUENCY:
+ return isScalarUnitFrequency(value);
+ case STRING:
return true;
case TIMESTAMP:
return TimestampValidator.getInstance().isValid(value, null);
return isList(value);
case MAP:
return isMap(value);
+ case SCALAR_UNIT:
default:
return false;
}
public Object convert(String value) {
switch (this) {
case STRING:
- case SCALAR_UNIT:
- case SCALAR_UNIT_SIZE:
+ return value;
case SCALAR_UNIT_TIME:
+ return convertScalarUnitTime(value);
+ case SCALAR_UNIT_BITRATE:
+ return convertScalarUnitBitrate(value);
+ case SCALAR_UNIT_SIZE:
+ return convertScalarUnitSize(value);
case SCALAR_UNIT_FREQUENCY:
- return value;
+ return convertScalarUnitFrequency(value);
case BOOLEAN:
return Boolean.valueOf(value);
case FLOAT:
} catch (ConstraintValueDoNotMatchPropertyTypeException e) {
throw new IllegalArgumentException("Value must be a valid Map", e);
}
+ case SCALAR_UNIT:
default:
return null;
}
}
- @Override
- public String toString() {
- return name().toLowerCase();
+ private Long convertScalarUnitSize(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_SIZE_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "TiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TiB);
+ case "TB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TB);
+ case "GiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GiB);
+ case "GB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GB);
+ case "MiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MiB);
+ case "MB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MB);
+ case "KiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KiB);
+ case "kB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KB);
+ case "B":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.size");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.size");
+ }
+ }
+
+ private Long convertScalarUnitTime(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_TIME_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "d":
+ return (long) (Double.parseDouble(matcher.group(1)) * 24 * 60 * 60 * 1_000_000_000L); // 24hours * 60minutes * 60seconds
+ case "h":
+ return (long) (Double.parseDouble(matcher.group(1)) * 60 * 60 * 1_000_000_000L); // 60minutes * 60seconds
+ case "m":
+ return (long) (Double.parseDouble(matcher.group(1)) * 60 * 1_000_000_000L); // 60seconds
+ case "s":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000_000L);
+ case "ms":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000L);
+ case "us":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000L);
+ case "ns":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.time");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.time");
+ }
+ }
+
+ private Long convertScalarUnitFrequency(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_FREQUENCY_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "GHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000_000L);
+ case "MHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000L);
+ case "kHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000L);
+ case "Hz":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.frequency");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.frequency");
+ }
+ }
+
+ private Long convertScalarUnitBitrate(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_BITRATE_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "TiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_TiB);
+ case "TBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_TB);
+ case "GiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_GiB);
+ case "GBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_GB);
+ case "MiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_MiB);
+ case "MBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_MB);
+ case "KiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_KiB);
+ case "KBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_KB);
+ case "Bps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8);
+ case "Tibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TiB);
+ case "Tbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TB);
+ case "Gibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GiB);
+ case "Gbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GB);
+ case "Mibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MiB);
+ case "Mbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MB);
+ case "Kibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KiB);
+ case "Kbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KB);
+ case "bps":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.bitrate");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.bitrate");
+ }
+ }
+
+ private boolean isScalarUnitBitrate(final String value) {
+ return Pattern.compile(SCALAR_UNIT_BITRATE_PATTERN).matcher(value.trim()).find();
}
+
+ private boolean isScalarUnitSize(final String value) {
+ return Pattern.compile(SCALAR_UNIT_SIZE_PATTERN).matcher(value.trim()).find();
+ }
+
+ private boolean isScalarUnitTime(final String value) {
+ return Pattern.compile(SCALAR_UNIT_TIME_PATTERN).matcher(value.trim()).find();
+ }
+
+ private boolean isScalarUnitFrequency(final String value) {
+ return Pattern.compile(SCALAR_UNIT_FREQUENCY_PATTERN).matcher(value.trim()).find();
+ }
+
}
Code Review / sdc.git / blobdiff