1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
package org.bukkit.inventory.meta.tags;
/**
* This class represents an enum with a generic content type. It defines the
* types a custom item tag can have.
* <p>
* This interface can be used to create your own custom {@link ItemTagType} with
* different complex types. This may be useful for the likes of a
* UUIDItemTagType:
* <pre>
* <code>{@code
* public class UUIDItemTagType implements ItemTagType<byte[], UUID> {
*
* {@literal @Override}
* public Class<byte[]> getPrimitiveType() {
* return byte[].class;
* }
*
* {@literal @Override}
* public Class<UUID> getComplexType() {
* return UUID.class;
* }
*
* {@literal @Override}
* public byte[] toPrimitive(UUID complex, ItemTagAdapterContext context) {
* ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
* bb.putLong(complex.getMostSignificantBits());
* bb.putLong(complex.getLeastSignificantBits());
* return bb.array();
* }
*
* {@literal @Override}
* public UUID fromPrimitive(byte[] primitive, ItemTagAdapterContext context) {
* ByteBuffer bb = ByteBuffer.wrap(primitive);
* long firstLong = bb.getLong();
* long secondLong = bb.getLong();
* return new UUID(firstLong, secondLong);
* }
* }}</code></pre>
*
* @param <T> the primary object type that is stored in the given tag
* @param <Z> the retrieved object type when applying this item tag type
*/
public interface ItemTagType<T, Z> {
/*
The primitive one value types.
*/
ItemTagType<Byte, Byte> BYTE = new PrimitiveTagType<>(Byte.class);
ItemTagType<Short, Short> SHORT = new PrimitiveTagType<>(Short.class);
ItemTagType<Integer, Integer> INTEGER = new PrimitiveTagType<>(Integer.class);
ItemTagType<Long, Long> LONG = new PrimitiveTagType<>(Long.class);
ItemTagType<Float, Float> FLOAT = new PrimitiveTagType<>(Float.class);
ItemTagType<Double, Double> DOUBLE = new PrimitiveTagType<>(Double.class);
/*
String.
*/
ItemTagType<String, String> STRING = new PrimitiveTagType<>(String.class);
/*
Primitive Arrays.
*/
ItemTagType<byte[], byte[]> BYTE_ARRAY = new PrimitiveTagType<>(byte[].class);
ItemTagType<int[], int[]> INTEGER_ARRAY = new PrimitiveTagType<>(int[].class);
ItemTagType<long[], long[]> LONG_ARRAY = new PrimitiveTagType<>(long[].class);
/*
Nested TagContainer.
*/
ItemTagType<CustomItemTagContainer, CustomItemTagContainer> TAG_CONTAINER = new PrimitiveTagType<>(CustomItemTagContainer.class);
/**
* Returns the primitive data type of this tag.
*
* @return the class
*/
Class<T> getPrimitiveType();
/**
* Returns the complex object type the primitive value resembles.
*
* @return the class type
*/
Class<Z> getComplexType();
/**
* Returns the primitive data that resembles the complex object passed to
* this method.
*
* @param complex the complex object instance
* @param context the context this operation is running in
* @return the primitive value
*/
T toPrimitive(Z complex, ItemTagAdapterContext context);
/**
* Creates a complex object based of the passed primitive value
*
* @param primitive the primitive value
* @param context the context this operation is running in
* @return the complex object instance
*/
Z fromPrimitive(T primitive, ItemTagAdapterContext context);
/**
* A default implementation that simply exists to pass on the retrieved or
* inserted value to the next layer.
*
* This implementation does not add any kind of logic, but is used to
* provide default implementations for the primitive types.
*
* @param <T> the generic type of the primitive objects
*/
class PrimitiveTagType<T> implements ItemTagType<T, T> {
private final Class<T> primitiveType;
PrimitiveTagType(Class<T> primitiveType) {
this.primitiveType = primitiveType;
}
@Override
public Class<T> getPrimitiveType() {
return primitiveType;
}
@Override
public Class<T> getComplexType() {
return primitiveType;
}
@Override
public T toPrimitive(T complex, ItemTagAdapterContext context) {
return complex;
}
@Override
public T fromPrimitive(T primitive, ItemTagAdapterContext context) {
return primitive;
}
}
}
|
