コード例 #1
0
  @ServiceMethod(callByContent = true, target = ServiceMethodContext.TARGET_STICK)
  public CodeAssist requestAssist() {
    System.out.println("requestAssist");

    CodeAssist codeAssist = new JavaCodeAssist();
    codeAssist.setSrcCodeObjectId(getClientObjectId());

    String command = getLineAssistRequested();
    String options = "";

    boolean isImport = false;
    boolean isAnnotation = false;

    String endChar = "";

    // get options
    if (command.startsWith("-")) {
      int pos = command.indexOf(' ');
      if (pos != -1) {
        options = command.substring(1, pos);
      }
    }
    System.out.println(command);

    // get import
    if (command.startsWith("import ")) {
      isImport = true;
      endChar = ".*";

      command = command.substring(7).trim();
    } else if (command.startsWith("@")) {
      isAnnotation = true;

      command = command.substring(1).trim();
    }
    System.out.println(command);

    ArrayList<String> pkgNames = new ArrayList<String>();
    ArrayList<String> clsNames = new ArrayList<String>();

    if (annotationNames.size() == 0) cacheAnnotationNames();
    if (packageNames.size() == 0) cacheLibrary();

    // step 1 : isAnnotation, check options
    if (isAnnotation) {

      String expression = command.toLowerCase();

      for (int i = 0; i < annotationNames.size(); ++i) {
        if (expression.length() == 0 || annotationNames.get(i).toLowerCase().startsWith(expression))
          codeAssist.getAssistances().add(annotationNames.get(i));
      }

    } else if (options.isEmpty()) {

      // step 2 : check endsWith(".")
      if (command.endsWith(".")) {
        String expression = command.substring(0, command.length() - 1);

        System.out.println("expression : " + expression);
        System.out.println("isImport : " + isImport);

        // step 3 : check import
        if (isImport) {
          ArrayList<String> packages = findPackage(command, endChar);
          for (int i = 0; i < packages.size(); i++) pkgNames.add(packages.get(i));

          ArrayList<String> classes = findPackageClass(expression);
          for (int i = 0; i < classes.size(); i++) clsNames.add(classes.get(i));

        } else {
          // step 3-1 : this
          if ("this".equals(expression)) {
            ArrayList<String> thisClassInfo = findThisClass();
            for (int i = 0; i < thisClassInfo.size(); i++) clsNames.add(thisClassInfo.get(i));
          } else {

            String classDefine = findClassDefine(expression);
            System.out.println("findClassDefine : " + classDefine);

            if (classDefine != null) {
              ArrayList<String> classInfo = findClass(classDefine);
              for (int i = 0; i < classInfo.size(); i++) clsNames.add(classInfo.get(i));
            } else {
              ArrayList<String> packageClasses = findPackageClass(expression);
              for (int i = 0; i < packageClasses.size(); i++) clsNames.add(packageClasses.get(i));

              ArrayList<String> classes = findClasses(expression);
              for (int i = 0; i < classes.size(); i++) clsNames.add(classes.get(i));

              ArrayList<String> packages = findPackage(expression, endChar);
              for (int i = 0; i < packages.size(); i++) pkgNames.add(packages.get(i));
            }
          }
        }
      } else {
        if (command.isEmpty()) {
          ArrayList<String> thisClassInfo = findThisClass();
          for (int i = 0; i < thisClassInfo.size(); i++) clsNames.add(thisClassInfo.get(i));
        } else {
          String expression = command.toLowerCase();

          ArrayList<String> packages = findPackageStartWith(expression);
          for (int i = 0; i < packages.size(); i++) pkgNames.add(packages.get(i));

          ArrayList<String> classes = findClassesStartWith(expression);
          for (int i = 0; i < classes.size(); i++) clsNames.add(classes.get(i));
        }
      }
    }

    Collections.sort(clsNames);
    Collections.sort(pkgNames);

    // make assistances class
    for (int i = 0; i < clsNames.size(); i++) {
      codeAssist.getAssistances().add(clsNames.get(i));
    }

    // make assistances package
    for (int i = 0; i < pkgNames.size(); i++) codeAssist.getAssistances().add(pkgNames.get(i));

    /*
    CodeAssist codeAssist = new JavaCodeAssist();
    codeAssist.getMetaworksContext().setHow("normal");
    codeAssist.setSrcCodeObjectId(getClientObjectId());


    CodiClassLoader ccl = ((CodiClassLoader)Thread.currentThread().getContextClassLoader());
    Set<Kind> kinds = new HashSet<Kind>();
    kinds.add(Kind.CLASS);
    kinds.add(Kind.SOURCE);

    String command = getLineAssistRequested();

    String expression = command.toLowerCase();
    String options = "";

    boolean annotationMode = false;
    boolean importMode = false;

    System.out.println("command : " + command);
    // get options
    if(command.startsWith("-")) {
    	int pos = command.indexOf(' ');
    	if( pos != -1){
    		options = command.substring(1, pos);
    	}

    	command = command.substring(pos + 1).trim();
    	expression = command.toLowerCase();
    }
    System.out.println("options : " + options);


    // mode confirm
    if(expression.startsWith("import")){
    	importMode = true;

    	expression = expression.substring("import".length()).trim();

    	//codeAssist.getMetaworksContext().setHow("import");
    }else if(expression.startsWith("@")){
    	annotationMode = true;

    	expression = expression.substring("@".length()).trim();
    }
    System.out.println("expression : " + expression);

    if(annotationMode){
    	// make annotation cache
    	//if(annotationNames != null && annotationNames.size() == 0)
    		cacheAnnotationNames();

    	for(int i = 0; i < annotationNames.size(); ++i) {
    		if(expression.length() == 0 || annotationNames.get(i).toLowerCase().startsWith(expression))
    			codeAssist.getAssistances().add(annotationNames.get(i));
    	}
    }else{
    	// expression is empty
    	if(expression.length() == 0){
    		return codeAssist;
    	}

    	ArrayList<String> pkgNames = new ArrayList<String>();
    	ArrayList<String> clsNames = new ArrayList<String>();

    	String expressionValue = expression;

    	if(expression.endsWith(".")){
    		expressionValue = expressionValue.substring(0, expressionValue.length()-1);
    	}

    	// make package cache
    	if(packageNames != null)
    		cacheLibrary();

    	System.out.println("packageNames.size : " + packageNames.size());
    	System.out.println("classNames.size : " + classNames.size());

    	if("oi".equals(options) == false){
       		for(String packageName : packageNames.keySet()){
       			if(packageName.startsWith(expression))
       				pkgNames.add(packageName);
    		}
       		Collections.sort(pkgNames);
       		System.out.println("pkgNames.size : " + pkgNames.size());

       		// find class in package
       		if(packageNames.containsKey(expressionValue)){
       			Map<String, String> result = packageNames.get(expressionValue);

       			for(String clsName : result.keySet())   {
       				boolean annotation = false;

       				if(result.get(clsName).isEmpty()){
       					if(confirmAnnotation(clsName))
       						result.put(clsName, "annotation");
       					else
       						result.put(clsName, "class");
       				}

       				clsNames.add(clsName + "," + expressionValue + "," + result.get(clsName)) ;
       			}
       		}
       		System.out.println("clsNames.size 1: " + clsNames.size());

       		try {
           		Iterable<JavaFileObject> javaObjects;

       			FileInputJavaFileManager fileManager = (FileInputJavaFileManager) ccl.getJavaFileManager();

       			javaObjects = fileManager.list(StandardLocation.SOURCE_PATH, expression, kinds, true);
       			for(JavaFileObject javaObject : javaObjects){
       				String clsName = fileManager.getBinaryName(javaObject);

       				if(clsName.startsWith(expression)){
       					clsName = clsName.substring(expression.length() + 1, clsName.length());
       				}

       				System.out.println("clsName : " + clsName);
       				//codeAssist.getAssistances().add(clsName);
       			}
       		}catch(Exception ex) {}

       		if(classModeler != null){
    			if("this".equals(expression) || expression.trim().length()==0 || expression.endsWith("fields")){
    				ArrayList<ClassField> classFields = classModeler.getClassFields();
    				if(classFields!=null) {
    					for (ClassField field : classFields) {
    						//codeAssist.getAssistances().add(field.getId());
    						System.out.println("field.getId() : " +field.getId());
    					}
    				}
    			}

    			if("this".equals(expression) || expression.trim().length()==0 || expression.endsWith("methods")){
    				ArrayList<ClassMethod> classMethods = classModeler.getClassMethods();
    				if(classMethods!=null) {
    					for (ClassMethod classMethod : classMethods) {
    						//codeAssist.getAssistances().add(classMethod.getMethodName());
    						System.out.println("classMethod.getMethodName() : " +classMethod.getMethodName());
    					}
    				}
    			}
       		}
    	}


      		// find class
    	if(!command.endsWith(".")){


       		for(int i=0; i<classNames.size(); i++){
       			boolean isAddClass = false;
       			String clsName = classNames.get(i);

       			if("oi".equals(options)){
           			if(clsName.startsWith(command + ",")){
           				isAddClass = true;
           			}

       			}else{
           			if(clsName.toLowerCase().startsWith(expression)){
           				isAddClass = true;
           			}
       			}

       			if(isAddClass){
       				if(clsName.indexOf(",,") == -1){
       					String confirmClsName = clsName;

       					int pos = clsName.indexOf(",");
       					if(pos != -1)
       						confirmClsName = clsName.substring(pos, clsName.length()) + "." + clsName.substring(0, pos - 1);


       					if(confirmAnnotation(confirmClsName))
       						clsName = clsName + ",annotation,,";
       					else
       						clsName = clsName + ",class,,";
       					classNames.set(i, clsName);
       				}

       				clsNames.add(clsName);
       			}

       		}
    	}

      		// sort class
      		Collections.sort(clsNames);
      		System.out.println("clsNames.size 2: " + clsNames.size());


      		// make assistances class
      		for(int i=0; i<clsNames.size(); i++){
      			codeAssist.getAssistances().add(clsNames.get(i));
      		}

      		// make assistances package
      		for(int i=0; i<pkgNames.size(); i++)
      			codeAssist.getAssistances().add(pkgNames.get(i));

      		System.out.println("complete");
    }
     */

    /*
    if(expression.length() > 0){

    	String typeName = null;
    	String fullTypeName = null;
    	String[] lines = getCode().split("\n");

    	int defineRow = -1;
    	boolean checkImport = false;

    	//if(getCursorPosition().getRow() > 0)
    	if(lines.length > 0) {
    		//for(int i = getCursorPosition().getRow(); i >= 0 && fullTypeName==null; i--){
    		for(int i = lines.length-1; i >= 0 && fullTypeName==null; i--){
    			String line = lines[i];
    			int whereExp = defineRow = line.indexOf(" " + expression);
    			System.out.println("whereExp = " + whereExp);
    			if(typeName == null){ //if typeName is not set, find the expression's type first.
    				if(!line.trim().startsWith(expression) && whereExp > 0){
    					line = line.substring(0, whereExp).trim();
    					int j=line.length()-1;
    					for(; j>=0; j--){
    						char charAt = line.charAt(j);
    						if(!((charAt > 'A' && charAt <'z') || (charAt > '1' && charAt <'9') || charAt == '.'))
    							break;
    					}
    					if(j < 0) j = 0;
    					typeName = line.substring(j).trim();

    					if(typeName.equals("import")) {
    						if(packageNames != null && !packageNames.containsKey(expression)) cachePackageNames(codeAssist, expression);

    						Map<String, HashMap> packagesNamePerPrefix = packageNames.get(expression);
    			    		for(String packageName : packagesNamePerPrefix.keySet()){
    			    			codeAssist.getAssistances().add(packageName);
    						}
    			    		return codeAssist;
    					}

    					if(typeName.equals("return"))
    						typeName = null; //ignores 'return' is recognized as typeName
    					if(typeName!=null && typeName.equals("="))
    						typeName = null; //ignores '=' is recognized as typeName
    					//if(typeName!=null && typeName.startsWith("."))
    					//	typeName = typeName.substring(1);
    					if(typeName!=null && typeName.indexOf('.') > -1){
    						fullTypeName = typeName;
    					}
    				}
    			} else if(typeName.equals("import")) {
    				if(packageNames != null && !packageNames.containsKey(expression)) cachePackageNames(codeAssist, expression);

    				Map<String, HashMap> packagesNamePerPrefix = packageNames.get(expression);
    	    		for(String packageName : packagesNamePerPrefix.keySet()){
    	    			codeAssist.getAssistances().add(packageName);
    				}
    	    		return codeAssist;

    			} else { //if typeName found, search the import statement.
    				line = line.trim();
    				System.out.println("line = " + line);
    				System.out.println("typeName = " + typeName);

    				if((line.startsWith("import ") && line.endsWith(".*;")) || (line.startsWith("import ") && line.endsWith("." + typeName + ";"))) {
    					if(line.endsWith(".*;")) {
    						String searchClass = line.substring(line.indexOf(' '), line.length()-2).trim() + typeName;
    						try {
    							Thread.currentThread().getContextClassLoader().loadClass(searchClass);
    							fullTypeName = searchClass;
    							checkImport = true;
    						}catch(Exception ex) {}
    					}
    					else {
    						fullTypeName = line.substring(line.indexOf(' '), line.length()-1).trim();
    						checkImport = true;
    					}
    				}
    			}
    		}

    		//import 기능 수행
    		if((fullTypeName == null || fullTypeName.length() == 0) && !checkImport) {
    			System.out.println(typeName);

    			if(importNames != null && !importNames.containsKey(typeName)) cacheImportNames(typeName);

    			ArrayList<String> preImport = importNames.get(typeName);
        		for(int j = 0; j < preImport.size(); ++j){
        			codeAssist.getAssistances().add(preImport.get(j));
    			}

    			return codeAssist;
    		}

    		if(typeName != null) {
    			try{
    				String javaLangExp = "java.lang." + typeName;
    				Class.forName(javaLangExp);
    				fullTypeName = javaLangExp;
    			}catch(Exception e){

    			}
    		}

    		//TODO:
    		//if there should be use of asterisk in the import statement. etc. import com.abc.*,
    		// we need to try to append the typeName where the asterisk and load the class, if the class successfully loaded,
    		// we can get the class is right one. (sometimes, ambiguity issue can be arise)

    		System.out.println("fullTypeName = " + fullTypeName);

    		if(fullTypeName != null) {
    			try{
    				Class theClass = Thread.currentThread().getContextClassLoader().loadClass(fullTypeName);
    				for(Field field : theClass.getFields()) {
    					codeAssist.getAssistances().add(field.getName());
    				}

    				for(Method method : theClass.getMethods()) {
    					StringBuffer paramStmt = new StringBuffer("(");
    					int index = 0;
    					String sep = "";
    					for(Class paramCls : method.getParameterTypes()){
    						String clsNameOnly = UEngineUtil.getClassNameOnly(paramCls);
    						clsNameOnly = sep + clsNameOnly.substring(0, 1).toLowerCase() + clsNameOnly.substring(1, clsNameOnly.length());
    						paramStmt.append(clsNameOnly);
    						sep = ", ";
    					}
    					paramStmt.append(")");
    					codeAssist.getAssistances().add(method.getName() + paramStmt);

    				}
    				return codeAssist;
    			}catch(Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}


    	try {
       		Iterable<JavaFileObject> javaObjects;

    		FileInputJavaFileManager fileManager = (FileInputJavaFileManager) ccl.getJavaFileManager();

    		javaObjects = fileManager.list(StandardLocation.SOURCE_PATH, expression, kinds, true);
    		for(JavaFileObject javaObject : javaObjects){
    			String clsName = fileManager.getBinaryName(javaObject);

    			if(clsName.startsWith(expression)){
    				clsName = clsName.substring(expression.length() + 1, clsName.length());
    			}

    			codeAssist.getAssistances().add(clsName);
    		}
      		}catch(Exception ex) {}

    	if("this".equals(expression) || expression.trim().length()==0 || expression.endsWith("fields")){
    		ArrayList<ClassField> classFields = classModeler.getClassFields();
    		if(classFields!=null) {
    			for (ClassField field : classFields) {
    				codeAssist.getAssistances().add(field.getId());
    			}
    		}
    	}

    	if("this".equals(expression) || expression.trim().length()==0 || expression.endsWith("methods")){
    		ArrayList<ClassMethod> classMethods = classModeler.getClassMethods();
    		if(classMethods!=null) {
    			for (ClassMethod classMethod : classMethods) {
    				codeAssist.getAssistances().add(classMethod.getMethodName());
    			}
    		}
    	}

    }
     */

    return codeAssist;
  }