From b1078581d4730d4944180a739fcce51a39259112 Mon Sep 17 00:00:00 2001 From: Marcin Chrzanowski Date: Sun, 3 Nov 2019 12:55:03 +0100 Subject: Initialize gradle project --- .../edu/mimuw/cloudatlas/model/ValueDuration.java | 272 +++++++++++++++++++++ 1 file changed, 272 insertions(+) create mode 100644 src/main/java/pl/edu/mimuw/cloudatlas/model/ValueDuration.java (limited to 'src/main/java/pl/edu/mimuw/cloudatlas/model/ValueDuration.java') diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/model/ValueDuration.java b/src/main/java/pl/edu/mimuw/cloudatlas/model/ValueDuration.java new file mode 100644 index 0000000..bf9d0e0 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/model/ValueDuration.java @@ -0,0 +1,272 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.model; + +import java.lang.IllegalArgumentException; +import java.text.ParseException; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * A class representing duration in milliseconds. The duration can be negative. This is a simple wrapper of a Java + * Long object. + */ +public class ValueDuration extends ValueSimple { + public static class InvalidFormatException extends IllegalArgumentException { + } + + /** + * Regex pattern for duration strings. + */ + private static final Pattern DURATION_PATTERN = Pattern.compile( + "(?[+-])(?\\d+) " + + "(?[0-1][0-9]|2[0-3]):(?[0-5][0-9]):(?[0-5][0-9])." + + "(?[0-9]{3})" + ); + + /** + * Constructs a new ValueDuration object wrapping the specified value. + * + * @param value the value to wrap + */ + public ValueDuration(Long value) { + super(value); + } + + @Override + public Type getType() { + return TypePrimitive.DURATION; + } + + @Override + public Value getDefaultValue() { + return new ValueDuration(0l); + } + + /** + * Constructs a new ValueDuration object from the specified amounts of different time units. + * + * @param seconds a number of full seconds + * @param milliseconds a number of milliseconds (an absolute value does not have to be lower than 1000) + */ + public ValueDuration(long seconds, long milliseconds) { + this(seconds * 1000l + milliseconds); + } + + /** + * Constructs a new ValueDuration object from the specified amounts of different time units. + * + * @param minutes a number of full minutes + * @param seconds a number of full seconds (an absolute value does not have to be lower than 60) + * @param milliseconds a number of milliseconds (an absolute value does not have to be lower than 1000) + */ + public ValueDuration(long minutes, long seconds, long milliseconds) { + this(minutes * 60l + seconds, milliseconds); + } + + /** + * Constructs a new ValueDuration object from the specified amounts of different time units. + * + * @param hours a number of full hours + * @param minutes a number of full minutes (an absolute value does not have to be lower than 60) + * @param seconds a number of full seconds (an absolute value does not have to be lower than 60) + * @param milliseconds a number of milliseconds (an absolute value does not have to be lower than 1000) + */ + public ValueDuration(long hours, long minutes, long seconds, long milliseconds) { + this(hours * 60l + minutes, seconds, milliseconds); + } + + /** + * Constructs a new ValueDuration object from the specified amounts of different time units. + * + * @param days a number of full days + * @param hours a number of full hours (an absolute value does not have to be lower than 24) + * @param minutes a number of full minutes (an absolute value does not have to be lower than 60) + * @param seconds a number of full seconds (an absolute value does not have to be lower than 60) + * @param milliseconds a number of milliseconds (an absolute value does not have to be lower than 1000) + */ + public ValueDuration(long days, long hours, long minutes, long seconds, long milliseconds) { + this(days * 24l + hours, minutes, seconds, milliseconds); + } + + /** + * Constructs a new ValueDuration object from its textual representation. The representation has + * format: sd hh:mm:ss.lll where: + *
    + *
  • s is a sign (+ or -),
    • + *
  • d is a number of days,
    • + *
  • hh is a number of hours (between 00 and 23),
    • + *
  • mm is a number of minutes (between 00 and 59),
    • + *
  • ss is a number of seconds (between 00 and 59),
    • + *
  • lll is a number of milliseconds (between 000 and 999).
    • + *
+ *

+ * All fields are obligatory. + * + * @param value a textual representation of a duration + * @throws IllegalArgumentException if value does not meet described rules + */ + public ValueDuration(String value) { + this(parseDuration(value)); + } + + private static long parseDuration(String value) { + Matcher matcher = DURATION_PATTERN.matcher(value); + if (!matcher.matches()) { + throw new InvalidFormatException(); + } + + long result = parseLongGroup(matcher, "days"); + result *= 24; + result += parseLongGroup(matcher, "hours"); + result *= 60; + result += parseLongGroup(matcher, "minutes"); + result *= 60; + result += parseLongGroup(matcher, "seconds"); + result *= 1000; + result += parseLongGroup(matcher, "milliseconds"); + result *= matcher.group("sign").equals("+") ? 1 : -1; + + return result; + } + + private static long parseLongGroup(Matcher matcher, String group) { + return Long.parseLong(matcher.group(group)); + } + + @Override + public ValueBoolean isLowerThan(Value value) { + sameTypesOrThrow(value, Operation.COMPARE); + if(isNull() || value.isNull()) + return new ValueBoolean(null); + return new ValueBoolean(getValue() < ((ValueDuration)value).getValue()); + } + + @Override + public ValueDuration addValue(Value value) { + sameTypesOrThrow(value, Operation.ADD); + if (isNull() || value.isNull()) { + return new ValueDuration((Long) null); + } + + return new ValueDuration(getValue() + ((ValueDuration)value).getValue()); + } + + @Override + public ValueDuration subtract(Value value) { + sameTypesOrThrow(value, Operation.SUBTRACT); + if (isNull() || value.isNull()) + return new ValueDuration((Long) null); + return new ValueDuration(getValue() - ((ValueDuration)value).getValue()); + } + + @Override + public ValueDuration multiply(Value value) { + if (!value.getType().isCompatible(TypePrimitive.INTEGER)) { + throw new IncompatibleTypesException(getType(), value.getType(), Operation.MULTIPLY); + } + + if (isNull() || value.isNull()) { + return new ValueDuration((Long) null); + } + + return new ValueDuration(getValue() * ((ValueInt)value).getValue()); + } + + @Override + public Value divide(Value value) { + if (!value.getType().isCompatible(TypePrimitive.INTEGER)) { + throw new IncompatibleTypesException(getType(), value.getType(), Operation.MULTIPLY); + } + + if (isNull() || value.isNull()) { + return new ValueDuration((Long) null); + } + + if (((ValueInt)value).getValue() == 0l) { + throw new ArithmeticException("Division by zero."); + } + + return new ValueDuration(getValue() / ((ValueInt)value).getValue()); + } + + @Override + public ValueDuration modulo(Value value) { + if (!value.getType().isCompatible(TypePrimitive.INTEGER)) { + throw new IncompatibleTypesException(getType(), value.getType(), Operation.MULTIPLY); + } + + if (isNull() || value.isNull()) { + return new ValueDuration((Long) null); + } + + if (((ValueInt)value).getValue() == 0l) { + throw new ArithmeticException("Division by zero."); + } + + return new ValueDuration(getValue() % ((ValueInt)value).getValue()); + } + + @Override + public ValueDuration negate() { + if(isNull()) { + return new ValueDuration((Long) null); + } + + return new ValueDuration(-getValue()); + } + + public String toString() { + long remainingUnits = getValue(); + boolean positive = remainingUnits >= 0; + remainingUnits = positive ? remainingUnits : -remainingUnits; + + long milliseconds = remainingUnits % 1000; + remainingUnits /= 1000; + long seconds = remainingUnits % 60; + remainingUnits /= 60; + long minutes = remainingUnits % 60; + remainingUnits /= 60; + long hours = remainingUnits % 24; + remainingUnits /= 24; + long days = remainingUnits; + + return (positive ? "+" : "-") + Long.toString(days) + " " + Long.toString(hours) + + ":" + Long.toString(minutes) + ":" + Long.toString(seconds) + "." + + Long.toString(milliseconds); + } + + @Override + public Value convertTo(Type type) { + switch(type.getPrimaryType()) { + case STRING: + return getValue() == null? ValueString.NULL_STRING : new ValueString(toString()); + case DURATION: + return this; + default: + throw new UnsupportedConversionException(getType(), type); + } + } +} -- cgit v1.2.3