第021回_TokenManagerの実装3_コンテキスト切り替え機能

public class ParsingData
{
    //トークンバッファ
    private   StringBuilder        m_str;
    //トークンリスト
    private   LinkedList<Token>    m_list;
    //消費カウンタ
    protected Integer              m_consumedCounter;
    //字句解析器のスタック
    protected BaseStackLexer       m_stack;

    public ParsingData(StringBuilder newBuffer)
    {
        m_str             = newBuffer;
        m_list            = new LinkedList<Token>();
        m_consumedCounter = new Integer(0);
        m_stack           = new BaseStackLexer();
    }

    public StringBuilder getStringBuilder()
    {
        return  m_str;
    }
    
    public LinkedList<Token> getList()
    {
        return m_list;
    }
    
    public int getConsumeCounter()
    {
        return m_consumedCounter;
    }
    
    public void consume()
    {
        Token token = m_list.poll();
        int len = token.length();
        m_str.delete(0, len);
        m_consumedCounter++;
    }

    public BaseStackLexer getStackLexer()
    {
        return m_stack;
    }
    
    public void startSection()
    {
        clear();
    }

    public void endSection()
    {
        m_stack.pop();
        clear();
    }
    
    private void clear()
    {
        //リストが空でない場合
        if (!m_list.isEmpty())
        {
            m_tokenBuilder.clear();
            m_list.clear();
        }
    }
}

public class ParsingDataStack
{
    private static ParsingDataStack m_instance = new ParsingDataStack();

    private Stack<ParsingData>  m_data;

    private ParsingDataStack()
    {
        m_data    = new Stack<ParsingData>();
    }

    public static ParsingDataStack getInstance()
    {
        return m_instance;
    }
    
    //新しいコンテキストを作って、そこに移動する
    public void newContext(StringBuilder newBuffer)
    {
        m_data.push(new ParsingData(newBuffer));
    }

    //1つ前のコンテキストに戻る
    public void goBackPreviousContext()
    {
        m_data.pop();
    }
    
    public StringBuilder getStringBuilder()
    {
        ParsingData pd = m_data.peek();
        return pd.getStringBuilder();
    }
    
    public LinkedList<Token> getList()
    {
        ParsingData pd = m_data.peek();
        return pd.getList();
    }
    
    public int getConsumeCounter()
    {
        ParsingData pd = m_data.peek();
        return pd.getConsumeCounter();
    }
    
    public void consume()
    {
        ParsingData pd = m_data.peek();
        pd.consume();
    }

    public BaseStackLexer getStackLexer()
    {
        ParsingData pd = m_data.peek();
        return pd.getStackLexer();
    }
    
    public void startSection()
    {
        ParsingData pd = m_data.peek();
        pd.startSection();
    }

    public void endSection()
    {
        ParsingData pd = m_data.peek();
        pd.endSection();
    }
}

public class TokenManager
{
    private static final TokenManager m_instance = new TokenManager();

    //追加
    private static ParsingDataStack m_parsedData = ParsingDataStack.getInstance();

    //シングルトンパターン
    private TokenManager(){}

    public static TokenManager getInstance()
    {
        return m_instance;
    }

    //修正
    public void setDocumentToken(DocumentToken t)
    {
        //修正
        //文字列バッファに設定する
        StringBuilder str = new StringBuilder();
        str.append(t.getStr());

        //追加
        m_parsingData.init(str);
    }

    //追加
    public void setNewString(String str)
    {
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        m_parsingData.newContext(sb);
    }

    //追加
    public void finalize()
    {
        m_parsingData.goBackPreviousContext();
    }

    //修正
    public void consumeToken()
    {
        m_parsingData.consumeToken();
    }

    //修正
    public int getConsumedCount()
    {
        return m_parsingData.getConsumeCounter();
    }

    //修正
    public Token nextToken()
    {
        LinkedList<Token> list = m_parsingData.getList();
        
        //トークンリストが空の場合
        if (list.isEmpty())
        {
            //追加で解析してlistを補充する
            tokenize();
        }
        
        //トークンリストの先頭の参照を得る
        Token token = list.getFirst();

        return token;
    }

    //修正
    //追加で解析してlistを補充する
    private Token tokenize()
    {
        ConditionLexer lexer =  m_parsingData.getStackLexer().peek();
        
        StringBuilder str = m_parsingData.getStringBuilder();
        Token token = lexer.nextToken(str);

        LinkedList<Token> list = m_parsingData.getList();
        list.add(token);
        
        return token;
    }

    //修正
    //字句解析器制御メソッド
    public void notifyQuoteStart()
    {
        m_parsingData.getStackLexer().pushQuoteStart();
        m_parsingData.startSection();
    }
    public void notifyQuoteEnd()
    {
        m_parsingData.endSection();
    }
    
    public void notifyDoubleQuoteStart()
    {
        m_parsingData.getStackLexer().pushDoubleQuoteStart();
        m_parsingData.startSection();
    }
    public void notifyDoubleQuoteEnd()
    {
        m_parsingData.endSection();
    }

    public void notifyAttValueQuoteSectionStart()
    {
        m_parsingData.getStackLexer().pushAttValueQuoteSection();
        m_parsingData.startSection();
    }
    public void notifyAttValueQuoteSectionEnd()
    {
        m_parsingData.endSection();
    }
    
    public void notifyAttValueDoubleQuoteSectionStart()
    {
        m_parsingData.getStackLexer().pushAttValueDoubleQuoteSection();
        m_parsingData.startSection();
    }
    public void notifyAttValueDoubleQuoteSectionEnd()
    {
        m_parsingData.endSection();
    }

    public void notifyEntityValueQuoteSectionStart()
    {
        m_parsingData.getStackLexer().pushGeEntityValueQuoteSection();
        m_parsingData.startSection();
    }
    public void notifyEntityValueQuoteSectionEnd()
    {
        m_parsingData.endSection();
    }
    
    public void notifyEntityValueDoubleQuoteSectionStart()
    {
        m_parsingData.getStackLexer().pushGeEntityValueDoubleQuoteSection();
        m_parsingData.startSection();
    }
    public void notifyEntityValueDoubleQuoteSectionEnd()
    {
        m_parsingData.endSection();
    }

    public void notifyNormalSectionStart()
    {
        m_parsingData.getStackLexer().pushNormal();
        m_parsingData.startSection();
    }
    public void notifyNormalSectionEnd()
    {
        m_parsingData.endSection();
    }
    
    public void notifyCDataStart()      
    {
        m_parsingData.getStackLexer().pushCData();
        m_parsingData.startSection();
    }
    public void notifyCDataEnd()
    {
        m_parsingData.endSection();
    }

    public void notifyCharDataStart()
    {
        m_parsingData.getStackLexer().pushCharData();
        m_parsingData.startSection();
    }
    public void notifyCharDataEnd()
    {
        m_parsingData.endSection();
    }
    public void notifyIgnoreWordStart()
    {
        m_parsingData.getStackLexer().pushIgnore();
        m_parsingData.startSection();
    }
    public void notifyIgnoreWordEnd()
    {
        m_parsingData.endSection();
    }
    public void notifyPIWordStart()
    {
        m_parsingData.getStackLexer().pushPI();
        m_parsingData.startSection();
    }
    public void notifyPIWordEnd()
    {
        m_parsingData.endSection();
    }
}