Coverage Report

Coverage Report - com.lexicalscope.fluentreflection.FluentAccess

Classes in this File

 package com.lexicalscope.fluentreflection;
 
 import java.lang.reflect.Type;
 import java.util.List;
 
 import org.hamcrest.Matcher;
 
 /*
  * Copyright 2011 Tim Wood
  *
  * 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.
  */
 
 /**
  * Reflection access to a class or an object.
  *
  * @author tim
  *
  * @param <T> the underlying type being reflected on
  */
 public interface FluentAccess<T> extends FluentAnnotated {
     /**
      * Obtain the class being reflected
      *
      * @return the class being reflected
      */
     Class<T> classUnderReflection();
 
     /**
      * All interfaces implemented by this type
      *
      * @return all the interfaces
      */
     List<FluentClass<?>> interfaces();
 
     /**
      * Return the list of all superclasses with the immediate parent first
      *
      * @return list of superclasses nearest first
      */
     List<FluentClass<?>> superclasses();
 
     /**
      * Does this type or any of its implemented types match the given matcher?
      *
      * @param typeMatcher
      *            matcher on the required type
      *
      * @return does the type or any of its supertypes match the given matcher
      */
     boolean isType(ReflectionMatcher<FluentClass<?>> typeMatcher);
 
     /**
      * All methods
      *
      * @return all the methods
      */
     List<FluentMethod> methods();
 
     /**
      * All methods declared by this type
      *
      * @return methods declared by this type
      */
     List<FluentMethod> declaredMethods();
 
     /**
      * Find all methods matching the supplied matcher
      *
      * @param methodMatcher
      *            matches the methods
      *
      * @return The methods matching the supplied matcher
      */
     List<FluentMethod> methods(Matcher<? super FluentMethod> methodMatcher);
 
     /**
      * Find the first method matching the supplied matcher
      *
      * @param methodMatcher
      *            matches the method
      *
      * @return The method matching the supplied matcher
      */
     FluentMethod method(Matcher<? super FluentMethod> methodMatcher);
 
     /**
      * Find the first method with the given name
      *
      * @param name
      *            the name of the method
      *
      * @return The method matching the name
      */
     FluentMethod method(String name);
 
     /**
      * Call a method by name if one can be found that can be called with the given arguments
      *
      * @param name the name of the method
      * @param args the arguments of the method
      *
      * @return the result of calling the method
      */
     FluentObject<?> call(String name, Object ... args);
 
     /**
      * Call a method using a matcher, if one can be found that can also be called with the given arguments
      *
      * @param methodMatcher matches the method
      * @param args the arguments of the method
      *
      * @return the result of calling the method
      */
     FluentObject<?> call(Matcher<? super FluentMethod> methodMatcher, Object ... args);
 
     /**
      * All fields
      *
      * @return all the fields
      */
     List<FluentField> fields();
 
     /**
      * Find all fields matching the supplied matcher
      *
      * @param fieldMatcher
      *            matches the field
      *
      * @return The fields matching the supplied matcher
      */
     List<FluentField> fields(ReflectionMatcher<? super FluentField> fieldMatcher);
 
     /**
      * All fields declared by this type
      *
      * @return fields declared by this type
      */
     List<FluentField> declaredFields();
 
     /**
      * Find field matching the supplied matcher
      *
      * @param fieldMatcher
      *            matches the field
      *
      * @return The first field matching the supplied matcher
      */
     FluentField field(ReflectionMatcher<FluentMember> fieldMatcher);
 
     /**
      * Determines if this {@code Class} object represents a
      * primitive type.
      *
      * @return true if and only if this class represents a primitive type
      */
     boolean isPrimitive();
 
     /**
      * Determines if this {@code Class} object represents the wrapper of a
      * primitive type.
      *
      * @return true iff this class is one of the primative wrapper types
      */
     boolean isUnboxable();
 
     /**
      * Determines if this {@code Class} object is a primitive wrapper
      * type, and the unwrapped type can be assigned from the parameter.
      * Can the parameter be boxed into this type?
      *
      * @param from the type that maybe be assignable to this type
      *
      * @return true iff this class is a primitive wrapper type, and the
      * unwrapped type can be assigned from the parameter
      */
     boolean canBeBoxed(Class<?> from);
 
     /**
      * Determines if this {@code Class} object is a primitive
      * type, and the wrapped type can be assigned from the parameter.
      * Can the parameter be unboxed into this type?
      *
      * @param from the type that maybe be assignable to this type
      *
      * @return true iff this class is a primitive type, and the
      * wrapped type can be assigned from the parameter
      */
     boolean canBeUnboxed(Class<?> from);
 
     /**
      * If this class is a primitive type return the wrapped type
      *
      * @return the wrapped type or this
      */
     FluentClass<T> boxedType();
 
     /**
      * If this class is a primitive wrapper type return the unwrapped type
      *
      * @return the unwrapped type or this
      */
     FluentClass<T> unboxedType();
 
     /**
      * True if the given object can be assigned to a variable of the type
      * represented by this class
      *
      * @param value
      *            the value that might be assigned
      *
      * @return true iff the value can be assigned to variables of this type
      */
     boolean assignableFromObject(Object value);
 
     /**
      * Is the parameter assignable from this class?
      *
      * @param klass the class that may be assignable to
      *
      * @return true iff the parameter is assignable from this class
      */
     boolean assignableTo(Class<?> klass);
 
     FluentClass<?> typeArgument(int typeParameter);
 
     /**
      * @return the name of the class under reflection
      */
     String name();
 
     /**
      * @return the simple name of the class under reflection
      */
     String simpleName();
 
     /**
      * @return the underlying type instance
      */
     Type type();
 }

