ValueWrapper.java

package com.vesoft.nebula.driver.graph.data;
 
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_BOOL;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_DATE;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_DECIMAL;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_DURATION;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_EDGE;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_EMBEDDINGVECTOR;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_FLOAT32;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_FLOAT64;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_INT16;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_INT32;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_INT64;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_INT8;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_LIST;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_LOCALDATETIME;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_LOCALTIME;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_NODE;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_PATH;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_RECORD;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_STRING;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_UINT16;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_UINT32;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_UINT64;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_UINT8;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_ZONEDDATETIME;
import static com.vesoft.nebula.driver.graph.decode.ColumnType.COLUMN_TYPE_ZONEDTIME;
 
import com.vesoft.nebula.driver.graph.decode.ColumnType;
import com.vesoft.nebula.driver.graph.exception.InvalidValueException;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetTime;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Objects;
import java.util.Vector;
 
public class ValueWrapper {
 
    private final Object     value;
    private final ColumnType type;
 
    DateTimeFormatter zonedDateTimeFormatter =
            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX");
    DateTimeFormatter localDateTimeFormatter =
            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSSSS");
    DateTimeFormatter zonedTimeFormatter     = DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSSXXXXX");
    DateTimeFormatter localTimeFormatter     = DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSS");
 
    public ValueWrapper(Object value, ColumnType type) {
        this.value = value;
        this.type = type;
    }
 
    public ColumnType getDataType() {
        return type;
    }
 
    public String getDataTypeString() {
        switch (type) {
            case COLUMN_TYPE_BOOL:
                return "BOOLEAN";
            case COLUMN_TYPE_UINT8:
                return "UINT8";
            case COLUMN_TYPE_INT8:
                return "INT8";
            case COLUMN_TYPE_UINT16:
                return "UINT16";
            case COLUMN_TYPE_INT16:
                return "INT16";
            case COLUMN_TYPE_UINT32:
                return "UINT32";
            case COLUMN_TYPE_INT32:
                return "INT32";
            case COLUMN_TYPE_UINT64:
                return "UINT64";
            case COLUMN_TYPE_INT64:
                return "INT64";
            case COLUMN_TYPE_FLOAT32:
                return "FLOAT";
            case COLUMN_TYPE_FLOAT64:
                return "DOUBLE";
            case COLUMN_TYPE_STRING:
                return "STRING";
            case COLUMN_TYPE_NODE:
                return "NODE";
            case COLUMN_TYPE_EDGE:
                return "EDGE";
            case COLUMN_TYPE_LIST:
                return "LIST";
            case COLUMN_TYPE_DURATION:
                return "DURATION";
            case COLUMN_TYPE_LOCALTIME:
                return "LOCAL_TIME";
            case COLUMN_TYPE_LOCALDATETIME:
                return "LOCAL_DATETIME";
            case COLUMN_TYPE_ZONEDTIME:
                return "ZONED_TIME";
            case COLUMN_TYPE_ZONEDDATETIME:
                return "ZONED_DATETIME";
            case COLUMN_TYPE_DATE:
                return "DATE";
            case COLUMN_TYPE_RECORD:
                return "RECORD";
            case COLUMN_TYPE_PATH:
                return "PATH";
            case COLUMN_TYPE_DECIMAL:
                return "DECIMAL";
            case COLUMN_TYPE_ANY:
                return "ANY";
            default:
                throw new IllegalArgumentException("Unknown data type: " + type);
        }
    }
 
 
    public Object getValue() {
        return value;
    }
 
    public boolean isNull() {
        return value == null;
    }
 
    public boolean isBoolean() {
        return type == COLUMN_TYPE_BOOL;
    }
 
    public boolean isLong() {
        return type == COLUMN_TYPE_UINT64 || type == COLUMN_TYPE_INT64;
    }
 
    public boolean isInt() {
        return type == COLUMN_TYPE_UINT8 || type == COLUMN_TYPE_INT8
                || type == COLUMN_TYPE_UINT16 || type == COLUMN_TYPE_INT16
                || type == COLUMN_TYPE_UINT32 || type == COLUMN_TYPE_INT32;
    }
 
