org.unlaxer.jaddress.parser.StringAndCharacterKinds Maven / Gradle / Ivy

Go to download
package org.unlaxer.jaddress.parser;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.function.BinaryOperator;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

import io.vavr.Tuple2;

public class StringAndCharacterKinds implements List{
	
	final List inner;
	
	final String joined;
	
	public StringAndCharacterKinds(String string) {
		this(CharacterKind.stringAndCharacterKindsOf(string));
	}
	
	public StringAndCharacterKinds(List inner) {
		super();
		this.inner = inner;
		joined = inner.stream()
			.map(StringAndCharacterKind::get)
			.collect(Collectors.joining());
	}
	
	public int size() {
		return inner.size();
	}

	public boolean isEmpty() {
		return inner.isEmpty();
	}
	
	public boolean isPresent() {
		return false == inner.isEmpty();
	}

	public boolean contains(Object o) {
		return inner.contains(o);
	}

	public Iterator iterator() {
		return inner.iterator();
	}

	public Object[] toArray() {
		return inner.toArray();
	}

	public  T[] toArray(T[] a) {
		return inner.toArray(a);
	}

	public boolean add(StringAndCharacterKind e) {
		return inner.add(e);
	}

	public boolean remove(Object o) {
		return inner.remove(o);
	}

	public boolean containsAll(Collection c) {
		return inner.containsAll(c);
	}

	public boolean addAll(Collection c) {
		return inner.addAll(c);
	}

	public boolean addAll(int index, Collection c) {
		return inner.addAll(index, c);
	}

	public boolean removeAll(Collection c) {
		return inner.removeAll(c);
	}


	public boolean retainAll(Collection c) {
		return inner.retainAll(c);
	}

	public void clear() {
		inner.clear();
	}

	public boolean equals(Object o) {
		return inner.equals(o);
	}

	public int hashCode() {
		return inner.hashCode();
	}

	public StringAndCharacterKind get(int index) {
		return inner.get(index);
	}

	public StringAndCharacterKind set(int index, StringAndCharacterKind element) {
		return inner.set(index, element);
	}

	public void add(int index, StringAndCharacterKind element) {
		inner.add(index, element);
	}

	public StringAndCharacterKind remove(int index) {
		return inner.remove(index);
	}

	public int indexOf(Object o) {
		return inner.indexOf(o);
	}

	public int lastIndexOf(Object o) {
		return inner.lastIndexOf(o);
	}

	public ListIterator listIterator() {
		return inner.listIterator();
	}

	public ListIterator listIterator(int index) {
		return inner.listIterator(index);
	}
	
	public ListIterator listIteratorFromLast() {
		return inner.listIterator(inner.size());
	}

	public List subList(int fromIndexInclusive, int toIndexExclusive) {
		return inner.subList(fromIndexInclusive, toIndexExclusive);
	}
	
	public StringAndCharacterKinds subListAsStringAndCharacterKinds(ListIndex  fromIndexInclusive, ListIndex toIndexExclusive) {
		return new StringAndCharacterKinds(inner.subList(fromIndexInclusive.value, toIndexExclusive.value));
	}
	
//	public AddressToken subListAsAddressToken(int fromIndexInclusive, int toIndexExclusive) {
//		return new StringAndCharacterKinds(inner.subList(fromIndexInclusive, toIndexExclusive));
//	}
	
	public String joined() {
		return joined;
	}
	
	public final static  BinaryOperator joiner = (left,right)->{
		
		left.inner();
		
		List sum = new ArrayList<>();
		
		sum.addAll(left.inner());
		sum.addAll(right.inner());
		
		StringAndCharacterKinds joined = new StringAndCharacterKinds(sum);
		
		return joined;
		
	};
	
	public List inner(){
		return inner;
	}
	
	public static StringAndCharacterKinds join(StringAndCharacterKinds left , StringAndCharacterKinds right) {
		
		return joiner.apply(left, right);
	}
	
	public StringAndCharacterKinds join(StringAndCharacterKinds adding) {
		if(adding.isEmpty()){
			return this;
		}
		return StringAndCharacterKinds.join(this , adding);
	}
	
	static final StringAndCharacterKinds EMPTY = new StringAndCharacterKinds(Collections.emptyList());
	
	public static StringAndCharacterKinds empty() {
		return EMPTY;
	}
	
	List> characterKindIndexOf(CharacterKind... characterKinds){
		
		List> indexes = new ArrayList<>();
		
		int index = 0;
		for(StringAndCharacterKind stringAndCharacterKind : inner) {
			
			for (CharacterKind characterKind : characterKinds) {
				if(stringAndCharacterKind.characterKind == characterKind) {
					indexes.add(new Tuple2<>(index , stringAndCharacterKind));
					break;
				}
			}
			index++;
		}
		return indexes;
	}
	
