compiler/src/main/java/org/apache/royale/compiler/internal/definitions/VectorInformation.java

/*
 *
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.royale.compiler.internal.definitions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.royale.compiler.constants.IASKeywordConstants;
import org.apache.royale.compiler.constants.IASLanguageConstants;
import org.apache.royale.compiler.constants.INamespaceConstants;
import org.apache.royale.compiler.internal.tree.as.GetterNode;
import org.apache.royale.compiler.internal.tree.as.IdentifierNode;
import org.apache.royale.compiler.internal.tree.as.NamespaceIdentifierNode;
import org.apache.royale.compiler.internal.tree.as.ParameterNode;
import org.apache.royale.compiler.internal.tree.as.SetterNode;
import org.apache.royale.compiler.internal.tree.as.VariableNode;
import org.apache.royale.compiler.tree.as.IDefinitionNode;

/**
 * Class keeps information about the vector node, used to construct it
 */
class VectorInformation
{
    // Enum to describe what the type of a return or parameter to one of the
    // Vector methods should be.
    // DEFAULT_TYPE - whatever is defined in Vector$object is correct
    // VECTOR_TYPE - the type is "Vector$object", but should be replaced with an instantiated vector type
    //               such as, Vector.<Foo>
    // VECTOR_COLLECTION_TYPE - the type should be replaced with the type parameter of the instantiated vector
    //               i.e. - for Vector.<String> this type should be 'String'
    static enum Type
    {
        DEFAULT_TYPE,
        VECTOR_TYPE,
        VECTOR_COLLECTION_TYPE

    }

    public static class FunctionInfo
    {
        private String name;

        private List<ArgumentInfo> arguments = new ArrayList<ArgumentInfo>();

        Enum<Type> t;

        public FunctionInfo(Type retType)
        {
            t = retType;
        }

        public FunctionInfo(String name, Type retType)
        {
            this.name = name;
            t = retType;
        }

        public void addArgumentType(ArgumentInfo info)
        {
            arguments.add(info);
        }

        public String getName()
        {
            return name;
        }

        public boolean returnIsVector()
        {
            return t == Type.VECTOR_TYPE;
        }

        public boolean returnIsTypeOfCollection()
        {
            return t == Type.VECTOR_COLLECTION_TYPE;
        }

        public ArgumentInfo[] getArgumentInfo()
        {
            return arguments.toArray(new ArgumentInfo[0]);
        }

        public boolean needsAdjustments()
        {

            if (returnIsVector() || returnIsTypeOfCollection())
                return true;

            for (ArgumentInfo arg : getArgumentInfo())
            {
                if (arg.returnIsVector() || arg.returnIsTypeOfCollection())
                    return true;
            }

            return false;
        }

    }

    public static class ArgumentInfo
    {
        private String name;
        private Enum<Type> type;
        private String defaultValue;

        public ArgumentInfo(String name, Type type)
        {
            this.name = name;
            this.type = type;
        }

        public ArgumentInfo(String name, Type type, String defaultValue)
        {
            this(name, type);
            this.defaultValue = defaultValue;
        }

        public String getName()
        {
            return name;
        }

        public String getDefaultValue()
        {
            return defaultValue;
        }

        public boolean returnIsVector()
        {
            return type == Type.VECTOR_TYPE;
        }

        public boolean returnIsTypeOfCollection()
        {
            return type == Type.VECTOR_COLLECTION_TYPE;
        }
    }

    private static VectorInformation instance;

    private HashSet<String> excludedMethods = new HashSet<String>();

    private HashMap<String, FunctionInfo> info = new HashMap<String, FunctionInfo>();

    private ArrayList<FunctionInfo> additionalInfo = new ArrayList<FunctionInfo>();

    public static VectorInformation getInformation()
    {
        if (instance == null)
            instance = new VectorInformation();
        
        return instance;
    }

    public FunctionInfo getFunctionInfo(String funcName)
    {
        return info.get(funcName);
    }

    public FunctionInfo[] getAdditionalInfo()
    {
        return additionalInfo.toArray(new FunctionInfo[0]);
    }