    public boolean isFloat() {
        return type == COLUMN_TYPE_FLOAT32;
    }
 
 
    public boolean isDouble() {
        return type == COLUMN_TYPE_FLOAT64;
    }
 
    public boolean isString() {
        return type == COLUMN_TYPE_STRING;
    }
 
    public boolean isList() {
        return type == COLUMN_TYPE_LIST;
    }
 
    public boolean isNode() {
        return type == COLUMN_TYPE_NODE;
    }
 
    public boolean isEdge() {
        return type == COLUMN_TYPE_EDGE;
    }
 
    public boolean isLocalTime() {
        return type == COLUMN_TYPE_LOCALTIME;
    }
 
    public boolean isZonedTime() {
        return type == COLUMN_TYPE_ZONEDTIME;
    }
 
    public boolean isLocalDateTime() {
        return type == COLUMN_TYPE_LOCALDATETIME;
    }
 
    public boolean isZonedDateTime() {
        return type == COLUMN_TYPE_ZONEDDATETIME;
    }
 
    public boolean isDate() {
        return type == COLUMN_TYPE_DATE;
    }
 
    public boolean isRecord() {
        return type == COLUMN_TYPE_RECORD;
    }
 
    public boolean isDuration() {
        return type == COLUMN_TYPE_DURATION;
    }
 
    public boolean isPath() {
        return type == COLUMN_TYPE_PATH;
    }
 
    public boolean isDecimal() {
        return type == COLUMN_TYPE_DECIMAL;
    }
 
    public boolean asBoolean() throws InvalidValueException {
        if (type == COLUMN_TYPE_BOOL) {
            return (java.lang.Boolean) value;
        }
        throw new InvalidValueException(
                "Cannot get field `boolean` because value's type is " + getDataType());
    }
 
 
    public int asInt() throws InvalidValueException {
        if (type == COLUMN_TYPE_INT8 || type == COLUMN_TYPE_UINT8
                || type == COLUMN_TYPE_UINT16 || type == COLUMN_TYPE_INT16
                || type == COLUMN_TYPE_UINT32 || type == COLUMN_TYPE_INT32) {
            return Integer.parseInt(value.toString());
        }
        throw new InvalidValueException(
                "Cannot get field `int` because value's type is " + getDataType());
    }
 
    public long asLong() throws InvalidValueException {
        if (type == COLUMN_TYPE_INT64 || type == COLUMN_TYPE_UINT64) {
            return (long) value;
        }
        throw new InvalidValueException(
                "Cannot get field `long` because value's type is " + getDataType());
    }
 
 
    public String asString() throws InvalidValueException {
        if (type == COLUMN_TYPE_STRING) {
            return (java.lang.String) value;
        }
        throw new InvalidValueException(
                "Cannot get field `string` because value's type is " + getDataType());
    }
 
    public float asFloat() throws InvalidValueException {
        if (type == COLUMN_TYPE_FLOAT32) {
            return (float) value;
        }
        throw new InvalidValueException(
                "Cannot get field `float` because value's type is " + getDataType());
    }
 
    public double asDouble() throws InvalidValueException {
        if (type == COLUMN_TYPE_FLOAT64) {
            return (double) value;
        }
        throw new InvalidValueException(
                "Cannot get field `double` because value's type is " + getDataType());
    }
 
    public List<ValueWrapper> asList() throws InvalidValueException {
        if (type == COLUMN_TYPE_LIST) {
            return (List<ValueWrapper>) value;
        }
        throw new InvalidValueException(
                "Cannot get field `list` because value's type is " + getDataType());
    }
 
    public Node asNode() throws InvalidValueException {
        if (type == COLUMN_TYPE_NODE) {
            return (Node) value;
        }
        throw new InvalidValueException(
                "cannot get field `node` because value's type is " + getDataType());
    }
 
    public Edge asEdge() throws InvalidValueException {
        if (type == COLUMN_TYPE_EDGE) {
            return (Edge) value;
        }
        throw new InvalidValueException(
                "cannot get field `edge` because value's type is " + getDataType());
    }
 