	public StringAndCharacterKinds cutFilterchracterKindIndexOf(CharacterKind... characterKinds){
		
		List results  = new ArrayList<>();
		
		for(StringAndCharacterKind stringAndCharacterKind : inner) {
			
			boolean isMatch= false;
			
			for (CharacterKind characterKind : characterKinds) {
				if(stringAndCharacterKind.characterKind == characterKind) {
					isMatch = true;
					break;
				}
			}
			if(false == isMatch) {
				results.add(stringAndCharacterKind);
			}
		}
		return new StringAndCharacterKinds(results);
	}
	
//	public TripletAddressToken createTriplet(ListIndex _fromIndex, ListIndex _toIndexExclusive) {
//		
//		int fromIndex = _fromIndex.value;
//		int toIndexExclusive = _toIndexExclusive.value;
//		
//		boolean hasPredecessor = fromIndex > 0;
//		boolean hasSuccessor= toIndexExclusive < size();
//		if(hasPredecessor && hasSuccessor) {
//			return new TripletAddressToken(
//					subListAsAddressToken(0, fromIndex),
//					subListAsAddressToken(fromIndex, toIndexExclusive),
//					subListAsAddressToken(toIndexExclusive, size())
//			);
//		}else if(false == hasPredecessor && false == hasSuccessor) {
//			return new MatchedString(
//					StringAndCharacterKinds.empty(),
//					subListAsAddressToken(fromIndex, toIndexExclusive),
//					StringAndCharacterKinds.empty()
//			);
//		}else if(false == hasPredecessor) {
//			return new MatchedString(
//					StringAndCharacterKinds.empty(),
//					subListAsAddressToken(fromIndex, toIndexExclusive),
//					subListAsAddressToken(toIndexExclusive, size())
//			);
//		}else {
//			return new MatchedString(
//					subListAsAddressToken(0, fromIndex),
//					subListAsAddressToken(fromIndex, toIndexExclusive),
//					StringAndCharacterKinds.empty()
//			);
//		}
//	}

	@Override
	public String toString() {
		
		return inner.stream()
			.map(StringAndCharacterKind::toString)
			.collect(Collectors.joining(",", "[", "]"));
	}
	
	public StringAndCharacterKinds strip() {
		String strip = joined.strip();
		if(strip.length() != joined.length()) {
			return CharacterKind.stringAndCharacterKindsOf(strip);
		}
		return this;
	}
	
	static final Predicate notSpaceAndDelimitor =
		Predicate.not(characterKind-> 
			characterKind == CharacterKind.delimitorHyphen ||
			characterKind == CharacterKind.delimitorJapaneseSymbol ||
			characterKind == CharacterKind.delimitorSpace
		);
	
	public StringAndCharacterKinds stripIncludesSymbols() {
		return strip(notSpaceAndDelimitor);
	}
	
	public StringAndCharacterKinds strip(Predicate matchWithNonStrip) {
		
		ListIndex left = indexOf(notSpaceAndDelimitor , TopOrBottom.top);
		
		if(left.value == -1 ) {
			return StringAndCharacterKinds.empty();
		}
		
		ListIndex right = indexOf(notSpaceAndDelimitor , TopOrBottom.bottom);
		
		if(left.value > right.value) {
			return StringAndCharacterKinds.empty();
		}
		
		List subList = inner.subList(left.value, right.value);
		
		return new StringAndCharacterKinds(subList);
	}
	
	public enum TopOrBottom{
		top,
		bottom
		;
		public boolean isTop() {
			return this == top;
		}
		public boolean isBottom() {
			return this == bottom;
		}

	}
	
	public ListIndex indexOf(Predicate predicate , TopOrBottom from) {
		
		ListIterator iterator = from == TopOrBottom.top ?
			listIterator():
			listIteratorFromLast();
			
		Supplier checker = from == TopOrBottom.top ?
			()->iterator.hasNext():
			()->iterator.hasPrevious();
			
		Supplier fetcher = from == TopOrBottom.top ?
			()->iterator.next():
			()->iterator.previous();
			
		Supplier indexFetcher = from == TopOrBottom.top ?
				()->iterator.nextIndex():
				()->iterator.previousIndex()+1;
			
		Integer index = null;
		boolean match = false;
		while (checker.get()) {
			index = indexFetcher.get();
			StringAndCharacterKind stringAndCharacterKind = fetcher.get();
			CharacterKind characterKind = stringAndCharacterKind.characterKind;
			if(predicate.test(characterKind)) {
				match = true;
				break;
			}
		}
		return ListIndex.of(match ? index : -1);
	}

	
	public StringAndCharacterKinds substring(
			StringIndex  beginIndexInclusive, 
			StringIndex endIndexExclusive , 
			SeparatorKind leadingSeparator ,
			SeparatorKind tailingSeparator) {
		
		String substring = joined.substring(beginIndexInclusive.value, endIndexExclusive.value);
		
		return CharacterKind.stringAndCharacterKindsOf(substring);
	}
	
	public StringAndCharacterKinds substring(
			StringIndex  beginIndexInclusive, 
			SeparatorKind leadingSeparator ,
			SeparatorKind tailingSeparator) {
		
		String substring = joined.substring(beginIndexInclusive.value);
		
		return CharacterKind.stringAndCharacterKindsOf(substring);
	}

	
	public boolean contains(String word) {
		return joined().contains(word);
	}
	
	public StringIndex indexOf(String word , StringIndex fromIndex) {
		return StringIndex.of(joined().indexOf(word, fromIndex.value));
	}
}