    public IDefinitionNode[] getDefinitions()
    {
        IDefinitionNode[] retVal = new IDefinitionNode[4];
        VariableNode thisNode = new VariableNode(new IdentifierNode(IASKeywordConstants.THIS));
        thisNode.setType(null, new IdentifierNode(IASLanguageConstants.Vector));
        retVal[0] = thisNode;

        //and super
        VariableNode superNode = new VariableNode(new IdentifierNode(IASKeywordConstants.SUPER));
        superNode.setType(null, new IdentifierNode(IASLanguageConstants.Object));
        retVal[1] = superNode;

        //add the fixed getter/setter pair
        GetterNode fixGetter = new GetterNode(null, null, new IdentifierNode("fixed"));
        NamespaceIdentifierNode pub = new NamespaceIdentifierNode(INamespaceConstants.public_);
        pub.span(-1, -1, -1, -1, -1, -1);
        fixGetter.setNamespace(pub);
        fixGetter.setType(null, new IdentifierNode(IASLanguageConstants.Boolean));
        retVal[2] = fixGetter;

        SetterNode fixSetter = new SetterNode(null, null, new IdentifierNode("fixed"));
        pub = new NamespaceIdentifierNode(INamespaceConstants.public_);
        pub.span(-1, -1, -1, -1, -1, -1);
        fixSetter.setNamespace(pub);
        fixSetter.setType(null, new IdentifierNode(IASLanguageConstants.void_));
        ParameterNode value = new ParameterNode(new IdentifierNode("value"));
        value.setType(null, new IdentifierNode(IASLanguageConstants.Boolean));
        fixSetter.getParametersContainerNode().addChild(value);
        retVal[3] = fixSetter;

        return retVal;
    }

    public boolean isExcluded(String name)
    {
        return excludedMethods.contains(name);
    }