    public LocalTime asLocalTime() throws InvalidValueException {
        if (type == COLUMN_TYPE_LOCALTIME) {
            return (LocalTime) value;
        }
        throw new InvalidValueException(
                "cannot get field `localtime` because value's type is " + getDataType());
    }
 
 
    public OffsetTime asZonedTime() throws InvalidValueException {
        if (type == COLUMN_TYPE_ZONEDTIME) {
            return (OffsetTime) value;
        }
        throw new InvalidValueException(
                "cannot get field `zonedtime` because value's type is " + getDataType());
    }
 
 
    public LocalDate asDate() throws InvalidValueException {
        if (type == COLUMN_TYPE_DATE) {
            return (LocalDate) value;
        }
        throw new InvalidValueException(
                "cannot get field `date` because value's type is " + getDataType());
    }
 
    public LocalDateTime asLocalDateTime() throws InvalidValueException {
        if (type == COLUMN_TYPE_LOCALDATETIME) {
            return (LocalDateTime) value;
        }
        throw new InvalidValueException(
                "cannot get field `localdatetime` because value's type is " + getDataType());
    }
 
    public ZonedDateTime asZonedDateTime() throws InvalidValueException {
        if (type == COLUMN_TYPE_ZONEDDATETIME) {
            return (ZonedDateTime) value;
        }
        throw new InvalidValueException(
                "cannot get field `zoneddatetime` because value's type is " + getDataType());
    }
 
    public NDuration asDuration() throws InvalidValueException {
        if (type == COLUMN_TYPE_DURATION) {
            return (NDuration) value;
        }
        throw new InvalidValueException(
                "cannot get field `duration` because value's type is " + getDataType());
    }
 
    public NRecord asRecord() throws InvalidValueException {
        if (type == COLUMN_TYPE_RECORD) {
            return (NRecord) value;
        }
        throw new InvalidValueException(
                "cannot get field `record` because value's type is " + getDataType());
    }
 
    public Path asPath() throws InvalidValueException {
        if (type == COLUMN_TYPE_PATH) {
            return (Path) value;
        }
        throw new InvalidValueException(
                "cannot get field `path` because value's type is " + getDataType());
    }
 
    public BigDecimal asDecimal() throws InvalidValueException {
        if (type == COLUMN_TYPE_DECIMAL) {
            return (BigDecimal) value;
        }
        throw new InvalidValueException(
                "cannot get field `decimal` because value's type is " + getDataType());
    }
 
    public EmbeddingVector asVector() throws InvalidValueException {
        if (type == COLUMN_TYPE_EMBEDDINGVECTOR) {
            return (EmbeddingVector) value;
        }
        throw new InvalidValueException(
                "cannot get field `vector` because value's type is " + getDataType());
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        ValueWrapper that = (ValueWrapper) o;
        return Objects.equals(value, that.value);
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
 
    @Override
    public String toString() {
        if (isNull()) {
            return null;
        } else if (isBoolean()) {
            return String.valueOf(asBoolean());
        } else if (isInt()) {
            return String.valueOf(asInt());
        } else if (isLong()) {
            return String.valueOf(asLong());
        } else if (isFloat()) {
            return String.valueOf(asFloat());
        } else if (isDouble()) {
            return String.valueOf(asDouble());
        } else if (isString()) {
            return asString();
        } else if (isList()) {
            return asList().toString();
        } else if (isRecord()) {
            return asRecord().toString();
        } else if (isNode()) {
            return asNode().toString();
        } else if (isEdge()) {
            return asEdge().toString();
        } else if (isLocalTime()) {
            return asLocalTime().format(localTimeFormatter);
        } else if (isZonedTime()) {
            return asZonedTime().format(zonedTimeFormatter);
        } else if (isLocalDateTime()) {
            return asLocalDateTime().format(localDateTimeFormatter);
        } else if (isZonedDateTime()) {
            return asZonedDateTime().format(zonedDateTimeFormatter);
        } else if (isDate()) {
            return asDate().toString();
        } else if (isDuration()) {
            return asDuration().toString();
        } else if (isPath()) {
            return asPath().toString();
        } else if (isDecimal()) {
            return asDecimal().toString();
        }
        return "Unknown type: " + getDataType();
    }
}