Eclipse plugins 插件开发学习 - IScanner 和 IBuffer 封装的高级应用类

由于 IScanner 和 IBuffer 修改源码比较麻烦，功能也不是很强大，需要编写大量的代码。

所以这里谢了一个辅助类，来改善代码。

package  com.humpic.plugins.helper.utils;

import  java.util.ArrayList;
import  java.util.List;
import  org.apache.commons.lang.StringUtils;
import  org.eclipse.jdt.core. * ;
import  org.eclipse.jdt.core.compiler.IScanner;
import  org.eclipse.jdt.core.compiler.InvalidInputException;

public   class  ObjectScanBuffer {
     private  Offset offset  =   new  Offset();
     private  IBuffer buffer;
     private  IScanner scanner;

     public  ObjectScanBuffer(IType objectClass) {
         try  {
            ICompilationUnit cu  =  objectClass.getCompilationUnit();
             this .buffer  =  cu.getBuffer();
             this .scanner  =  ToolFactory.createScanner( false ,  false ,  false ,  false );
             this .scanner.setSource( this .buffer.getCharacters());
             //  不扫描 package 和 import 部分
            ISourceRange sr  =  objectClass.getSourceRange();
             this .scanner.resetTo(sr.getOffset(), sr.getOffset()  +  sr.getLength()  -   1 );
        }  catch  (JavaModelException e) {
             throw   new  RuntimeException(e);
        }
    }

     /**
     * 返回下一个 Token
      */
     public   int  getNextToken()  throws  InvalidInputException {
         return   this .scanner.getNextToken();
    }

     /**
     * 查找 Token
     * 
     *  @param  reset
     *            为 true，那么如果没有找到，则会重置 scan 位置
      */
     public   boolean  findToken( int  token,  boolean  reset)  throws  InvalidInputException {
         int [] savepoint  =   this .savePoint();
         int  t  =   this .scanner.getNextToken();
         while  (t  !=  token) {
             if  (t  <=   0 )
                 break ;
            t  =   this .scanner.getNextToken();
        }
         if  (t  !=  token  &&  reset) {
             this .resetPoint(savepoint);
        }
         return  t  ==  token;
    }

     /**
     * 查找 Token， 如果碰到 stopToken，则停止.
     * 
     *  @param  reset
     *            为 true，那么如果没有找到，则会重置 scan 位置
      */
     public   boolean  findToken( int  token,  int  stopToken,  boolean  reset)  throws  InvalidInputException {
         int [] savepoint  =   this .savePoint();
         int  t  =   this .scanner.getNextToken();
         while  (t  !=  token) {
             if  (t  <=   0 )
                 break ;
             if  (t  ==  stopToken)
                 break ;
            t  =   this .scanner.getNextToken();
        }
         if  (t  !=  token  &&  reset) {
             this .resetPoint(savepoint);
        }
         return  t  ==  token;
    }

     /**
     * 查找从 startToken 到 endToken 中间的所有 Tokens
     * 
     *  @param  reset
     *            为 true，那么如果没有找到，则会重置 scan 位置 (如果 startToken 找到，重置到 startToken)
     *  @return  new Object[] { new Integer(token), tokenText }
      */
     public  List findTokensBetween( int  startToken,  int  endToken,  boolean  reset)  throws  InvalidInputException {
        List tokens  =   new  ArrayList();
         if  ( this .findToken(startToken, reset)) {
             int [] savepoint  =   this .savePoint();

             int  t  =   this .scanner.getNextToken();
             while  (t  !=  endToken) {
                 if  (t  <=   0 )
                     break ;
                tokens.add( new  Object[] {  new  Integer(t),  this .getTokenText() });
                t  =   this .scanner.getNextToken();
            }
             if  (t  !=  endToken) {
                tokens.clear();
                 if  (reset) {
                     this .resetPoint(savepoint);
                }
            }
        }
         return  tokens;
    }

     /**
     * 在 findTokensBetween 返回中查找 是否存在 token
      */
     public   boolean  existToken(List tokens,  int  token) {
         for  ( int  i  =   0 ; i  <  tokens.size(); i ++ ) {
            Object[] t  =  (Object[]) tokens.get(i);
             if  (((Integer) t[ 0 ]).intValue()  ==  token) {
                 return   true ;
            }
        }
         return   false ;
    }

