Add generated builder code.

Author: brendandburns

fluent/src/main/java/io/kubernetes/client/fluent/BaseFluent.java

@@ -0,0 +1,124 @@
+package io.kubernetes.client.fluent;
+
+import java.util.LinkedHashSet;
+import java.util.stream.Collectors;
+import java.util.Set;
+import java.util.ArrayList;
+import java.lang.String;
+import java.util.Objects;
+import java.lang.Class;
+import java.util.List;
+import java.lang.Boolean;
+import java.util.Arrays;
+
+public class BaseFluent<F extends io.kubernetes.client.fluent.Fluent<F>> implements io.kubernetes.client.fluent.Fluent<F>,io.kubernetes.client.fluent.Visitable<F> {
+
+    public static final java.lang.String VISIT = "visit";
+    public final io.kubernetes.client.fluent.VisitableMap _visitables = new VisitableMap();
+
+    public static <T>io.kubernetes.client.fluent.VisitableBuilder<T,?> builderOf(T item) {
+        if (item instanceof Editable) { 
+          Object editor = ((Editable) item).edit(); 
+          if (editor instanceof VisitableBuilder) { 
+            return (VisitableBuilder<T, ?>) editor; 
+          } 
+        } 
+        try { 
+          return (VisitableBuilder<T, ?>) Class.forName(item.getClass().getName() + "Builder").getConstructor(item.getClass()) 
+              .newInstance(item); 
+        } catch (Exception e) { 
+          throw new IllegalStateException("Failed to create builder for: " + item.getClass(), e); 
+        } 
+    }
+
+    public static <T>java.util.ArrayList<T> build(java.util.List<? extends io.kubernetes.client.fluent.Builder<? extends T>> list) {
+        return list == null ? null : new ArrayList<T>(list.stream().map(Builder::build).collect(Collectors.toList()));
+    }
+
+    public static <T>java.util.List<T> build(java.util.Set<? extends io.kubernetes.client.fluent.Builder<? extends T>> set) {
+        return set == null ? null : set.stream().map(Builder::build).collect(Collectors.toList());
+    }
+
+    public static <T>java.util.ArrayList<T> aggregate(java.util.List<? extends T>... lists) {
+        return new ArrayList(Arrays.stream(lists).filter(Objects::nonNull).collect(Collectors.toList()));
+    }
+
+    public static <T>java.util.LinkedHashSet<T> aggregate(java.util.Set<? extends T>[] sets) {
+        return new LinkedHashSet(Arrays.stream(sets).filter(Objects::nonNull).collect(Collectors.toSet()));
+    }
+
+    public static <V extends io.kubernetes.client.fluent.Visitor<?>,F>java.lang.Boolean canVisit(V visitor,F fluent) {
+        if (visitor instanceof TypedVisitor) { 
+          if (!((TypedVisitor) visitor).getType().isAssignableFrom(fluent.getClass())) { 
+            return false; 
+          } 
+        } 
+        if (visitor instanceof PathAwareTypedVisitor) { 
+          PathAwareTypedVisitor pathAwareTypedVisitor = (PathAwareTypedVisitor) visitor; 
+          Class parentType = pathAwareTypedVisitor.getParentType(); 
+          Class actaulParentType = pathAwareTypedVisitor.getActualParentType(); 
+          if (!parentType.isAssignableFrom(actaulParentType)) { 
+            return false; 
+          } 
+        } 
+        return hasCompatibleVisitMethod(visitor, fluent); 
+    }
+
+    public static <V,F>java.lang.Boolean hasCompatibleVisitMethod(V visitor,F fluent) {
+        for (java.lang.reflect.Method method : visitor.getClass().getMethods()) {
+          if (!method.getName().equals(VISIT) || method.getParameterTypes().length != 1) {
+            continue;
+          }
+          Class visitorType = method.getParameterTypes()[0];
+          if (visitorType.isAssignableFrom(fluent.getClass())) {
+            return true;
+          } else {
+            return false;
+          }
+        }
+        return false;
+    }
+
+    public F accept(io.kubernetes.client.fluent.Visitor... visitors) {
+        return isPathAwareVisitorArray(visitors) ? acceptPathAware(asPathAwareVisitorArray(visitors)) : acceptInternal(visitors);
+    }
+
+    public <V>F accept(java.lang.Class<V> type,io.kubernetes.client.fluent.Visitor<V> visitor) {
+        return accept(new TypedVisitor<V>() {
+          @Override
+          public Class<V> getType() {
+            return type;
+          }
+          @Override
+          public void visit(V element) {
+            visitor.visit(element);
+          }
+        });
+    }
+
+    public F acceptInternal(io.kubernetes.client.fluent.Visitor<?>... visitors) {
+        for (Visitor visitor : visitors) {
+          for (Visitable visitable : _visitables) {
+            visitable.accept(visitor);
+          }
+        
+          if (canVisit(visitor, this)) {
+            visitor.visit(this);
+          }
+        }
+        return (F) this;
+    }
+
+    private F acceptPathAware(io.kubernetes.client.fluent.PathAwareTypedVisitor<?,?>... pathAwareTypedVisitors) {
+        return acceptInternal(Arrays.stream(pathAwareTypedVisitors).map(p -> p.next(this)).toArray(size -> new PathAwareTypedVisitor[size]));
+    }
+
+    private static boolean isPathAwareVisitorArray(io.kubernetes.client.fluent.Visitor<?>[] visitors) {
+        return !Arrays.stream(visitors).filter(v -> !(v instanceof PathAwareTypedVisitor)).findAny().isPresent();
+    }
+
+    private static io.kubernetes.client.fluent.PathAwareTypedVisitor<?,?>[] asPathAwareVisitorArray(io.kubernetes.client.fluent.Visitor<?>[] visitors) {
+        return Arrays.stream(visitors).filter(v -> v instanceof PathAwareTypedVisitor).map(v -> (PathAwareTypedVisitor) v).toArray(size -> new PathAwareTypedVisitor[size]);
+    }
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/Builder.java

@@ -0,0 +1,8 @@
+package io.kubernetes.client.fluent;
+
+
+public interface Builder<T> {
+
+
+    T build();
+}

fluent/src/main/java/io/kubernetes/client/fluent/Editable.java

@@ -0,0 +1,8 @@
+package io.kubernetes.client.fluent;
+
+
+public interface Editable<T> {
+
+
+    T edit();
+}

fluent/src/main/java/io/kubernetes/client/fluent/Fluent.java

@@ -0,0 +1,7 @@
+package io.kubernetes.client.fluent;
+
+
+public interface Fluent<F extends io.kubernetes.client.fluent.Fluent<F>> {
+
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/Nested.java

@@ -0,0 +1,8 @@
+package io.kubernetes.client.fluent;
+
+
+public interface Nested<F> {
+
+
+    F and();
+}

fluent/src/main/java/io/kubernetes/client/fluent/PathAwareTypedVisitor.java

@@ -0,0 +1,49 @@
+package io.kubernetes.client.fluent;
+
+import java.util.ArrayList;
+import java.lang.Class;
+import java.lang.Object;
+import java.util.List;
+
+public class PathAwareTypedVisitor<V,P> extends io.kubernetes.client.fluent.TypedVisitor<V> {
+
+    java.util.List<java.lang.Object> path;
+    io.kubernetes.client.fluent.PathAwareTypedVisitor<V,P> delegate;
+    java.lang.Class<P> parentType;
+
+    PathAwareTypedVisitor(java.util.List<java.lang.Object> path) {
+        this.path = path;
+        this.delegate = this;
+        this.parentType = (Class<P>) getTypeArguments(PathAwareTypedVisitor.class, getClass()).get(1);
+    }
+
+    PathAwareTypedVisitor(java.util.List<java.lang.Object> path,io.kubernetes.client.fluent.PathAwareTypedVisitor<V,P> delegate) {
+        this.path = path;
+        this.delegate = this;
+        this.parentType = (Class<P>) getTypeArguments(PathAwareTypedVisitor.class, delegate.getClass()).get(1);
+    }
+
+    public void visit(V element) {
+        delegate.path = path;
+        delegate.visit(element);
+    }
+
+    io.kubernetes.client.fluent.PathAwareTypedVisitor<V,P> next(java.lang.Object item) {
+        List<Object> path = new ArrayList<Object>(this.path);
+        path.add(item);
+        return new PathAwareTypedVisitor<V, P>(path, this);
+    }
+
+    P getParent() {
+        return path.size() - 2 >= 0 ? (P) path.get(path.size() - 2) : null;
+    }
+
+    java.lang.Class<P> getParentType() {
+        return parentType != null ? parentType : delegate.getParentType();
+    }
+
+    protected java.lang.Class<?> getActualParentType() {
+        return path.size() - 2 >= 0 ? path.get(path.size() - 2).getClass() : Void.class;
+    }
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/TypedVisitor.java

@@ -0,0 +1,65 @@
+package io.kubernetes.client.fluent;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.ArrayList;
+import java.lang.Class;
+import java.util.List;
+import java.lang.reflect.GenericArrayType;
+import java.util.Map;
+import java.util.LinkedHashMap;
+
+public abstract class TypedVisitor<V> implements io.kubernetes.client.fluent.Visitor<V> {
+
+
+    public java.lang.Class<V> getType() {
+        return (Class<V>) getTypeArguments(TypedVisitor.class, getClass()).get(0);
+    }
+
+    java.lang.Class<?> getClass(java.lang.reflect.Type type) {
+        if (type instanceof Class) {return (Class) type;} else if (type instanceof ParameterizedType) {return getClass(((ParameterizedType) type).getRawType());} else if (type instanceof GenericArrayType) {Type componentType = ((GenericArrayType) type).getGenericComponentType(); Class<?> componentClass = getClass(componentType); if (componentClass != null) {return Array.newInstance(componentClass, 0).getClass();} else {return null;}} else {return null;}
+    }
+
+    <T>java.util.List<java.lang.Class<?>> getTypeArguments(java.lang.Class<T> baseClass,java.lang.Class<? extends T> childClass) {
+            Map<Type, Type> resolvedTypes = new LinkedHashMap<>();
+            Type type = childClass;
+            // start walking up the inheritance hierarchy until we hit baseClass
+            while (!getClass(type).equals(baseClass)) {
+              if (type instanceof Class) {
+                // there is no useful information for us in raw types, so just keep going.
+                type = ((Class) type).getGenericSuperclass();
+              } else {
+                ParameterizedType parameterizedType = (ParameterizedType) type;
+                Class<?> rawType = (Class) parameterizedType.getRawType();
+                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+                TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
+                for (int i = 0; i < actualTypeArguments.length; i++) {
+                  resolvedTypes.put(typeParameters[i], actualTypeArguments[i]);
+                }
+                if (!rawType.equals(baseClass)) {
+                  type = rawType.getGenericSuperclass();
+                }
+              }
+            }
+            // finally, for each actual type argument provided to baseClass, determine (if possible)
+            // the raw class for that type argument.
+            Type[] actualTypeArguments;
+            if (type instanceof Class) {
+              actualTypeArguments = ((Class) type).getTypeParameters();
+            } else {
+              actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
+            }
+            List<Class<?>> typeArgumentsAsClasses = new ArrayList<>();
+            // resolve types by chasing down type variables.
+            for (Type baseType : actualTypeArguments) {
+              while (resolvedTypes.containsKey(baseType)) {
+                baseType = resolvedTypes.get(baseType);
+              }
+              typeArgumentsAsClasses.add(getClass(baseType));
+            }
+            return typeArgumentsAsClasses;
+    }
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/Visitable.java

@@ -0,0 +1,16 @@
+package io.kubernetes.client.fluent;
+
+import java.lang.Class;
+import java.lang.FunctionalInterface;
+
+  
+  @java.lang.FunctionalInterface
+  public interface Visitable<T> {
+
+
+    T accept(io.kubernetes.client.fluent.Visitor... visitor);
+    default <V>T accept(java.lang.Class<V> type,io.kubernetes.client.fluent.Visitor<V> visitor) {
+        return accept(new TypedVisitor<V>() {@Override public Class<V> getType() {return type;} @Override public void visit(V element) {visitor.visit(element);}});
+    }
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/VisitableBuilder.java

@@ -0,0 +1,7 @@
+package io.kubernetes.client.fluent;
+
+
+public interface VisitableBuilder<T,V extends VisitableBuilder<T,V>> extends io.kubernetes.client.fluent.Builder<T>,io.kubernetes.client.fluent.Visitable<V> {
+
+
+}

fluent/src/main/java/io/kubernetes/client/fluent/VisitableMap.java

@@ -0,0 +1,38 @@
+package io.kubernetes.client.fluent;
+
+import java.util.stream.Collectors;
+import java.lang.Iterable;
+import java.util.function.Consumer;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.lang.Object;
+import java.util.List;
+import java.lang.String;
+import java.util.Spliterator;
+
+public class VisitableMap extends java.util.HashMap<java.lang.String,java.util.List<io.kubernetes.client.fluent.Visitable<?>>> implements java.lang.Iterable<io.kubernetes.client.fluent.Visitable<?>> {
+
+
+    public java.util.List<io.kubernetes.client.fluent.Visitable<?>> get(java.lang.Object key) {
+        if (!containsKey(key)) {put(String.valueOf(key), new ArrayList());}
+        return super.get(key);
+    }
+
+    public java.util.List<io.kubernetes.client.fluent.Visitable<?>> aggregate() {
+        return values().stream().flatMap(l -> l.stream()).collect(Collectors.toList());
+    }
+
+    public java.util.Iterator<io.kubernetes.client.fluent.Visitable<?>> iterator() {
+        return aggregate().iterator();
+    }
+
+    public void forEach(java.util.function.Consumer<? super io.kubernetes.client.fluent.Visitable<?>> action) {
+        aggregate().forEach(action);
+    }
+
+    public java.util.Spliterator spliterator() {
+        return aggregate().spliterator();
+    }
+
+}