This project has retired. For details please refer to its
Attic page.
GiraphTypes xref
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.giraph.conf;
19
20 import static org.apache.giraph.conf.GiraphConstants.EDGE_VALUE_CLASS;
21 import static org.apache.giraph.conf.GiraphConstants.OUTGOING_MESSAGE_VALUE_CLASS;
22 import static org.apache.giraph.conf.GiraphConstants.VERTEX_CLASS;
23 import static org.apache.giraph.conf.GiraphConstants.VERTEX_ID_CLASS;
24 import static org.apache.giraph.conf.GiraphConstants.VERTEX_VALUE_CLASS;
25 import static org.apache.giraph.utils.ConfigurationUtils.getTypesHolderClass;
26 import static org.apache.giraph.utils.ReflectionUtils.getTypeArguments;
27
28 import org.apache.giraph.graph.DefaultVertex;
29 import org.apache.giraph.graph.Vertex;
30 import org.apache.hadoop.conf.Configuration;
31 import org.apache.hadoop.io.Writable;
32 import org.apache.hadoop.io.WritableComparable;
33
34 import com.google.common.base.Preconditions;
35
36
37
38
39
40
41
42
43 public class GiraphTypes<I extends WritableComparable, V extends Writable,
44 E extends Writable> {
45
46 private Class<I> vertexIdClass;
47
48 private Class<V> vertexValueClass;
49
50 private Class<E> edgeValueClass;
51
52 private Class<? extends Writable> outgoingMessageValueClass;
53
54 private Class<? extends Vertex> vertexClass = DefaultVertex.class;
55
56
57
58
59
60 public GiraphTypes() { }
61
62
63
64
65
66
67
68
69
70
71 public GiraphTypes(Class<I> vertexIdClass,
72 Class<V> vertexValueClass,
73 Class<E> edgeValueClass,
74 Class<? extends Writable> incomingMessageValueClass,
75 Class<? extends Writable> outgoingMessageValueClass) {
76 this.edgeValueClass = edgeValueClass;
77 this.outgoingMessageValueClass = outgoingMessageValueClass;
78 this.vertexIdClass = vertexIdClass;
79 this.vertexValueClass = vertexValueClass;
80 }
81
82
83
84
85
86
87
88
89
90
91
92
93 public static <IX extends WritableComparable, VX extends Writable,
94 EX extends Writable> GiraphTypes<IX, VX, EX> readFrom(
95 Configuration conf) {
96 GiraphTypes<IX, VX, EX> types = new GiraphTypes<IX, VX, EX>();
97 types.readDirect(conf);
98 if (!types.hasData()) {
99 Class<? extends TypesHolder> klass = getTypesHolderClass(conf);
100 if (klass != null) {
101 types.inferFrom(klass);
102 }
103 }
104 return types;
105 }
106
107
108
109
110
111
112 public void inferFrom(Class<? extends TypesHolder> klass) {
113 Class<?>[] classList = getTypeArguments(TypesHolder.class, klass);
114 Preconditions.checkArgument(classList.length == 5);
115 vertexIdClass = (Class<I>) classList[0];
116 vertexValueClass = (Class<V>) classList[1];
117 edgeValueClass = (Class<E>) classList[2];
118 outgoingMessageValueClass = (Class<? extends Writable>) classList[4];
119 }
120
121
122
123
124
125
126 private void readDirect(Configuration conf) {
127 vertexIdClass = (Class<I>) VERTEX_ID_CLASS.get(conf);
128 vertexValueClass = (Class<V>) VERTEX_VALUE_CLASS.get(conf);
129 edgeValueClass = (Class<E>) EDGE_VALUE_CLASS.get(conf);
130 outgoingMessageValueClass = OUTGOING_MESSAGE_VALUE_CLASS.get(conf);
131 vertexClass = VERTEX_CLASS.get(conf);
132 }
133
134
135
136
137
138
139 public boolean hasData() {
140 return vertexIdClass != null &&
141 vertexValueClass != null &&
142 edgeValueClass != null &&
143 outgoingMessageValueClass != null;
144 }
145
146
147
148
149
150
151 public void writeTo(Configuration conf) {
152 VERTEX_ID_CLASS.set(conf, vertexIdClass);
153 VERTEX_VALUE_CLASS.set(conf, vertexValueClass);
154 EDGE_VALUE_CLASS.set(conf, edgeValueClass);
155 OUTGOING_MESSAGE_VALUE_CLASS.set(conf, outgoingMessageValueClass);
156 }
157
158
159
160
161
162
163 public void writeIfUnset(Configuration conf) {
164 VERTEX_ID_CLASS.setIfUnset(conf, vertexIdClass);
165 VERTEX_VALUE_CLASS.setIfUnset(conf, vertexValueClass);
166 EDGE_VALUE_CLASS.setIfUnset(conf, edgeValueClass);
167 OUTGOING_MESSAGE_VALUE_CLASS.setIfUnset(conf, outgoingMessageValueClass);
168 }
169
170 public Class<E> getEdgeValueClass() {
171 return edgeValueClass;
172 }
173
174 Class<? extends Writable> getInitialOutgoingMessageValueClass() {
175 return outgoingMessageValueClass;
176 }
177
178 public Class<I> getVertexIdClass() {
179 return vertexIdClass;
180 }
181
182 public Class<V> getVertexValueClass() {
183 return vertexValueClass;
184 }
185
186 public Class<? extends Vertex> getVertexClass() {
187 return vertexClass;
188 }
189
190 public void setEdgeValueClass(Class<E> edgeValueClass) {
191 this.edgeValueClass = edgeValueClass;
192 }
193
194 public void setVertexIdClass(Class<I> vertexIdClass) {
195 this.vertexIdClass = vertexIdClass;
196 }
197
198 public void setVertexValueClass(Class<V> vertexValueClass) {
199 this.vertexValueClass = vertexValueClass;
200 }
201
202 public void setOutgoingMessageValueClass(
203 Class<? extends Writable> outgoingMessageValueClass) {
204 this.outgoingMessageValueClass = outgoingMessageValueClass;
205 }
206 }