io.datarouter.scanner.ScannerTool Maven / Gradle / Ivy

Go to download
/**
 * Copyright © 2009 HotPads ([email protected])
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.datarouter.scanner;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class ScannerTool{

	public static  boolean allMatch(Scanner scanner, Predicate predicate){
		try(var $ = scanner){
			while(scanner.advance()){
				if(!predicate.test(scanner.current())){
					return false;
				}
			}
			return true;
		}
	}

	public static  boolean anyMatch(Scanner scanner, Predicate predicate){
		try(var $ = scanner){
			while(scanner.advance()){
				if(predicate.test(scanner.current())){
					return true;
				}
			}
			return false;
		}
	}

	public static > C collect(Scanner scanner, Supplier collectionSupplier){
		try(var $ = scanner){
			C collection = collectionSupplier.get();
			while(scanner.advance()){
				collection.add(scanner.current());
			}
			return collection;
		}
	}

	public static  long count(Scanner scanner){
		try(var $ = scanner){
			long count = 0;
			while(scanner.advance()){
				++count;
			}
			return count;
		}
	}

	public static  Optional findAny(Scanner scanner){
		try(var $ = scanner){
			if(scanner.advance()){
				return Optional.of(scanner.current());
			}
			return Optional.empty();
		}
	}

	public static  Optional findFirst(Scanner scanner){
		try(var $ = scanner){
			if(scanner.advance()){
				return Optional.of(scanner.current());
			}
			return Optional.empty();
		}
	}

	public static  Optional findLast(Scanner scanner){
		try(var $ = scanner){
			T last = null;
			boolean foundAny = false;
			while(scanner.advance()){
				last = scanner.current();
				foundAny = true;
			}
			return foundAny ? Optional.of(last) : Optional.empty();
		}
	}

	public static  Scanner flush(Scanner scanner, Consumer> consumer){
		List list = Collections.unmodifiableList(list(scanner));
		consumer.accept(list);
		return Scanner.of(list);
	}

	public static  void forEach(Scanner scanner, Consumer action){
		try(var $ = scanner){
			while(scanner.advance()){
				action.accept(scanner.current());
			}
		}
	}

	public static  boolean hasAny(Scanner scanner){
		try(var $ = scanner){
			return scanner.advance();
		}
	}

	public static  boolean isEmpty(Scanner scanner){
		try(var $ = scanner){
			return !scanner.advance();
		}
	}

	public static  ArrayList list(Scanner scanner){
		try(var $ = scanner){
			ArrayList list = new ArrayList<>();
			while(scanner.advance()){
				list.add(scanner.current());
			}
			return list;
		}
	}

	public static  Optional max(Scanner scanner, Comparator comparator){
		try(var $ = scanner){
			T max = null;
			while(scanner.advance()){
				T current = scanner.current();
				if(max == null || comparator.compare(current, max) > 0){
					max = current;
				}
			}
			return Optional.ofNullable(max);
		}
	}

	public static  Optional min(Scanner scanner, Comparator comparator){
		try(var $ = scanner){
			T min = null;
			while(scanner.advance()){
				T current = scanner.current();
				if(min == null || comparator.compare(current, min) < 0){
					min = current;
				}
			}
			return Optional.ofNullable(min);
		}
	}

	public static  Stream nativeStream(Scanner scanner){
		Spliterator spliterator = spliterator(scanner);
		Stream stream = StreamSupport.stream(spliterator, false);
		stream.onClose(() -> scanner.close());
		return stream;
	}

	public static  boolean noneMatch(Scanner scanner, Predicate predicate){
		try(var $ = scanner){
			while(scanner.advance()){
				if(predicate.test(scanner.current())){
					return false;
				}
			}
			return true;
		}
	}

	public static  Optional reduce(Scanner scanner, BinaryOperator reducer){
		try(var $ = scanner){
			T result = null;
			boolean foundAny = false;
			while(scanner.advance()){
				if(!foundAny){
					result = scanner.current();
				}else{
					result = reducer.apply(result, scanner.current());
				}
				foundAny = true;
			}
			return foundAny ? Optional.of(result) : Optional.empty();
		}
	}

	public static  T reduce(Scanner scanner, T seed, BinaryOperator reducer){
		try(var $ = scanner){
			T result = seed;
			while(scanner.advance()){
				result = reducer.apply(result, scanner.current());
			}
			return result;
		}
	}

	public static  Scanner skip(Scanner scanner, long numToSkip){
		long numSkipped = 0;
		while(numSkipped < numToSkip){
			if(!scanner.advance()){
				scanner.close();
				return scanner;
			}
			++numSkipped;
		}
		return scanner;
	}

	public static  Spliterator spliterator(Scanner scanner){
		return Spliterators.spliteratorUnknownSize(scanner.iterator(), 0);
	}

	public static  List take(Scanner scanner, int numToTake){
		List items = new ArrayList<>();
		while(items.size() < numToTake){
			if(!scanner.advance()){
				scanner.close();
				return items;
			}
			items.add(scanner.current());
		}
		return items;
	}

	public static Object[] toArray(Scanner scanner){
		try(Scanner ref = scanner){
			return list(scanner).toArray();
		}
	}

}