continue firefox evaluate
authorVladimir Krivosheev <vladimir.krivosheev@jetbrains.com>
Mon, 26 Jan 2015 16:49:43 +0000 (17:49 +0100)
committerVladimir Krivosheev <vladimir.krivosheev@jetbrains.com>
Mon, 26 Jan 2015 17:44:51 +0000 (18:44 +0100)
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/FieldLoader.java
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/FieldProcessor.java
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/InterfaceReader.java
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/MethodHandler.java
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/ReaderGenerator.java
platform/script-debugger/protocol/protocol-reader/src/org/jetbrains/protocolReader/TypeHandler.java

index 37aab7b4fc16b6778825b1554c3c8b7dc8553f0b..ad4f12e289043b8d14bb410a890e0a6035ea0588 100644 (file)
@@ -3,8 +3,6 @@ package org.jetbrains.protocolReader;
 import org.jetbrains.annotations.NotNull;
 
 class FieldLoader {
-  public static final char FIELD_PREFIX = '_';
-
   final String name;
   final String jsonName;
 
@@ -15,17 +13,4 @@ class FieldLoader {
     this.jsonName = jsonName;
     this.valueReader = valueReader;
   }
-
-  public void writeFieldDeclaration(@NotNull TextOutput out) {
-    out.append("private").space();
-    valueReader.appendFinishedValueTypeName(out);
-    out.space().append(FIELD_PREFIX).append(name);
-    if (valueReader instanceof PrimitiveValueReader) {
-      String defaultValue = ((PrimitiveValueReader)valueReader).defaultValue;
-      if (defaultValue != null) {
-        out.append(" = ").append(defaultValue);
-      }
-    }
-    out.semi();
-  }
 }
