How to use

PersistentSet

in

com.oath.cyclops.types.persistent

public Class[] classes() {
    return springBuilder.classes(config, classes.stream().toArray(i->new Class[classes.size()]));
}

public SpringContextFactory(Config config, Class<?> c, Set<Class<?>> classes) {
  PersistentSet<Class> s = config.getClasses()
          .plusAll(classes);
  s= s.plus(c);
  Microserver microserver = c.getAnnotation(Microserver.class);
  final PersistentSet<Class> immutableS = s;
  s = Optional.ofNullable(microserver)
        .flatMap(ms -> Optional.ofNullable(ms.blacklistedClasses()))
        .map(bl -> {
          Set<Class> blacklistedClasses = Arrays.stream(bl)
                             .collect(Collectors.toSet());
          return (PersistentSet<Class>)immutableS.stream()
                   .filter(clazz -> !blacklistedClasses.contains(clazz)).hashSet();
        })
        .orElse(immutableS);
  this.classes = s;
  this.config = config;
  springBuilder = ReactiveSeq.fromStream(PluginLoader.INSTANCE.plugins.get()
                                    .stream())
                .filter(m -> m.springBuilder() != null)
                .map(Plugin::springBuilder)
                .findFirst()
                .orElse(new SpringApplicationConfigurator());
}

public SpringContextFactory(SpringBuilder builder, Config config, Class<?> c, Set<Class<?>> classes) {
  PersistentSet<Class> s = config.getClasses();
  for(Class next : classes){
    s = s.plus(next);
  }
  s = s.plus(c);
  Microserver microserver = c.getAnnotation(Microserver.class);
  final PersistentSet<Class> immutableS = s;
  s = Optional.ofNullable(microserver)
        .flatMap(ms -> Optional.ofNullable(ms.blacklistedClasses()))
        .map(bl -> {
          Set<Class> blacklistedClasses = Arrays.stream(bl)
                             .collect(Collectors.toSet());
          PersistentSet<Class> rs = immutableS.stream()
                   .filter(clazz -> !blacklistedClasses.contains(clazz))
                    .hashSet();
          return rs;
        })
        .orElse(immutableS);
  this.classes = s;
  this.config = config;
  springBuilder = builder;
}

@Override
public boolean equals(Object o) {
  if(!(o instanceof PersistentSet) || o==null)
    return false;
  PersistentSet s = (PersistentSet)o;
  for(T next : this){
    if(!s.containsValue(next))
      return false;
  }
  return size()==s.size();
}

@Override
public Object[] toArray() {
 return host.stream().toArray();
}

@Override
public int size() {
 return host.size();
}

public Config withClassesArray(Class... classes) {
  PersistentSet<Class> org = this.classes;
  for (Class c : classes)
    org = org.plus(c);
  return this.withClasses(org);
}

@Override
public Iterator<T> iterator() {
 return host.iterator();
}

@Override
public boolean contains(Object o) {
 return host.containsValue((T)o);
}

@Override
public boolean isEmpty() {
 return host.isEmpty();
}

@Override
public boolean equals(Object o) {
  if(!(o instanceof PersistentSet) || o==null)
    return false;
  PersistentSet s = (PersistentSet)o;
  for(T next : this){
    if(!s.containsValue(next))
      return false;
  }
  return size()==s.size();
}

public SpringContextFactory(SpringBuilder builder, Config config, Class<?> c, Set<Class<?>> classes) {
  PersistentSet<Class> s = config.getClasses();
  for(Class next : classes){
    s = s.plus(next);
  }
  s = s.plus(c);
  Microserver microserver = c.getAnnotation(Microserver.class);
  final PersistentSet<Class> immutableS = s;
  s = Optional.ofNullable(microserver)
        .flatMap(ms -> Optional.ofNullable(ms.blacklistedClasses()))
        .map(bl -> {
          Set<Class> blacklistedClasses = Arrays.stream(bl)
                             .collect(Collectors.toSet());
          PersistentSet<Class> rs = immutableS.stream()
                   .filter(clazz -> !blacklistedClasses.contains(clazz))
                    .hashSet();
          return rs;
        })
        .orElse(immutableS);
  this.classes = s;
  this.config = config;
  springBuilder = builder;
}

@Override
public Object[] toArray() {
 return host.stream().toArray();
}

@Override
public int size() {
 return host.size();
}

public Config withClassesArray(Class... classes) {
  PersistentSet<Class> org = this.classes;
  for (Class c : classes)
    org = org.plus(c);
  return this.withClasses(org);
}

@Override
public Iterator<T> iterator() {
 return host.iterator();
}

@Override
public boolean contains(Object o) {
 return host.containsValue((T)o);
}

@Override
public boolean isEmpty() {
 return host.isEmpty();
}

public ApplicationContext createSpringContext() {
  try {
    ApplicationContext springContext = springBuilder.createSpringApp(config, classes.stream().toArray(i->new Class[classes.size()]));
    return springContext;
  } catch (Exception e) {
    logger.error(InternalErrorCode.STARTUP_FAILED_SPRING_INITIALISATION.toString(), e.getMessage());
    ExceptionSoftener.throwSoftenedException(e);
  }
  return null;
}
public Class[] classes() {

@Override
public boolean equals(Object o) {
  if(!(o instanceof PersistentSet) || o==null)
    return false;
  PersistentSet s = (PersistentSet)o;
  for(T next : this){
    if(!s.containsValue(next))
      return false;
  }
  return size()==s.size();
}