1		package com.lexicalscope.fluentreflection;
2
3		import java.lang.reflect.Type;
4		import java.util.List;
5
6		import org.hamcrest.Matcher;
7
8		/*
9		* Copyright 2011 Tim Wood
10		*
11		* Licensed under the Apache License, Version 2.0 (the "License");
12		* you may not use this file except in compliance with the License.
13		* You may obtain a copy of the License at
14		*
15		* http://www.apache.org/licenses/LICENSE-2.0
16		*
17		* Unless required by applicable law or agreed to in writing, software
18		* distributed under the License is distributed on an "AS IS" BASIS,
19		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20		* See the License for the specific language governing permissions and
21		* limitations under the License.
22		*/
23
24		/**
25		* Reflection access to a class or an object.
26		*
27		* @author tim
28		*
29		* @param <T> the underlying type being reflected on
30		*/
31		public interface FluentAccess<T> extends FluentAnnotated {
32		/**
33		* Obtain the class being reflected
34		*
35		* @return the class being reflected
36		*/
37		Class<T> classUnderReflection();
38
39		/**
40		* All interfaces implemented by this type
41		*
42		* @return all the interfaces
43		*/
44		List<FluentClass<?>> interfaces();
45
46		/**
47		* Return the list of all superclasses with the immediate parent first
48		*
49		* @return list of superclasses nearest first
50		*/
51		List<FluentClass<?>> superclasses();
52
53		/**
54		* Does this type or any of its implemented types match the given matcher?
55		*
56		* @param typeMatcher
57		* matcher on the required type
58		*
59		* @return does the type or any of its supertypes match the given matcher
60		*/
61		boolean isType(ReflectionMatcher<FluentClass<?>> typeMatcher);
62
63		/**
64		* All methods
65		*
66		* @return all the methods
67		*/
68		List<FluentMethod> methods();
69
70		/**
71		* All methods declared by this type
72		*
73		* @return methods declared by this type
74		*/
75		List<FluentMethod> declaredMethods();
76
77		/**
78		* Find all methods matching the supplied matcher
79		*
80		* @param methodMatcher
81		* matches the methods
82		*
83		* @return The methods matching the supplied matcher
84		*/
85		List<FluentMethod> methods(Matcher<? super FluentMethod> methodMatcher);
86
87		/**
88		* Find the first method matching the supplied matcher
89		*
90		* @param methodMatcher
91		* matches the method
92		*
93		* @return The method matching the supplied matcher
94		*/
95		FluentMethod method(Matcher<? super FluentMethod> methodMatcher);
96
97		/**
98		* Find the first method with the given name
99		*
100		* @param name
101		* the name of the method
102		*
103		* @return The method matching the name
104		*/
105		FluentMethod method(String name);
106
107		/**
108		* Call a method by name if one can be found that can be called with the given arguments
109		*
110		* @param name the name of the method
111		* @param args the arguments of the method
112		*
113		* @return the result of calling the method
114		*/
115		FluentObject<?> call(String name, Object ... args);
116
117		/**
118		* Call a method using a matcher, if one can be found that can also be called with the given arguments
119		*
120		* @param methodMatcher matches the method
121		* @param args the arguments of the method
122		*
123		* @return the result of calling the method
124		*/
125		FluentObject<?> call(Matcher<? super FluentMethod> methodMatcher, Object ... args);
126
127		/**
128		* All fields
129		*
130		* @return all the fields
131		*/
132		List<FluentField> fields();
133
134		/**
135		* Find all fields matching the supplied matcher
136		*
137		* @param fieldMatcher
138		* matches the field
139		*
140		* @return The fields matching the supplied matcher
141		*/
142		List<FluentField> fields(ReflectionMatcher<? super FluentField> fieldMatcher);
143
144		/**
145		* All fields declared by this type
146		*
147		* @return fields declared by this type
148		*/
149		List<FluentField> declaredFields();
150
151		/**
152		* Find field matching the supplied matcher
153		*
154		* @param fieldMatcher
155		* matches the field
156		*
157		* @return The first field matching the supplied matcher
158		*/
159		FluentField field(ReflectionMatcher<FluentMember> fieldMatcher);
160
161		/**
162		* Determines if this {@code Class} object represents a
163		* primitive type.
164		*
165		* @return true if and only if this class represents a primitive type
166		*/
167		boolean isPrimitive();
168
169		/**
170		* Determines if this {@code Class} object represents the wrapper of a
171		* primitive type.
172		*
173		* @return true iff this class is one of the primative wrapper types
174		*/
175		boolean isUnboxable();
176
177		/**
178		* Determines if this {@code Class} object is a primitive wrapper
179		* type, and the unwrapped type can be assigned from the parameter.
180		* Can the parameter be boxed into this type?
181		*
182		* @param from the type that maybe be assignable to this type
183		*
184		* @return true iff this class is a primitive wrapper type, and the
185		* unwrapped type can be assigned from the parameter
186		*/
187		boolean canBeBoxed(Class<?> from);
188
189		/**
190		* Determines if this {@code Class} object is a primitive
191		* type, and the wrapped type can be assigned from the parameter.
192		* Can the parameter be unboxed into this type?
193		*
194		* @param from the type that maybe be assignable to this type
195		*
196		* @return true iff this class is a primitive type, and the
197		* wrapped type can be assigned from the parameter
198		*/
199		boolean canBeUnboxed(Class<?> from);
200
201		/**
202		* If this class is a primitive type return the wrapped type
203		*
204		* @return the wrapped type or this
205		*/
206		FluentClass<T> boxedType();
207
208		/**
209		* If this class is a primitive wrapper type return the unwrapped type
210		*
211		* @return the unwrapped type or this
212		*/
213		FluentClass<T> unboxedType();
214
215		/**
216		* True if the given object can be assigned to a variable of the type
217		* represented by this class
218		*
219		* @param value
220		* the value that might be assigned
221		*
222		* @return true iff the value can be assigned to variables of this type
223		*/
224		boolean assignableFromObject(Object value);
225
226		/**
227		* Is the parameter assignable from this class?
228		*
229		* @param klass the class that may be assignable to
230		*
231		* @return true iff the parameter is assignable from this class
232		*/
233		boolean assignableTo(Class<?> klass);
234
235		FluentClass<?> typeArgument(int typeParameter);
236
237		/**
238		* @return the name of the class under reflection
239		*/
240		String name();
241
242		/**
243		* @return the simple name of the class under reflection
244		*/
245		String simpleName();
246
247		/**
248		* @return the underlying type instance
249		*/
250		Type type();
251		}