@Override
public void setOwner(AbstractPlayer owner) {
this.owner = owner;
for (AbstractProperty property : propertyGroup.getProperties()) {
property.forceUpdate();
}
}
public void readExternal(@NotNull Element element) {
Map<String, AbstractProperty> propertyByName = new THashMap<>();
for (AbstractProperty abstractProperty : myExternalizers.keySet()) {
propertyByName.put(abstractProperty.getName(), abstractProperty);
}
for (Element child : element.getChildren()) {
AbstractProperty property = propertyByName.get(child.getName());
if (property == null) {
continue;
}
Externalizer externalizer = myExternalizers.get(property);
if (externalizer == null) {
continue;
}
try {
myValues.put(property, externalizer.readValue(child));
} catch (Exception e) {
LOG.info(e);
}
}
}
@Override
public TupleType buildType(Optional<CassandraOptions> cassandraOptions) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(format("Build current '%s' tuple8 data type", fieldName));
}
return tupleTypeFactory.typeFor(
aProperty.buildType(cassandraOptions),
bProperty.buildType(cassandraOptions),
cProperty.buildType(cassandraOptions),
dProperty.buildType(cassandraOptions),
eProperty.buildType(cassandraOptions),
fProperty.buildType(cassandraOptions),
gProperty.buildType(cassandraOptions),
hProperty.buildType(cassandraOptions));
}
public void writeExternal(@NotNull Element element) {
if (myExternalizers.isEmpty()) {
return;
}
List<AbstractProperty> properties = new ArrayList<>(myExternalizers.keySet());
Collections.sort(properties, AbstractProperty.NAME_COMPARATOR);
for (AbstractProperty property : properties) {
Externalizer externalizer = myExternalizers.get(property);
if (externalizer == null) {
continue;
}
Object propValue = property.get(this);
if (!Comparing.equal(propValue, property.getDefault(this))) {
Element child = new Element(property.getName());
externalizer.writeValue(child, propValue);
if (!JDOMUtil.isEmpty(child)) {
element.addContent(child);
}
}
}
}
@Override
TupleValue encodeFromJavaInternal(
Tuple8<A, B, C, D, E, F, G, H> tuple8, Optional<CassandraOptions> cassandraOptions) {
if (LOGGER.isTraceEnabled()) {
LOGGER.trace(format("Encode from Java '%s' tuple8 %s to CQL type", fieldName, tuple8));
}
return getRuntimeTupleType(cassandraOptions)
.newValue(
aProperty.encodeFromRaw(tuple8._1(), cassandraOptions),
bProperty.encodeFromRaw(tuple8._2(), cassandraOptions),
cProperty.encodeFromRaw(tuple8._3(), cassandraOptions),
dProperty.encodeFromRaw(tuple8._4(), cassandraOptions),
eProperty.encodeFromRaw(tuple8._5(), cassandraOptions),
fProperty.encodeFromRaw(tuple8._6(), cassandraOptions),
gProperty.encodeFromRaw(tuple8._7(), cassandraOptions),
hProperty.encodeFromRaw(tuple8._8(), cassandraOptions));
}
@Override
Tuple8<A, B, C, D, E, F, G, H> decodeFromRawInternal(Object o) {
if (LOGGER.isTraceEnabled()) {
LOGGER.trace(format("Decode '%s' tuple8 raw object %s", fieldName, o));
}
Validator.validateTrue(
TupleValue.class.isAssignableFrom(o.getClass()),
"The class of object %s to decode should be %s",
o,
TupleValue.class.getCanonicalName());
final List<DataType> types = tupleType.getComponentTypes();
return new Tuple8<>(
aProperty.decodeFromRaw(extractType((TupleValue) o, types.get(0), aProperty, 0)),
bProperty.decodeFromRaw(extractType((TupleValue) o, types.get(1), bProperty, 1)),
cProperty.decodeFromRaw(extractType((TupleValue) o, types.get(2), cProperty, 2)),
dProperty.decodeFromRaw(extractType((TupleValue) o, types.get(3), dProperty, 3)),
eProperty.decodeFromRaw(extractType((TupleValue) o, types.get(4), eProperty, 4)),
fProperty.decodeFromRaw(extractType((TupleValue) o, types.get(5), fProperty, 5)),
gProperty.decodeFromRaw(extractType((TupleValue) o, types.get(6), gProperty, 6)),
hProperty.decodeFromRaw(extractType((TupleValue) o, types.get(7), hProperty, 7)));
}
@Override
public int compareTo(AbstractProperty otherProperty) {
return sequenceNumber - otherProperty.getSequenceNumber();
}
public void rememberKey(AbstractProperty property) {
LOG.assertTrue(myExternalizers.get(property) == null, property.getName());
myExternalizers.put(property, null);
}
public <T> void registerProperty(AbstractProperty<T> property, Externalizer<T> externalizer) {
String name = property.getName();
LOG.assertTrue(!myExternalizers.containsKey(property), name);
myExternalizers.put(property, externalizer);
}
@Override
protected Object getValueOf(AbstractProperty property) {
Object value = myValues.get(property);
return value != null ? value : property.getDefault(this);
}
@Override
public void setTimes(Date times) {
super.setTimes(times);
this.times = times;
}
@Override
public void setUnit(String unit) {
super.setUnit(unit);
this.unit = unit;
}
@Override
public void setObservedURL(String observedURL) {
super.setObservedURL(observedURL);
this.observedURL = observedURL;
}
@Override
public void setPropertyName(String propertyName) {
super.setPropertyName(propertyName);
this.propertyName = propertyName;
}
/**
* Register pre-defined Property Accessor
*
* @param propertyAccessor AbstractProperty
*/
private void registerPropertyAccessor(AbstractProperty propertyAccessor) {
propertyAccessors.put(propertyAccessor.getName(), propertyAccessor);
}
