How to use

uk.gov.gchq.gaffer.types.TypeValue

constructor

  @Override
  public TypeValue apply(final Object value) {
    return new TypeValue(null, null != value ? value.toString() : null);
  }
}

  @Override
  public Pair<TypeValue, byte[]>[] getHistoricSerialisationPairs() {
    TypeValue typeValue = new TypeValue("testType", "testValue");
    return new Pair[]{
        new Pair(typeValue, new byte[]{116, 101, 115, 116, 84, 121, 112, 101, 0, 116, 101, 115, 116, 86, 97, 108, 117, 101})
    };

  }
}

@Override
public TypeValue deserialise(final byte[] bytes) throws SerialisationException {
  int lastDelimiter = 0;
  TypeValue typeValue = new TypeValue();
  for (int i = 0; i < bytes.length; i++) {
    if (bytes[i] == ByteArrayEscapeUtils.DELIMITER) {
      if (i > 0) {
        try {
          typeValue.setType(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, i), CommonConstants.UTF_8));
        } catch (final UnsupportedEncodingException e) {
          throw new SerialisationException("Failed to deserialise the Type from TypeValue Object", e);
        }
      }
      lastDelimiter = i + 1;
      break;
    }
  }
  if (bytes.length > lastDelimiter) {
    try {
      typeValue.setValue(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, bytes.length), CommonConstants.UTF_8));
    } catch (final UnsupportedEncodingException e) {
      throw new SerialisationException("Failed to deserialise the Value from TypeValue Object", e);
    }
  }
  return typeValue;
}

@Test
public void testComparisonsAreAsExpected() {
  TypeValue typeValue = new TypeValue("a", "b");
  assertEquals(0, typeValue.compareTo(new TypeValue("a", "b")));
  assertTrue(typeValue.compareTo(null) > 0);
  assertTrue(typeValue.compareTo(new TypeValue()) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("1", "b")) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("a", "a")) > 0);
  assertTrue(typeValue.compareTo(new TypeValue("b", "a")) < 0);
  assertTrue(typeValue.compareTo(new TypeValue("a", "c")) < 0);
}

  @Test
  public void testHashCodeAndEqualsMethodTreatsEmptyStringAsNull() {
    // Given
    TypeValue typeValueEmptyStrings = new TypeValue("", "");
    TypeValue typeValueNullStrings = new TypeValue(null, null);

    // When
    boolean equalsResult = typeValueEmptyStrings.equals(typeValueNullStrings);

    // Then
    assertTrue(equalsResult);
    assertEquals(typeValueEmptyStrings.hashCode(), typeValueNullStrings.hashCode());
  }
}

@Test
public void shouldConvertObjectToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = 1L;
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, value.toString()), result);
}

@Test
public void shouldConvertStringToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = "value1";
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, value.toString()), result);
}

@Test
public void shouldConvertNullToTypeValue() {
  // Given
  final ToTypeValue function = new ToTypeValue();
  final Object value = null;
  // When
  final TypeValue result = function.apply(value);
  // Then
  assertEquals(new TypeValue(null, null), result);
}

@Test
public void testCanSerialiseDeSerialiseCorrectlyValueOnly() throws SerialisationException {
  TypeValue typeValue = new TypeValue();
  typeValue.setValue("testValue");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("\0testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertNull(deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Test
public void testCanSerialiseDeSerialiseCorrectly() throws SerialisationException {
  TypeValue typeValue = new TypeValue("testType", "testValue");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("testType\0testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Test
public void testCanSerialiseDeSerialiseCorrectlyTypeOnly() throws SerialisationException {
  TypeValue typeValue = new TypeValue();
  typeValue.setType("testType");
  byte[] bytes = serialiser.serialise(typeValue);
  String serialisedForm = new String(bytes);
  assertEquals("testType\0", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(bytes);
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertNull(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Test
public void testCanSerialiseDeserialiseCorrectlyAndBeEscaped() throws SerialisationException {
  TypeValue typeValue = new TypeValue("testType", "testValue");
  byte[] bytes = ByteArrayEscapeUtils.escape(serialiser.serialise(typeValue));
  String serialisedForm = new String(bytes);
  assertEquals("testType\1\1testValue", serialisedForm);
  TypeValue deSerialisedTypeValue = serialiser.deserialise(ByteArrayEscapeUtils
      .unEscape(bytes));
  assertEquals(typeValue.getType(), deSerialisedTypeValue.getType());
  assertEquals(typeValue.getValue(), deSerialisedTypeValue.getValue());
  assertEquals(typeValue, deSerialisedTypeValue);
}

@Override
public TypeValue deserialise(final Object[] objects) throws SerialisationException {
  if (objects.length == 2) {
    if (objects[0] instanceof String && objects[1] instanceof String) {
      return new TypeValue((String) objects[0], (String) objects[1]);
    } else if (null == objects[0]) {
      return null;
    }
  }
  throw new SerialisationException("Could not de-serialise objects to a TypeValue");
}

  @Override
  public TypeValue read(final Kryo kryo, final Input input, final Class<TypeValue> aClass) {
    final String type = input.readString();
    final String value = input.readString();
    return new TypeValue(type, value);
  }
}

@Override
public TypeValue deserialise(final byte[] bytes) throws SerialisationException {
  int lastDelimiter = 0;
  TypeValue typeValue = new TypeValue();
  for (int i = 0; i < bytes.length; i++) {
    if (bytes[i] == ByteArrayEscapeUtils.DELIMITER) {
      if (i > 0) {
        try {
          typeValue.setType(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, i), CommonConstants.UTF_8));
        } catch (final UnsupportedEncodingException e) {
          throw new SerialisationException("Failed to deserialise the Type from TypeValue Object", e);
        }
      }
      lastDelimiter = i + 1;
      break;
    }
  }
  if (bytes.length > lastDelimiter) {
    try {
      typeValue.setValue(new String(ByteArrayEscapeUtils.unEscape(bytes, lastDelimiter, bytes.length), CommonConstants.UTF_8));
    } catch (final UnsupportedEncodingException e) {
      throw new SerialisationException("Failed to deserialise the Value from TypeValue Object", e);
    }
  }
  return typeValue;
}