index eeb7ddf77ca1ad85a956db0ae8c494b4ecf4f65d..6406f76f1da0063973968fb7c98ac41005df85ae 100644 (file)
@@ -8,12 +8,15 @@ import org.jetbrains.jsonProtocol.JsonSubtypeCasting;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
 
 final class FieldProcessor<T> {
-  private final List<FieldLoader> fieldLoaders = new ArrayList<>();
-  private final LinkedHashMap<Method, MethodHandler> methodHandlerMap = new LinkedHashMap<>();
-  private final List<VolatileFieldBinding> volatileFields = new ArrayList<>();
+  final List<FieldLoader> fieldLoaders = new ArrayList<>();
+  final LinkedHashMap<Method, MethodHandler> methodHandlerMap = new LinkedHashMap<>();
+  final List<VolatileFieldBinding> volatileFields = new ArrayList<>();
   boolean lazyRead;
   private final InterfaceReader reader;
 
@@ -22,12 +25,7 @@ final class FieldProcessor<T> {
 
     Method[] methods = typeClass.getMethods();
     // todo sort by source location
-    Arrays.sort(methods, new Comparator<Method>() {
-      @Override
-      public int compare(@NotNull Method o1, @NotNull Method o2) {
-        return o1.getName().compareTo(o2.getName());
-      }
-    });
+    Arrays.sort(methods, (o1, o2) -> o1.getName().compareTo(o2.getName()));
 
     Package classPackage = typeClass.getPackage();
     for (Method method : methods) {
@@ -100,7 +98,7 @@ final class FieldProcessor<T> {
         writeMethodDeclarationJava(out, method);
         out.openBlock();
         if (effectiveFieldName != null) {
-          out.append("return ").append(FieldLoader.FIELD_PREFIX).append(effectiveFieldName).semi();
+          out.append("return ").append(TypeHandler.FIELD_PREFIX).append(effectiveFieldName).semi();
         }
         out.closeBlock();
       }
@@ -124,18 +122,6 @@ final class FieldProcessor<T> {
     return handler;
   }
 
-  List<VolatileFieldBinding> getVolatileFields() {
-    return volatileFields;
-  }
-
-  List<FieldLoader> getFieldLoaders() {
-    return fieldLoaders;
-  }
-
-  LinkedHashMap<Method, MethodHandler> getMethodHandlerMap() {
-    return methodHandlerMap;
-  }
-
   @NotNull
   private VolatileFieldBinding allocateVolatileField(final ValueReader fieldTypeParser, boolean internalType) {
     int position = volatileFields.size();
index 84844be0301a6960ce3bc7529d2faa551f6aaf01..4f71a40d27ce4eb334c8028d813f59663f924707 100644 (file)
@@ -134,35 +134,30 @@ class InterfaceReader {
       createIfNotExists(aClass);
     }
 
-    TypeHandler<?> typeHandler = createTypeHandler(typeClass);
-    for (TypeRef ref : refs) {
-      if (ref.typeClass == typeClass) {
-        assert ref.type == null;
-        ref.type = typeHandler;
-        break;
-      }
-    }
-    typeToTypeHandler.put(typeClass, typeHandler);
-  }
-
-  private <T> TypeHandler<T> createTypeHandler(Class<T> typeClass) {
     if (!typeClass.isInterface()) {
       throw new JsonProtocolModelParseException("Json model type should be interface: " + typeClass.getName());
     }
 
-    FieldProcessor<T> fields = new FieldProcessor<>(this, typeClass);
-    LinkedHashMap<Method, MethodHandler> methodHandlerMap = fields.getMethodHandlerMap();
-    for (Method method : methodHandlerMap.keySet()) {
+    FieldProcessor<?> fields = new FieldProcessor<>(this, typeClass);
+    for (Method method : fields.methodHandlerMap.keySet()) {
       Class<?> returnType = method.getReturnType();
       if (returnType != typeClass) {
         createIfNotExists(returnType);
       }
     }
 
-    return new TypeHandler<>(typeClass, getSuperclassRef(typeClass),
-                              fields.getVolatileFields(), methodHandlerMap,
-                              fields.getFieldLoaders(),
-                              fields.lazyRead);
+    TypeHandler<?> typeHandler = new TypeHandler<>(typeClass, getSuperclassRef(typeClass),
+                                                   fields.volatileFields, fields.methodHandlerMap,
+                                                   fields.fieldLoaders,
+                                                   fields.lazyRead);
+    for (TypeRef ref : refs) {
+      if (ref.typeClass == typeClass) {
+        assert ref.type == null;
+        ref.type = typeHandler;
+        break;
+      }
+    }
+    typeToTypeHandler.put(typeClass, typeHandler);
   }
 
   ValueReader getFieldTypeParser(Type type, boolean isSubtyping, @Nullable Method method) {
index a9caa4e22929aeefb64df45dd02524544f603dd5..48d4640a7c834ae5f024e6a12483886afba208af 100644 (file)
@@ -1,7 +1,6 @@
 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-
 package org.jetbrains.protocolReader;
 
 import org.jetbrains.annotations.NotNull;
index a66f0442c9f6b60297c7768e681ac79e035f0d32..56981fbd9985c0e4582bc15e02fee4ad0916ec4c 100644 (file)
@@ -131,7 +131,7 @@ public final class ReaderGenerator {
 
     for (TypeHandler<?> typeHandler : configuration.typeToTypeHandler.values()) {
       out.newLine();
-      typeHandler.writeStaticClassJava(rootClassScope);
+      typeHandler.write(rootClassScope);
       out.newLine();
     }
 
index b88509d950658bd6a6811312a58c3398f546f1b4..3b17bb3f0c6b705d99934639ed1742864a1c6987 100644 (file)
@@ -9,6 +9,8 @@ import java.util.List;
 import java.util.Map;
 
 class TypeHandler<T> {
+  public static final char FIELD_PREFIX = '_';
+
   final Class<T> typeClass;
 
   private final List<VolatileFieldBinding> volatileFields;
@@ -50,7 +52,7 @@ class TypeHandler<T> {
     }
   }
 
-  public void writeStaticClassJava(@NotNull FileScope fileScope) {
+  public void write(@NotNull FileScope fileScope) {
     TextOutput out = fileScope.getOutput();
     String valueImplClassName = fileScope.getTypeImplShortName(this);
     out.append("private static final class ").append(valueImplClassName);
@@ -68,7 +70,16 @@ class TypeHandler<T> {
     }
 
     for (FieldLoader loader : fieldLoaders) {
-      loader.writeFieldDeclaration(out);
+      out.append("private").space();
+      loader.valueReader.appendFinishedValueTypeName(out);
+      out.space().append(FIELD_PREFIX).append(loader.name);
+      if (loader.valueReader instanceof PrimitiveValueReader) {
+        String defaultValue = ((PrimitiveValueReader)loader.valueReader).defaultValue;
+        if (defaultValue != null) {
+          out.append(" = ").append(defaultValue);
+        }
+      }
+      out.semi();
       out.newLine();
     }
 
@@ -235,6 +246,6 @@ class TypeHandler<T> {
 
   @NotNull
   private static TextOutput assignField(TextOutput out, String fieldName) {
-    return out.append(FieldLoader.FIELD_PREFIX).append(fieldName).append(" = ");
+    return out.append(FIELD_PREFIX).append(fieldName).append(" = ");
   }
 }
\ No newline at end of file