@NotNull
@Override
public LexerPosition getCurrentPosition() {
    final int start = getTokenStart();
    final int state = getState();

    return new LexerPosition() {
        @Override
        public int getOffset() {
            return start;
        }

        @Override
        public int getState() {
            return state;
        }
    };
}
 

@Override
public void restore(@NotNull final LexerPosition position) {
    final int prefixLength = prefix.length();

    final int newOffset = position.getOffset() - prefixLength;
    if (newOffset == 0) {
        this.afterPrefix = false;
    }

    if (newOffset < myDelegate.getBufferEnd()) {
        this.delegateEOF = false;
        this.afterEOF = false;
    }

    myDelegate.restore(new LexerPosition() {
        @Override
        public int getOffset() {
            return newOffset;
        }

        @Override
        public int getState() {
            return position.getState();
        }
    });
}
 

public void load(@Nonnull final com.igormaznitsa.mindmap.model.parser.MindMapLexer.LexerPosition position) {
  if (this.pos == null) {
    this.pos = position.makeCopy();
  } else {
    this.pos.set(position);
  }
}
 

@Override
public void restore(LexerPosition position) {
  final Position p = (Position)position;
  myBaseLexer.restore(p.getBasePosition());
  final LexerPosition templatePos = p.getTemplatePosition();
  if (templatePos != null && templatePos.getOffset() < myTemplateLexer.getBufferEnd()) {
    myTemplateLexer.restore(templatePos);
  }
  else {
    setupTemplateToken();
  }
}
 

@Nonnull
@Override
public LexerPosition getCurrentPosition() {
  this.pos.load(this.delegate.getCurrentPosition());
  return this.pos;
}
 

@Override
public void restore(@Nonnull LexerPosition position) {
  this.pos.save(this.delegate.getCurrentPosition());
}
 

public void save(@Nonnull final com.igormaznitsa.mindmap.model.parser.MindMapLexer.LexerPosition position) {
  position.set(this.pos);
}
 

@NotNull
@Override
public synchronized LexerPosition getCurrentPosition() {
    return super.getCurrentPosition();
}
 

@Override
public synchronized void restore(@NotNull LexerPosition position) {
    super.restore(position);
}
 

@Override
public IElementType merge(final IElementType mergeToken, final Lexer originalLexer)
{
	if(!ourMergeSet.contains(mergeToken))
	{
		return mergeToken;
	}

	while(true)
	{
		IElementType currentToken = originalLexer.getTokenType();
		if(currentToken == null)
		{
			break;
		}

		// we need merge two docs if one line between
		if(mergeToken == CSharpTokensImpl.LINE_DOC_COMMENT && currentToken == CSharpTokens.WHITE_SPACE)
		{
			LexerPosition currentPosition = originalLexer.getCurrentPosition();
			originalLexer.advance();
			boolean docIsNext = originalLexer.getTokenType() == CSharpTokensImpl.LINE_DOC_COMMENT;
			originalLexer.restore(currentPosition);
			if(docIsNext)
			{
				currentToken = CSharpTokensImpl.LINE_DOC_COMMENT;
			}
			else
			{
				break;
			}
		}

		if(currentToken != mergeToken)
		{
			break;
		}

		originalLexer.advance();
	}
	return mergeToken;
}
 

public Position(LexerPosition templatePosition, LexerPosition jspPosition) {
  myTemplatePosition = templatePosition;
  myBasePosition = jspPosition;
}
 

public LexerPosition getTemplatePosition() {
  return myTemplatePosition;
}
 

public LexerPosition getBasePosition() {
  return myBasePosition;
}
 

@Override
public LexerPosition getCurrentPosition() {
  return new Position(myTemplateLexer.getCurrentPosition(), myBaseLexer.getCurrentPosition());
}