    private VectorInformation()
    {
        excludedMethods.add("sortOn");
        excludedMethods.add(IASLanguageConstants.Array);
        excludedMethods.add(IASLanguageConstants.Object);
        //populate hard-coded function into
        //concat
        FunctionInfo concat = new FunctionInfo("concat", VectorInformation.Type.VECTOR_TYPE);
        info.put("concat", concat);
        concat.addArgumentType(new ArgumentInfo("parameters", VectorInformation.Type.DEFAULT_TYPE));
        //every
        FunctionInfo everyInfo = new FunctionInfo("every", VectorInformation.Type.VECTOR_TYPE);
        info.put("every", everyInfo);
        everyInfo.addArgumentType(new ArgumentInfo("callback", VectorInformation.Type.DEFAULT_TYPE));
        everyInfo.addArgumentType(new ArgumentInfo("thisObject", VectorInformation.Type.DEFAULT_TYPE, IASKeywordConstants.NULL));
        //filter
        FunctionInfo filter = new FunctionInfo("filter", VectorInformation.Type.VECTOR_TYPE);
        info.put("filter", filter);
        filter.addArgumentType(new ArgumentInfo("callback", VectorInformation.Type.DEFAULT_TYPE));
        filter.addArgumentType(new ArgumentInfo("thisObject", VectorInformation.Type.DEFAULT_TYPE, IASKeywordConstants.NULL));
        //forEach
        FunctionInfo forEach = new FunctionInfo("forEach", VectorInformation.Type.DEFAULT_TYPE);
        info.put("forEach", forEach);
        forEach.addArgumentType(new ArgumentInfo("callback", VectorInformation.Type.DEFAULT_TYPE));
        forEach.addArgumentType(new ArgumentInfo("thisObject", VectorInformation.Type.DEFAULT_TYPE, IASKeywordConstants.NULL));
        //indexOf
        FunctionInfo indexOf = new FunctionInfo("indexOf", VectorInformation.Type.DEFAULT_TYPE);
        info.put("indexOf", indexOf);
        indexOf.addArgumentType(new ArgumentInfo("searchElement", VectorInformation.Type.VECTOR_COLLECTION_TYPE));
        indexOf.addArgumentType(new ArgumentInfo("fromIndex", VectorInformation.Type.DEFAULT_TYPE, "0"));
        //join
        FunctionInfo joinInfo = new FunctionInfo("join", VectorInformation.Type.DEFAULT_TYPE);
        joinInfo.addArgumentType(new ArgumentInfo("sep", VectorInformation.Type.DEFAULT_TYPE, "\",\""));
        info.put("join", joinInfo);
        //indexOf
        FunctionInfo lastIndexOf = new FunctionInfo("lastIndexOf", VectorInformation.Type.DEFAULT_TYPE);
        info.put("lastIndexOf", lastIndexOf);
        lastIndexOf.addArgumentType(new ArgumentInfo("searchElement", VectorInformation.Type.VECTOR_COLLECTION_TYPE));
        lastIndexOf.addArgumentType(new ArgumentInfo("fromIndex", VectorInformation.Type.DEFAULT_TYPE, "0x7fffffff"));
        //map
        FunctionInfo map = new FunctionInfo("map", VectorInformation.Type.VECTOR_TYPE);
        info.put("map", map);
        map.addArgumentType(new ArgumentInfo("callback", VectorInformation.Type.DEFAULT_TYPE));
        map.addArgumentType(new ArgumentInfo("thisObject", VectorInformation.Type.DEFAULT_TYPE, IASKeywordConstants.NULL));
        //pop
        info.put("pop", new FunctionInfo("pop", VectorInformation.Type.VECTOR_COLLECTION_TYPE));
        //push
        FunctionInfo push = new FunctionInfo("push", VectorInformation.Type.DEFAULT_TYPE);
        push.addArgumentType(new ArgumentInfo("parameters", Type.DEFAULT_TYPE));
        info.put("push", push);

        //reverse
        info.put("reverse", new FunctionInfo("reverse", VectorInformation.Type.VECTOR_TYPE));
        //shift
        info.put("shift", new FunctionInfo("shift", VectorInformation.Type.VECTOR_COLLECTION_TYPE));
        //map
        FunctionInfo slice = new FunctionInfo("slice", VectorInformation.Type.VECTOR_TYPE);
        info.put("slice", slice);
        slice.addArgumentType(new ArgumentInfo("startIndex", VectorInformation.Type.DEFAULT_TYPE, "0"));
        slice.addArgumentType(new ArgumentInfo("endIndex", VectorInformation.Type.DEFAULT_TYPE, "16777215"));
        //some
        FunctionInfo some = new FunctionInfo("some", VectorInformation.Type.DEFAULT_TYPE);
        info.put("some", some);
        some.addArgumentType(new ArgumentInfo("callback", VectorInformation.Type.DEFAULT_TYPE));
        some.addArgumentType(new ArgumentInfo("thisObject", VectorInformation.Type.DEFAULT_TYPE, IASKeywordConstants.NULL));
        //sort
        FunctionInfo sort = new FunctionInfo("sort", VectorInformation.Type.VECTOR_TYPE);
        info.put("sort", sort);
        sort.addArgumentType(new ArgumentInfo("compareFunction", VectorInformation.Type.DEFAULT_TYPE));
        //splice
        FunctionInfo splice = new FunctionInfo("splice", VectorInformation.Type.VECTOR_TYPE);
        info.put("splice", splice);
        splice.addArgumentType(new ArgumentInfo("startIndex", VectorInformation.Type.DEFAULT_TYPE));
        splice.addArgumentType(new ArgumentInfo("deleteCount", VectorInformation.Type.DEFAULT_TYPE));
        splice.addArgumentType(new ArgumentInfo("items", VectorInformation.Type.DEFAULT_TYPE));

        FunctionInfo unshift = new FunctionInfo("unshift", VectorInformation.Type.DEFAULT_TYPE);
        info.put("unshift", unshift);
        unshift.addArgumentType(new ArgumentInfo("parameters", Type.DEFAULT_TYPE));

        additionalInfo.add(new FunctionInfo("toLocaleString", VectorInformation.Type.DEFAULT_TYPE));
    }

    Set<Entry<String, FunctionInfo>> getFunctionInfos()
    {
        return info.entrySet();
    }
}