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

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

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import org.unlaxer.jaddress.entity.standard.SingleOrRange階層要素;
import org.unlaxer.jaddress.entity.standard.郵便番号;
import org.unlaxer.jaddress.entity.standard.階層要素;
import org.unlaxer.util.collection.ID;
import org.unlaxer.util.collection.TreeNode;

public interface AddressParser {
	
	static NextStateResolverBy階層要素 stateResolver = new SimpleNextStateResolverBy階層要素();
	
	public Map processorByState();
	
	public default ParsingResult parse(ParsingParameters parameters) {
		
		return parse(
			parameters.addresses(), 
			parameters.id(),
			parameters.zip(),
			parameters.dataAccessContext()
		);
	}
	
	public default ParsingResult parse(ParsingContext parsingContext) {
		return parse(parsingContext , processorByState());
	}
	
	public default ParsingResult parse(List addresses  , ID id , 郵便番号 zip , DataAccessContext  dataAccessContext) {
		
		ParsingContext parsingContext = ParsingContext.create(id , dataAccessContext);
		
		Map processorByState = processorByState();
		
		long 不明Count =addresses.stream()
			.map(AddressElement::start階層要素)
			.filter(_階層要素-> _階層要素 == 階層要素.不明)
			.count();
		
		boolean allAddressIs不明 = 不明Count == addresses.size();
		boolean has不明Address = 不明Count >0;
		
		if(has不明Address) {
			
			AddressContext addressContext = AddressContext.create(zip, addresses);
			ParsingTarget parsingTarget = ParsingTarget.create(parsingContext, addressContext);
			parsingContext.addParsingTarget(parsingTarget);
			
			if(allAddressIs不明){
				
				ParsingResult parsed = parse(parsingContext , processorByState);
				return parsed;
				
			} 
			PartialParsingResult partialParsingResult = 
				PartialParsingResult.create(parsingTarget , ParsingState.入力Address組み合わせエラー);
			partialParsingResult.set(new AddressElements(addressContext));
			
			ParsingResult parsingResult = ParsingResult.create(partialParsingResult);
			return parsingResult;
		}
		
		addresses.stream()
			.forEach(addressElement->{
				
				SingleOrRange階層要素 target階層要素 = addressElement.singleOrRange階層要素();
				
				
				AddressContext addressContext = AddressContext.create(id, zip, addressElement);
				
				ParsingState nextState = stateResolver().apply(target階層要素);
				
				TargetStateAndElement targetStateAndElement = new TargetStateAndElement(nextState, target階層要素);
				
				ParsingTarget parsingTarget = 
					ParsingTarget.create(parsingContext, addressContext , targetStateAndElement);
				
				parsingContext.addParsingTarget(parsingTarget);
			});
		
		ParsingResult parsed = parse(parsingContext , processorByState);
		return parsed;
	}
	
	
	public default NextStateResolverBy階層要素 stateResolver() {
		return stateResolver;
	}
	
	
	private static ParsingResult parse(ParsingContext parsingContext , Map processorByState) {
		
		List results = parsingContext.parsingTargets().stream()
			.map(parsingTarget->parse(parsingTarget,processorByState))
			.collect(Collectors.toList());
		
		ParsingResult parsingResult = ParsingResult.create(results);
		
		return parsingResult;
	}

	static Consumer overWriteWithAddressContext(TreeNode baseAddressTree) {
		
		return currentAddressContext->{
			
			AddressContext addressContext = currentAddressContext.parsingTarget().addressContext();
			
			TreeNode addritionalTreeNode = addressContext.addressTree().root();
			AddressElement addressElement = addritionalTreeNode.get();
			
			SingleOrRange階層要素 current階層要素 = addressElement._階層要素;
			
			Optional> targetBaseNode = baseAddressTree.findWithContent(element->{
				return element._階層要素.equals(current階層要素);
			});
			
			targetBaseNode.ifPresent(_targetBaseNode->{
				ID targetId = _targetBaseNode.id();
				_targetBaseNode.parent()
					.ifPresent(parent->parent.resetChild(targetId, addritionalTreeNode));
			});
		};
	}
	
	private static PartialParsingResult parse(ParsingTarget parsingTarget , Map processorByState) {
		
		AddressContext addressContext  = parsingTarget.addressContext();
		
		LoggerContext.debug("START:{} {}" , addressContext.zip().asHyphonated() , addressContext.addressString().joined());

		while (true) {
			
			ParsingState targetState = parsingTarget.targetState();
			
			AddressProcessor processor = processorByState.get(targetState);
			
			
			if(processor == null) {
				
				break;
			}
			LoggerContext.debug("■ Processor is {}", processor.getClass().getSimpleName());
			
			
			TargetStateAndElement targetStateAndElement = processor.process(parsingTarget);
			parsingTarget.setTargetStateAndElement(targetStateAndElement);
		}
		LoggerContext.debug("END");
		
		PartialParsingResult partialParsingResult = parsingTarget.partialParsingResult();
		
		return partialParsingResult;
		
	}
}