Found 141334 results in 4336 files, showing top 50 files (show more).
github.com/apache/juneau:juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java: [ master, ]
62: 		MAP, COLLECTION, CLASS, METHOD, NUMBER, DECIMAL, BOOLEAN, CHAR, DATE, ARRAY, ENUM, OTHER, CHARSEQ, STR, OBJ, URI, BEANMAP,...(43 bytes skipped)...
58: public final class ClassMeta<T> implements Type {
61: 	enum ClassCategory {
65: 	final Class<T> innerClass;                              // The class being wrapped.
68: 	private final Class<? extends T> implClass;             // The implementation class to use if this is an interface.
84: 		isMemberClass;                                       // True if this is a non-static member class.
140: 	ClassMeta(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] pojoSwaps, PojoSwap<?,?>[] childPojoSwaps, Object example) ...(2 bytes skipped)...
223: 	ClassMeta(ClassMeta<T> mainType, ClassMeta<?> keyType, ClassMeta<?> valueType, ClassMeta<?> elementType) {
266: 	ClassMeta(ClassMeta<?>[] args) {
306: 	private final class ClassMetaBuilder<T> {
307: 		Class<T> innerClass;
309: 		Class<? extends T> implClass;
314: 			isMemberClass = false,
351: 		ClassMetaBuilder(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] pojoSwaps, PojoSwap<?,?>[] childPojoSwaps, Object example) ...(2 bytes skipped)...
929: 	public Class<T> getInnerClass() {
1152: 	public boolean isClass() {
1451: 	public boolean isMemberClass() {
743: 		private ClassMeta<?> findClassMeta(Class<?> c) {
808: 	public ClassCategory getClassCategory() {
942: 	public ClassMeta<?> getSerializedClassMeta(BeanSession session) {
38:  * A wrapper class around the {@link Class} object that provides cached information about that class.
41:  * Instances of this class can be created through the {@link BeanContext#getClassMeta(Class)} method.
44:  * The {@link BeanContext} class will cache and reuse instances of this class except for the following class types:
52:  * This class is tied to the {@link BeanContext} class because it's that class that makes the determination of what is
55:  * @param <T> The class type of the wrapped class.
60: 	/** Class categories. */
69: 	private final ClassCategory cc;                         // The class category.
72: 		noArgConstructor,                                    // The no-arg constructor for this class (if it has one).
82: 		isDelegate,                                          // True if this class extends Delegate.
83: 		isAbstract,                                          // True if this class is abstract.
88: ...(4 bytes skipped)...vate final PojoSwap<?,?>[] childPojoSwaps;           // Any PojoSwaps where the normal type is a subclass of this class.
89: 	private final ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
97: 		elementType,                                         // If ARRAY or COLLECTION, the element class type.
98: 		keyType,                                             // If MAP, the key class type.
99: 		valueType;                                           // If MAP, the value class type.
100: 	private final BeanMeta<T> beanMeta;                     // The bean meta for this bean class (if it's a bean).
102: ...(7 bytes skipped)...ropertyName,                                    // The property name of the _type property for this class and subclasses.
104: 		dictionaryName;                                      // The dictionary name of this class if it has one.
106: 	private final InvocationHandler invocationHandler;      // The invocation handler for this class (if it has one).
107: 	private final BeanRegistry beanRegistry;                // The bean registry of this class meta (if it has one).
110: 	private final Map<Class<?>,Mutater<?,T>> fromMutaters = new ConcurrentHashMap<>();
111: 	private final Map<Class<?>,Mutater<T,?>> toMutaters = new ConcurrentHashMap<>();
118: 	 * Construct a new {@code ClassMeta} based on the specified {@link Class}.
120: 	 * @param innerClass The class being wrapped.
123: 	 * 	For interfaces and abstract classes, this represents the "real" class to instantiate.
126: 	 * 	The {@link BeanFilter} programmatically associated with this class.
129: 	 * 	The {@link PojoSwap} programmatically associated with this class.
132: 	 * 	The child {@link PojoSwap PojoSwaps} programmatically associated with this class.
133: 	 * 	These are the <c>PojoSwaps</c> that have normal classes that are subclasses of this class.
137: 	 * 	Used for delayed initialization when the possibility of class reference loops exist.
148: 			// We always immediately add this class meta to the bean context cache so that we can resolve recursive references.
199: 	private static boolean isCacheable(Class<?> c) {
221: 	 * Used for creating Map and Collection class metas that shouldn't be cached.
267: 		this.innerClass = (Class<T>) Object[].class;
342: 		ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
367: 			Class<T> c = innerClass;
385: 				else if (c == void.class || c == Void.class)
388: 				if (ci.isChildOf(Delegate.class))
391: 				if (c == Object.class)
395: 				else if (c.equals(Class.class))
396: 					cc = ClassCategory.CLASS;
397: 				else if (ci.isChildOf(Method.class))
399: 				else if (ci.isChildOf(CharSequence.class)) {
400: 					if (c.equals(String.class))
405: 				else if (ci.isChildOf(Number.class)) {
406: 					if (ci.isChildOfAny(Float.class, Double.class))
411: 				else if (ci.isChildOf(Collection.class))
413: 				else if (ci.isChildOf(Map.class)) {
414: 					if (ci.isChildOf(BeanMap.class))
419: 				else if (c == Character.class)
421: 				else if (c == Boolean.class)
423: 				else if (ci.isChildOfAny(Date.class, Calendar.class))
427: 				else if (ci.isChildOfAny(URL.class, URI.class) || bc.hasAnnotation(org.apache.juneau.annotation.URI.class, c))
429: 				else if (ci.isChildOf(Reader.class))
431: 				else if (ci.isChildOf(InputStream.class))
433: 				else if (ci.is(Optional.class))
443: 			// parse() is used by the java logging Level class.
444: 			// forName() is used by Class and Charset
448: ...(23 bytes skipped)...C, PUBLIC, NOT_DEPRECATED) && m.hasName(methodName) && m.hasReturnType(c) && m.hasParamTypes(String.class)) {
458: ...(8 bytes skipped)...m.isAll(PUBLIC, NOT_DEPRECATED, STATIC) && m.hasName("example") && m.hasFuzzyParamTypes(BeanSession.class)) {
465: 				if (bc.hasAnnotation(ParentProperty.class, f)) {
471: 				if (bc.hasAnnotation(NameProperty.class, f)) {
480: 				if (bc.hasAnnotation(Example.class, f)) {
490: 				if (bc.hasAnnotation(ParentProperty.class, m)) {
496: 				if (bc.hasAnnotation(NameProperty.class, m)) {
505: 				if (bc.hasAnnotation(Example.class, m)) {
506: 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
507: 						throw new Class...(22 bytes skipped)..., "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
520: 					if (pt.size() == (isMemberClass ? 1 : 0) && c != Object.class && ! isAbstract) {
524: 						if (arg.is(String.class))
536: 			if (innerClass != Object.class) {
565: 						keyType = findClassMeta(Object.class);
566: 						valueType = findClassMeta(Object.class);
576: 						elementType = findClassMeta(Object.class);
614: 			Bean b = bc == null ? null : bc.getAnnotation(Bean.class, c);
626: 			Example e = bc == null ? null : bc.getAnnotation(Example.class, c);
650: 						Iterator<? extends Enum> i = EnumSet.allOf((Class<? extends Enum>)c).iterator();
666: 					case CLASS:
683: 			this.stringMutater = Mutaters.get(String.class, c);
688: 				List<Bean> ba = info.getAnnotations(Bean.class, bc);
698: 			Swap swap = bc == null ? null : bc.getAnnotation(Swap.class, innerClass);
701: 			Swaps swaps = bc == null ? null : bc.getAnnotation(Swaps.class, innerClass);
720: 			Class<?> c = s.value();
721: 			if (c == Null.class)
725: 			if (ci.isChildOf(PojoSwap.class)) {
726: 				PojoSwap ps = castOrCreate(PojoSwap.class, c);
734: 			if (ci.isChildOf(Surrogate.class)) {
740: 			throw new ClassMetaRuntimeException(c, "Invalid swap class ''{0}'' specified.  Must extend from PojoSwap or Surrogate.", c);
753: 	 * Returns the {@link ClassInfo} wrapper for the underlying class.
755: 	 * @return The {@link ClassInfo} wrapper for the underlying class, never <jk>null</jk>.
762: 	 * Returns the type property name associated with this class and subclasses.
768: 	 * 	The type property name associated with this bean class, or <jk>null</jk> if there is no explicit type
776: 	 * Returns the bean dictionary name associated with this class.
782: 	 * 	The type name associated with this bean class, or <jk>null</jk> if there is no type name defined or this
790: 	 * Returns the bean registry for this class.
794: 	 * defined on the class, regardless of whether the class is an actual bean.
797: 	 * @return The bean registry for this class, or <jk>null</jk> if no bean registry is associated with it.
804: 	 * Returns the category of this class.
806: 	 * @return The category of this class.
813: 	 * Returns <jk>true</jk> if this class is a superclass of or the same as the specified class.
815: 	 * @param c The comparison class.
816: 	 * @return <jk>true</jk> if this class is a superclass of or the same as the specified class.
818: 	public boolean isAssignableFrom(Class<?> c) {
823: 	 * Returns <jk>true</jk> if this class is a subclass of or the same as the specified class.
825: 	 * @param c The comparison class.
826: 	 * @return <jk>true</jk> if this class is a subclass of or the same as the specified class.
828: 	public boolean isInstanceOf(Class<?> c) {
833: 	 * Returns <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
839: 	 * @return <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
846: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the normal class of one of the
847: 	 * child POJO swaps associated with this class.
849: 	 * @param normalClass The normal class being resolved.
852: 	protected PojoSwap<?,?> getChildPojoSwapForSwap(Class<?> normalClass) {
873: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the swap class of one of the child
874: 	 * POJO swaps associated with this class.
876: 	 * @param swapClass The swap class being resolved.
879: 	protected PojoSwap<?,?> getChildPojoSwapForUnswap(Class<?> swapClass) {
900: 	 * Locates the no-arg constructor for the specified class.
904: 	 * If class is abstract, always returns <jk>null</jk>.
907: 	 * @param c The class from which to locate the no-arg constructor.
912: 	protected static <T> Constructor<? extends T> findNoArgConstructor(Class<?> c, Visibility v) {
925: 	 * Returns the {@link Class} object that this class type wraps.
927: 	 * @return The wrapped class object.
934: 	 * Returns the serialized (swapped) form of this class if there is an {@link PojoSwap} associated with it.
939: 	 * @return The serialized class type, or this object if no swap is associated with the class.
948: 	 * Returns the example of this class.
953: 	 * @return The serialized class type, or this object if no swap is associated with the class.
1020: 	 * For array and {@code Collection} types, returns the class type of the components of the array or
1023: 	 * @return The element class type, or <jk>null</jk> if this class is not an array or Collection.
1030: 	 * For {@code Map} types, returns the class type of the keys of the {@code Map}.
1032: 	 * @return The key class type, or <jk>null</jk> if this class is not a Map.
1039: 	 * For {@code Map} types, returns the class type of the values of the {@code Map}.
1041: 	 * @return The value class type, or <jk>null</jk> if this class is not a Map.
1048: 	 * Returns <jk>true</jk> if this class implements {@link Delegate}, meaning it's a representation of some other
1051: 	 * @return <jk>true</jk> if this class implements {@link Delegate}.
1058: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map}.
1060: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map}.
1067: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1069: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1076: 	 * Returns <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1078: 	 * @return <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1085: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection}.
1087: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection}.
1094: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Optional}.
1096: 	 * @return <jk>true</jk> if this class is a subclass of {@link Optional}.
1103: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1105: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1112: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1114: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1121: 	 * Returns <jk>true</jk> if this class extends from {@link Set}.
1123: 	 * @return <jk>true</jk> if this class extends from {@link Set}.
1126: 		return cc == COLLECTION && info.isChildOf(Set.class);
1130: 	 * Returns <jk>true</jk> if this class extends from {@link List}.
1132: 	 * @return <jk>true</jk> if this class extends from {@link List}.
1135: 		return cc == COLLECTION && info.isChildOf(List.class);
1139: 	 * Returns <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1141: 	 * @return <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1144: 		return cc == ARRAY && this.innerClass == byte[].class;
1148: 	 * Returns <jk>true</jk> if this class is {@link Class}.
1150: 	 * @return <jk>true</jk> if this class is {@link Class}.
1153: 		return cc == ClassCategory.CLASS;
1157: 	 * Returns <jk>true</jk> if this class is {@link Method}.
1159: 	 * @return <jk>true</jk> if this class is {@link Method}.
1166: 	 * Returns <jk>true</jk> if this class is an {@link Enum}.
1168: 	 * @return <jk>true</jk> if this class is an {@link Enum}.
1175: 	 * Returns <jk>true</jk> if this class is an array.
1177: 	 * @return <jk>true</jk> if this class is an array.
1184: 	 * Returns <jk>true</jk> if this class is a bean.
1186: 	 * @return <jk>true</jk> if this class is a bean.
1193: 	 * Returns <jk>true</jk> if this class is {@link Object}.
1195: 	 * @return <jk>true</jk> if this class is {@link Object}.
1202: 	 * Returns <jk>true</jk> if this class is not {@link Object}.
1204: 	 * @return <jk>true</jk> if this class is not {@link Object}.
1211: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Number}.
1213: 	 * @return <jk>true</jk> if this class is a subclass of {@link Number}.
1220: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1222: 	 * @return <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1229: 	 * Returns <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1231: 	 * @return <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1234: 		return innerClass == Float.class || innerClass == float.class;
1238: 	 * Returns <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1240: 	 * @return <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1243: 		return innerClass == Double.class || innerClass == double.class;
1247: 	 * Returns <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1249: 	 * @return <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1252: 		return innerClass == Short.class || innerClass == short.class;
1256: 	 * Returns <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1258: 	 * @return <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1261: 		return innerClass == Integer.class || innerClass == int.class;
1265: 	 * Returns <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1267: 	 * @return <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1270: 		return innerClass == Long.class || innerClass == long.class;
1276: 	 * @param c The class to test against.
1279: 	public boolean isType(Class<?> c) {
1284: 	 * Returns <jk>true</jk> if this class is a {@link Boolean}.
1286: 	 * @return <jk>true</jk> if this class is a {@link Boolean}.
1293: 	 * Returns <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1295: 	 * @return <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1302: 	 * Returns <jk>true</jk> if this class is a {@link String}.
1304: 	 * @return <jk>true</jk> if this class is a {@link String}.
1311: 	 * Returns <jk>true</jk> if this class is a {@link Character}.
1313: 	 * @return <jk>true</jk> if this class is a {@link Character}.
1320: 	 * Returns <jk>true</jk> if this class is a primitive.
1322: 	 * @return <jk>true</jk> if this class is a primitive.
1329: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1331: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1338: 	 * Returns <jk>true</jk> if this class is a {@link Date}.
1340: 	 * @return <jk>true</jk> if this class is a {@link Date}.
1343: 		return cc == DATE && info.isChildOf(Date.class);
1347: 	 * Returns <jk>true</jk> if this class is a {@link Calendar}.
1349: 	 * @return <jk>true</jk> if this class is a {@link Calendar}.
1352: 		return cc == DATE && info.isChildOf(Calendar.class);
1356: 	 * Returns <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1358: 	 * @return <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1365: 	 * Returns <jk>true</jk> if this class is a {@link Reader}.
1367: 	 * @return <jk>true</jk> if this class is a {@link Reader}.
1374: 	 * Returns <jk>true</jk> if this class is an {@link InputStream}.
1376: 	 * @return <jk>true</jk> if this class is an {@link InputStream}.
1383: 	 * Returns <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1385: 	 * @return <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1429: 	 * @return <jk>true</jk> if instance of this class can be null.
1438: 	 * Returns <jk>true</jk> if this class is abstract.
1440: 	 * @return <jk>true</jk> if this class is abstract.
1447: 	 * Returns <jk>true</jk> if this class is an inner class.
1449: 	 * @return <jk>true</jk> if this class is an inner class.
1456: 	 * All public methods on this class including static methods.
1461: 	 * @return The public methods on this class.
1468: 	 * Returns the {@link PojoSwap} associated with this class that's the best match for the specified session.
1472: 	 * 	<br>If multiple swaps are associated with a class, only the first one with a matching media type will
1475: 	 * 	The {@link PojoSwap} associated with this class, or <jk>null</jk> if there are no POJO swaps associated with
1476: 	 * 	this class.
1497: 	 * Returns the builder swap associated with this class.
1500: 	 * @return The builder swap associated with this class, or <jk>null</jk> if it doesn't exist.
1507: 	 * Returns the {@link BeanMeta} associated with this class.
1510: 	 * 	The {@link BeanMeta} associated with this class, or <jk>null</jk> if there is no bean meta associated with
1511: 	 * 	this class.
1518: 	 * Returns the no-arg constructor for this class.
1520: 	 * @return The no-arg constructor for this class, or <jk>null</jk> if it does not exist.
1527: 	 * Returns the interface proxy invocation handler for this class.
1536: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1538: 	 * @return <jk>true</jk> if a new instance of this class can be constructed.
1553: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1554: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1555: 	 * the defining class.
1558: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1560: 	 * 	<jk>true</jk> if a new instance of this class can be created within the context of the specified outer object.
1569: 	 * Returns <jk>true</jk> if this class can be instantiated as a bean.
1570: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1571: 	 * the defining class.
1574: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1589: 	 * Returns <jk>true</jk> if this class can call the {@link #newInstanceFromString(Object, String)} method.
1592: 	 * 	The outer class object for non-static member classes.
1594: 	 * @return <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1601: 				return outer != null && stringConstructor.hasParamTypes(outer.getClass(), String.class);
1630: 	 * Returns the reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1632: 	 * @return The reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1659: 	 * @return The default value, or <jk>null</jk> if this class type is not a primitive.
1695: 	 * Create a new instance of the main class of this declared type from a <c>String</c> input.
1698: 	 * In order to use this method, the class must have one of the following methods:
1706: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1715: 			return (T)Enum.valueOf((Class<? extends Enum>)this.innerClass, arg);
1731: 		throw new InstantiationError("No string constructor or valueOf(String) method found for class '"+getInnerClass().getName()+"'");
1735: 	 * Create a new instance of the main class of this declared type.
1749: 			return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] { getInnerClass(), java.io.Serializable.class }, h);
1759: 	 * 	The instance of the owning object of the member class instance.
1760: 	 * 	Can be <jk>null</jk> if instantiating a non-member or static class.
1774: 	 * @param cm The class meta to compare to.
1775: 	 * @return <jk>true</jk> if the specified class-meta is equivalent to this one.
1789: 	 * Same as {@link #toString()} except use simple class names.
1791: 	 * @param simple Print simple class names only (no package).
1802: 	 * @param simple Print simple class names only (no package).
1816: 			return sb.append(BeanMap.class.getName()).append('<').append(n).append('>');
1823: 	 * Returns <jk>true</jk> if the specified object is an instance of this class.
1826: 	 * This is a simple comparison on the base class itself and not on any generic parameters.
1829: 	 * @return <jk>true</jk> if the specified object is an instance of this class.
1838: 	 * Returns a readable name for this class (e.g. <js>"java.lang.String"</js>, <js>"boolean[]"</js>).
1840: 	 * @return The readable name for this class.
1847: 	 * Shortcut for calling {@link Class#getName()} on the inner class of this metadata.
1849: 	 * @return The  name of the inner class.
1856: 	 * Shortcut for calling {@link Class#getSimpleName()} on the inner class of this metadata.
1858: 	 * @return The simple name of the inner class.
1865: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1867: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1870: 		return hasMutaterFrom(Reader.class);
1874: 	 * Returns the transform for this class for creating instances from a Reader.
1879: 		return getFromMutater(Reader.class);
1883: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1885: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1888: 		return hasMutaterFrom(InputStream.class);
1892: 	 * Returns the transform for this class for creating instances from an InputStream.
1897: 		return getFromMutater(InputStream.class);
1901: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1903: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1910: 	 * Returns the transform for this class for creating instances from a String.
1919: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1921: 	 * @param c The class type to convert from.
1922: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1924: 	public boolean hasMutaterFrom(Class<?> c) {
1929: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1931: 	 * @param c The class type to convert from.
1932: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1939: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1941: 	 * @param c The class type to convert from.
1942: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1944: 	public boolean hasMutaterTo(Class<?> c) {
1949: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1951: 	 * @param c The class type to convert from.
1952: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1959: 	 * Transforms the specified object into an instance of this class.
1971: 	 * Transforms the specified object into an instance of this class.
1974: 	 * @param c The class
1978: 	public <O> O mutateTo(Object o, Class<O> c) {
1984: 	 * Transforms the specified object into an instance of this class.
1987: 	 * @param c The class
1995: 	 * Returns the transform for this class for creating instances from other object types.
1997: 	 * @param c The transform-from class.
2001: 	public <I> Mutater<I,T> getFromMutater(Class<I> c) {
2015: 	 * Returns the transform for this class for creating instances from other object types.
2017: 	 * @param c The transform-from class.
2021: 	public <O> Mutater<T,O> getToMutater(Class<O> c) {
2038: 	 * @return <jk>true</jk> if the inner class has the annotation.
2040: 	public boolean hasAnnotation(Class<? extends Annotation> a) {
2048: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2050: 	public <A extends Annotation> A getAnnotation(Class<A> a) {
2055: 	 * Returns the declared annotation defined on this class.
2058: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2060: 	public <A extends Annotation> A getDeclaredAnnotation(Class<A> a) {
2065: 	 * Returns all annotations of the specified type defined on the specified class or parent classes/interfaces.
2072: 	public <A extends Annotation> List<A> getAnnotations(Class<A> a) {
2077: 	 * Identical to {@link #getAnnotations(Class)} but optionally returns the list in reverse (parent-to-child) order.
2084: 	public <A extends Annotation> List<A> getAnnotationsParentFirst(Class<A> a) {
15: import static org.apache.juneau.ClassMeta.ClassCategory.*;
16: import static org.apache.juneau.internal.ClassUtils.*;
57: @Bean(bpi="innerClass,classCategory,elementType,keyType,valueType,notABeanReason,initException,beanMeta")
66: 	final ClassInfo info;
85: 	private final Object primitiveDefault;                  // Default value for primitive type classes.
96: 	private final ClassMeta<?>
108: 	private final ClassMeta<?>[] args;                      // Arg types if this is an array of args.
122: 	 * @param implClass
141: 		this.innerClass = innerClass;
142: 		this.info = ClassInfo.of(innerClass);
149: 			if (beanContext != null && beanContext.cmCache != null && isCacheable(innerClass))
150: 				beanContext.cmCache.put(innerClass, this);
152: 			ClassMetaBuilder<T> builder = new ClassMetaBuilder(innerClass, beanContext, implClass, beanFilter, pojoSwaps, childPojoSwaps, example);
176: 			this.isMemberClass = builder.isMemberClass;
178: 			this.implClass = builder.implClass;
187: 		} catch (ClassMetaRuntimeException e) {
197: 	 * Generated classes shouldn't be cacheable to prevent needlessly filling up the cache.
201: 		char x = n.charAt(n.length()-1);  // All generated classes appear to end with digits.
224: 		this.innerClass = mainType.innerClass;
226: 		this.implClass = mainType.implClass;
238: 		this.isMemberClass = mainType.isMemberClass;
268: 		this.info = ClassInfo.of(innerClass);
270: 		this.implClass = null;
282: 		this.isMemberClass = false;
308: 		ClassInfo ci;
311: 		ClassCategory cc = ClassCategory.OTHER;
327: 		ClassMeta<?>
352: 			this.innerClass = innerClass;
356: 			this.implClass = implClass;
357: 			ClassInfo ici = ClassInfo.of(implClass);
368: 			ci = ClassInfo.of(c);
371: 				innerClass = this.innerClass = ci.inner();
437: 			isMemberClass = ci.isMemberClass() && ci.isNotStatic();
440: 			// fromString() must be checked before valueOf() so that Enum classes can create their own
467: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
473: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
482: 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of ...(16 bytes skipped)...
492: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and hav...(22 bytes skipped)...
498: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have ...(20 bytes skipped)...
519: 					List<ClassInfo> pt = cs.getParamTypes();
522: 					} else if (pt.size() == (isMemberClass ? 2 : 1)) {
523: 						ClassInfo arg = pt.get(isMemberClass ? 1 : 0);
537: 				ClassInfo x = implClass == null ? ci : ici;
548: 				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
556: 					elementType = findClassMeta(innerClass.getComponentType());
560: 					ClassMeta[] parameters = findParameters();
572: 					ClassMeta[] parameters = findParameters();
586: 						newMeta = new BeanMeta(ClassMeta.this, bc, beanFilter, null);
611: 			if (beanMeta != null && bc != null && bc.isUseInterfaceProxies() && innerClass.isInterface())
690: 					return new AnnotationBeanFilterBuilder(innerClass, ba).build();
723: 			ClassInfo ci = ClassInfo.of(c);
747: 		private ClassMeta<?>[] findParameters() {
748: 			return beanContext.findParameters(innerClass, innerClass);
757: 	public ClassInfo getInfo() {
854: 			PojoSwap<?,?> s = childSwapMap.get(normalClass);
857: 					if (s == null && f.getNormalClass().isParentOf(normalClass))
861: 				PojoSwap<?,?> s2 = childSwapMap.putIfAbsent(normalClass, s);
881: 			PojoSwap<?,?> s = childUnswapMap.get(swapClass);
884: 					if (s == null && f.getSwapClass().isParentOf(swapClass))
888: 				PojoSwap<?,?> s2 = childUnswapMap.putIfAbsent(swapClass, s);
905: 	 * Note that this also returns the 1-arg constructor for non-static member classes.
913: 		ClassInfo ci = ClassInfo.of(c);
916: 		boolean isMemberClass = ci.isMemberClass() && ci.isNotStatic();
918: 			if (cc.hasNumParams(isMemberClass ? 1 : 0) && cc.isVisible(v) && cc.isNotDeprecated())
930: 		return innerClass;
996: 					Object o = Array.newInstance(getElementType().innerClass, 1);
1015: 			throw new ClassMetaRuntimeException(e);
1025: 	public ClassMeta<?> getElementType() {
1034: 	public ClassMeta<?> getKeyType() {
1043: 	public ClassMeta<?> getValueType() {
1325: 		return innerClass.isPrimitive();
1405: 	public ClassMeta<?>[] getArgs() {
1416: 	public ClassMeta<?> getArg(int index) {
1432: 		if (innerClass.isPrimitive())
1452: 		return isMemberClass;
1541: 		if (isMemberClass)
1563: 		if (isMemberClass)
1564: 			return outer != null && noArgConstructor != null && noArgConstructor.hasParamTypes(outer.getClass());
1583: 		if (isMemberClass)
1584: 			return outer != null && beanMeta.constructor.hasParamTypes(outer.getClass());
1593: 	 * 	Can be <jk>null</jk> for non-member or static classes.
1600: 			if (isMemberClass)
1727: 			if (isMemberClass)
1743: 			return (T)Array.newInstance(getInnerClass().getComponentType(), 0);
1751: 			return (T)Array.newInstance(this.elementType.innerClass,0);
1756: 	 * Same as {@link #newInstance()} except for instantiating non-static member classes.
1765: 		if (isMemberClass)
1777: 	public boolean same(ClassMeta<?> cm) {
1806: 		String n = innerClass.getName();
1833: 			return info.isParentOf(o.getClass()) || (isPrimitive() && info.getPrimitiveWrapper() == o.getClass());
1852: 		return innerClass.getName();
1861: 		return innerClass.getSimpleName();
1934: 	public boolean hasMutaterFrom(ClassMeta<?> c) {
1935: 		return getFromMutater(c.getInnerClass()) != null;
1954: 	public boolean hasMutaterTo(ClassMeta<?> c) {
1955: 		return getToMutater(c.getInnerClass()) != null;
1966: 		Mutater t = getFromMutater(o.getClass());
1990: 	public <O> O mutateTo(Object o, ClassMeta<O> c) {
1991: 		return mutateTo(o, c.getInnerClass());
2006: 			t = Mutaters.get(c, innerClass);
2026: 			t = Mutaters.get(innerClass, c);
2035: 	 * Shortcut for calling <code>getInnerClass().getAnnotation(a) != <jk>null</jk></code>.
2045: 	 * Shortcut for calling <c>getInnerClass().getAnnotation(a)</c>.
2090: 		return innerClass.hashCode();
2095: 		if (o == null || ! (o instanceof ClassMeta))
2097: 		ClassMeta<?> o2 = (ClassMeta<?>)o;
2098: 		return o2.innerClass.equals(innerClass);
90: 		childSwapMap,                                        // Maps normal subclasses to PojoSwaps.
91: 		childUnswapMap;                                      // Maps swap subclasses to PojoSwaps.
601: 			} catch (NoClassDefFoundError e) {
744: 			return beanContext.getClassMeta(c, false);
795: 	 * This allows interfaces to define subclasses with type names.
944: 		return (ps == null ? this : ps.getSwapClassMeta(session));
github.com/googlecreativelab/pattern-radio:kubernetes/tools/classifier_clustering/package-lock.json: [ master, ]
1590:             "needle": "^2.2.1",
1573:         "needle": {
2:   "name": "classification_pooling",
github.com/apache/activemq-artemis:artemis-commons/src/main/java/org/apache/activemq/artemis/utils/algo/KMPNeedle.java: [ master, ]
34:    private final byte[] needle;
25: public final class KMPNeedle {
36:    private KMPNeedle(byte[] needle) {
22: ...(43 bytes skipped)...ttps://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm">Knuth-Morris-Pratt</a>'s needle to be used
37:       Objects.requireNonNull(needle);
38:       this.needle = needle;
39:       this.jumpTable = createJumpTable(needle);
42:    private static int[] createJumpTable(byte[] needle) {
43:       final int[] jumpTable = new int[needle.length + 1];
45:       for (int i = 1; i < needle.length; i++) {
46:          while (j > 0 && needle[j] != needle[i]) {
49:          if (needle[j] == needle[i]) {
67:     * the remaining haystack to be processed is < of the remaining needle to be matched.
73:       final int needleLength = needle.length;
82:          while (j > 0 && needle[j] != value) {
86:          if (needle[j] == value) {
99:    public static KMPNeedle of(byte[] needle) {
100:       return new KMPNeedle(needle);
74:       int remainingNeedle = needleLength;
77:          if (remainingNeedle > remainingHayStack) {
84:             remainingNeedle = needleLength - j;
88:             remainingNeedle--;
89:             assert remainingNeedle >= 0;
91:          if (j == needleLength) {
92:             final int startMatch = index - needleLength + 1;
github.com/kubernetes/minikube:site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/kubernetes/minikube:site/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/tensorflow/playground:package-lock.json: [ master, ]
1628:             "needle": "^2.2.1",
190:         "class-utils": "^0.3.5",
1154:         "posix-character-classes": "^0.1.0",
581:     "class-utils": {
583:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1609:         "needle": {
2770:     "posix-character-classes": {
2772:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/angular/material-start:package-lock.json: [ master, ]
1624:             "needle": "^2.2.1",
407:         "class-utils": "^0.3.5",
1041:         "posix-character-classes": "^0.1.0",
648:     "class-utils": {
650:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1605:         "needle": {
3023:     "posix-character-classes": {
3025:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/dart-lang/sdk:runtime/vm/object.h: [ master, ]
911: class Class : public Object {
464:   static RawClass* class_class() { return class_class_; }
465:   static RawClass* dynamic_class() { return dynamic_class_; }
466:   static RawClass* void_class() { return void_class_; }
467:   static RawClass* never_class() { return never_class_; }
468:   static RawClass* type_arguments_class() { return type_arguments_class_; }
469:   static RawClass* patch_class_class() { return patch_class_class_; }
470:   static RawClass* function_class() { return function_class_; }
471:   static RawClass* closure_data_class() { return closure_data_class_; }
472:   static RawClass* signature_data_class() { return signature_data_class_; }
473:   static RawClass* redirection_data_class() { return redirection_data_class_; }
474:   static RawClass* ffi_trampoline_data_class() {
477:   static RawClass* field_class() { return field_class_; }
478:   static RawClass* script_class() { return script_class_; }
479:   static RawClass* library_class() { return library_class_; }
480:   static RawClass* namespace_class() { return namespace_class_; }
481:   static RawClass* kernel_program_info_class() {
484:   static RawClass* code_class() { return code_class_; }
485:   static RawClass* bytecode_class() { return bytecode_class_; }
486:   static RawClass* instructions_class() { return instructions_class_; }
487:   static RawClass* instructions_section_class() {
490:   static RawClass* object_pool_class() { return object_pool_class_; }
491:   static RawClass* pc_descriptors_class() { return pc_descriptors_class_; }
492:   static RawClass* code_source_map_class() { return code_source_map_class_; }
493:   static RawClass* compressed_stackmaps_class() {
496:   static RawClass* var_descriptors_class() { return var_descriptors_class_; }
497:   static RawClass* exception_handlers_class() {
500:   static RawClass* deopt_info_class() { return deopt_info_class_; }
501:   static RawClass* context_class() { return context_class_; }
502:   static RawClass* context_scope_class() { return context_scope_class_; }
503:   static RawClass* api_error_class() { return api_error_class_; }
504:   static RawClass* language_error_class() { return language_error_class_; }
505:   static RawClass* unhandled_exception_class() {
508:   static RawClass* unwind_error_class() { return unwind_error_class_; }
509:   static RawClass* dyncalltypecheck_class() { return dyncalltypecheck_class_; }
510:   static RawClass* singletargetcache_class() {
513:   static RawClass* unlinkedcall_class() { return unlinkedcall_class_; }
514:   static RawClass* monomorphicsmiablecall_class() {
517:   static RawClass* icdata_class() { return icdata_class_; }
518:   static RawClass* megamorphic_cache_class() {
521:   static RawClass* subtypetestcache_class() { return subtypetestcache_class_; }
753:   static RawClass* class_class_;           // Class of the Class vm object.
1331:   RawClass::ClassLoadingState class_loading_state() const {
1348:   bool is_synthesized_class() const {
1353:   bool is_enum_class() const { return EnumBit::decode(raw_ptr()->state_bits_); }
1765:   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
1766:   RawClass* origin_class() const { return raw_ptr()->origin_class_; }
4536:   RawClass* toplevel_class() const { return raw_ptr()->toplevel_class_; }
7747:   virtual RawClass* type_class() const {
1198:   bool IsNullClass() const { return id() == kNullCid; }
1201:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1204:   bool IsVoidClass() const { return id() == kVoidCid; }
1207:   bool IsNeverClass() const { return id() == kNeverCid; }
1210:   bool IsObjectClass() const { return id() == kInstanceCid; }
1219:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1222:   bool IsClosureClass() const { return id() == kClosureCid; }
1223:   static bool IsClosureClass(RawClass* cls) {
1229:   bool IsTypedefClass() const { return signature_function() != Object::null(); }
1666:   class ClassFinalizedBits : public BitField<uint32_t,
1670:   class ClassLoadingBits : public BitField<uint32_t,
1759:   kCurrentClass,  // Consider type params of current class only.
1763: class PatchClass : public Object {
4362: class ClassDictionaryIterator : public DictionaryIterator {
4944:   RawArray* classes_cache() const { return raw_ptr()->classes_cache_; }
6824:   intptr_t SizeFromClass() const {
7327:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
7577:   virtual bool HasTypeClass() const {
7738:   virtual bool HasTypeClass() const {
7821:   virtual bool HasTypeClass() const { return false; }
303: #define DEFINE_CLASS_TESTER(clazz)                                             \
754:   static RawClass* dynamic_class_;         // Class of the 'dynamic' type.
755:   static RawClass* void_class_;            // Class of the 'void' type.
756:   static RawClass* never_class_;           // Class of the 'Never' type.
757:   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
758:   static RawClass* patch_class_class_;     // Class of the PatchClass vm object.
759:   static RawClass* function_class_;        // Class of the Function vm object.
760:   static RawClass* closure_data_class_;    // Class of ClosureData vm obj.
761:   static RawClass* signature_data_class_;  // Class of SignatureData vm obj.
762:   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
763:   static RawClass* ffi_trampoline_data_class_;  // Class of FfiTrampolineData
765:   static RawClass* field_class_;                // Class of the Field vm object.
766:   static RawClass* script_class_;     // Class of the Script vm object.
767:   static RawClass* library_class_;    // Class of the Library vm object.
768:   static RawClass* namespace_class_;  // Class of Namespace vm object.
769:   static RawClass* kernel_program_info_class_;  // Class of KernelProgramInfo vm
771:   static RawClass* code_class_;                 // Class of the Code vm object.
772:   static RawClass* bytecode_class_;      // Class of the Bytecode vm object.
773:   static RawClass* instructions_class_;  // Class of the Instructions vm object.
775:       instructions_section_class_;       // Class of InstructionsSection.
776:   static RawClass* object_pool_class_;   // Class of the ObjectPool vm object.
777:   static RawClass* pc_descriptors_class_;   // Class of PcDescriptors vm object.
778:   static RawClass* code_source_map_class_;  // Class of CodeSourceMap vm object.
780:       compressed_stackmaps_class_;             // Class of CompressedStackMaps.
781:   static RawClass* var_descriptors_class_;     // Class of LocalVarDescriptors.
782:   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
783:   static RawClass* deopt_info_class_;          // Class of DeoptInfo.
784:   static RawClass* context_class_;           // Class of the Context vm object.
785:   static RawClass* context_scope_class_;     // Class of ContextScope vm object.
786:   static RawClass* dyncalltypecheck_class_;  // Class of ParameterTypeCheck.
787:   static RawClass* singletargetcache_class_;  // Class of SingleTargetCache.
788:   static RawClass* unlinkedcall_class_;       // Class of UnlinkedCall.
790:       monomorphicsmiablecall_class_;  // Class of MonomorphicSmiableCall.
791:   static RawClass* icdata_class_;     // Class of ICData.
792:   static RawClass* megamorphic_cache_class_;    // Class of MegamorphiCache.
793:   static RawClass* subtypetestcache_class_;     // Class of SubtypeTestCache.
794:   static RawClass* api_error_class_;            // Class of ApiError.
795:   static RawClass* language_error_class_;       // Class of LanguageError.
796:   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
797:   static RawClass* unwind_error_class_;         // Class of UnwindError.
4384:   Class& toplevel_class_;
7556:   static intptr_t type_class_id_offset() {
7744:   virtual classid_t type_class_id() const {
7822:   virtual classid_t type_class_id() const { return kIllegalCid; }
295:   intptr_t GetClassId() const {
557:   static const ClassId kClassId = kObjectCid;
1191:   RawGrowableObjectArray* direct_subclasses() const {
1648:     kClassFinalizedPos = 2,
1649:     kClassFinalizedSize = 2,
1650:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1651:     kClassLoadingSize = 2,
1654:     kSynthesizedClassBit,
1676:   class SynthesizedClassBit
2183:   RawICData* AsUnaryClassChecks() const {
6529:     kClassIdIndex,
6600:     kInstanceClassIdOrFunction = 1,
7828:   bool IsClassTypeParameter() const {
8601:   static const ClassId kClassId = kOneByteStringCid;
8728:   static const ClassId kClassId = kTwoByteStringCid;
8801:   static const ClassId kClassId = kExternalOneByteStringCid;
8888:   static const ClassId kClassId = kExternalTwoByteStringCid;
9177:   static const ClassId kClassId = kImmutableArrayCid;
10740: RawObject* MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
44: class Assembler;
48: class Program;
49: class TreeNode;
52: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
53: CLASS_LIST(DEFINE_FORWARD_DECLARATION)
55: class Api;
56: class ArgumentsDescriptor;
57: class Closure;
58: class Code;
59: class DeoptInstr;
60: class DisassemblyFormatter;
61: class FinalizablePersistentHandle;
62: class FlowGraphCompiler;
63: class HierarchyInfo;
64: class LocalScope;
65: class CodeStatistics;
66: class IsolateGroupReloadContext;
68: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
72: class Symbols;
73: class ZoneTextBuffer;
211:   friend class SnapshotReader;
225:   friend class Object;
234:   friend class StackFrame;                                                     \
235:   friend class Thread;
259:   friend class Object;                                                         \
260:   friend class StackFrame;                                                     \
261:   friend class Thread;
278: class Object {
302: // Class testers.
305:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
306: #undef DEFINE_CLASS_TESTER
475:     return ffi_trampoline_data_class_;
482:     return kernel_program_info_class_;
488:     return instructions_section_class_;
494:     return compressed_stackmaps_class_;
498:     return exception_handlers_class_;
506:     return unhandled_exception_class_;
511:     return singletargetcache_class_;
515:     return monomorphicsmiablecall_class_;
519:     return megamorphic_cache_class_;
547:   template <class FakeObject>
572:     //   core impl class name shown -> _OneByteString
700:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
718:     // Indicates this class cannot be extended by dart code.
724:   static void RegisterClass(const Class& cls,
727:   static void RegisterPrivateClass(const Class& cls,
803:   friend void ClassTable::Register(const Class& cls);
805:   friend class Closure;
806:   friend class SnapshotReader;
807:   friend class InstanceDeserializationCluster;
808:   friend class OneByteString;
809:   friend class TwoByteString;
810:   friend class ExternalOneByteString;
811:   friend class ExternalTwoByteString;
812:   friend class Thread;
815:   friend class Reusable##name##HandleScope;
823: class PassiveObject : public Object {
871: // The first string in the triplet is a type name (usually a class).
877: enum class Nullability : int8_t {
885: enum class TypeEquality {
896: enum class NNBDMode {
904: enum class NNBDCompiledMode {
1023:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1024:   // to this class.
1044:   // This class represents a typedef if the signature function is not null.
1050:   // Return the Type with type parameters declared by this class filled in with
1056:   // class preceded by the type arguments declared for superclasses, etc.
1058:   // class B<T, S>
1059:   // class C<R> extends B<R, int>
1087:   // Return a TypeParameter if the type_name is a type parameter of this class.
1092:   // the super class.
1095:   // Return true if this class declares type parameters.
1098:   // If this class is parameterized, each instance has a type_arguments field.
1112:         compiler::target::Class::kNoTypeArguments) {
1113:       return compiler::target::Class::kNoTypeArguments;
1125:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1127:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1129:       target_value = RTN::Class::kNoTypeArguments;
1160:   // The super type of this class, Object type if not explicitly specified.
1170:   // Asserts that the class of the super type has been resolved.
1183:   // Returns the list of classes directly implementing this class.
1187:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1190:   // Returns the list of classes having this class as direct superclass.
1194:   void AddDirectSubclass(const Class& subclass) const;
1197:   // Check if this class represents the class of null.
1200:   // Check if this class represents the 'dynamic' class.
1203:   // Check if this class represents the 'void' class.
1206:   // Check if this class represents the 'Never' class.
1209:   // Check if this class represents the 'Object' class.
1212:   // Check if this class represents the 'Function' class.
1215:   // Check if this class represents the 'Future' class.
1218:   // Check if this class represents the 'FutureOr' class.
1221:   // Check if this class represents the 'Closure' class.
1228:   // Check if this class represents a typedef class.
1240:                           const Class& cls,
1245:   // Check if this is the top level class.
1253:   // Returns an array of instance and static fields defined by this class.
1259:   // If this is a dart:internal.ClassID class, then inject our own const
1264:   // Returns an array of all instance fields of this class and its superclasses
1280:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1336:     return class_loading_state() >= RawClass::kDeclarationLoaded;
1341:     return class_loading_state() >= RawClass::kTypeFinalized;
1351:   void set_is_synthesized_class() const;
1354:   void set_is_enum_class() const;
1372:   // Tests if this is a mixin application class which was desugared
1373:   // to a normal class by kernel mixin transformation
1475:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1500:   // class and return the resulting value, or an error object if evaluating the
1510:   // Load class declaration (super type, interfaces, type parameters and
1516:   // Allocate a class used for VM internal objects.
1517:   template <class FakeObject, class TargetFakeObject>
1518:   static RawClass* New(Isolate* isolate, bool register_class = true);
1525:                        bool register_class = true);
1531:   static RawClass* NewStringClass(intptr_t class_id, Isolate* isolate);
1534:   static RawClass* NewTypedDataClass(intptr_t class_id, Isolate* isolate);
1537:   static RawClass* NewTypedDataViewClass(intptr_t class_id, Isolate* isolate);
1540:   static RawClass* NewExternalTypedDataClass(intptr_t class_id,
1544:   static RawClass* NewPointerClass(intptr_t class_id, Isolate* isolate);
1547:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1551:   void DisableCHAOptimizedCode(const Class& subclass);
1557:   // Return the list of code objects that were compiled using CHA of this class.
1558:   // These code objects will be invalidated if new subclasses of this class
1567:                    const Class& old_enum) const;
1569:                              const Class& old_cls) const;
1572:                                      const Class& new_cls) const;
1573:   void CopyCanonicalConstants(const Class& old_cls) const;
1574:   void CopyDeclarationType(const Class& old_cls) const;
1575:   void CheckReload(const Class& replacement,
1623:   // Caches the declaration type of this class.
1626:   bool CanReloadFinalized(const Class& replacement,
1628:   bool CanReloadPreFinalized(const Class& replacement,
1632:   bool RequiresInstanceMorphing(const Class& replacement) const;
1634:   template <class FakeInstance, class TargetFakeInstance>
1664:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1665:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1674:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1675:   class PatchBit : public BitField<uint32_t, bool, kPatchBit, 1> {};
1678:   class FieldsMarkedNullableBit
1680:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1681:   class TransformedMixinApplicationBit
1683:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1684:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1685:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1718:   // Calculates number of type arguments of this class.
1723:   // Assigns empty array to all raw class array fields.
1736:   // Allocate an instance class which has a VM implementation.
1737:   template <class FakeInstance, class TargetFakeInstance>
1740:                        bool register_class = true,
1743:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1746:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1747:   friend class AbstractType;
1748:   friend class Instance;
1749:   friend class Object;
1750:   friend class Type;
1751:   friend class InterpreterHelpers;
1752:   friend class Intrinsifier;
1753:   friend class ClassFunctionVisitor;
1758:   kAny,           // Consider type params of current class and functions.
1790:     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
1793:   static RawPatchClass* New(const Class& patched_class,
1794:                             const Class& origin_class);
1796:   static RawPatchClass* New(const Class& patched_class, const Script& source);
1799:   void set_patched_class(const Class& value) const;
1800:   void set_origin_class(const Class& value) const;
1806:   friend class Class;
1809: class ParameterTypeCheck : public Object {
1841:   friend class Class;
1844: class SingleTargetCache : public Object {
1874:   friend class Class;
1877: class MonomorphicSmiableCall : public Object {
1903:   friend class Class;
1906: class UnlinkedCall : public Object {
1929:   friend class Class;
1937: class ICData : public Object {
2127:   // Used for unoptimized static calls when no class-ids are checked.
2132:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2134:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2140:   // Adds sorted so that Smi is the first class-id. Use only for
2142:   void AddReceiverCheck(intptr_t receiver_class_id,
2154:                   GrowableArray<intptr_t>* class_ids,
2156:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2160:                           intptr_t* class_id,
2197:   bool HasReceiverClassId(intptr_t class_id) const;
2269:   friend class FlowGraphSerializer;  // For is_megamorphic()
2320:   class NumArgsTestedBits : public BitField<uint32_t,
2324:   class TrackingExactnessBit : public BitField<uint32_t,
2328:   class DeoptReasonBits : public BitField<uint32_t,
2332:   class RebindRuleBits : public BitField<uint32_t,
2336:   class MegamorphicBit
2339:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2369:   friend class CallSiteResetter;
2370:   friend class CallTargets;
2371:   friend class Class;
2372:   friend class Deserializer;
2373:   friend class ICDataTestTask;
2374:   friend class Interpreter;
2375:   friend class Serializer;
2376:   friend class SnapshotWriter;
2398: class Function : public Object {
2416:   // owner class of this function, then its signature type is a parameterized
2466:   // parameter of this function and R is a type parameter of class C, the owner
2472:   // parameter of this function and R is a type parameter of class C, the owner
2484:   // generic functions or class type parameters.
2498:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3247:       const Class& klass = Class::Handle(Owner());
3293:   // The owner is the scope class of the function type.
3300:   static RawFunction* NewEvalFunction(const Class& owner,
3351: // a hoisted check class instruction.
3366:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3389:   // static: Considered during class-side or top-level resolution rather than
3488:   class KindBits : public BitField<uint32_t,
3493:   class RecognizedBits : public BitField<uint32_t,
3497:   class ModifierBits : public BitField<uint32_t,
3503:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3541:   friend class Class;
3542:   friend class SnapshotWriter;
3543:   friend class Parser;  // For set_eval_script.
3546:   friend class RawFunction;
3547:   friend class ClassFinalizer;  // To reset parent_function.
3548:   friend class Type;            // To adjust parent_function.
3551: class ClosureData : public Object {
3575:   friend class Class;
3576:   friend class Function;
3577:   friend class HeapProfiler;
3580: class SignatureData : public Object {
3598:   friend class Class;
3599:   friend class Function;
3600:   friend class HeapProfiler;
3603: class RedirectionData : public Object {
3610:   // The type specifies the class and type arguments of the target constructor.
3625:   friend class Class;
3626:   friend class Function;
3627:   friend class HeapProfiler;
3630: enum class EntryPointPragma {
3638: class FfiTrampolineData : public Object {
3666:   friend class Class;
3667:   friend class Function;
3668:   friend class HeapProfiler;
3671: class Field : public Object {
3831:   // Called during class finalization.
3854:   RawClass* Origin() const;  // Either mixin class, or same as owner().
3859:   // Used by class finalizer, otherwise initialized in constructor.
3958:   // Return class id that any non-null value read from this field is guaranteed
3959:   // to have or kDynamicCid if such class id is not known.
4069:   // assumptions about guarded class id and nullability of this field.
4146:   friend class Interpreter;              // Access to bit field.
4147:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4167:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4168:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4169:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4170:   class HasNontrivialInitializerBit
4172:   class UnboxingCandidateBit
4174:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4175:   class DoubleInitializedBit
4177:   class InitializerChangedAfterInitializatonBit
4182:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4183:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4184:   class GenericCovariantImplBit
4186:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4187:   class IsExtensionMemberBit
4189:   class NeedsLoadGuardBit
4191:   class HasInitializerBit
4193:   class IsNonNullableIntBit
4234:   friend class Class;
4235:   friend class HeapProfiler;
4236:   friend class RawField;
4237:   friend class FieldSerializationCluster;
4238:   friend class FieldDeserializationCluster;
4241: class Script : public Object {
4337:   friend class Class;
4338:   friend class Precompiler;
4341: class DictionaryIterator : public ValueObject {
4357:   friend class ClassDictionaryIterator;
4358:   friend class LibraryPrefixIterator;
4366:     // one top-level class per library left, not an array to iterate over.
4375:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4378:   // Returns a non-null raw class.
4389: class LibraryPrefixIterator : public DictionaryIterator {
4399: class Library : public Object {
4456:   void AddClass(const Class& cls) const;
4491:   void AddAnonymousClass(const Class& cls) const;
4495:   void AddClassMetadata(const Class& cls,
4537:   void set_toplevel_class(const Class& value) const;
4742:   // Lookup class in the core lib which also contains various VM
4744:   static RawClass* LookupCoreClass(const String& class_name);
4748:                                   const char* class_name,
4823:   friend class Bootstrap;
4824:   friend class Class;
4825:   friend class Debugger;
4826:   friend class DictionaryIterator;
4827:   friend class Isolate;
4828:   friend class LibraryDeserializationCluster;
4829:   friend class Namespace;
4830:   friend class Object;
4831:   friend class Precompiler;
4836: class Namespace : public Object {
4866:   friend class Class;
4867:   friend class Precompiler;
4870: class KernelProgramInfo : public Object {
4949:                         const Class& klass) const;
4960:   friend class Class;
4966: class ObjectPool : public Object {
5088:   friend class Class;
5089:   friend class Object;
5090:   friend class RawObjectPool;
5093: class Instructions : public Object {
5102:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5103:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5224:   friend class Class;
5225:   friend class Code;
5226:   friend class AssemblyImageWriter;
5227:   friend class BlobImageWriter;
5228:   friend class ImageWriter;
5233: class InstructionsSection : public Object {
5256:   friend class Class;
5259: class LocalVarDescriptors : public Object {
5294:   friend class Class;
5295:   friend class Object;
5298: class PcDescriptors : public Object {
5338:   class Iterator : ValueObject {
5387:     friend class PcDescriptors;
5432:   friend class Class;
5433:   friend class Object;
5436: class CodeSourceMap : public Object {
5478:   friend class Class;
5479:   friend class Object;
5482: class CompressedStackMaps : public Object {
5558:   friend class Class;
5559:   friend class CompressedStackMapsIterator;  // For PayloadByte
5560:   friend class StackMapEntry;                // For PayloadByte
5563: class ExceptionHandlers : public Object {
5612:   friend class Class;
5613:   friend class Object;
5616: class Code : public Object {
5824:   enum class PoolAttachment {
5829:   class KindField : public BitField<intptr_t, CallKind, 0, 2> {};
5830:   class EntryPointField
5832:   class OffsetField
5857:   class Comments : public ZoneAllocated {
5881:     friend class Code;
5959:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6087:   friend class RawObject;  // For RawObject::SizeFromClass().
6088:   friend class RawCode;
6097:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6101:   class ForceOptimizedBit
6104:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6105:   class PtrOffBits
6108:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6195:   friend class Class;
6196:   friend class CodeTestHelper;
6197:   friend class SnapshotWriter;
6198:   friend class StubCode;     // for set_object_pool
6199:   friend class Precompiler;  // for set_object_pool
6200:   friend class FunctionSerializationCluster;
6201:   friend class CodeSerializationCluster;
6202:   friend class CodeDeserializationCluster;
6203:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6204:   friend class StubCode;               // for set_object_pool
6205:   friend class MegamorphicCacheTable;  // for set_object_pool
6206:   friend class CodePatcher;            // for set_instructions
6207:   friend class ProgramVisitor;         // for set_instructions
6210:   friend class RawFunction;
6211:   friend class CallSiteResetter;
6212:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6215: class Bytecode : public Object {
6326:   class SlowFindRawBytecodeVisitor : public FindObjectVisitor {
6353:   friend class BytecodeDeserializationCluster;
6354:   friend class RawObject;  // For RawObject::SizeFromClass().
6355:   friend class RawBytecode;
6358:   friend class Class;
6359:   friend class SnapshotWriter;
6362: class Context : public Object {
6427:   friend class Class;
6428:   friend class Object;
6431: // The ContextScope class makes it possible to delay the compilation of a local
6441: class ContextScope : public Object {
6518:   friend class Class;
6519:   friend class Object;
6522: class MegamorphicCache : public Object {
6560:   void Insert(const Smi& class_id, const Object& target) const;
6571:   friend class Class;
6572:   friend class MegamorphicCacheTable;
6573:   friend class ProgramVisitor;
6582:   void InsertLocked(const Smi& class_id, const Object& target) const;
6586:                               const Smi& class_id,
6596: class SubtypeTestCache : public Object {
6610:   void AddCheck(const Object& instance_class_id_or_function,
6618:                 Object* instance_class_id_or_function,
6651:   friend class Class;
6652:   friend class Serializer;
6653:   friend class Deserializer;
6656: class Error : public Object {
6664: class ApiError : public Error {
6683:   friend class Class;
6686: class LanguageError : public Error {
6749:   friend class Class;
6752: class UnhandledException : public Error {
6781:   friend class Class;
6782:   friend class ObjectStore;
6785: class UnwindError : public Error {
6805:   friend class Class;
6808: // Instance is the base class for all instance objects (aka the Object class
6810: class Instance : public Object {
6826:     const Class& cls = Class::Handle(clazz());
6906:   // class implementing a 'call' method, return true and set the function
6929:       const Class& method_cls,
6945:   static RawInstance* New(const Class& cls, Heap::Space space = Heap::kNew);
6953:   // only the class_id is different. So, it is safe to use subtype instances in
6995:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7006:   static RawInstance* NewFromCidAndSize(SharedClassTable* shared_class_table,
7012:   friend class ByteBuffer;
7013:   friend class Class;
7014:   friend class Closure;
7015:   friend class Pointer;
7016:   friend class DeferredObject;
7017:   friend class RegExp;
7018:   friend class SnapshotWriter;
7019:   friend class StubCode;
7020:   friend class TypedDataView;
7021:   friend class InstanceSerializationCluster;
7022:   friend class InstanceDeserializationCluster;
7023:   friend class ClassDeserializationCluster;  // vtable
7024:   friend class InstanceMorpher;
7025:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7028: class LibraryPrefix : public Instance {
7063:   friend class Class;
7067: class TypeArguments : public Instance {
7113:   // a raw (null) function type arguments, i.e. consider each class type
7174:   bool CanShareInstantiatorTypeArguments(const Class& instantiator_class) const;
7191:   // Add the class name and URI of each type argument of this vector to the uris
7198:   // type from the various type argument vectors (class instantiator, function,
7275:   // If raw_instantiated is true, consider each class type parameter to be first
7289:   friend class AbstractType;
7290:   friend class Class;
7291:   friend class ClearTypeHashVisitor;
7292:   friend class Object;
7297: class AbstractType : public Instance {
7328:   virtual classid_t type_class_id() const;
7329:   virtual RawClass* type_class() const;
7354:   // instantiation. Consider a class C<T> declaring a non-generic method
7356:   // generic function bar<B> as argument and its function type refers to class
7427:   // Add the class name and URI of each occuring type to the uris
7433:   // The name of this type's class, i.e. without the type argument names of this
7441:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
7444:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
7453:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
7466:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
7484:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
7487:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
7502:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
7543:   friend class Class;
7544:   friend class Function;
7545:   friend class TypeArguments;
7548: // A Type consists of a class, possibly parameterized with type
7551: // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
7554: class Type : public AbstractType {
7557:     return OFFSET_OF(RawType, type_class_id_);
7578:     ASSERT(type_class_id() != kIllegalCid);
7585:   virtual classid_t type_class_id() const;
7586:   virtual RawClass* type_class() const;
7587:   void set_type_class(const Class& value) const;
7600:   // canonicalization (passed-in cls must match type_class()).
7601:   bool IsDeclarationTypeOf(const Class& cls) const;
7605:   // However, in case of a generic typedef, they document how the typedef class
7689:   // The finalized type of the given non-parameterized class.
7690:   static RawType* NewNonParameterizedType(const Class& type_class);
7692:   static RawType* New(const Class& clazz,
7712:   friend class Class;
7713:   friend class TypeArguments;
7714:   friend class ClearTypeHashVisitor;
7721: class TypeRef : public AbstractType {
7745:     return AbstractType::Handle(type()).type_class_id();
7748:     return AbstractType::Handle(type()).type_class();
7793:   friend class Class;
7796: // A TypeParameter represents a type parameter of a parameterized class.
7800: // the class HashMap<K, V>. At compile time, the TypeParameter is not
7803: // as type argument (rather than type parameter) of the parameterized class.
7806: class TypeParameter : public AbstractType {
7823:   classid_t parameterized_class_id() const;
7824:   RawClass* parameterized_class() const;
7829:     return parameterized_class_id() != kFunctionCid;
7877:   // Only one of parameterized_class and parameterized_function is non-null.
7878:   static RawTypeParameter* New(const Class& parameterized_class,
7890:   void set_parameterized_class(const Class& value) const;
7900:   friend class Class;
7901:   friend class ClearTypeHashVisitor;
7904: class Number : public Instance {
7921:   friend class Class;
7924: class Integer : public Number {
7997:   friend class Class;
8000: class Smi : public Integer {
8034:   static RawClass* Class();
8057:     // Indicates this class cannot be extended by dart code.
8064:   friend class Api;  // For ValueFromRaw
8065:   friend class Class;
8066:   friend class Object;
8067:   friend class ReusableSmiHandleScope;
8068:   friend class Thread;
8071: class SmiTraits : AllStatic {
8083: class Mint : public Integer {
8113:   friend class Integer;
8123:   friend class Class;
8124:   friend class Number;
8127: // Class Double represents class Double in corelib_impl, which implements
8128: // abstract class double in corelib.
8129: class Double : public Number {
8160:   friend class Class;
8161:   friend class Number;
8165: class String : public Instance {
8185:   class CodePointIterator : public ValueObject {
8485:   friend class Class;
8486:   friend class Symbols;
8487:   friend class StringSlice;  // SetHash
8489:   friend class CharArray;     // SetHash
8490:   friend class ConcatString;  // SetHash
8491:   friend class OneByteString;
8492:   friend class TwoByteString;
8493:   friend class ExternalOneByteString;
8494:   friend class ExternalTwoByteString;
8495:   friend class RawOneByteString;
8496:   friend class RODataSerializationCluster;  // SetHash
8497:   friend class Pass2Visitor;                // Stack "handle"
8500: class OneByteString : public AllStatic {
8633:   friend class Class;
8634:   friend class String;
8635:   friend class Symbols;
8636:   friend class ExternalOneByteString;
8637:   friend class SnapshotReader;
8638:   friend class StringHasher;
8639:   friend class Utf8;
8642: class TwoByteString : public AllStatic {
8758:   friend class Class;
8759:   friend class String;
8760:   friend class SnapshotReader;
8761:   friend class Symbols;
8764: class ExternalOneByteString : public AllStatic {
8844:     // Indicates this class cannot be extended by dart code.
8848:   friend class Class;
8849:   friend class String;
8850:   friend class SnapshotReader;
8851:   friend class Symbols;
8852:   friend class Utf8;
8855: class ExternalTwoByteString : public AllStatic {
8931:     // Indicates this class cannot be extended by dart code.
8935:   friend class Class;
8936:   friend class String;
8937:   friend class SnapshotReader;
8938:   friend class Symbols;
8941: // Class Bool implements Dart core class bool.
8942: class Bool : public Instance {
8971:   friend class Class;
8972:   friend class Object;  // To initialize the true and false values.
8975: class Array : public Instance {
9083:   // Make the array immutable to Dart code by switching the class pointer
9121:   static RawArray* New(intptr_t class_id,
9160:   friend class Class;
9161:   friend class ImmutableArray;
9162:   friend class Interpreter;
9163:   friend class Object;
9164:   friend class String;
9167: class ImmutableArray : public AllStatic {
9187:     // Indicates this class cannot be extended by dart code.
9195:   friend class Class;
9198: class GrowableObjectArray : public Instance {
9305:   friend class Array;
9306:   friend class Class;
9309: class Float32x4 : public Instance {
9340:   friend class Class;
9343: class Int32x4 : public Instance {
9373:   friend class Class;
9376: class Float64x2 : public Instance {
9401:   friend class Class;
9404: class TypedDataBase : public Instance {
9473:   friend class Class;
9488: class TypedData : public TypedDataBase {
9539:   static intptr_t MaxElements(intptr_t class_id) {
9540:     ASSERT(RawObject::IsTypedDataClassId(class_id));
9541:     return (kSmiMax / ElementSizeInBytes(class_id));
9544:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
9545:     ASSERT(RawObject::IsTypedDataClassId(class_id));
9547:            ElementSizeInBytes(class_id);
9550:   static RawTypedData* New(intptr_t class_id,
9615:   // Therefore this method is private and the call-sites in this class need to
9624:   friend class Class;
9625:   friend class CompressedStackMapsIterator;
9626:   friend class ExternalTypedData;
9627:   friend class TypedDataView;
9630: class ExternalTypedData : public TypedDataBase {
9672:   static intptr_t MaxElements(intptr_t class_id) {
9673:     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
9674:     return (kSmiMax / ElementSizeInBytes(class_id));
9677:   static RawExternalTypedData* New(intptr_t class_id,
9706:   friend class Class;
9709: class TypedDataView : public TypedDataBase {
9711:   static RawTypedDataView* New(intptr_t class_id,
9713:   static RawTypedDataView* New(intptr_t class_id,
9780:   friend class Class;
9781:   friend class Object;
9782:   friend class TypedDataViewDeserializationCluster;
9785: class ByteBuffer : public AllStatic {
9803: class Pointer : public Instance {
9846:   friend class Class;
9849: class DynamicLibrary : public Instance {
9875:   friend class Class;
9882: class LinkedHashMap : public Instance {
9964:   class Iterator : ValueObject {
10008:   friend class Class;
10009:   friend class LinkedHashMapDeserializationCluster;
10012: class Closure : public Instance {
10078:   friend class Class;
10081: class Capability : public Instance {
10092:   friend class Class;
10095: class ReceivePort : public Instance {
10112:   friend class Class;
10115: class SendPort : public Instance {
10135:   friend class Class;
10140: class TransferableTypedDataPeer {
10167: class TransferableTypedData : public Instance {
10179:   friend class Class;
10183: class StackTrace : public Instance {
10240:   friend class Class;
10241:   friend class Debugger;
10244: class RegExpFlags {
10294: class RegExp : public Instance {
10313:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
10314:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
10448:   friend class Class;
10451: class WeakProperty : public Instance {
10480:   friend class Class;
10483: class MirrorReference : public Instance {
10512:   friend class Class;
10515: class UserTag : public Instance {
10548:   friend class Class;
10551: // Represents abstract FutureOr class in dart:async.
10552: class FutureOr : public Instance {
10568:   friend class Class;
10575:     return Smi::Class();
10578:   return Isolate::Current()->class_table()->At(raw()->GetClassId());
10722:                                 const Smi& class_id,
10725:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
10798: // This helper class can then be used via
10833: class ArrayOfTuplesView {
10837:   class Iterator;
10839:   class TupleView {
10863:     friend class Iterator;
10866:   class Iterator {
10916:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
153:   static const ClassId kClassId = k##object##Cid;                              \
299:   inline RawClass* clazz() const;
561:     // Internal names are the true names of classes, fields,
565:     // The names of core implementation classes (like _OneByteString)
570:     //   private constructor        -> _MyClass@6b3832b.
571:     //   private named constructor  -> _MyClass@6b3832b.named
581:     //   _MyClass@6b3832b.      -> _MyClass
582:     //   _MyClass@6b3832b.named -> _MyClass.named
588:     // the names of core implementation classes are remapped to their
593:     //   _MyClass@6b3832b.      -> _MyClass
594:     //   _MyClass@6b3832b.named -> _MyClass.named
774:   static RawClass*
779:   static RawClass*
789:   static RawClass*
933:   static intptr_t host_instance_size(RawClass* clazz) {
936:   static intptr_t target_instance_size(RawClass* clazz) {
1005:     return RawObject::ClassIdTag::is_valid(value);
1012:   static intptr_t id_offset() { return OFFSET_OF(RawClass, id_); }
1014:     return OFFSET_OF(RawClass, num_type_arguments_);
1025:   RawClass* Mixin() const;
1052:   // in superclass clauses.
1066:     return OFFSET_OF(RawClass, declaration_type_);
1084:     return OFFSET_OF(RawClass, type_parameters_);
1149:     return OFFSET_OF(RawClass, host_type_arguments_field_offset_in_words_);
1154:     return OFFSET_OF(RawClass, target_type_arguments_field_offset_in_words_);
1167:     return OFFSET_OF(RawClass, super_type_);
1171:   // |original_classes| only has an effect when reloading. If true and we
1172:   // are reloading, it will prefer the original classes to the replacement
1173:   // classes.
1174:   RawClass* SuperClass(bool original_classes = false) const;
1213:   bool IsDartFunctionClass() const;
1216:   bool IsFutureClass() const;
1231:   static bool IsInFullSnapshot(RawClass* cls) {
1266:   // |original_classes| only has an effect when reloading. If true and we
1267:   // are reloading, it will prefer the original classes to the replacement
1268:   // classes.
1269:   RawArray* OffsetToFieldMap(bool original_classes = false) const;
1318:     return RoundedAllocationSize(sizeof(RawClass));
1332:     return ClassLoadingBits::decode(raw_ptr()->state_bits_);
1357:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1358:            RawClass::kFinalized;
1363:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1364:            RawClass::kPreFinalized;
1406:     return RawClass::BinaryDeclarationOffset::decode(
1412:                     RawClass::BinaryDeclarationOffset::update(
1457:     return RawClass::IsDeclaredInBytecode::decode(
1465:                     RawClass::IsDeclaredInBytecode::update(
1520:   // Allocate instance classes.
1521:   static RawClass* New(const Library& lib,
1526:   static RawClass* NewNativeWrapper(const Library& library,
1530:   // Allocate the raw string classes.
1533:   // Allocate the raw TypedData classes.
1536:   // Allocate the raw TypedDataView/ByteDataView classes.
1539:   // Allocate the raw ExternalTypedData classes.
1543:   // Allocate the raw Pointer classes.
1582:   static int32_t host_instance_size_in_words(const RawClass* cls) {
1586:   static int32_t target_instance_size_in_words(const RawClass* cls) {
1594:   static int32_t host_next_field_offset_in_words(const RawClass* cls) {
1598:   static int32_t target_next_field_offset_in_words(const RawClass* cls) {
1607:       const RawClass* cls) {
1612:       const RawClass* cls) {
1635:   static RawClass* NewCommon(intptr_t index);
1667:                                              RawClass::ClassFinalizedState,
1671:                                            RawClass::ClassLoadingState,
1719:   // This includes type arguments of a superclass and takes overlapping
1738:   static RawClass* New(intptr_t id,
1744:   static RawClass* NewInstanceClass();
1756: // Classification of type genericity according to type parameter owners.
1786:     return RoundedAllocationSize(sizeof(RawPatchClass));
1788:   static bool IsInFullSnapshot(RawPatchClass* cls) {
1803:   static RawPatchClass* New();
1805:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1880:   classid_t expected_cid() const { return raw_ptr()->expected_cid_; }
1886:   static RawMonomorphicSmiableCall* New(classid_t expected_cid,
1932: // Object holding information about an IC: test classes and their
1997:   V(CheckClass)                                                                \
2034:   // Call site classification that is helpful for hot-reload. Call sites with
2288:   // to list the call site's observed receiver classes and targets.
2489:   RawClass* Owner() const;
2491:   RawClass* origin() const;
3350: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3357:   V(ProhibitsHoistingCheckClass)                                               \
3853:   RawClass* Owner() const;
4371:   ClassDictionaryIterator(const Library& library,
4379:   RawClass* GetNextClass();
4382:   void MoveToNextClass();
4386:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4463:   RawClass* LookupClass(const String& name) const;
4464:   RawClass* LookupClassAllowPrivate(const String& name) const;
4465:   RawClass* SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4466:   RawClass* LookupLocalClass(const String& name) const;
4719:   // Eagerly compile all classes and functions in the library.
4722:   // Finalize all classes in all libraries.
4743:   // helper methods and classes. Allow look up of private classes.
4880:                                    const Array& classes_cache,
4945:   void set_classes_cache(const Array& cache) const;
4946:   RawClass* LookupClass(Thread* thread, const Smi& name_index) const;
4947:   RawClass* InsertClass(Thread* thread,
5970:     ASSERT(owner.IsFunction() || owner.IsClass() || owner.IsAbstractType());
7007:                                         classid_t cid,
7095:   // Names of internal classes are mapped to their public interfaces.
7295: // AbstractType is an abstract superclass.
7420:   // Names of internal classes are mapped to their public interfaces.
7435:   RawString* ClassName() const;
7740:            AbstractType::Handle(type()).HasTypeClass();
9433:   static intptr_t ElementSizeInBytes(classid_t cid) {
9437:   static TypedDataElementType ElementType(classid_t cid) {
9752:     const classid_t cid = typed_data.GetClassId();
10493:   RawClass* GetClassReferent() const;
10572: RawClass* Object::clazz() const {
10831: //     classes (e.g. 'Code', 'Smi', 'Object')
297:                                   : raw()->GetClassId();
327:   // Object::DictionaryName() returns String::null(). Only subclasses
1051:   // dynamic and type parameters declared in superclasses filled in as declared
1192:     return raw_ptr()->direct_subclasses_;
1195:   void ClearDirectSubclasses() const;
1349:     return SynthesizedClassBit::decode(raw_ptr()->state_bits_);
1652:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1668:                                              kClassFinalizedPos,
1669:                                              kClassFinalizedSize> {};
1672:                                            kClassLoadingPos,
1673:                                            kClassLoadingSize> {};
1677:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
2159:   void GetOneClassCheckAt(intptr_t index,
2165:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2166:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2182:   RawICData* AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2184:     return AsUnaryClassChecksForArgNr(0);
2186:   RawICData* AsUnaryClassChecksForCid(intptr_t cid,
2193:   RawICData* AsUnaryClassChecksSortedByCount() const;
3248:       return RawObject::IsTypedDataViewClassId(klass.id());
4723:   static RawError* FinalizeAllClasses();
4767:   void EnsureTopLevelClassIsFinalized() const;
4787:   void InitClassDictionary() const;
6589:   static inline RawObject* GetClassId(const Array& array, intptr_t index);
6817:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7296: // Subclasses of AbstractType are Type and TypeParameter.
8304:     return raw()->GetClassId() == kOneByteStringCid;
8308:     return raw()->GetClassId() == kTwoByteStringCid;
8312:     return raw()->GetClassId() == kExternalOneByteStringCid;
8316:     return raw()->GetClassId() == kExternalTwoByteStringCid;
8320:     return RawObject::IsExternalStringClassId(raw()->GetClassId());
9034:   bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
9422:     return ElementSizeInBytes(raw()->GetClassId()) * Length();
9426:     return ElementType(raw()->GetClassId());
9430:     return element_size(ElementType(raw()->GetClassId()));
9440:     } else if (RawObject::IsTypedDataClassId(cid)) {
9444:     } else if (RawObject::IsTypedDataViewClassId(cid)) {
9449:       ASSERT(RawObject::IsExternalTypedDataClassId(cid));
9603:     intptr_t cid = obj.raw()->GetClassId();
9604:     return RawObject::IsTypedDataClassId(cid);
9686:     intptr_t cid = obj.raw()->GetClassId();
9687:     return RawObject::IsExternalTypedDataClassId(cid);
9733:     intptr_t cid = data.raw()->GetClassId();
9734:     ASSERT(RawObject::IsTypedDataClassId(cid) ||
9735:            RawObject::IsExternalTypedDataClassId(cid));
9736:     return RawObject::IsExternalTypedDataClassId(cid);
9753:     ASSERT(RawObject::IsTypedDataClassId(cid) ||
9754:            RawObject::IsExternalTypedDataClassId(cid));
9859:     intptr_t cid = obj.raw()->GetClassId();
9860:     return RawObject::IsFfiDynamicLibraryClassId(cid);
10585:   intptr_t cid = value->GetClassIdMayBeSmi();
10741:   return array.At((index * kEntryLength) + kClassIdIndex);
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-planes/combined.js: [ master, ]
5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
685:  * Find elements by tag or class name.
688:  * - {string} .className Class name.
5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12064:      * tags that have a specific class name.
12069:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13797:     'intro-finale/items-needle-thread',
13798:     'intro-finale/items-needle',
15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
704:     if (params.className) {
705:       query += '.' + params.className;
710:     if (params.tagName && params.className) {
711:       var els = el.getElementsByClassName(params.className);
723:     } else if (params.className) {
724:       return el.getElementsByClassName(params.className);
727:     if (params.className) {
734:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
738:         if (el.className.match(regExp)) {
6532:                                             className: 'jsb' });
6547:                                             className: 'lsbb' });
12080:             el.className.indexOf(params.excludeClassName) == -1) {
12109:             (el.parentNode.className.indexOf('ds') != -1)) {
12121:                                             className: 'lsbb' });
12155:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12205:       // “View Google in Tablet | Classic” switcher.
709:   } else if (document.getElementsByClassName) {
12079:         if (!params.excludeClassName ||
12162:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-embedded/combined.js: [ master, ]
5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
686:  * Find elements by tag or class name.
689:  * - {string} .className Class name.
5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12033:      * tags that have a specific class name.
12038:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13843:             nItems = ['needle', 'noodles'];
15362:     'intro-finale/items-needle-thread',
15363:     'intro-finale/items-needle',
16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
705:     if (params.className) {
706:       query += '.' + params.className;
711:     if (params.tagName && params.className) {
712:       var els = el.getElementsByClassName(params.className);
724:     } else if (params.className) {
725:       return el.getElementsByClassName(params.className);
728:     if (params.className) {
735:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
739:         if (el.className.match(regExp)) {
6505:                                             className: 'jsb' });
6520:                                             className: 'lsbb' });
12049:             el.className.indexOf(params.excludeClassName) == -1) {
12078:             (el.parentNode.className.indexOf('ds') != -1)) {
12090:                                             className: 'lsbb' });
12124:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12174:       // “View Google in Tablet | Classic” switcher.
710:   } else if (document.getElementsByClassName) {
12048:         if (!params.excludeClassName ||
12131:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/apache/activemq:activemq-web/src/main/resources/org/apache/activemq/web/prototype.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
skia.googlesource.com/buildbot:autoroll/package-lock.json: [ master, ]
2163:             "needle": "^2.2.1",
3687:         "xml-char-classes": "^1.0.0"
2144:         "needle": {
5695:     "xml-char-classes": {
5697:       "resolved": "https://registry.npmjs.org/xml-char-classes/-/xml-char-classes-1.0.0.tgz",
skia.googlesource.com/buildbot:task_scheduler/package-lock.json: [ master, ]
1376:             "needle": "^2.2.1",
2446:         "xml-char-classes": "^1.0.0"
1357:         "needle": {
3772:     "xml-char-classes": {
3774:       "resolved": "https://registry.npmjs.org/xml-char-classes/-/xml-char-classes-1.0.0.tgz",
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
android.googlesource.com/platform/superproject:external/swiftshader/third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
48:   Record *Class;
89: class SearchableTableEmitter {
526:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
648:     Enum->Class = Records.getClass(FilterClass);
649:     if (!Enum->Class)
713:     Record *Class = NameRec.second.get();
714:     if (Class->getSuperClasses().size() != 1 ||
715:         !Class->isSubClassOf(SearchableTable))
718:     StringRef TableName = Class->getName();
720:     if (!Class->isValueUnset("EnumNameField")) {
721:       StringRef NameField = Class->getValueAsString("EnumNameField");
723:       if (!Class->isValueUnset("EnumValueField"))
724:         ValueField = Class->getValueAsString("EnumValueField");
727:       Enum->Name = (Twine(Class->getName()) + "Values").str();
728:       Enum->PreprocessorGuard = Class->getName().upper();
729:       Enum->Class = Class;
737:     Table->Name = (Twine(Class->getName()) + "sList").str();
738:     Table->PreprocessorGuard = Class->getName().upper();
739:     Table->CppTypeName = Class->getName();
741:     for (const RecordVal &Field : Class->getValues()) {
757:          Class->getValueAsListOfStrings("SearchableFields")) {
616:   Record *IntrinsicClass = Records.getClass("Intrinsic");
617:   Record *InstructionClass = Records.getClass("Instruction");
620:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
622:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
629:   // Emit tables in a deterministic order to avoid needless rebuilds.
647:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
650:       PrintFatalError(Twine("Enum FilterClass '") + FilterClass +
654:                        Records.getAllDerivedDefinitions(FilterClass));
679:                                     TableRec->getValueAsString("FilterClass")));
711:   Record *SearchableTable = Records.getClass("SearchableTable");
131:       return DI->getDef()->isSubClassOf("Intrinsic");
524:     if (TypeRec->isSubClassOf("GenericEnum")) {
712:   for (auto &NameRec : Records.getClasses()) {
github.com/chromium/chromium:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
12088: const Class = function(info, mixin) {
8388:  function superPropertiesClass(constructor) {
10431: DomApiNative.prototype.classList;
11782:     static _finalizeClass() {
325:  * Wraps an ES6 class expression mixin such that the mixin is only applied
330:  * @param {T} mixin ES6 class expression mixin to wrap
353:     // copy inherited mixin set from the extended class, or the base class
379: class Debouncer {
1857: class StyleNode {
2490: class MixinMap {
2523: class ApplyShim {
3099: class CustomStyleInterface {
3224: class ApplyShimInterface {
3491: class DomModule extends HTMLElement {
4129:  * Element class mixin that provides basic meta-programming for creating one
4134:  * once at class definition time to create property accessors for properties
4143:  * @summary Element class mixin for reacting to property changes from
4149:      * @param {function(new:T)} superClass Class to apply mixin to.
4160:   class PropertiesChanged extends superClass {
4609:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
4726:  * Element class mixin that provides basic meta-programming for creating one
4735:  * -   Implement the `_propertiesChanged` callback on the class.
4736:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
4752:  * @summary Element class mixin for reacting to property changes from
4772:   class PropertyAccessors extends base {
5091:  * @summary Element class mixin that provides basic template parsing and stamping
5096:      * @param {function(new:T)} superClass Class to apply mixin to.
5106:   class TemplateStamp extends superClass {
5927:  * @param {Function} constructor Class that `_parseTemplate` is currently
5964:  * @param {Function} constructor Class that `_parseTemplate` is currently
6494:  * Element class mixin that provides meta-programming for Polymer's template
6498:  * property effects to an element class:
6525:  * @summary Element class mixin that provides meta-programming for Polymer's
6546:   class PropertyEffects extends propertyEffectsBase {
7111:      * Runs each class of effects for the batch of changed properties in
7674:     // -- static class methods ------------
7843:      *   bound template for the class. When true (as passed from
8046:           // when a class$ binding's initial literal value is set.
8047:           if (name == 'class' && node.hasAttribute('class')) {
8272: class HostStack {
8320:  * Registers a class prototype for telemetry purposes.
8382:   * Returns the super class constructor for the given class, if it is an
8386:   * @return {?PropertiesMixinConstructor} Super class constructor
8391:    // Note, the `PropertiesMixin` class below only refers to the class
8401:   * given class. Properties not in object format are converted to at
8431:  class PropertiesMixin extends base {
8466:     * Finalize an element class. This includes ensuring property
8468:     * `finalize` and finalizes the class constructor.
8484:     * @return {Object} Object containing properties for this class
8576:  * Element class mixin that provides the core API for Polymer's meta-programming
8581:  * used to configure Polymer's features for the class:
8617:  * The base class provides default implementations for the following standard
8636:  * @property importPath {string} Set to the value of the class's static
8640:  * @summary Element class mixin that provides the core API for Polymer's
8659:    * @param {PolymerElementConstructor} constructor Element class
8660:    * @return {PolymerElementProperties} Flattened properties for this class
8682:    * @param {PolymerElementConstructor} constructor Element class
8683:    * @return {Array} Array containing own observers for the given class
8746:    * @param {!PolymerElement} proto Element class prototype to add accessors
8800:    * @param {PolymerElementConstructor} klass Element class
8871:   class PolymerElement extends polymerElementBase {
8929:      *   this class
8954:      * Note that when subclassing, if the super class overrode the default
8959:      * If a subclass would like to modify the super class template, it should
8965:      *   class MySubClass extends MySuperClass {
8981:       // - constructor.template (this getter): the template for the class.
8983:       //     dom-module, or from the super class's template (or can be overridden
9033:      * @return {string} The import path for this element class
9067:      * Overrides the default `PropertyAccessors` to ensure class
9347:  * Element class mixin that provides API for adding Polymer's cross-platform
9357:  * @summary Element class mixin that provides API for adding Polymer's
9364:      * @param {function(new:T)} superClass Class to apply mixin to.
9373:       class GestureEventListeners extends superClass {
9748:  * Class that listens for changes (additions or removals) to
9769:  * class TestSelfObserve extends PolymerElement {
9785:  * @summary Class that listens for changes (additions or removals) to
9789: let FlattenedNodesObserver = class {
10097:  * Node API wrapper class returned from `Polymer.dom.(target)` when
10102: class DomApiNative {
10315:  * Event API wrapper class returned from `dom.(target)` when
10318: class EventApi {
10446:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
10552:  * Element class mixin that provides Polymer's "legacy" API intended to be
10563:  * @summary Element class mixin that provides Polymer's "legacy" API
10593:   class LegacyElement extends legacyElementBase {
10611:      *  closure for some reason even in a static method, rather than the class
10695:      * add support for class initialization via the `_registered` callback.
10721:      * Users may override this method to perform class registration time
10723:      * only once for the class.
11424:      * Toggles a CSS class on or off.
11426:      * @param {string} name CSS class name
11427:      * @param {boolean=} bool Boolean to force the class on or off.
11428:      *    When unspecified, the state of the class will be reversed.
11672: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
11673: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
11745:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
11746:   made. The list of behaviors was previously made into one generated class per
11751:   The generated class is directly tied to the info object and behaviors
11766:  * @param {function(new:HTMLElement)} Base base class to extend with info object
11768:  * @return {function(new:HTMLElement)} Generated class
11774:   // manages behavior and lifecycle processing (filled in after class definition)
11779:   class PolymerGenerated extends Base {
11861:       // only proceed if the generated class' prototype has not been registered.
11867:         // copy properties onto the generated class lazily if we're optimizing,
11872:         // and not the generated class prototype; if the element has been
11988:     // NOTE: ensure the behavior is extending a class with
11995:     // get flattened, deduped list of behaviors *not* already on super class
12019:  * Generates a class that extends `LegacyElement` based on the
12023:  * to the generated class.
12082:  *   to become class methods.
12084:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
12086:  * @return {function(new:HTMLElement)} Generated class
12090:     console.warn('Polymer.Class requires `info` argument');
12111:  * Legacy class factory and registration helper for defining Polymer
12116:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
12117:  *     customElements.define(info.is, Class(info));
12119:  * See `Class` for details on valid legacy metadata format for `info`.
12125:  *   to become class methods.
12126:  * @return {function(new: HTMLElement)} Generated class
12130:   // if input is a `class` (aka a function with a prototype), use the prototype
12136:     klass = Polymer.Class(info);
12142: Polymer.Class = Class;
12175:  * Element class mixin to skip strict dirty-checking for objects and arrays
12210:  * @summary Element class mixin to skip strict dirty-checking for objects
12220:   class MutableData extends superClass {
12249:  * Element class mixin to add the optional ability to skip strict
12285:  * @summary Element class mixin to optionally skip strict dirty-checking
12295:   class OptionalMutableData extends superClass {
12348: // Base class for HTMLTemplateElement extension that has property effects
12350: // class only because Babel (incorrectly) requires super() in the class
12392:  * Base class for TemplateInstance.
12397: const templateInstanceBase = PropertyEffects(class {});
12405: class TemplateInstanceBase extends templateInstanceBase {
12627:  * @suppress {missingProperties} class.prototype is not defined for some reason
12643:    * Anonymous class created by the templatize
12647:   let klass = class extends templatizerBase { };
12656:  * @suppress {missingProperties} class.prototype is not defined for some reason
12661:     // Provide data API and property effects on memoized template class
12671:         class TemplatizedTemplate extends templatizedBase {};
12741:  * Returns an anonymous `PropertyEffects` class bound to the
12742:  * `<template>` provided.  Instancing the class will result in the
12762:  *    method on the generated class should be called to forward host
12771:  * - `mutableData`: When `true`, the generated class will skip strict
12801:  * `templatize()` return the same class for all duplicates of a template.
12802:  * The class returned from `templatize()` is generated only once using
12814:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
12832:   // Get memoized base class for the prototypical template, which
12845:   // Subclass base class and add reference for this specific template
12847:   let klass = class TemplateInstance extends baseClass {};
12977:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
12983:    * @param {boolean=} mutableData When `true`, the generated class will skip
13002:    * returned is an instance of the anonymous class generated by `templatize`
13075: class DomBind extends domBindBase {
13181:  * Class representing a static string value which can be used to filter
13182:  * strings by asseting that they have been created via this class. The
13185: class LiteralString {
13252:  *         <div class="shadowed">${this.partialTemplate}</div>
13280:  * Base class that provides the core API for Polymer's meta-programming
13290:  * @summary Custom element base class that provides the core API for Polymer's
13345:  * class EmployeeList extends PolymerElement {
13416: class DomRepeat extends domRepeatBase {
14052: class DomIf extends PolymerElement {
14348:   class ArraySelectorMixin extends elementBase {
14666:  * class EmployeeList extends PolymerElement {
14719: class ArraySelector extends baseArraySelector {
14864: class CustomStyle extends HTMLElement {
2356:         // remove build comment so it is not needlessly copied into every element instance
4133:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
4150:      * @return {function(new:T)} superClass with mixin applied.
4152:     (superClass) => {
4156:    * @mixinClass
4755: const PropertyAccessors = dedupingMixin(superClass => {
4763:    const base = PropertiesChanged(superClass);
4767:    * @mixinClass
5097:      * @return {function(new:T)} superClass with mixin applied.
5099:     (superClass) => {
5103:    * @mixinClass
6528: const PropertyEffects = dedupingMixin(superClass => {
6537:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
6541:    * @mixinClass
6979:      * Overrides superclass implementation.
7991:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8025:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8086:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8372: const PropertiesMixin = dedupingMixin(superClass => {
8379:  const base = PropertiesChanged(superClass);
8426:   * @mixinClass
8436:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8448:     * Finalizes an element definition, including ensuring any super classes
8451:     * `_finalizeClass` to finalize each constructor in the prototype chain.
8456:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
8461:        this._finalizeClass();
8472:    static _finalizeClass() {
8481:     * from super classes. Properties not in object format are converted to
8490:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
8703:    * these values may not be changed. For example, a subclass cannot
8739:    * reflectToAttribute property not do so in a subclass. We've chosen to
8741:    * For example, a readOnly effect generates a special setter. If a subclass
8866:    * @mixinClass
8882:      * Override of PropertiesMixin _finalizeClass to create observers and
8886:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8888:     static _finalizeClass() {
8889:       super._finalizeClass();
8955:      * implementation and the subclass would like to provide an alternate
8970:      *         subContent.textContent = 'This came from MySubClass';
8988:       //     constructor.template, saved in _finalizeClass(). Note that before
9001:           // Next look for superclass template (call the super impl this
9002:           // way so that `this` points to the superclass)
9297:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
9313:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
9365:      * @return {function(new:T)} superClass with mixin applied.
9367:     (superClass) => {
9370:        * @mixinClass
10048:  * Forces several classes of asynchronously queued tasks to flush:
10455:   // Note, `classList` is here only for legacy compatibility since it does not
10458:     'classList'
10490:   // Properties that should return the logical, not composed tree. Note, `classList`
10497:     'childNodes', 'children', 'classList'
10588:    * @mixinClass
11433:     toggleClass(name, bool, node) {
11436:         bool = !node.classList.contains(name);
11439:         node.classList.add(name);
11441:         node.classList.remove(name);
11742: /* Note about construction and extension of legacy classes.
11748:   manually. Note, there may *still* be multiple generated classes in the
11753:   behaviors not active on the superclass. In order to call through to the
11761:   and not `_finalizeClass`.
11781:     // explicitly not calling super._finalizeClass
11783:       // if calling via a subclass that hasn't been generated, pass through to super
11785:         super._finalizeClass();
11865:         // ensure superclass is registered first.
12213: const MutableData = dedupingMixin(superClass => {
12217:    * @mixinClass
12288: const OptionalMutableData = dedupingMixin(superClass => {
12291:    * @mixinClass
12383: // Applies a DataTemplate subclass to a <template> instance
12629: function createTemplatizerClass(template, templateInfo, options) {
12662:     let klass = templateInfo.templatizeTemplateClass;
12670:       klass = templateInfo.templatizeTemplateClass =
12838:   let baseClass = templateInfo.templatizeInstanceClass;
12839:   if (!baseClass) {
12840:     baseClass = createTemplatizerClass(template, templateInfo, options);
12841:     templateInfo.templatizeInstanceClass = baseClass;
14333: let ArraySelectorMixin = dedupingMixin(superClass => {
14340:   let elementBase = ElementMixin(superClass);
14344:    * @mixinClass
4942:      * `__dataProto`, and it is up to the subclasser to decide how/when
8580:  * Subclassers may provide the following static getters to return metadata
8705:    * by subclasses.
8738:    * effects via subclassing. For example, a user might want to make a
11772: function GenerateClassFromInfo(info, Base, behaviors) {
12094:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
android.googlesource.com/platform/external/free-image:Source/LibRawLite/dcraw/dcraw.c: [ master, ]
153: #define CLASS
99:    access them are prefixed with "CLASS".  Note that a thread-safe
100:    C++ class cannot have non-const static local variables.
217: int CLASS fc (int row, int col)
243: 	      char *needle, size_t needlelen)
247:     if (!memcmp (c, needle, needlelen))
254: void CLASS merror (void *ptr, char *where)
261: void CLASS derror()
273: ushort CLASS sget2 (uchar *s)
281: ushort CLASS get2()
288: unsigned CLASS sget4 (uchar *s)
297: unsigned CLASS get4()
304: unsigned CLASS getint (int type)
309: float CLASS int_to_float (int i)
316: double CLASS getreal (int type)
340: void CLASS read_shorts (ushort *pixel, int count)
347: void CLASS canon_black (double dark[2])
361: void CLASS canon_600_fixed_wb (int temp)
382: int CLASS canon_600_color (int ratio[2], int mar)
411: void CLASS canon_600_auto_wb()
453: void CLASS canon_600_coeff()
477: void CLASS canon_600_load_raw()
518: void CLASS remove_zeroes()
535: int CLASS canon_s2is()
546: void CLASS canon_a5_load_raw()
573: unsigned CLASS getbits (int nbits)
592: void CLASS init_decoder()
624: uchar * CLASS make_decoder (const uchar *source, int level)
650: void CLASS crw_init_tables (unsigned table)
720: int CLASS canon_has_lowbits()
735: void CLASS canon_compressed_load_raw()
817:   struct CLASS decode *huff[6];
821: int CLASS ljpeg_start (struct jhead *jh, int info_only)
873: int CLASS ljpeg_diff (struct decode *dindex)
888: ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
925: void CLASS lossless_jpeg_load_raw()
970: void CLASS canon_sraw_load_raw()
1037: void CLASS adobe_copy_pixel (int row, int col, ushort **rp)
1061: void CLASS adobe_dng_load_raw_lj()
1090: void CLASS adobe_dng_load_raw_nc()
1111: void CLASS pentax_tree()
1131: void CLASS pentax_k10_load_raw()
1148: void CLASS nikon_compressed_load_raw()
1221: int CLASS nikon_is_compressed()
1236: int CLASS nikon_e995()
1254: int CLASS nikon_e2100()
1269: void CLASS nikon_3700()
1295: int CLASS minolta_z2()
1308: void CLASS nikon_e900_load_raw()
1327: void CLASS fuji_load_raw()
1353: void CLASS jpeg_thumb (FILE *tfp);
1355: void CLASS ppm_thumb (FILE *tfp)
1367: void CLASS layer_thumb (FILE *tfp)
1384: void CLASS rollei_thumb (FILE *tfp)
1402: void CLASS rollei_load_raw()
1428: int CLASS bayer (unsigned row, unsigned col)
1433: void CLASS phase_one_flat_field (int is_float, int nc)
1477: void CLASS phase_one_correct()
1601: void CLASS phase_one_load_raw()
1628: unsigned CLASS ph1_bits (int nbits)
1643: void CLASS phase_one_load_raw_c()
1694: void CLASS hasselblad_load_raw()
1726: void CLASS leaf_hdr_load_raw()
1753: void CLASS unpacked_load_raw();
1755: void CLASS sinar_4shot_load_raw()
1790: void CLASS imacon_full_load_raw()
1799: void CLASS packed_12_load_raw()
1837: void CLASS unpacked_load_raw()
1855: void CLASS nokia_load_raw()
1879: unsigned CLASS pana_bits (int nbits)
1895: void CLASS panasonic_load_raw()
1918: void CLASS olympus_e300_load_raw()
1945: void CLASS olympus_e410_load_raw()
1986: void CLASS minolta_rd175_load_raw()
2014: void CLASS casio_qv5700_load_raw()
2034: void CLASS quicktake_100_load_raw()
2101: const int * CLASS make_decoder_int (const int *source, int level)
2118: int CLASS radc_token (int tree)
2164: void CLASS kodak_radc_load_raw()
2233: void CLASS kodak_jpeg_load_raw() {}
2249: void CLASS kodak_jpeg_load_raw()
2290: void CLASS kodak_dc120_load_raw()
2306: void CLASS eight_bit_load_raw()
2331: void CLASS kodak_yrgb_load_raw()
2355: void CLASS kodak_262_load_raw()
2404: int CLASS kodak_65000_decode (short *out, int bsize)
2450: void CLASS kodak_65000_load_raw()
2466: void CLASS kodak_ycbcr_load_raw()
2493: void CLASS kodak_rgb_load_raw()
2509: void CLASS kodak_thumb_load_raw()
2519: void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
2536: void CLASS sony_load_raw()
2569: void CLASS sony_arw_load_raw()
2589: void CLASS sony_arw2_load_raw()
2630: void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
2696: void CLASS smal_v6_load_raw()
2709: int CLASS median4 (int *p)
2722: void CLASS fill_holes (int holes)
2748: void CLASS smal_v9_load_raw()
2770: void CLASS foveon_decoder (unsigned size, unsigned code)
2801: void CLASS foveon_thumb (FILE *tfp)
2840: void CLASS foveon_load_camf()
2854: void CLASS foveon_load_raw()
2892: const char * CLASS foveon_camf_param (const char *block, const char *param)
2914: void * CLASS foveon_camf_matrix (unsigned dim[3], const char *name)
2948: int CLASS foveon_fixed (void *ptr, int size, const char *name)
2960: float CLASS foveon_avg (short *pix, int range[2], float cfilt)
2974: short * CLASS foveon_make_curve (double max, double mul, double filt)
2993: void CLASS foveon_make_curves
3004: int CLASS foveon_apply_curve (short *curve, int i)
3012: void CLASS foveon_interpolate()
3415: void CLASS bad_pixels (char *fname)
3474: void CLASS subtract (char *fname)
3514: void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
3543: void CLASS cam_xyz_coeff (double cam_xyz[4][3])
3567: void CLASS colorcheck()
3660: void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
3671: void CLASS wavelet_denoise()
3746: void CLASS scale_colors()
3853: void CLASS pre_interpolate()
3887: void CLASS border_interpolate (int border)
3909: void CLASS lin_interpolate()
3955:    described in http://scien.stanford.edu/class/psych221/projects/99/tingchen/algodep/vargra.html
3960: void CLASS vng_interpolate()
4089: void CLASS ppg_interpolate()
4146: void CLASS ahd_interpolate()
4271: void CLASS median_filter()
4299: void CLASS blend_highlights()
4337: void CLASS recover_highlights()
4414: void CLASS tiff_get (unsigned base,
4425: void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
4438: int CLASS parse_tiff_ifd (int base);
4440: void CLASS parse_makernote (int base, int uptag)
4688:       load_raw = &CLASS olympus_e410_load_raw;
4716: void CLASS get_timestamp (int reversed)
4737: void CLASS parse_exif (int base)
4768: void CLASS parse_gps (int base)
4789: void CLASS romm_coeff (float romm_cam[3][3])
4803: void CLASS parse_mos (int offset)
4868: void CLASS linear_table (unsigned len)
4878: void CLASS parse_kodak_ifd (int base)
4909: void CLASS parse_minolta (int base);
4911: int CLASS parse_tiff_ifd (int base)
4982: 	load_raw = &CLASS panasonic_load_raw;
5033: 	  load_raw = &CLASS sinar_4shot_load_raw;
5039: 	  load_raw = &CLASS sony_arw_load_raw;
5173: 	load_raw = &CLASS imacon_full_load_raw;
5176: 	  load_raw = &CLASS unpacked_load_raw;
5284: 	load_raw = &CLASS packed_12_load_raw;
5319: void CLASS parse_tiff (int base)
5365: 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
5366: 	  case 12: load_raw = &CLASS packed_12_load_raw;
5371: 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
5374: 	  load_raw = &CLASS olympus_e300_load_raw;
5377: 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
5379: 	load_raw = &CLASS kodak_262_load_raw;			break;
5381: 	load_raw = &CLASS sony_arw2_load_raw;
5385: 	load_raw = &CLASS sony_arw_load_raw;			break;
5389: 	load_raw = &CLASS packed_12_load_raw;			break;
5391: 	load_raw = &CLASS nikon_compressed_load_raw;		break;
5393: 	load_raw = &CLASS pentax_k10_load_raw;			break;
5396: 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
5397: 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
5398: 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
5424: 	write_thumb = &CLASS layer_thumb;
5428: 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
5430: 	  write_thumb = &CLASS ppm_thumb;
5434: 		&CLASS kodak_ycbcr_load_raw : &CLASS kodak_rgb_load_raw;
5439: void CLASS parse_minolta (int base)
5479: void CLASS parse_external_jpeg()
5529: void CLASS ciff_block_1030()
5553: void CLASS parse_ciff (int offset, int length)
5657: void CLASS parse_rollei()
5692:   write_thumb = &CLASS rollei_thumb;
5695: void CLASS parse_sinar_ia()
5720:   load_raw = &CLASS unpacked_load_raw;
5723:   write_thumb = &CLASS ppm_thumb;
5727: void CLASS parse_phase_one (int base)
5782: 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
5794: void CLASS parse_fuji (int offset)
5821: int CLASS parse_jpeg (int offset)
5847: void CLASS parse_riff()
5887: void CLASS parse_smal (int offset, int fsize)
5902:   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
5903:   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
5906: void CLASS parse_cine()
5924:     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
5925:     case 16:  load_raw = &CLASS  unpacked_load_raw;
5955: char * CLASS foveon_gets (int offset, char *str, int len)
5965: void CLASS parse_foveon()
6000: 	  write_thumb = &CLASS jpeg_thumb;
6006: 	  write_thumb = &CLASS foveon_thumb;
6054: void CLASS adobe_coeff (char *make, char *model)
6499: void CLASS simple_coeff (int index)
6519: short CLASS guess_byte_order (int words)
6542: void CLASS identify()
6633:   write_thumb = &CLASS jpeg_thumb;
6718:     load_raw = &CLASS nokia_load_raw;
6777:       load_raw = &CLASS adobe_dng_load_raw_nc;
6779:       load_raw = &CLASS adobe_dng_load_raw_lj;
6784: 	&CLASS lossless_jpeg_load_raw : &CLASS canon_compressed_load_raw;
6787:       load_raw = &CLASS packed_12_load_raw;
6792:     load_raw = &CLASS packed_12_load_raw;
6802:     load_raw = &CLASS foveon_load_raw;
6810:     load_raw = &CLASS canon_sraw_load_raw;
6818:     load_raw = &CLASS canon_600_load_raw;
6827:     load_raw = &CLASS canon_a5_load_raw;
6834:     load_raw = &CLASS canon_a5_load_raw;
6840:     load_raw = &CLASS canon_a5_load_raw;
6848:     load_raw = &CLASS canon_a5_load_raw;
6856:     load_raw = &CLASS canon_a5_load_raw;
6864:     load_raw = &CLASS canon_a5_load_raw;
6874:     load_raw = &CLASS canon_a5_load_raw;
6882:     load_raw = &CLASS canon_a5_load_raw;
6890:     load_raw = &CLASS canon_a5_load_raw;
6898:     load_raw = &CLASS canon_a5_load_raw;
6906:     load_raw = &CLASS canon_a5_load_raw;
6914:     load_raw = &CLASS canon_a5_load_raw;
6922:     load_raw = &CLASS canon_a5_load_raw;
7066:       load_raw = &CLASS packed_12_load_raw;
7089:     load_raw = &CLASS nikon_e900_load_raw;
7101:     load_raw = &CLASS nikon_e900_load_raw;
7110:     load_raw = &CLASS packed_12_load_raw;
7136:     load_raw = &CLASS packed_12_load_raw;
7157:     load_raw = &CLASS packed_12_load_raw;
7173:     load_raw = &CLASS packed_12_load_raw;
7177:     load_raw = &CLASS unpacked_load_raw;
7197:     load_raw = &CLASS fuji_load_raw;
7204:     load_raw = &CLASS minolta_rd175_load_raw;
7213:     load_raw = &CLASS unpacked_load_raw;
7218:       load_raw = &CLASS packed_12_load_raw;
7224:       load_raw = &CLASS packed_12_load_raw;
7241:       load_raw = &CLASS unpacked_load_raw;
7253:       load_raw = &CLASS eight_bit_load_raw;
7262:       load_raw = &CLASS packed_12_load_raw;
7271:     load_raw = &CLASS packed_12_load_raw;
7278:     load_raw = &CLASS packed_12_load_raw;
7285:     load_raw = &CLASS unpacked_load_raw;
7290:     load_raw = &CLASS eight_bit_load_raw;
7301:     load_raw = &CLASS unpacked_load_raw;
7309:     load_raw = &CLASS unpacked_load_raw;
7315:     load_raw = &CLASS eight_bit_load_raw;
7319:     load_raw = &CLASS eight_bit_load_raw;
7323:     load_raw = &CLASS eight_bit_load_raw;
7328: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7333:     load_raw = &CLASS unpacked_load_raw;
7342: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7350:     load_raw = &CLASS unpacked_load_raw;
7356: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7362:     load_raw = &CLASS unpacked_load_raw;
7375:     if (load_raw == &CLASS lossless_jpeg_load_raw)
7376:       load_raw = &CLASS hasselblad_load_raw;
7397:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7406:       load_raw = &CLASS leaf_hdr_load_raw;
7442:       load_raw = &CLASS panasonic_load_raw;
7443:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7538:     load_raw = &CLASS packed_12_load_raw;
7543:     if (load_raw == &CLASS olympus_e410_load_raw) {
7551:       if (load_raw == &CLASS unpacked_load_raw) {
7557:       if (load_raw == &CLASS unpacked_load_raw)
7569:     load_raw = &CLASS packed_12_load_raw;
7574:     load_raw = &CLASS sony_load_raw;
7582:     load_raw = &CLASS sony_load_raw;
7600:     load_raw = &CLASS kodak_yrgb_load_raw;
7618: