You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2017/12/20 00:56:18 UTC
[21/49] groovy git commit: Move source files to proper packages
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/lang/Delegate.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/lang/Delegate.java b/src/main/groovy/lang/Delegate.java
deleted file mode 100644
index 3d418c7..0000000
--- a/src/main/groovy/lang/Delegate.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * 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 groovy.lang;
-
-import groovy.transform.Undefined;
-import org.codehaus.groovy.transform.GroovyASTTransformationClass;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation to automatically delegate part of the functionality of an owner class to the
- * annotated delegation target. The target can be a field (or property) or a method's return value.
- * <p>
- * The delegate type is either the type of the annotated field (or property) or the return type of
- * the annotated method. The method can be thought of as a getter or factory method for the delegate.
- * All public instance methods present in the delegate type and not present in the owner class
- * will be added to owner class at compile time. The implementation of such automatically added
- * methods is code which calls through to the delegate as per the normal delegate pattern.
- * <p>
- * As an example, consider this code:
- * <pre class="groovyTestCase">
- * class Event {
- * {@code @Delegate} Date when
- * String title, url
- * }
- *
- * def gr8conf = new Event(title: "GR8 Conference",
- * url: "http://www.gr8conf.org",
- * when: Date.parse("yyyy/MM/dd", "2009/05/18"))
- *
- * def javaOne = new Event(title: "JavaOne",
- * url: "http://java.sun.com/javaone/",
- * when: Date.parse("yyyy/MM/dd", "2009/06/02"))
- *
- * assert gr8conf.before(javaOne.when)
- * </pre>
- *
- * In this example, the {@code Event} class will have a method called
- * {@code before(Date otherDate)} as well as other public methods of the
- * {@code Date} class.
- * The implementation of the {@code before()} method will look like this:
- * <pre>
- * public boolean before(Date otherDate) {
- * return when.before(otherDate);
- * }
- * </pre>
- *
- * By default, the owner class will also be modified to implement any interfaces
- * implemented by the delegate type. So, in the example above, because {@code Date}
- * implements {@code Cloneable} the following will be true:
- *
- * <pre>
- * assert gr8conf instanceof Cloneable
- * </pre>
- *
- * This behavior can be disabled by setting the
- * annotation's {@code interfaces} element to false,
- * i.e. {@code @Delegate(interfaces = false)}, e.g. in the above
- * example, the delegate definition would become:
- * <pre>
- * {@code @Delegate}(interfaces = false) Date when
- * </pre>
- * and the following would be true:
- * <pre>
- * assert !(gr8conf instanceof Cloneable)
- * </pre>
- *
- * If multiple delegation targets are used and the same method signature occurs
- * in more than one of the respective delegate types, then the delegate will be
- * made to the first defined target having that signature. If this does occur,
- * it might be regarded as a smell (or at least poor style) and it might be
- * clearer to do the delegation by long hand.
- * <p>
- * By default, methods of the delegate type marked as {@code @Deprecated} are
- * not automatically added to the owner class (but see the technical note
- * about interfaces below). You can force these methods to
- * be added by setting the annotation's {@code deprecated} element to true,
- * i.e. {@code @Delegate(deprecated = true)}.
- * <p>
- * For example, in the example above if we change the delegate definition to:
- * <pre>
- * {@code @Delegate}(deprecated = true) Date when
- * </pre>
- * then the following additional lines will execute successfully (during 2009):
- * <pre>
- * assert gr8conf.year + 1900 == 2009
- * assert gr8conf.toGMTString().contains(" 2009 ")
- * </pre>
- * Otherwise these lines produce a groovy.lang.MissingPropertyException
- * or groovy.lang.MissingMethodException respectively as those two methods are
- * {@code @Deprecated} in {@code Date}.
- * <p>
- * <b>Technical notes</b>:
- * <ul>
- * <li>Static methods, synthetic methods or methods from the <code>GroovyObject</code> interface
- * are not candidates for delegation</li>
- * <li>Non-abstract non-static methods defined in the owner class or its superclasses take
- * precedence over methods with identical signatures from a {@code @Delegate} target</li>
- * <li>All methods defined in the owner class (including static, abstract or private etc.)
- * take precedence over methods with identical signatures from a {@code @Delegate} target</li>
- * <li>Recursive delegation to your own class is not allowed</li>
- * <li>Mixing of {@code @Delegate} with default method arguments is known not to work in some cases.
- * We recommend not using these features together.</li>
- * <li>When the delegate type is an interface, the {@code deprecated} attribute will be
- * ignored if the owner class implements that interface (i.e. you must set {@code interfaces=false}
- * if you want the {@code deprecated} attribute to be used). Otherwise, the resulting class would
- * not compile anyway without manually adding in any deprecated methods in the interface.</li>
- * <li>{@code @Delegate} can work in combination with {@code @Lazy} when annotating a field (or property)</li>
- * </ul>
- */
-@java.lang.annotation.Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.FIELD, ElementType.METHOD})
-@GroovyASTTransformationClass("org.codehaus.groovy.transform.DelegateASTTransformation")
-public @interface Delegate {
- /**
- * @return true if owner class should implement interfaces implemented by delegate type
- */
- boolean interfaces() default true;
-
- /**
- * Whether to apply the delegate pattern to deprecated methods; to avoid compilation
- * errors, this is ignored if the type of the delegate target is an interface and
- * {@code interfaces=true}.
- *
- * @return true if owner class should delegate to methods annotated with @Deprecated
- */
- boolean deprecated() default false;
-
- /**
- * Whether to carry over annotations from the methods of the delegate
- * to your delegating method. Currently Closure annotation members are
- * not supported.
- *
- * @return true if generated delegate methods should keep method annotations
- */
- boolean methodAnnotations() default false;
-
- /**
- * Whether to carry over annotations from the parameters of delegate
- * methods to your delegating method. Currently Closure annotation members are
- * not supported.
- *
- * @return true if generated delegate methods should keep parameter annotations
- */
- boolean parameterAnnotations() default false;
-
- /**
- * List of method and/or property names to exclude when delegating.
- * Only one of 'includes', 'includeTypes', 'excludes' or 'excludeTypes' should be used.
- * For convenience, a String with comma separated names
- * can be used in addition to an array (using Groovy's literal list notation) of String values.
- * If interfaces is true (the default), you will need to manually supply any methods excluded
- * from delegation that are required for the interface.
- * @since 2.2.0
- */
- String[] excludes() default {};
-
-
- /**
- * List of interfaces containing method signatures to exclude when delegating.
- * Only one of 'includes', 'includeTypes', 'excludes', 'excludeTypes' should be used.
- * If interfaces is true (the default), you will need to manually supply any methods excluded
- * from delegation that are required for the interface.
- * @since 2.3.0
- */
- Class[] excludeTypes() default {};
-
- /**
- * List of method and/or property names to include when delegating.
- * Only one of 'includes', 'includeTypes', 'excludes' or 'excludeTypes' should be used.
- * For convenience, a String with comma separated names
- * can be used in addition to an array (using Groovy's literal list notation) of String values.
- * The default value is a special marker value indicating that no includes are defined; all fields
- * are included if 'includes' remains undefined and 'excludes' is explicitly or implicitly an empty list.
- * If interfaces is true (the default), you will need to manually supply any methods not included
- * via delegation that are required for the interface.
- * @since 2.2.0
- */
- String[] includes() default {Undefined.STRING};
-
- /**
- * List of interfaces containing method signatures to include when delegating.
- * Only one of 'includes', 'includeTypes', 'excludes' or 'excludeTypes' should be used.
- * The default value is a special marker value indicating that no includeTypes are defined.
- * If interfaces is true (the default), you will need to manually supply any methods excluded
- * from delegation that are required for the interface.
- * @since 2.3.0
- */
- Class[] includeTypes() default {Undefined.CLASS.class};
-
- /**
- * Whether to apply the delegate pattern to all methods, including those with names that are considered internal.
- *
- * @return true if owner class should delegate to methods which have internal names
- * @since 2.5.0
- */
- boolean allNames() default false;
-}
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/lang/DelegatesTo.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/lang/DelegatesTo.java b/src/main/groovy/lang/DelegatesTo.java
deleted file mode 100644
index 54a5e36..0000000
--- a/src/main/groovy/lang/DelegatesTo.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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 groovy.lang;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * This annotation can be used by API or DSL writers to document parameters which accept a closure.
- * In that case, using this annotation, you can specify what the delegate type of the closure will
- * be. This is important for IDE support.
- * <p>
- * This annotation can also be used to help the type checker ({@link groovy.transform.TypeChecked})
- * which would not report errors then if the delegate is of the documented type. Of course, it is
- * also compatible with {@link groovy.transform.CompileStatic}.
- * <p>
- * Example:
- * <pre>
- * // Document the fact that the delegate of the closure will be an ExecSpec
- * ExecResult exec(@DelegatesTo(ExecSpec) Closure closure) { ... }
- * </pre>
- *
- * @author Cedric Champeau
- * @author Peter Niderwieser
- * @since 2.1.0
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target({ElementType.PARAMETER})
-public @interface DelegatesTo {
- Class value() default Target.class;
-
- /**
- * The {@link Closure#resolveStrategy} used by the closure.
- */
- int strategy() default Closure.OWNER_FIRST;
-
- /**
- * The index of the generic type that will be the type of the closure's delegate.
- * The generic types are considered with respect to the {@code @DelegatesTo.Target} annotated
- * parameter for this usage, with the index starting at 0.
- */
- int genericTypeIndex() default -1;
-
- /**
- * In cases when there are multiple {@code @DelegatesTo.Target} annotated parameters, this
- * member should be set to the {@link DelegatesTo.Target#value()} of the correct target.
- */
- String target() default "";
-
- /**
- * The type member should be used when the type of the delegate cannot
- * be represented with {@link #value()}, {@link #genericTypeIndex()} or
- * {@link #target()}. In this case, it is possible to use a String to represent
- * the type, at the cost of potential uncaught errors at compile time if the
- * type is invalid and increased compile time.
- *
- * @return a String representation of a type
- * @since 2.4.0
- */
- String type() default "";
-
- /**
- * Parameter annotation used to specify the delegate for a {@code @DelegatesTo} annotated
- * parameter of the same method.
- */
- @Retention(RetentionPolicy.RUNTIME)
- @java.lang.annotation.Target({ElementType.PARAMETER})
- public static @interface Target {
-
- /**
- * An identifier that should be used to disambiguate targets when there are
- * multiple {@code @DelegatesTo.Target} annotated parameters.
- */
- String value() default "";
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/lang/DelegatingMetaClass.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/lang/DelegatingMetaClass.java b/src/main/groovy/lang/DelegatingMetaClass.java
deleted file mode 100644
index ee2ade9..0000000
--- a/src/main/groovy/lang/DelegatingMetaClass.java
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
- * 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 groovy.lang;
-
-import org.codehaus.groovy.ast.ClassNode;
-import org.codehaus.groovy.runtime.InvokerHelper;
-
-import java.lang.reflect.Method;
-import java.util.List;
-
-/**
- * @author John Wilson
- */
-
-public class DelegatingMetaClass implements MetaClass, MutableMetaClass, GroovyObject {
- protected MetaClass delegate;
-
- public DelegatingMetaClass(final MetaClass delegate) {
- this.delegate = delegate;
- }
-
- public DelegatingMetaClass(final Class theClass) {
- this(GroovySystem.getMetaClassRegistry().getMetaClass(theClass));
- }
-
- public boolean isModified() {
- return this.delegate instanceof MutableMetaClass && ((MutableMetaClass) this.delegate).isModified();
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#addNewInstanceMethod(java.lang.reflect.Method)
- */
- public void addNewInstanceMethod(Method method) {
- if (delegate instanceof MutableMetaClass)
- ((MutableMetaClass) delegate).addNewInstanceMethod(method);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#addNewStaticMethod(java.lang.reflect.Method)
- */
- public void addNewStaticMethod(Method method) {
- if (delegate instanceof MutableMetaClass)
- ((MutableMetaClass) delegate).addNewStaticMethod(method);
- }
-
- public void addMetaMethod(MetaMethod metaMethod) {
- if (delegate instanceof MutableMetaClass)
- ((MutableMetaClass) delegate).addMetaMethod(metaMethod);
- }
-
- public void addMetaBeanProperty(MetaBeanProperty metaBeanProperty) {
- if (delegate instanceof MutableMetaClass)
- ((MutableMetaClass) delegate).addMetaBeanProperty(metaBeanProperty);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#initialize()
- */
- public void initialize() {
- delegate.initialize();
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getAttribute(java.lang.Object, java.lang.String)
- */
- public Object getAttribute(Object object, String attribute) {
- return delegate.getAttribute(object, attribute);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getClassNode()
- */
- public ClassNode getClassNode() {
- return delegate.getClassNode();
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getMetaMethods()
- */
- public List<MetaMethod> getMetaMethods() {
- return delegate.getMetaMethods();
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getMethods()
- */
- public List<MetaMethod> getMethods() {
- return delegate.getMethods();
- }
-
- public List<MetaMethod> respondsTo(Object obj, String name, Object[] argTypes) {
- return delegate.respondsTo(obj, name, argTypes);
- }
-
- public List<MetaMethod> respondsTo(Object obj, String name) {
- return delegate.respondsTo(obj, name);
- }
-
- public MetaProperty hasProperty(Object obj, String name) {
- return delegate.hasProperty(obj, name);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getProperties()
- */
- public List<MetaProperty> getProperties() {
- return delegate.getProperties();
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#getProperty(java.lang.Object, java.lang.String)
- */
- public Object getProperty(Object object, String property) {
- return delegate.getProperty(object, property);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#invokeConstructor(java.lang.Object[])
- */
- public Object invokeConstructor(Object[] arguments) {
- return delegate.invokeConstructor(arguments);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#invokeMethod(java.lang.Object, java.lang.String, java.lang.Object)
- */
- public Object invokeMethod(Object object, String methodName, Object arguments) {
- return delegate.invokeMethod(object, methodName, arguments);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#invokeMethod(java.lang.Object, java.lang.String, java.lang.Object[])
- */
- public Object invokeMethod(Object object, String methodName, Object[] arguments) {
- return delegate.invokeMethod(object, methodName, arguments);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#invokeStaticMethod(java.lang.Object, java.lang.String, java.lang.Object[])
- */
- public Object invokeStaticMethod(Object object, String methodName, Object[] arguments) {
- return delegate.invokeStaticMethod(object, methodName, arguments);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#setAttribute(java.lang.Object, java.lang.String, java.lang.Object)
- */
- public void setAttribute(Object object, String attribute, Object newValue) {
- delegate.setAttribute(object, attribute, newValue);
- }
-
- /* (non-Javadoc)
- * @see groovy.lang.MetaClass#setProperty(java.lang.Object, java.lang.String, java.lang.Object)
- */
- public void setProperty(Object object, String property, Object newValue) {
- delegate.setProperty(object, property, newValue);
- }
-
- /* (non-Javadoc)
- * @see java.lang.Object#equals(java.lang.Object)
- */
- public boolean equals(Object obj) {
- return delegate.equals(obj);
- }
-
- /* (non-Javadoc)
- * @see java.lang.Object#hashCode()
- */
- public int hashCode() {
- return delegate.hashCode();
- }
-
- public String toString() {
- return super.toString() + "[" + delegate.toString() + "]";
- }
-
- /**
- * @deprecated
- */
- @Deprecated
- public MetaMethod pickMethod(String methodName, Class[] arguments) {
- return delegate.pickMethod(methodName, arguments);
- }
-
- public Object getAttribute(Class sender, Object receiver, String messageName, boolean useSuper) {
- return this.delegate.getAttribute(sender, receiver, messageName, useSuper);
- }
-
- public Object getProperty(Class sender, Object receiver, String messageName, boolean useSuper, boolean fromInsideClass) {
- return this.delegate.getProperty(sender, receiver, messageName, useSuper, fromInsideClass);
- }
-
- public MetaProperty getMetaProperty(String name) {
- return this.delegate.getMetaProperty(name);
- }
-
- public MetaMethod getStaticMetaMethod(String name, Object[] args) {
- return this.delegate.getStaticMetaMethod(name, args);
- }
-
- public MetaMethod getStaticMetaMethod(String name, Class[] argTypes) {
- return this.delegate.getStaticMetaMethod(name, argTypes);
- }
-
- public MetaMethod getMetaMethod(String name, Object[] args) {
- return this.delegate.getMetaMethod(name, args);
- }
-
- public Class getTheClass() {
- return this.delegate.getTheClass();
- }
-
- public Object invokeMethod(Class sender, Object receiver, String methodName, Object[] arguments, boolean isCallToSuper, boolean fromInsideClass) {
- return this.delegate.invokeMethod(sender, receiver, methodName, arguments, isCallToSuper, fromInsideClass);
- }
-
- public Object invokeMissingMethod(Object instance, String methodName, Object[] arguments) {
- return this.delegate.invokeMissingMethod(instance, methodName, arguments);
- }
-
- public Object invokeMissingProperty(Object instance, String propertyName, Object optionalValue, boolean isGetter) {
- return this.delegate.invokeMissingProperty(instance, propertyName, optionalValue, isGetter);
- }
-
- public boolean isGroovyObject() {
- return GroovyObject.class.isAssignableFrom(this.delegate.getTheClass());
- }
-
- public void setAttribute(Class sender, Object receiver, String messageName, Object messageValue, boolean useSuper, boolean fromInsideClass) {
- this.delegate.setAttribute(sender, receiver, messageName, messageValue, useSuper, fromInsideClass);
- }
-
- public void setProperty(Class sender, Object receiver, String messageName, Object messageValue, boolean useSuper, boolean fromInsideClass) {
- this.delegate.setProperty(sender, receiver, messageName, messageValue, useSuper, fromInsideClass);
- }
-
- public int selectConstructorAndTransformArguments(int numberOfConstructors, Object[] arguments) {
- return this.delegate.selectConstructorAndTransformArguments(numberOfConstructors, arguments);
- }
-
- public void setAdaptee(MetaClass adaptee) {
- this.delegate = adaptee;
- }
-
- public MetaClass getAdaptee() {
- return this.delegate;
- }
-
- public Object invokeMethod(String name, Object args) {
- try {
- return getMetaClass().invokeMethod(this, name, args);
- }
- catch (MissingMethodException e) {
- if (delegate instanceof GroovyObject)
- return ((GroovyObject) delegate).invokeMethod(name, args);
- else
- throw e;
- }
- }
-
- public Object getProperty(String property) {
- try {
- return getMetaClass().getProperty(this, property);
- }
- catch (MissingPropertyException e) {
- if (delegate instanceof GroovyObject)
- return ((GroovyObject) delegate).getProperty(property);
- else
- throw e;
- }
- }
-
- public void setProperty(String property, Object newValue) {
- try {
- getMetaClass().setProperty(this, property, newValue);
- }
- catch (MissingPropertyException e) {
- if (delegate instanceof GroovyObject)
- ((GroovyObject) delegate).setProperty(property, newValue);
- else
- throw e;
- }
- }
-
- public MetaClass getMetaClass() {
- return InvokerHelper.getMetaClass(getClass());
- }
-
- public void setMetaClass(MetaClass metaClass) {
- throw new UnsupportedOperationException();
- }
-}
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/lang/DeprecationException.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/lang/DeprecationException.java b/src/main/groovy/lang/DeprecationException.java
deleted file mode 100644
index 36ad893..0000000
--- a/src/main/groovy/lang/DeprecationException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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 groovy.lang;
-
-/**
- * Use this exception to mark a method implementation as being deprecated.
- *
- * Use the message to indicate the recommended way of calling the desired functionality.
- * Make throwing this exception the only line in the method implementation, i.e. unlike
- * the JavaDoc deprecated feature there is no relay to the new implementation but an early
- * and deliberate halt of execution ("fail early").
- *
- * This exception is supposed to be used in the SNAPSHOT releases only. Before release, all
- * references to this exception should be resolved and the according methods removed.
- *
- * @author Dierk Koenig
- */
-public class DeprecationException extends RuntimeException {
-
- public DeprecationException(String message) {
- super(message);
- }
-
- public DeprecationException(String message, Throwable cause) {
- super(message, cause);
- }
-}
http://git-wip-us.apache.org/repos/asf/groovy/blob/10110145/src/main/groovy/lang/EmptyRange.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/lang/EmptyRange.java b/src/main/groovy/lang/EmptyRange.java
deleted file mode 100644
index b67b32e..0000000
--- a/src/main/groovy/lang/EmptyRange.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * 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 groovy.lang;
-
-import org.codehaus.groovy.runtime.InvokerHelper;
-
-import java.util.AbstractList;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-/**
- * Constructing Ranges like 0..<0
- */
-public class EmptyRange<T extends Comparable> extends AbstractList<T> implements Range<T> {
-
- /**
- * The value at which the range originates (may be <code>null</code>).
- */
- protected T at;
-
- /**
- * Creates a new {@link EmptyRange}.
- *
- * @param at the value at which the range starts (may be <code>null</code>).
- */
- public EmptyRange(T at) {
- this.at = at;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public T getFrom() {
- return at;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public T getTo() {
- return at;
- }
-
- /**
- * Never true for an empty range.
- *
- * @return <code>false</code>
- */
- @Override
- public boolean isReverse() {
- return false;
- }
-
- /**
- * Never true for an empty range.
- *
- * @return <code>false</code>
- */
- @Override
- public boolean containsWithinBounds(Object o) {
- return false;
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String inspect() {
- return InvokerHelper.inspect(at) + "..<" + InvokerHelper.inspect(at);
- }
-
- /**
- * {@inheritDoc}
- */
- public String toString() {
- return (null == at)
- ? "null..<null"
- : at + "..<" + at;
- }
-
- /**
- * Always 0 for an empty range.
- *
- * @return 0
- */
- @Override
- public int size() {
- return 0;
- }
-
- /**
- * Always throws <code>IndexOutOfBoundsException</code> for an empty range.
- *
- * @throws IndexOutOfBoundsException always
- */
- @Override
- public T get(int index) {
- throw new IndexOutOfBoundsException("can't get values from Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException always
- */
- @Override
- public boolean add(T o) {
- throw new UnsupportedOperationException("cannot add to Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public boolean addAll(int index, Collection<? extends T> c) {
- throw new UnsupportedOperationException("cannot add to Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public boolean addAll(Collection<? extends T> c) {
- throw new UnsupportedOperationException("cannot add to Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public boolean remove(Object o) {
- throw new UnsupportedOperationException("cannot remove from Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public T remove(int index) {
- throw new UnsupportedOperationException("cannot remove from Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public boolean removeAll(Collection<?> c) {
- throw new UnsupportedOperationException("cannot remove from Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public boolean retainAll(Collection<?> c) {
- throw new UnsupportedOperationException("cannot retainAll in Empty Ranges");
- }
-
- /**
- * Always throws <code>UnsupportedOperationException</code> for an empty range.
- *
- * @throws UnsupportedOperationException
- */
- @Override
- public T set(int index, T element) {
- throw new UnsupportedOperationException("cannot set in Empty Ranges");
- }
-
- /**
- * Always does nothing for an empty range.
- */
- @Override
- public void step(int step, Closure closure) {
- }
-
- /**
- * Always returns an empty list for an empty range.
- */
- @Override
- public List<T> step(int step) {
- return new ArrayList<T>();
- }
-}