第043回_EncodingDecl3

public class EncodingDetector
{
    //内部クラス
    private static class SupportedEncoding
    {
        private SupportedEncodingFamilies m_supportedEncodingFamilies 
                            = SupportedEncodingFamilies.getInstance();

        private FileInputStream        m_input;
        private AbstractEncodingFamily m_family;
        
        public SupportedEncoding(FileInputStream input)
        {
            m_input = input;
            m_family = null;
        }
        
        public void identifyEncodingFamily()
        {
            byte[] buf = new byte[]{0,0,0,0};
            
            try
            {
                //4byte読み取る
                m_input.read(buf);
            }
            catch (IOException e)
            {
                //何もしない
            }
            
            //サポートする文字符号化方式のファミリに一致するものを探す
            //読み込めなかった場合は 0 0 0 0 を与える
            m_family = m_supportedEncodingFamilies.match(buf);
        }
        
        public AbstractEncoding identifyEncoding()
        {
            AbstractEncoding retval = null;
        
            //リテラル探索が必要な場合
            if (m_family.needLiteralSeaching())
            {
                //第1リテラルを取得する
                byte[] literal1 = m_family.getLiteral(m_input);
                
                //第1リテラルを取得できなかった場合
                if (literal1 == null)
                {
                    //エラーを設定する
                    ErrorEncoding error = new ErrorEncoding();
                    error.setNoVersionNumLiteral();
                    retval = error;
                }
                //第1リテラルを取得できた場合
                else
                {
                    //第2リテラルを取得する
                    byte[] literal2 = m_family.getLiteral(m_input);
                    
                    //第2リテラルを取得できなかった場合
                    if (literal2 == null)
                    {
                        //未指定なのでデフォルトの文字符号化方式を
                        //ファミリから取得する
                        retval = m_family.getDefaultEncoding();
                    }
                    //第2リテラルを取得できた場合
                    else
                    {
                        //取得したリテラルでファミリ内から
                        //該当する文字符号化方式を取得する
                        retval = m_family.getEncoding(literal2);
                    }
                }
            }
            //リテラル探索が不要な場合
            else
            {
                //デフォルトの文字符号化方式を設定する
                retval = m_family.getDefaultEncoding();
            }
            
            return retval;
        }
    }

    private final String m_path;
    

    public EncodingDetector(String path)
    {
        m_path = path;
    }

    public AbstractEncoding guess()
    {
        AbstractEncoding retval = null;
        
        try
        {
            FileInputStream input = new FileInputStream(m_path);

            SupportedEncoding se = new SupportedEncoding(input);
            
            //先頭の4バイトを使って文字符号化方式のファミリ
            //(同一の先頭バイト列を持つ異なる文字符号化方式)を分類する
            se.identifyEncodingFamily();
            
            //エンコーディング宣言を使ってファミリの中から1つを選択する
            //(ファミリが現在1つの場合もチェックする)
            retval = se.identifyEncoding();
        }
        catch (FileNotFoundException e)
        {
            //エラーを設定する
            ErrorEncoding error = new ErrorEncoding();
            error.setFileNotException();
            retval = error;
        }

        return retval;
    }

}

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

    public static SupportedEncodingFamilies getInstance()
    {
        return m_instance;
    }
    
    private final UnknownEncodingFamily m_unkwnon
                  = new UnknownEncodingFamily();
    private final ArrayList<AbstractEncodingFamily>
              m_familyList = new ArrayList<AbstractEncodingFamily>();

    private SupportedEncodingFamilies()
    {
        m_familyList.add(new Utf_8WithBomFamily());
        m_familyList.add(new Utf_8WithoutBomFamily());
        m_familyList.add(new Utf_16BEWithBomFamily());
        m_familyList.add(new Utf_16LEWithBomFamily());
    }

    public AbstractEncodingFamily match(byte[] buf)
    {
        AbstractEncodingFamily retval = null;
        
        for(AbstractEncodingFamily family : m_familyList)
        {
            boolean b = family.startMatch(buf);
            
            if (b)
            {
                retval = family;
                break;
            }
            else
            {
                //何もしない
            }
        }
        
        //どれにもマッチしなかった場合
        if (retval == null)
        {
            retval = m_unkwnon; 
        }
        //いずれかにマッチした場合
        else
        {
            //何もしない
        }
        
        return retval;
    }
}