Java tutorial
/* * Copyright 2008 Google Inc. * * Licensed 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 com.google.common.css.compiler.ast; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.css.SourceCodeLocation; import java.util.List; import java.util.Map; import javax.annotation.Nullable; /** * A node representing a function. * * @author oana@google.com (Oana Florescu) */ public class CssFunctionNode extends CssValueNode implements ChunkAware { /** * Contains the list of recognized CSS functions. */ public abstract static class Function { /** A map of function names to function objects. */ private static final Map<String, Function> NAME_TO_FUNCTION_MAP; static { List<String> recognizedCssFunctions = ImmutableList.of( // CSS 2.1 "attr", "counter", "rect", "rgb", "url", // Per-site user stylesheet rules // http://lists.w3.org/Archives/Public/www-style/2004Aug/0135 "domain", "url-prefix", // IE8 and earlier: // .fiftyPercentOpacity { filter: alpha(opacity=50); } "alpha", // CSS 3 "cubic-bezier", "format", // used with @font-face "from", "hsl", "hsla", "local", // used with @font-face "perspective", "rgba", "rotate", "rotateX", "rotateY", "rotateZ", "rotate3d", "scale", "scaleX", "scaleY", "scaleZ", "scale3d", "steps", "to", "translate", "translateX", "translateY", "translateZ", "translate3d", // Filter // w3.org/TR/filter-effects-1/#FilterProperty // "url" already in list "blur", "brightness", "contrast", "drop-shadow", "grayscale", "hue-rotate", "invert", "opacity", "saturate", "sepia", // Image-Set "image-set", "-moz-image-set", "-ms-image-set", "-o-image-set", "-webkit-image-set", // These take the type of gradient (linear or radial) as a parameter. "-khtml-gradient", "-webkit-gradient", // Prefer -webkit-(linear|radial)-gradient // Linear gradients "linear-gradient", "-moz-linear-gradient", "-ms-linear-gradient", "-o-linear-gradient", "-webkit-linear-gradient", "repeating-linear-gradient", "-moz-repeating-linear-gradient", "-ms-repeating-linear-gradient", "-o-repeating-linear-gradient", "-webkit-repeating-linear-gradient", // Radial gradients "radial-gradient", "-moz-radial-gradient", "-ms-radial-gradient", "-o-radial-gradient", "-webkit-radial-gradient", "repeating-radial-gradient", "-moz-repeating-radial-gradient", "-ms-repeating-radial-gradient", "-o-repeating-radial-gradient", "-webkit-repeating-radial-gradient", // Calc "calc", "-webkit-calc", "-moz-calc", // CSS Shapes "inset", "circle", "ellipse", "polygon"); ImmutableMap.Builder<String, Function> builder = ImmutableMap.builder(); for (String functionName : recognizedCssFunctions) { builder.put(functionName, new Function(functionName) { @Override public boolean isRecognized() { return true; } }); } NAME_TO_FUNCTION_MAP = builder.build(); } /** * Serves as a placeholder for custom functions. */ public static final Function CUSTOM = new Function(null /* functionName */) { @Override public boolean isRecognized() { return false; } }; /** The name of the function, as it appears in a CSS stylesheet. */ private final String functionName; private Function(String functionName) { this.functionName = functionName; } /** * Returns the CSS {@link Function} with the specified name, or {@code null} * if the name is not in the list of recognized names. Multiple invocations * of this method with the same parameter will return the same object. For a * function that is not in the list of recognized names but should be * considered valid, use {@link Function#CUSTOM}. */ public static Function byName(String name) { return NAME_TO_FUNCTION_MAP.get(name); } /** * Returns {@code true} when this function is in the list of * recognized names. */ public abstract boolean isRecognized(); /** * @return the name of the CSS function, such as "rgb" or "url" */ public String getFunctionName() { return functionName; } /** * For debugging only. */ @Override public String toString() { return getFunctionName(); } } private final Function function; private CssFunctionArgumentsNode arguments; private Object chunk; /** * Constructor of the class. * * TODO(oana): Deal with the situation that we have an unrecognized * function. * * @param function * @param sourceCodeLocation */ public CssFunctionNode(@Nullable Function function, @Nullable SourceCodeLocation sourceCodeLocation) { super(null, sourceCodeLocation); this.function = function; this.arguments = new CssFunctionArgumentsNode(); becomeParentForNode(this.arguments); } /** * Copy constructor. * * @param function */ public CssFunctionNode(CssFunctionNode function) { super(function); this.function = function.getFunction(); this.arguments = new CssFunctionArgumentsNode(function.getArguments()); becomeParentForNode(this.arguments); this.chunk = function.getChunk(); } /** * Constructor used by the proxy mechanism, avoids unnecessary arguments node * initialization. * * <p>NOTE(dgajda): The signature of this constructor only differs in argument * order from the main constructor of this class. * * @param function implementation of the function which is "called" by this * node * @param sourceCodeLocation location of this node */ protected CssFunctionNode(@Nullable SourceCodeLocation sourceCodeLocation, @Nullable Function function) { super(null, sourceCodeLocation); this.function = function; } @Override public CssFunctionNode deepCopy() { return new CssFunctionNode(this); } public Function getFunction() { return function; } public String getFunctionName() { return function.toString(); } public CssFunctionArgumentsNode getArguments() { return arguments; } public void setArguments(CssFunctionArgumentsNode arguments) { removeAsParentOfNode(this.arguments); this.arguments = arguments; becomeParentForNode(this.arguments); } @Override public String toString() { StringBuffer output = new StringBuffer(); if (function.getFunctionName() != null) { output.append(function.getFunctionName()); } output.append("("); for (CssNode node : getArguments().childIterable()) { output.append(node.toString()); } output.append(")"); return output.toString(); } @Override public Object getChunk() { return chunk; } @Override public void setChunk(Object chunk) { this.chunk = chunk; } /** * Print the node instead of null when this node is a parameter. */ @Override public String getValue() { return toString(); } }