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

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

import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.unlaxer.jaddress.entity.standard.SingleOrRange階層要素;
import org.unlaxer.jaddress.entity.standard.定義済みRange階層要素;
import org.unlaxer.jaddress.entity.standard.確定済み階層要素;
import org.unlaxer.jaddress.entity.standard.階層要素;
import org.unlaxer.jaddress.parser.PickerResults.PredecessorOrSuccessor;
import org.unlaxer.jaddress.parser.picker.PickerResult;
import org.unlaxer.jaddress.parser.picker.ValueAndSuffixPicker;
import org.unlaxer.util.collection.TreeNode;

import io.vavr.Tuple3;

public interface PickerParer{
	
	public enum Pick{
		withSuffix,
		withoutSuffix,
		;
		public boolean withSuffix() {
			return this == withSuffix;
		}
		public boolean withoutSuffix() {
			return this == withoutSuffix;
		}
	}
	
	public enum AfterAction{
		addResultToAddressContext,
		nothing
		;
	}
	
	public default  Optional parse(
			ParsingTarget parsingTarget,
			Pick pickWith,
			AfterAction afterAction){
		
		AddressContext addressContext = parsingTarget.addressContext();
		PickerResults pickerResults = addressContext.pickerResults();
		
		List> 
			targetTokens = targetTokens(pickerResults);
		for (Tuple3 tuple3 : targetTokens) {
			
			PredecessorOrSuccessor predecessorOrSuccessor  = tuple3._1();
			SingleOrRange階層要素 _階層要素 = tuple3._2();
			AddressToken source = tuple3._3();
			
			Optional parsed = parse(parsingTarget , source , pickWith , afterAction);
			
			parsed.ifPresent(result->{
				pickerResults.remove(_階層要素, predecessorOrSuccessor);
				pickerResults.add(parsed);
			});
			
			if(parsed.isPresent()) {
				return parsed;
			}
		}
		return Optional.empty();
	}
	
	public default SingleOrRange階層要素 pickupFrom(AddressContext addressContext) {
		
		町域or建物 _町域or建物 = 町域or建物();
		
		if(_町域or建物 == 町域or建物.町域) {
			return SingleOrRange階層要素.of(定義済みRange階層要素.町名より後);
		}
		
		Optional> find = addressContext.find(定義済みRange階層要素.建物より後);
		
		return find.isPresent() ?  
				SingleOrRange階層要素.of(定義済みRange階層要素.建物より後) : 
				SingleOrRange階層要素.of(定義済みRange階層要素.建物以降);
	}
	
	public default  Optional parse(
			ParsingTarget parsingTarget,
			AddressToken source , 
			Pick pickWith,
			AfterAction  afterAction) {
		
		AddressContext addressContext = parsingTarget.addressContext();
		
		TreeNode 建物以降Node =
				addressContext.addressTree().find(pickupFrom(addressContext).id()).orElseThrow();
		
		ValueAndSuffixPicker picker = picker();
		
			
		Optional pick =
				pickWith.withSuffix() ? 
					picker.pick(source):
					picker.pickWithoutSuffix(source);
		
		pick.ifPresent(pickerResult->{
			
			階層要素 output階層要素 = output階層要素();
			AddressElement addressElement = 
					AddressElementFactory.of(pickerResult.value(), output階層要素);
			
			if(pickerResult.suffix().isPresent()) {
				
				addressElement.setSuffix(pickerResult.suffix().asString());
				
				確定済み階層要素.from(output階層要素)
					.ifPresent(addressElement::set確定済み階層要素);
				
				ResolverResult resolverResult = resolverResultBy階層要素.get(output階層要素);
				if(resolverResult != null) {
					parsingTarget.addResolverResult(resolverResult);
				}
				
			}
			if(afterAction == AfterAction.addResultToAddressContext) {
				addChild(addressContext, 建物以降Node, addressElement);
			}
		});
		return pick;
	}
	
	static Map<階層要素,ResolverResult> resolverResultBy階層要素 = Map.of(
		階層要素.町域Top1,new ResolverResult(ResolverResultKindOfBoolean.丁目要素確定),
		階層要素.町域Top2,new ResolverResult(ResolverResultKindOfBoolean.番地要素確定),
		階層要素.町域Top3,new ResolverResult(ResolverResultKindOfBoolean.号要素確定),
		階層要素.町域Top4,new ResolverResult(ResolverResultKindOfBoolean.枝番要素確定),
		階層要素.建物Bottom1,new ResolverResult(ResolverResultKindOfBoolean.号室要素確定),
		階層要素.建物Bottom2,new ResolverResult(ResolverResultKindOfBoolean.階要素確定),
		階層要素.建物Bottom3,new ResolverResult(ResolverResultKindOfBoolean.棟要素確定),
		階層要素.方書き,new ResolverResult(ResolverResultKindOfBoolean.方書き要素確定)
	);
	
	public default void addChind(ParsingTarget parsingTarget , PickerResult pickerResult) {
		
		AddressContext addressContext = parsingTarget.addressContext();
		
		TreeNode 建物以降Node =
				addressContext.addressTree().find(pickupFrom(addressContext).id()).orElseThrow();
		
			AddressElement addressElement = 
					AddressElementFactory.of(pickerResult.value(), output階層要素());
			
			if(pickerResult.suffix().isPresent()) {
				addressElement.setSuffix(pickerResult.suffix().asString());
			}
			addChild(addressContext, 建物以降Node, addressElement);
			
			///FIXME remove child
	}
	
	public void addChild(AddressContext addressContext , TreeNode target , AddressElement child);
	
	public 階層要素 output階層要素();
	public ValueAndSuffixPicker picker();
	
	public List> targetTokens(PickerResults pickerResults);
	
	static void setTokenWithSuccessor(
			SingleOrRange階層要素 condition,
			List> results,
			SingleOrRange階層要素 _階層要素, AddressToken addressToken
			) {
		
		if(isInvalid(addressToken)) {
			return;
		}
		
		if(_階層要素.equals(condition)) {
			results.add(
				new Tuple3<>(
					PredecessorOrSuccessor.successor , 
					condition,
					addressToken
				)
			);
		}
	}
	
	static void setTokenWithPredecessor(
			SingleOrRange階層要素 condition,
			List> results,
			SingleOrRange階層要素 _階層要素, AddressToken addressToken
			) {
		
		if(isInvalid(addressToken)) {
			return;
		}
		
		if(_階層要素.equals(condition)) {
			results.add(
				new Tuple3<>(
					PredecessorOrSuccessor.predecessor , 
					condition,
					addressToken
				)
			);
		}
	}
	
	static boolean isInvalid(AddressToken addressToken) {
		String asString = addressToken.asString();
		return asString.isBlank();
	}
	
	public enum 町域or建物{
		町域,
		建物,
	}
	町域or建物 町域or建物();
	
}