io.kubernetes.client.fluent.BaseFluent Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of client-java-api-fluent Show documentation
There is a newer version: 23.0.0-legacy
Show newest version
package io.kubernetes.client.fluent;

import java.util.LinkedHashSet;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import java.util.Set;
import java.util.ArrayList;
import java.lang.String;
import java.util.AbstractMap;
import java.util.Objects;
import java.lang.Class;
import java.lang.Object;
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
public class BaseFluent> implements Fluent,Visitable{
  public static final String VISIT = "visit";
  public final VisitableMap _visitables = new VisitableMap();
  public static VisitableBuilder builderOf(T item) {
    if (item instanceof Editable) {
      Object editor = ((Editable) item).edit();
      if (editor instanceof VisitableBuilder) {
        return (VisitableBuilder) editor;
      }
    }

    try {
      return (VisitableBuilder) 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 List build(List> list) {
    return list == null ? null : new ArrayList(list.stream().map(Builder::build).collect(Collectors.toList()));
  }
  public static Set build(Set> set) {
    return set == null ? null : new LinkedHashSet(set.stream().map(Builder::build).collect(Collectors.toSet()));
  }
  public static List aggregate(List... lists) {
    return new ArrayList(Arrays.stream(lists).filter(Objects::nonNull).collect(Collectors.toList()));
  }
  public static Set aggregate(Set... sets) {
    return new LinkedHashSet(Arrays.stream(sets).filter(Objects::nonNull).collect(Collectors.toSet()));
  }
  public F accept(io.kubernetes.client.fluent.Visitor... visitors) {
    return accept(Collections.emptyList(), visitors);
  }
  public F accept(Class type,Visitor visitor) {
    return accept(Collections.emptyList(), new Visitor() {
      @Override
      public Class getType() {
        return type;
      }

      @Override
      public void visit(List> path, V element) {
        visitor.visit(path, element);
      }

      @Override
      public void visit(V element) {
        visitor.visit(element);
      }
    });
  }
  public F accept(List> path,io.kubernetes.client.fluent.Visitor... visitors) {
    return accept(path, "", visitors);
  }
  public F accept(List> path,String currentKey,io.kubernetes.client.fluent.Visitor... visitors) {
    Arrays.stream(visitors)
        .map(v -> VisitorListener.wrap(v))
        .filter(v -> ((Visitor) v).canVisit(path, this))
        .sorted((l, r) -> ((Visitor) r).order() - ((Visitor) l).order())
        .forEach(v -> {
          ((Visitor) v).visit(path, this);
        });

    List> copyOfPath = path != null ? new ArrayList(path) : new ArrayList<>();
    copyOfPath.add(new AbstractMap.SimpleEntry(currentKey, this));

    _visitables.forEach((key, visitables) -> {
      List> newPath = Collections.unmodifiableList(copyOfPath);
      // Copy visitables to avoid ConcurrrentModificationException when Visitors add/remove Visitables
      new ArrayList<>(visitables).forEach(visitable -> {
        Arrays.stream(visitors)
            .filter(v -> v.getType() != null && v.getType().isAssignableFrom(visitable.getClass()))
            .forEach(v -> visitable.accept(newPath, key, v));

        Arrays.stream(visitors)
            .filter(v -> v.getType() == null || !v.getType().isAssignableFrom(visitable.getClass()))
            .forEach(v -> visitable.accept(newPath, key, v));
      });
    });
    return (F) this;
  }
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + 0;
    return result;
  }
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    return true;
  }
  
}