X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-model%2Fsrc%2Fmain%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Fmodel%2Ftosca%2FToscaType.java;h=a3daaa038139e6c01665a1c40e71d9db96df3fff;hb=f995db01ee95606b6cded82822a73435ebc190c8;hp=f59ebe6922875f0bced67d3457f0347e6129ee97;hpb=7e08a2976d34066412af14fe633eecde3ce19fc7;p=sdc.git diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java index f59ebe6922..a3daaa0381 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/tosca/ToscaType.java @@ -27,6 +27,8 @@ import java.text.SimpleDateFormat; 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; @@ -53,9 +55,23 @@ public enum ToscaType { 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; @@ -94,7 +110,7 @@ public enum ToscaType { 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); @@ -104,9 +120,9 @@ public enum ToscaType { 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: @@ -114,6 +130,7 @@ public enum ToscaType { case LIST: case MAP: return true; + case SCALAR_UNIT: default: return false; } @@ -127,11 +144,15 @@ public enum ToscaType { 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); @@ -141,6 +162,7 @@ public enum ToscaType { return isList(value); case MAP: return isMap(value); + case SCALAR_UNIT: default: return false; } @@ -189,11 +211,15 @@ public enum ToscaType { 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: @@ -223,13 +249,150 @@ public enum ToscaType { } 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(); + } + }