     /**
     * 在 findTokensBetween 返回中查找 是否存在 tokenText
      */
     public   boolean  existToken(List tokens, String tokenText) {
         for  ( int  i  =   0 ; i  <  tokens.size(); i ++ ) {
            Object[] t  =  (Object[]) tokens.get(i);
             if  (StringUtils.equals((String) t[ 1 ], tokenText)) {
                 return   true ;
            }
        }
         return   false ;
    }

     /**
     * 返回当前的 Token 文本内容
      */
     public  String getTokenText() {
         return   new  String( this .scanner.getCurrentTokenSource());
    }

     /**
     * 返回下一个 Token 文本内容
      */
     public  String getNextTokenText()  throws  InvalidInputException {
         this .scanner.getNextToken();
         return   this .getTokenText();
    }

     /**
     * 当前 Token 前面是否存在 空格，或者回车符
      */
     public   boolean  skipSpaces() {
         int  pos  =   this .offset.getNewPos( this .scanner.getCurrentTokenStartPosition()  -   1 );
         if  (pos  <   0 )
             throw   new  RuntimeException( " 该Token所在的位置已经被删除或者修改过了 " );
        String s  =   this .buffer.getText(pos,  1 );
         char  c  =  (s.length()  ==   1   ?  s.charAt( 0 ) :  ' /0' );
         return  c  ==   '   '   ||  c  ==   ' '   ||  c  ==   ' ' ;
    }

     /**
     * 用 text 替换 当前的 Token
      */
     public   void  replaceText(String text) {
         int  pos  =   this .offset.getNewPos( this .scanner.getCurrentTokenStartPosition());
         if  (pos  <   0 )
             throw   new  RuntimeException( " 该Token所在的位置已经被删除或者修改过了 " );
         int  size  =   this .scanner.getCurrentTokenEndPosition()  -   this .scanner.getCurrentTokenStartPosition()  +   1 ;
         this .buffer.replace(pos, size, text);
         this .offset.addChange(pos,  0   -  size);
         this .offset.addChange(pos, text.length());
    }

     /**
     * 在当前 token 位置添加文本
      */
     public   void  appendText(String text) {
         this .appendText(text,  0 );
    }

     /**
     * 在距离当前 token 位置Offset距离的地方添加文本（offset可以为负数）
      */
     public   void  appendText(String text,  int  offset) {
         int  pos  =   this .offset.getNewPos( this .scanner.getCurrentTokenStartPosition()  +  offset);
         if  (pos  <   0 )
             throw   new  RuntimeException( " 该Token所在的位置已经被删除或者修改过了 " );
         int  size  =   0 ;
         this .buffer.replace(pos, size, text);
         this .offset.addChange(pos,  0   -  size);
         this .offset.addChange(pos, text.length());
    }

     /**
     * 保存当前位置
      */
     public   int [] savePoint() {
         return   new   int [] {  this .scanner.getCurrentTokenStartPosition(),  this .scanner.getCurrentTokenEndPosition() };
    }

     /**
     * 恢复到保存的位置
      */
     public   void  resetPoint( int [] savepoint) {
         this .scanner.resetTo(savepoint[ 0 ], savepoint[ 1 ]);
    }

     /**
     * 有2个相同的字符串Buffer，对一个Buffer进行Scan，然后在另外一个Buffer进行修改。
     * 这个类就是将用来Scan的原始Buffer的原始位置，映射到新的被修改过的字符串位置
      */
     private   static   class  Offset {
         private  List changes  =   new  ArrayList();

         //  在新的位置修改(newsize < 0 代表删除)
         protected   void  addChange( int  newpos,  int  newsize) {
             if  (newsize  ==   0 )
                 return ;
             this .changes.add( new   int [] { newpos, newsize });
            System.out.println( " changes:  "   +  newpos  +   "   "   +  newsize);
        }

