encodings: a solution for #363 #383 #194 #201 and alike. 3/5 completed

value-processor/src/org/immutables/value/processor/encode/EncodedElement.java

@@ -0,0 +1,28 @@
+package org.immutables.value.processor.encode;
+
+import java.util.List;
+import org.immutables.generator.Naming;
+import org.immutables.value.Value;
+import org.immutables.value.Value.Enclosing;
+import org.immutables.value.Value.Immutable;
+import org.immutables.value.processor.encode.Code.Term;
+
+@Immutable
+@Enclosing
+interface EncodedElement {
+	String name();
+	Type type();
+	Naming naming();
+	List<Param> params();
+	List<Term> code();
+
+	class Builder extends ImmutableEncodedElement.Builder {}
+
+	@Immutable
+	interface Param {
+		@Value.Parameter
+		String name();
+		@Value.Parameter
+		Type type();
+	}
+}

value-processor/src/org/immutables/value/processor/encode/Encodings.java

@@ -12,6 +12,7 @@
 import javax.lang.model.util.ElementFilter;
 import org.immutables.generator.AbstractTemplate;
 import org.immutables.generator.Generator;
+import org.immutables.generator.Naming;
 import org.immutables.generator.SourceExtraction;
 import org.immutables.generator.Templates;
 import org.immutables.value.processor.meta.Reporter;
@@ -36,6 +37,8 @@ public abstract class Encodings extends AbstractTemplate {
 
 	class Encoding {
 		private final CharSequence source;
+		private final Type.Factory types = new Type.Producer();
+		private final TypeExtractor typesReader;
 
 		private Object impl;
 
@@ -46,26 +49,25 @@ class Encoding {
 			source = SourceExtraction.extract(processing(), type);
 			if (source.length() == 0) {
 				reporter.withElement(type)
-						.error("No source code can be extracted @Encoding. Probably, compilation mode is not supported");
+						.error("No source code can be extracted for @Encoding class. Unsupported compilation mode");
 			}
 
+			this.typesReader = new TypeExtractor(types, type);
+
 			for (Element e : type.getEnclosedElements()) {
 				processMember(e);
 			}
 		}
 
 		private void processMember(Element member) {
 			if (member.getKind() == ElementKind.FIELD) {
-				if (processField((VariableElement) member))
-					return;
+				if (processField((VariableElement) member)) return;
 			}
 			if (member.getKind() == ElementKind.METHOD) {
-				if (processMethod((ExecutableElement) member))
-					return;
+				if (processMethod((ExecutableElement) member)) return;
 			}
 			if (member.getKind() == ElementKind.CLASS) {
-				if (processClass((TypeElement) member))
-					return;
+				if (processClass((TypeElement) member)) return;
 			}
 
 			reporter.withElement(member)
@@ -90,6 +92,12 @@ private boolean processField(VariableElement field) {
 							field.getSimpleName());
 					return true;
 				}
+
+				new EncodedElement.Builder()
+						.name(field.getSimpleName().toString())
+						.type(typesReader.get(field.asType()))
+						.naming(Naming.identity())
+						.build();
 			}
 			return false;
 		}
@@ -101,10 +109,4 @@ private boolean processClass(TypeElement type) {
 			return false;
 		}
 	}
-
-	class Impl {
-		Impl() {
-
-		}
-	}
 }

value-processor/src/org/immutables/value/processor/encode/Structurizer.java

@@ -0,0 +1,48 @@
+package org.immutables.value.processor.encode;
+
+import com.google.common.collect.Iterators;
+import com.google.common.collect.PeekingIterator;
+import java.util.List;
+import org.immutables.value.processor.encode.Code.Term;
+
+final class Structurizer {
+	private final PeekingIterator<Term> terms;
+
+	Structurizer(Iterable<Term> terms) {
+		this.terms = Iterators.peekingIterator(terms.iterator());
+	}
+
+	void structurize() {
+
+		while (terms.hasNext()) {
+			statement();
+		}
+	}
+
+	private void statement() {
+		while (terms.hasNext()) {
+			Term t = terms.next();
+
+		}
+	}
+
+	interface CompilationUnit {
+		List<Statement> statements();
+	}
+
+	interface Statement {
+		List<Term> body();
+	}
+
+	interface Elem {
+
+	}
+
+	interface Params {
+
+	}
+
+	interface Annotation extends Elem {
+
+	}
+}