ecommons/org.eclipse.statet.ecommons.text.core/src/org/eclipse/statet/ecommons/text/core/util/AbstractFragmentDocument.java - gerrit/statet/org.eclipse.statet-commons - Git at Google

 /*=============================================================================#
  # Copyright (c) 2005, 2021 Stephan Wahlbrink and others.
  #
  # This program and the accompanying materials are made available under the
  # terms of the Eclipse Public License 2.0 which is available at
  # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
  # which is available at https://www.apache.org/licenses/LICENSE-2.0.
  #
  # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
  #
  # Contributors:
  #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
  #=============================================================================*/

 package org.eclipse.statet.ecommons.text.core.util;

 import java.util.ArrayList;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jface.text.AbstractDocument;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.BadPartitioningException;
 import org.eclipse.jface.text.DocumentEvent;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.IDocumentPartitioner;
 import org.eclipse.jface.text.IDocumentPartitionerExtension2;
 import org.eclipse.jface.text.IDocumentPartitioningListener;
 import org.eclipse.jface.text.ITypedRegion;
 import org.eclipse.jface.text.Region;
 import org.eclipse.jface.text.TypedRegion;

 import org.eclipse.statet.jcommons.lang.NonNull;
 import org.eclipse.statet.jcommons.lang.NonNullByDefault;
 import org.eclipse.statet.jcommons.lang.Nullable;
 import org.eclipse.statet.jcommons.text.core.TextRegion;

 import org.eclipse.statet.ecommons.text.core.FragmentDocument;
 import org.eclipse.statet.ecommons.text.core.JFaceTextRegion;
 import org.eclipse.statet.internal.ecommons.text.core.ECommonsTextCorePlugin;


 /**
  * @since de.walware.ecommons.text 1.1
  */
 @NonNullByDefault
 public abstract class AbstractFragmentDocument extends AbstractSynchronizableDocument
 		implements FragmentDocument {


 	private static final byte NO_CHANGE= 0;
 	private static final byte PREFIX_CHANGE= 1;
 	private static final byte FRAGMENT_CHANGE= 2;


 	private class PartitionerMapper implements IDocumentPartitioner {

 		private final IDocumentPartitioner masterPartitioner;

 		public PartitionerMapper(final IDocumentPartitioner partitioner) {
 			this.masterPartitioner= partitioner;
 		}

 		@Override
 		public void connect(final IDocument document) {
 			throw new UnsupportedOperationException();
 		}

 		@Override
 		public void disconnect() {
 			throw new UnsupportedOperationException();
 		}

 		@Override
 		public void documentAboutToBeChanged(final DocumentEvent event) {
 			throw new UnsupportedOperationException();
 		}

 		@Override
 		public boolean documentChanged(final DocumentEvent event) {
 			throw new UnsupportedOperationException();
 		}

 		@Override
 		public ITypedRegion[] computePartitioning(final int offset, final int length) {
 			return remap(this.masterPartitioner.computePartitioning(
 					AbstractFragmentDocument.this.offsetInMaster + offset, length));
 		}

 		@Override
 		public String getContentType(final int offset) {
 			return this.masterPartitioner.getContentType(AbstractFragmentDocument.this.offsetInMaster + offset);
 		}

 		@Override
 		public String[] getLegalContentTypes() {
 			return this.masterPartitioner.getLegalContentTypes();
 		}

 		@Override
 		public ITypedRegion getPartition(final int offset) {
 			return remap(this.masterPartitioner.getPartition(AbstractFragmentDocument.this.offsetInMaster + offset));
 		}
 	}

 	private class PartitionerMapper2 extends PartitionerMapper implements IDocumentPartitionerExtension2 {

 		private final IDocumentPartitionerExtension2 masterPartitioner2;

 		public PartitionerMapper2(final IDocumentPartitioner partitioner) {
 			super(partitioner);
 			this.masterPartitioner2= (IDocumentPartitionerExtension2) partitioner;
 		}

 		@Override
 		public ITypedRegion[] computePartitioning(final int offset, final int length, final boolean includeZeroLengthPartitions) {
 			return this.masterPartitioner2.computePartitioning(AbstractFragmentDocument.this.offsetInMaster + offset, length, includeZeroLengthPartitions);
 		}

 		@Override
 		public String getContentType(final int offset, final boolean preferOpenPartitions) {
 			return this.masterPartitioner2.getContentType(AbstractFragmentDocument.this.offsetInMaster + offset, preferOpenPartitions);
 		}

 		@Override
 		public String @Nullable [] getManagingPositionCategories() {
 			return this.masterPartitioner2.getManagingPositionCategories();
 		}

 		@Override
 		public ITypedRegion getPartition(final int offset, final boolean preferOpenPartitions) {
 			return this.masterPartitioner2.getPartition(AbstractFragmentDocument.this.offsetInMaster + offset, preferOpenPartitions);
 		}

 	}


 	private final AbstractDocument master;

 	private int offsetInMaster= 0;

 	private byte change= NO_CHANGE;


 	/**
 	 * The default constructor does not perform any configuration but leaves it to the clients who
 	 * must first initialize the implementation plug-ins and then call <code>completeInitialization</code>.
 	 * Results in the construction of an empty document.
 	 */
 	public AbstractFragmentDocument() {
 		super();

 		this.master= createMasterDocument();

 		this.master.addDocumentListener(new IDocumentListener() {
 			@Override
 			public void documentAboutToBeChanged(final DocumentEvent event) {
 				switch (AbstractFragmentDocument.this.change) {
 				case PREFIX_CHANGE:
 					AbstractFragmentDocument.this.offsetInMaster+= - event.fLength + event.fText.length();
 					return;
 				case FRAGMENT_CHANGE:
 					return;
 				default:
 					throw new UnsupportedOperationException();
 				}
 			}
 			@Override
 			public void documentChanged(final DocumentEvent event) {
 			}
 		});
 		this.master.addDocumentPartitioningListener(new IDocumentPartitioningListener() {
 			@Override
 			@SuppressWarnings("deprecation")
 			public void documentPartitioningChanged(final IDocument document) {
 				fireDocumentPartitioningChanged(new Region(0, getLength()));
 			}
 		});
 	}


 	@Override
 	protected void completeInitialization() {
 		super.completeInitialization();

 		addDocumentListener(new IDocumentListener() {
 			@Override
 			public void documentAboutToBeChanged(final DocumentEvent event) {
 			}
 			@Override
 			public void documentChanged(final DocumentEvent event) {
 				if (AbstractFragmentDocument.this.change != NO_CHANGE) {
 					throw new IllegalStateException(String.valueOf(AbstractFragmentDocument.this.change));
 				}

 				AbstractFragmentDocument.this.change= FRAGMENT_CHANGE;
 				try {
 					replaceInMaster(AbstractFragmentDocument.this.offsetInMaster + event.fOffset,
 							event.fLength, event.fText );
 				}
 				catch (final BadLocationException e) {
 					ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
 							"Failed to edit master document.", e ));
 				}
 				finally {
 					AbstractFragmentDocument.this.change= NO_CHANGE;
 				}
 			}
 		});
 	}


 	protected abstract AbstractDocument createMasterDocument();

 	@Override
 	public AbstractDocument getMasterDocument() {
 		return this.master;
 	}

 	@Override
 	public int getOffsetInMasterDocument() {
 		return this.offsetInMaster;
 	}

 	@Override
 	public TextRegion getRegionInMasterDocument() {
 		synchronized (getLockObject()) {
 			return JFaceTextRegion.newByStartLength(this.offsetInMaster, getLength());
 		}
 	}

 	protected void replaceInMaster(final int offset, final int length, final String text)
 			throws BadLocationException {
 		this.master.replace(offset, length, text);
 	}


 	protected void setPrefix(final String text) {
 		if (text == null) {
 			throw new NullPointerException();
 		}
 		synchronized (getLockObject()) {
 			if (this.change != NO_CHANGE) {
 				throw new IllegalStateException(String.valueOf(this.change));
 			}

 			this.change= PREFIX_CHANGE;
 			try {
 				replaceInMaster(0, this.offsetInMaster, text);
 				this.offsetInMaster= text.length();
 			}
 			catch (final BadLocationException e) {
 				ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
 						"Failed to edit master document.", e ));
 			}
 			finally {
 				this.change= 0;
 			}
 		}
 	}


 	@Override
 	public void setInitialLineDelimiter(final String lineDelimiter) {
 		this.master.setInitialLineDelimiter(lineDelimiter);
 		super.setInitialLineDelimiter(lineDelimiter);
 	}


 	@Override
 	public void setDocumentPartitioner(final @Nullable IDocumentPartitioner partitioner) {
 		this.master.setDocumentPartitioner(partitioner);
 	}

 	@Override
 	public void setDocumentPartitioner(final String partitioning, final @Nullable IDocumentPartitioner partitioner) {
 		this.master.setDocumentPartitioner(partitioning, partitioner);
 	}

 	@Override
 	public String[] getPartitionings() {
 		return this.master.getPartitionings();
 	}

 	@Override
 	public @Nullable IDocumentPartitioner getDocumentPartitioner() {
 		return getDocumentPartitioner(DEFAULT_PARTITIONING);
 	}

 	@Override
 	public @Nullable IDocumentPartitioner getDocumentPartitioner(final String partitioning) {
 		final IDocumentPartitioner masterPartitioner= this.master.getDocumentPartitioner(partitioning);
 		if (masterPartitioner == null) {
 			return null;
 		}
 		if (masterPartitioner instanceof IDocumentPartitionerExtension2) {
 			return new PartitionerMapper2(masterPartitioner);
 		}
 		else {
 			return new PartitionerMapper(masterPartitioner);
 		}
 	}

 	@Override
 	public String[] getLegalContentTypes() {
 		return this.master.getLegalContentTypes();
 	}

 	@Override
 	public String[] getLegalContentTypes(final String partitioning) throws BadPartitioningException {
 		return this.master.getLegalContentTypes(partitioning);
 	}

 	@Override
 	public ITypedRegion[] computePartitioning(final int offset, final int length) throws BadLocationException {
 		return remap(this.master.computePartitioning(this.offsetInMaster + offset, length));
 	}

 	@Override
 	public ITypedRegion[] computePartitioning(final String partitioning, final int offset, final int length,
 			final boolean includeZeroLengthPartitions) throws BadLocationException, BadPartitioningException {
 		return remap(this.master.computePartitioning(partitioning, this.offsetInMaster + offset, length, includeZeroLengthPartitions));
 	}

 	@Override
 	public ITypedRegion getPartition(final int offset) throws BadLocationException {
 		return remap(this.master.getPartition(this.offsetInMaster + offset));
 	}

 	@Override
 	public ITypedRegion getPartition(final String partitioning, final int offset,
 			final boolean preferOpenPartitions) throws BadLocationException, BadPartitioningException {
 		return remap(this.master.getPartition(partitioning, this.offsetInMaster + offset, preferOpenPartitions));
 	}

 	@Override
 	public String getContentType(final int offset) throws BadLocationException {
 		return this.master.getContentType(this.offsetInMaster + offset);
 	}

 	@Override
 	public String getContentType(final String partitioning, final int offset,
 			final boolean preferOpenPartitions) throws BadLocationException, BadPartitioningException {
 		return this.master.getContentType(partitioning, this.offsetInMaster + offset, preferOpenPartitions);
 	}


 	private ITypedRegion[] remap(final ITypedRegion[] masterRegions) {
 		final ArrayList<ITypedRegion> regions= new ArrayList<>(masterRegions.length);
 		for (final ITypedRegion masterRegion : masterRegions) {
 			final ITypedRegion region= remap(masterRegion);
 			if (region != null) {
 				regions.add(region);
 			}
 		}
 		return regions.toArray(new @NonNull ITypedRegion[regions.size()]);
 	}

 	private @Nullable ITypedRegion remap(final ITypedRegion masterRegion) {
 		int offset= masterRegion.getOffset() - this.offsetInMaster;
 		int length= masterRegion.getLength();
 		if (offset + length >= 0) {
 			if (offset < 0) {
 				length= length + offset;
 				offset= 0;
 			}
 //			System.out.println("partitiong mapping: ("+masterRegion.getOffset()+", "+masterRegion.getLength()+") -["+this.offsetInMaster+"]-> ("+offset+", "+length+")");
 			return new TypedRegion(offset, length, masterRegion.getType());
 		}

 		{	final BadPartitioningException e= new BadPartitioningException("Failed to map partition from master to fragment document.");
 			e.fillInStackTrace();
 			ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
 					"Failed to compute partition.", e ));
 			return null;
 		}
 	}

 }
	/*=============================================================================#
	# Copyright (c) 2005, 2021 Stephan Wahlbrink and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License 2.0 which is available at
	# https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
	# which is available at https://www.apache.org/licenses/LICENSE-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
	#
	# Contributors:
	# Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
	#=============================================================================*/

	package org.eclipse.statet.ecommons.text.core.util;

	import java.util.ArrayList;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.jface.text.AbstractDocument;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.BadPartitioningException;
	import org.eclipse.jface.text.DocumentEvent;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IDocumentListener;
	import org.eclipse.jface.text.IDocumentPartitioner;
	import org.eclipse.jface.text.IDocumentPartitionerExtension2;
	import org.eclipse.jface.text.IDocumentPartitioningListener;
	import org.eclipse.jface.text.ITypedRegion;
	import org.eclipse.jface.text.Region;
	import org.eclipse.jface.text.TypedRegion;

	import org.eclipse.statet.jcommons.lang.NonNull;
	import org.eclipse.statet.jcommons.lang.NonNullByDefault;
	import org.eclipse.statet.jcommons.lang.Nullable;
	import org.eclipse.statet.jcommons.text.core.TextRegion;

	import org.eclipse.statet.ecommons.text.core.FragmentDocument;
	import org.eclipse.statet.ecommons.text.core.JFaceTextRegion;
	import org.eclipse.statet.internal.ecommons.text.core.ECommonsTextCorePlugin;


	/**
	* @since de.walware.ecommons.text 1.1
	*/
	@NonNullByDefault
	public abstract class AbstractFragmentDocument extends AbstractSynchronizableDocument
	implements FragmentDocument {


	private static final byte NO_CHANGE= 0;
	private static final byte PREFIX_CHANGE= 1;
	private static final byte FRAGMENT_CHANGE= 2;


	private class PartitionerMapper implements IDocumentPartitioner {

	private final IDocumentPartitioner masterPartitioner;

	public PartitionerMapper(final IDocumentPartitioner partitioner) {
	this.masterPartitioner= partitioner;
	}

	@Override
	public void connect(final IDocument document) {
	throw new UnsupportedOperationException();
	}

	@Override
	public void disconnect() {
	throw new UnsupportedOperationException();
	}

	@Override
	public void documentAboutToBeChanged(final DocumentEvent event) {
	throw new UnsupportedOperationException();
	}

	@Override
	public boolean documentChanged(final DocumentEvent event) {
	throw new UnsupportedOperationException();
	}

	@Override
	public ITypedRegion[] computePartitioning(final int offset, final int length) {
	return remap(this.masterPartitioner.computePartitioning(
	AbstractFragmentDocument.this.offsetInMaster + offset, length));
	}

	@Override
	public String getContentType(final int offset) {
	return this.masterPartitioner.getContentType(AbstractFragmentDocument.this.offsetInMaster + offset);
	}

	@Override
	public String[] getLegalContentTypes() {
	return this.masterPartitioner.getLegalContentTypes();
	}

	@Override
	public ITypedRegion getPartition(final int offset) {
	return remap(this.masterPartitioner.getPartition(AbstractFragmentDocument.this.offsetInMaster + offset));
	}
	}

	private class PartitionerMapper2 extends PartitionerMapper implements IDocumentPartitionerExtension2 {

	private final IDocumentPartitionerExtension2 masterPartitioner2;

	public PartitionerMapper2(final IDocumentPartitioner partitioner) {
	super(partitioner);
	this.masterPartitioner2= (IDocumentPartitionerExtension2) partitioner;
	}

	@Override
	public ITypedRegion[] computePartitioning(final int offset, final int length, final boolean includeZeroLengthPartitions) {
	return this.masterPartitioner2.computePartitioning(AbstractFragmentDocument.this.offsetInMaster + offset, length, includeZeroLengthPartitions);
	}

	@Override
	public String getContentType(final int offset, final boolean preferOpenPartitions) {
	return this.masterPartitioner2.getContentType(AbstractFragmentDocument.this.offsetInMaster + offset, preferOpenPartitions);
	}

	@Override
	public String @Nullable [] getManagingPositionCategories() {
	return this.masterPartitioner2.getManagingPositionCategories();
	}

	@Override
	public ITypedRegion getPartition(final int offset, final boolean preferOpenPartitions) {
	return this.masterPartitioner2.getPartition(AbstractFragmentDocument.this.offsetInMaster + offset, preferOpenPartitions);
	}

	}


	private final AbstractDocument master;

	private int offsetInMaster= 0;

	private byte change= NO_CHANGE;


	/**
	* The default constructor does not perform any configuration but leaves it to the clients who
	* must first initialize the implementation plug-ins and then call <code>completeInitialization</code>.
	* Results in the construction of an empty document.
	*/
	public AbstractFragmentDocument() {
	super();

	this.master= createMasterDocument();

	this.master.addDocumentListener(new IDocumentListener() {
	@Override
	public void documentAboutToBeChanged(final DocumentEvent event) {
	switch (AbstractFragmentDocument.this.change) {
	case PREFIX_CHANGE:
	AbstractFragmentDocument.this.offsetInMaster+= - event.fLength + event.fText.length();
	return;
	case FRAGMENT_CHANGE:
	return;
	default:
	throw new UnsupportedOperationException();
	}
	}
	@Override
	public void documentChanged(final DocumentEvent event) {
	}
	});
	this.master.addDocumentPartitioningListener(new IDocumentPartitioningListener() {
	@Override
	@SuppressWarnings("deprecation")
	public void documentPartitioningChanged(final IDocument document) {
	fireDocumentPartitioningChanged(new Region(0, getLength()));
	}
	});
	}


	@Override
	protected void completeInitialization() {
	super.completeInitialization();

	addDocumentListener(new IDocumentListener() {
	@Override
	public void documentAboutToBeChanged(final DocumentEvent event) {
	}
	@Override
	public void documentChanged(final DocumentEvent event) {
	if (AbstractFragmentDocument.this.change != NO_CHANGE) {
	throw new IllegalStateException(String.valueOf(AbstractFragmentDocument.this.change));
	}

	AbstractFragmentDocument.this.change= FRAGMENT_CHANGE;
	try {
	replaceInMaster(AbstractFragmentDocument.this.offsetInMaster + event.fOffset,
	event.fLength, event.fText );
	}
	catch (final BadLocationException e) {
	ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
	"Failed to edit master document.", e ));
	}
	finally {
	AbstractFragmentDocument.this.change= NO_CHANGE;
	}
	}
	});
	}


	protected abstract AbstractDocument createMasterDocument();

	@Override
	public AbstractDocument getMasterDocument() {
	return this.master;
	}

	@Override
	public int getOffsetInMasterDocument() {
	return this.offsetInMaster;
	}

	@Override
	public TextRegion getRegionInMasterDocument() {
	synchronized (getLockObject()) {
	return JFaceTextRegion.newByStartLength(this.offsetInMaster, getLength());
	}
	}

	protected void replaceInMaster(final int offset, final int length, final String text)
	throws BadLocationException {
	this.master.replace(offset, length, text);
	}


	protected void setPrefix(final String text) {
	if (text == null) {
	throw new NullPointerException();
	}
	synchronized (getLockObject()) {
	if (this.change != NO_CHANGE) {
	throw new IllegalStateException(String.valueOf(this.change));
	}

	this.change= PREFIX_CHANGE;
	try {
	replaceInMaster(0, this.offsetInMaster, text);
	this.offsetInMaster= text.length();
	}
	catch (final BadLocationException e) {
	ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
	"Failed to edit master document.", e ));
	}
	finally {
	this.change= 0;
	}
	}
	}


	@Override
	public void setInitialLineDelimiter(final String lineDelimiter) {
	this.master.setInitialLineDelimiter(lineDelimiter);
	super.setInitialLineDelimiter(lineDelimiter);
	}


	@Override
	public void setDocumentPartitioner(final @Nullable IDocumentPartitioner partitioner) {
	this.master.setDocumentPartitioner(partitioner);
	}

	@Override
	public void setDocumentPartitioner(final String partitioning, final @Nullable IDocumentPartitioner partitioner) {
	this.master.setDocumentPartitioner(partitioning, partitioner);
	}

	@Override
	public String[] getPartitionings() {
	return this.master.getPartitionings();
	}

	@Override
	public @Nullable IDocumentPartitioner getDocumentPartitioner() {
	return getDocumentPartitioner(DEFAULT_PARTITIONING);
	}

	@Override
	public @Nullable IDocumentPartitioner getDocumentPartitioner(final String partitioning) {
	final IDocumentPartitioner masterPartitioner= this.master.getDocumentPartitioner(partitioning);
	if (masterPartitioner == null) {
	return null;
	}
	if (masterPartitioner instanceof IDocumentPartitionerExtension2) {
	return new PartitionerMapper2(masterPartitioner);
	}
	else {
	return new PartitionerMapper(masterPartitioner);
	}
	}

	@Override
	public String[] getLegalContentTypes() {
	return this.master.getLegalContentTypes();
	}

	@Override
	public String[] getLegalContentTypes(final String partitioning) throws BadPartitioningException {
	return this.master.getLegalContentTypes(partitioning);
	}

	@Override
	public ITypedRegion[] computePartitioning(final int offset, final int length) throws BadLocationException {
	return remap(this.master.computePartitioning(this.offsetInMaster + offset, length));
	}

	@Override
	public ITypedRegion[] computePartitioning(final String partitioning, final int offset, final int length,
	final boolean includeZeroLengthPartitions) throws BadLocationException, BadPartitioningException {
	return remap(this.master.computePartitioning(partitioning, this.offsetInMaster + offset, length, includeZeroLengthPartitions));
	}

	@Override
	public ITypedRegion getPartition(final int offset) throws BadLocationException {
	return remap(this.master.getPartition(this.offsetInMaster + offset));
	}

	@Override
	public ITypedRegion getPartition(final String partitioning, final int offset,
	final boolean preferOpenPartitions) throws BadLocationException, BadPartitioningException {
	return remap(this.master.getPartition(partitioning, this.offsetInMaster + offset, preferOpenPartitions));
	}

	@Override
	public String getContentType(final int offset) throws BadLocationException {
	return this.master.getContentType(this.offsetInMaster + offset);
	}

	@Override
	public String getContentType(final String partitioning, final int offset,
	final boolean preferOpenPartitions) throws BadLocationException, BadPartitioningException {
	return this.master.getContentType(partitioning, this.offsetInMaster + offset, preferOpenPartitions);
	}


	private ITypedRegion[] remap(final ITypedRegion[] masterRegions) {
	final ArrayList<ITypedRegion> regions= new ArrayList<>(masterRegions.length);
	for (final ITypedRegion masterRegion : masterRegions) {
	final ITypedRegion region= remap(masterRegion);
	if (region != null) {
	regions.add(region);
	}
	}
	return regions.toArray(new @NonNull ITypedRegion[regions.size()]);
	}

	private @Nullable ITypedRegion remap(final ITypedRegion masterRegion) {
	int offset= masterRegion.getOffset() - this.offsetInMaster;
	int length= masterRegion.getLength();
	if (offset + length >= 0) {
	if (offset < 0) {
	length= length + offset;
	offset= 0;
	}
	// System.out.println("partitiong mapping: ("+masterRegion.getOffset()+", "+masterRegion.getLength()+") -["+this.offsetInMaster+"]-> ("+offset+", "+length+")");
	return new TypedRegion(offset, length, masterRegion.getType());
	}

	{ final BadPartitioningException e= new BadPartitioningException("Failed to map partition from master to fragment document.");
	e.fillInStackTrace();
	ECommonsTextCorePlugin.log(new Status(IStatus.ERROR, ECommonsTextCorePlugin.BUNDLE_ID,
	"Failed to compute partition.", e ));
	return null;
	}
	}

	}