         //  从老位置计算新位置 (返回 -1 代表已经被删除)
         protected   int  getNewPos( int  oldpos) {
             int  newpos  =  oldpos;
             for  ( int  i  =   0 ; i  <   this .changes.size(); i ++ ) {
                 int [] pos  =  ( int [])  this .changes.get(i);
                 if  (newpos  >=  pos[ 0 ]) {
                     if  (pos[ 1 ]  <   0 ) {
                         if  (newpos  +  pos[ 1 ]  <  pos[ 0 ]) {
                             return   - 1 ; //  return pos[0]; ???  //  已经被删除
                        }
                    }
                    newpos  +=  pos[ 1 ];
                }
            }
            System.out.println( " pos:  "   +  oldpos  +   "  =>  "   +  newpos);
             return  newpos;
        }
    }

     public   static   void  main(String[] args) {
        String s1  =   " 0123456789012345678901234567890123456789012345678901234567890123456789 " ;
         //  "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String s2  =  s1;

        Offset offset  =   new  Offset();
        s2  =  testReplaceText(offset, s2,  4 ,  5 ,  " @@@ " );
        s2  =  testAppendText(offset, s2,  10 ,  " %%%%%% " );
        s2  =  testReplaceText(offset, s2,  14 ,  0 ,  " $$ " );
        s2  =  testAppendText(offset, s2,  32 ,  " ###### " );
        s2  =  testReplaceText(offset, s2,  44 ,  3 ,  " ******** " );
        s2  =  testReplaceText(offset, s2,  24 ,  5 ,  " @@@ " );
        System.out.println(s2);
        System.out.println("result = " + (s2.equals("0123@@@9%%%%%%0123$$4567890123@@@901######234567890123********78901234567890123456789")));
    }

     private   static  String testReplaceText(Offset offset, String s,  int  start,  int  size, String text) {
         int  pos  =  offset.getNewPos(start);
        offset.addChange(pos,  0   -  size);
        offset.addChange(pos, text.length());
         return  StringUtils.left(s, pos)  +  text  +  StringUtils.right(s, s.length()  -  pos  -  size);
    }

     private   static  String testAppendText(Offset offset, String s,  int  start, String text) {
         int  pos  =  offset.getNewPos(start);
        offset.addChange(pos, text.length());
         return  StringUtils.left(s, pos)  +  text  +  StringUtils.right(s, s.length()  -  pos);
    }
}

 

接下来，我们看一下具体的应用：

描述： 判断一个类是否已经实现 Java.io.Serializable， 如果没有实现，那么加入实现代码

     public   void  generate(Shell parentShell, IType objectClass) {

        System.out.println( " AddSerializableGenerator " );

        IField existingFields  =  objectClass.getField( " serialVersionUID " );

         try  {
             //  import
            ICompilationUnit cu  =  objectClass.getCompilationUnit();
            cu.createImport( " java.io.Serializable " ,  null ,  null );

             //  field
             if  ( ! existingFields.exists()) {
                IJavaElement insertPosition  =   null ;
                 if  (objectClass.getMethods().length  >   0 )
                    insertPosition  =  objectClass.getMethods()[ 0 ];
                 if  (objectClass.getFields().length  >   0 )
                    insertPosition  =  objectClass.getFields()[ 0 ];

                String formattedContent  =   " private static final long serialVersionUID =  "   +  RandomStringUtils.randomNumeric( 19 )  +   " L; " ;
                objectClass.createField(formattedContent, insertPosition,  true ,  null );
            }

             //  implements
             if  (cu.isWorkingCopy()) {
                ObjectScanBuffer sb  =  new  ObjectScanBuffer(objectClass);
                List tokens = sb.findTokensBetween(ITerminalSymbols.TokenNameclass, ITerminalSymbols.TokenNameLBRACE,  false );
                 if  (sb.existToken(tokens, "Serializable")) {
                    System.out.println("Serializable interface has been implements");
                     return ;
                }
                 if  (sb.existToken(tokens, ITerminalSymbols.TokenNameimplements)) {
                    sb.appendText(", Serializable ");
                }  else  {
                     if  (!sb.skipSpaces())
                        sb.appendText(" ");
                    sb.appendText("implements Serializable " );
                }
            }
        }  catch  (Exception e) {
            MessageDialog.openError(parentShell, "Generation Failed " , e.getMessage());
        }
    }