All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.github.dakusui.thincrest.metamor.InputResolver Maven / Gradle / Ivy

The newest version!
package com.github.dakusui.thincrest.metamor;

import com.github.dakusui.thincrest_pcond.core.printable.PrintableFunction;
import com.github.dakusui.thincrest_pcond.forms.Printables;

import java.util.*;
import java.util.function.Function;
import java.util.function.Supplier;

import static java.util.Collections.emptyList;
import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

public interface InputResolver extends Function>, I> {
  class Impl extends PrintableFunction>, I> implements InputResolver {
    public Impl(Supplier s, Function>, ? extends I> function) {
      super(new Object(), emptyList(), s, function);
    }
  }
  
  interface Sequence extends Dataset> {
    class Impl implements Sequence {
  
      private final String inputVariableName;
      private final List> inputResolvers;
      
      public Impl(String inputVariableName, List> inputResolvers) {
        this.inputVariableName = requireNonNull(inputVariableName);
        this.inputResolvers = requireNonNull(inputResolvers);
      }
      
      @Override
      public InputResolver get(int i) {
        return inputResolvers.get(i);
      }
      
      @Override
      public int size() {
        return inputResolvers.size();
      }
  
      @Override
      public String name() {
        return this.inputVariableName;
      }
  
      @Override
      public String toString() {
        return inputVariableName + ":" + inputResolvers;
      }

      @Override
      public Iterator> iterator() {
        return new AbstractList>() {

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

          @Override
          public InputResolver get(int index) {
            return Impl.this.get(index);
          }
        }.iterator();
      }
    }
    
    interface Factory extends Function> {
      int count();
      
      class Impl
          extends PrintableFunction>
          implements Factory {
        
        private final int count;
        
        public Impl(Supplier s, Function> function, int count) {
          super(new Object(), emptyList(), s, function);
          this.count = count;
        }
        
        public Impl(String inputVariableName, List>> functions) {
          this(
              () -> functions.stream()
                  .map(Objects::toString)
                  .collect(joining(",", "[", "]")),
              Factory.Impl.toSequenceCreatorFunction(inputVariableName, functions), functions.size());
        }
        
        @Override
        public int count() {
          return this.count;
        }
        
        private static  Function> toSequenceCreatorFunction(String inputVariableName, List>> functions) {
          return (X value) -> new Sequence.Impl<>(
              inputVariableName,
              functions.stream()
                  .map(f -> f.apply(value))
                  .collect(toList()));
        }
      }
      
      class Builder {
        private final List>> functions = new LinkedList<>();
        private final String                                                   placeHolderVariableName;
        private final String inputVariableName;
  
        public Builder(String inputVariableName, String placeHolderVariableName) {
          this.placeHolderVariableName = placeHolderVariableName;
          this.inputVariableName = inputVariableName;
        }
        
        public Builder function(Function formatter, Function f) {
          this.functions.add(Printables.function(() -> formatter.apply(this.placeHolderVariableName), x -> new InputResolver.Impl<>(() -> formatter.apply(x), ds -> f.apply(x))));
          return this;
        }
        
        public Factory build() {
          return new Impl<>(this.inputVariableName, this.functions);
        }
      }
    }
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy