ClassDefAdapterFromTokens.java

/* 
 * Copyright (C) 2006, 2007  Dennis Hunziker, Ueli Kistler
 * Copyright (C) 2007  Reto Schuettel, Robin Stocker
 *
 * IFS Institute for Software, HSR Rapperswil, Switzerland
 * 
 */

package org.python.pydev.refactoring.ast.adapters;

import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import org.python.pydev.core.IToken;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.SpecialStr;
import org.python.pydev.parser.jython.ast.ClassDef;
import org.python.pydev.parser.jython.ast.FunctionDef;
import org.python.pydev.parser.jython.ast.Name;
import org.python.pydev.parser.jython.ast.NameTok;
import org.python.pydev.parser.jython.ast.argumentsType;
import org.python.pydev.parser.jython.ast.exprType;
import org.python.pydev.parser.jython.ast.factory.AdapterPrefs;

public class ClassDefAdapterFromTokens implements IClassDefAdapter {

    private List<IToken> tokens;
    private String parentName;
    private AdapterPrefs adapterPrefs;
    private ModuleAdapter module;
    private List<FunctionDefAdapter> cache;

    public ClassDefAdapterFromTokens(ModuleAdapter module, String parentName, List<IToken> tokens,
            AdapterPrefs adapterPrefs) {
        this.module = module;
        this.parentName = parentName;
        this.tokens = tokens;
        this.adapterPrefs = adapterPrefs;
    }

    public List<SimpleAdapter> getAssignedVariables() {
        throw new RuntimeException("Not implemented");
    }

    public List<SimpleAdapter> getAttributes() {
        throw new RuntimeException("Not implemented");
    }

    public List<String> getBaseClassNames() {
        return new ArrayList<String>();
    }

    public List<IClassDefAdapter> getBaseClasses() {
        return new ArrayList<IClassDefAdapter>();
    }

    public FunctionDefAdapter getFirstInit() {
        return null;
    }

    public List<FunctionDefAdapter> getFunctions() {
        return getFunctionsInitFiltered();
    }

    public synchronized List<FunctionDefAdapter> getFunctionsInitFiltered() {
        if (cache == null) {
            cache = new ArrayList<FunctionDefAdapter>();
            for (IToken tok : this.tokens) {
                if (tok.getType() == IToken.TYPE_FUNCTION || tok.getType() == IToken.TYPE_BUILTIN
                        || tok.getType() == IToken.TYPE_UNKNOWN) {
                    String args = tok.getArgs();

                    List<exprType> arguments = new ArrayList<exprType>();
                    boolean useAnyArgs = false;
                    if (args.length() > 0) {
                        StringTokenizer strTok = new StringTokenizer(args, "( ,)");
                        if (!strTok.hasMoreTokens()) {
                            useAnyArgs = true;
                        } else {
                            while (strTok.hasMoreTokens()) {
                                String nextArg = strTok.nextToken();
                                arguments.add(new Name(nextArg, Name.Load, false));
                            }
                        }
                    } else {
                        useAnyArgs = true;
                    }

                    argumentsType functionArguments = new argumentsType(arguments.toArray(new exprType[0]), null, null,
                            null, null, null, null, null, null, null);
                    if (useAnyArgs) {
                        Name name = new Name("self", Name.Store, false);
                        name.addSpecial(new SpecialStr(",", -1, -1), true);
                        functionArguments.args = new exprType[] { name };
                        functionArguments.vararg = new NameTok("args", NameTok.VarArg);
                        functionArguments.kwarg = new NameTok("kwargs", NameTok.KwArg);
                    }
                    //                System.out.println(tok.getRepresentation()+tok.getArgs());
                    FunctionDef functionDef = new FunctionDef(
                            new NameTok(tok.getRepresentation(), NameTok.FunctionName), functionArguments, null, null,
                            null);
                    cache.add(new FunctionDefAdapter(this.getModule(), null, functionDef, adapterPrefs));
                }
            }
        }
        return cache;
    }

    public String getNodeBodyIndent() {
        throw new RuntimeException("Not implemented");
    }

    public List<PropertyAdapter> getProperties() {
        throw new RuntimeException("Not implemented");
    }

    public boolean hasAttributes() {
        throw new RuntimeException("Not implemented");
    }

    public boolean hasBaseClass() {
        return false;
    }

    public boolean hasFunctions() {
        throw new RuntimeException("Not implemented");
    }

    public boolean hasFunctionsInitFiltered() {
        return this.tokens.size() > 0;
    }

    public boolean hasInit() {
        throw new RuntimeException("Not implemented");
    }

    public boolean isNested() {
        throw new RuntimeException("Not implemented");
    }

    public boolean isNewStyleClass() {
        throw new RuntimeException("Not implemented");
    }

    public String getName() {
        return parentName;
    }

    public String getParentName() {
        throw new RuntimeException("Not implemented");
    }

    public ClassDef getASTNode() {
        throw new RuntimeException("Not implemented");
    }

    public SimpleNode getASTParent() {
        throw new RuntimeException("Not implemented");
    }

    public ModuleAdapter getModule() {
        return this.module;
    }

    public int getNodeFirstLine() {
        return 0;
    }

    public int getNodeIndent() {
        return 0;
    }

    public int getNodeLastLine() {
        return 0;
    }

    public AbstractNodeAdapter<? extends SimpleNode> getParent() {
        return null;
    }

    public SimpleNode getParentNode() {
        return null;
    }

    public boolean isModule() {
        return false;
    }

}