Found 113491 results in 3688 files, showing top 50 files (show more).
github.com/apache/juneau:juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java: [ master, ]
63: 		MAP, COLLECTION, CLASS, METHOD, NUMBER, DECIMAL, BOOLEAN, CHAR, DATE, ARRAY, ENUM, OTHER, CHARSEQ, STR, OBJ, URI, BEANMAP,...(43 bytes skipped)...
59: public final class ClassMeta<T> implements Type {
62: 	enum ClassCategory {
66: 	final Class<T> innerClass;                              // The class being wrapped.
69: 	private final Class<? extends T> implClass;             // The implementation class to use if this is an interface.
85: 		isMemberClass;                                       // True if this is a non-static member class.
141: 	ClassMeta(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] pojoSwaps, PojoSwap<?,?>[] childPojoSwaps, Object example) ...(2 bytes skipped)...
224: 	ClassMeta(ClassMeta<T> mainType, ClassMeta<?> keyType, ClassMeta<?> valueType, ClassMeta<?> elementType) {
267: 	ClassMeta(ClassMeta<?>[] args) {
307: 	private final class ClassMetaBuilder<T> {
308: 		Class<T> innerClass;
310: 		Class<? extends T> implClass;
315: 			isMemberClass = false,
352: 		ClassMetaBuilder(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] pojoSwaps, PojoSwap<?,?>[] childPojoSwaps, Object example) ...(2 bytes skipped)...
932: 	public Class<T> getInnerClass() {
1155: 	public boolean isClass() {
1454: 	public boolean isMemberClass() {
746: 		private ClassMeta<?> findClassMeta(Class<?> c) {
811: 	public ClassCategory getClassCategory() {
945: 	public ClassMeta<?> getSerializedClassMeta(BeanSession session) {
39:  * A wrapper class around the {@link Class} object that provides cached information about that class.
42:  * Instances of this class can be created through the {@link BeanContext#getClassMeta(Class)} method.
45:  * The {@link BeanContext} class will cache and reuse instances of this class except for the following class types:
53:  * This class is tied to the {@link BeanContext} class because it's that class that makes the determination of what is
56:  * @param <T> The class type of the wrapped class.
61: 	/** Class categories. */
70: 	private final ClassCategory cc;                         // The class category.
73: 		noArgConstructor,                                    // The no-arg constructor for this class (if it has one).
83: 		isDelegate,                                          // True if this class extends Delegate.
84: 		isAbstract,                                          // True if this class is abstract.
89: ...(4 bytes skipped)...vate final PojoSwap<?,?>[] childPojoSwaps;           // Any PojoSwaps where the normal type is a subclass of this class.
90: 	private final ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
98: 		elementType,                                         // If ARRAY or COLLECTION, the element class type.
99: 		keyType,                                             // If MAP, the key class type.
100: 		valueType;                                           // If MAP, the value class type.
101: 	private final BeanMeta<T> beanMeta;                     // The bean meta for this bean class (if it's a bean).
103: ...(7 bytes skipped)...ropertyName,                                    // The property name of the _type property for this class and subclasses.
105: 		dictionaryName;                                      // The dictionary name of this class if it has one.
107: 	private final InvocationHandler invocationHandler;      // The invocation handler for this class (if it has one).
108: 	private final BeanRegistry beanRegistry;                // The bean registry of this class meta (if it has one).
111: 	private final Map<Class<?>,Mutater<?,T>> fromMutaters = new ConcurrentHashMap<>();
112: 	private final Map<Class<?>,Mutater<T,?>> toMutaters = new ConcurrentHashMap<>();
119: 	 * Construct a new {@code ClassMeta} based on the specified {@link Class}.
121: 	 * @param innerClass The class being wrapped.
124: 	 * 	For interfaces and abstract classes, this represents the "real" class to instantiate.
127: 	 * 	The {@link BeanFilter} programmatically associated with this class.
130: 	 * 	The {@link PojoSwap} programmatically associated with this class.
133: 	 * 	The child {@link PojoSwap PojoSwaps} programmatically associated with this class.
134: 	 * 	These are the <c>PojoSwaps</c> that have normal classes that are subclasses of this class.
138: 	 * 	Used for delayed initialization when the possibility of class reference loops exist.
149: 			// We always immediately add this class meta to the bean context cache so that we can resolve recursive references.
200: 	private static boolean isCacheable(Class<?> c) {
222: 	 * Used for creating Map and Collection class metas that shouldn't be cached.
268: 		this.innerClass = (Class<T>) Object[].class;
343: 		ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
368: 			Class<T> c = innerClass;
386: 				else if (c == void.class || c == Void.class)
389: 				if (ci.isChildOf(Delegate.class))
392: 				if (c == Object.class)
396: 				else if (c.equals(Class.class))
397: 					cc = ClassCategory.CLASS;
398: 				else if (ci.isChildOf(Method.class))
400: 				else if (ci.isChildOf(CharSequence.class)) {
401: 					if (c.equals(String.class))
406: 				else if (ci.isChildOf(Number.class)) {
407: 					if (ci.isChildOfAny(Float.class, Double.class))
412: 				else if (ci.isChildOf(Collection.class))
414: 				else if (ci.isChildOf(Map.class)) {
415: 					if (ci.isChildOf(BeanMap.class))
420: 				else if (c == Character.class)
422: 				else if (c == Boolean.class)
424: 				else if (ci.isChildOfAny(Date.class, Calendar.class))
428: 				else if (ci.isChildOfAny(URL.class, URI.class) || bc.hasAnnotation(org.apache.juneau.annotation.URI.class, c))
430: 				else if (ci.isChildOf(Reader.class))
432: 				else if (ci.isChildOf(InputStream.class))
434: 				else if (ci.is(Optional.class))
444: 			// parse() is used by the java logging Level class.
445: 			// forName() is used by Class and Charset
449: ...(23 bytes skipped)...C, PUBLIC, NOT_DEPRECATED) && m.hasName(methodName) && m.hasReturnType(c) && m.hasParamTypes(String.class)) {
459: ...(8 bytes skipped)...m.isAll(PUBLIC, NOT_DEPRECATED, STATIC) && m.hasName("example") && m.hasFuzzyParamTypes(BeanSession.class)) {
466: 				if (bc.hasAnnotation(ParentProperty.class, f)) {
472: 				if (bc.hasAnnotation(NameProperty.class, f)) {
481: 				if (bc.hasAnnotation(Example.class, f)) {
491: 				if (bc.hasAnnotation(ParentProperty.class, m)) {
497: 				if (bc.hasAnnotation(NameProperty.class, m)) {
506: 				if (bc.hasAnnotation(Example.class, m)) {
507: 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
508: 						throw new Class...(22 bytes skipped)..., "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
521: 					if (pt.size() == (isMemberClass ? 1 : 0) && c != Object.class && ! isAbstract) {
525: 						if (arg.is(String.class))
537: 			if (innerClass != Object.class) {
566: 						keyType = findClassMeta(Object.class);
567: 						valueType = findClassMeta(Object.class);
577: 						elementType = findClassMeta(Object.class);
616: 				for (Bean b : bc.getAnnotations(Bean.class, c)) {
629: 				for (Example e : bc.getAnnotations(Example.class, c))
652: 						Iterator<? extends Enum> i = EnumSet.allOf((Class<? extends Enum>)c).iterator();
668: 					case CLASS:
685: 			this.stringMutater = Mutaters.get(String.class, c);
690: 				List<Bean> ba = info.getAnnotations(Bean.class, bc);
702: 				for (Swap swap : bc.getAnnotations(Swap.class, innerClass))
704: 				for (Swaps swaps : bc.getAnnotations(Swaps.class, innerClass))
723: 			Class<?> c = s.value();
724: 			if (c == Null.class)
728: 			if (ci.isChildOf(PojoSwap.class)) {
729: 				PojoSwap ps = castOrCreate(PojoSwap.class, c);
737: 			if (ci.isChildOf(Surrogate.class)) {
743: 			throw new ClassMetaRuntimeException(c, "Invalid swap class ''{0}'' specified.  Must extend from PojoSwap or Surrogate.", c);
756: 	 * Returns the {@link ClassInfo} wrapper for the underlying class.
758: 	 * @return The {@link ClassInfo} wrapper for the underlying class, never <jk>null</jk>.
765: 	 * Returns the type property name associated with this class and subclasses.
771: 	 * 	The type property name associated with this bean class, or <jk>null</jk> if there is no explicit type
779: 	 * Returns the bean dictionary name associated with this class.
785: 	 * 	The type name associated with this bean class, or <jk>null</jk> if there is no type name defined or this
793: 	 * Returns the bean registry for this class.
797: 	 * defined on the class, regardless of whether the class is an actual bean.
800: 	 * @return The bean registry for this class, or <jk>null</jk> if no bean registry is associated with it.
807: 	 * Returns the category of this class.
809: 	 * @return The category of this class.
816: 	 * Returns <jk>true</jk> if this class is a superclass of or the same as the specified class.
818: 	 * @param c The comparison class.
819: 	 * @return <jk>true</jk> if this class is a superclass of or the same as the specified class.
821: 	public boolean isAssignableFrom(Class<?> c) {
826: 	 * Returns <jk>true</jk> if this class is a subclass of or the same as the specified class.
828: 	 * @param c The comparison class.
829: 	 * @return <jk>true</jk> if this class is a subclass of or the same as the specified class.
831: 	public boolean isInstanceOf(Class<?> c) {
836: 	 * Returns <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
842: 	 * @return <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
849: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the normal class of one of the
850: 	 * child POJO swaps associated with this class.
852: 	 * @param normalClass The normal class being resolved.
855: 	protected PojoSwap<?,?> getChildPojoSwapForSwap(Class<?> normalClass) {
876: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the swap class of one of the child
877: 	 * POJO swaps associated with this class.
879: 	 * @param swapClass The swap class being resolved.
882: 	protected PojoSwap<?,?> getChildPojoSwapForUnswap(Class<?> swapClass) {
903: 	 * Locates the no-arg constructor for the specified class.
907: 	 * If class is abstract, always returns <jk>null</jk>.
910: 	 * @param c The class from which to locate the no-arg constructor.
915: 	protected static <T> Constructor<? extends T> findNoArgConstructor(Class<?> c, Visibility v) {
928: 	 * Returns the {@link Class} object that this class type wraps.
930: 	 * @return The wrapped class object.
937: 	 * Returns the serialized (swapped) form of this class if there is an {@link PojoSwap} associated with it.
942: 	 * @return The serialized class type, or this object if no swap is associated with the class.
951: 	 * Returns the example of this class.
956: 	 * @return The serialized class type, or this object if no swap is associated with the class.
1023: 	 * For array and {@code Collection} types, returns the class type of the components of the array or
1026: 	 * @return The element class type, or <jk>null</jk> if this class is not an array or Collection.
1033: 	 * For {@code Map} types, returns the class type of the keys of the {@code Map}.
1035: 	 * @return The key class type, or <jk>null</jk> if this class is not a Map.
1042: 	 * For {@code Map} types, returns the class type of the values of the {@code Map}.
1044: 	 * @return The value class type, or <jk>null</jk> if this class is not a Map.
1051: 	 * Returns <jk>true</jk> if this class implements {@link Delegate}, meaning it's a representation of some other
1054: 	 * @return <jk>true</jk> if this class implements {@link Delegate}.
1061: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map}.
1063: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map}.
1070: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1072: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1079: 	 * Returns <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1081: 	 * @return <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1088: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection}.
1090: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection}.
1097: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Optional}.
1099: 	 * @return <jk>true</jk> if this class is a subclass of {@link Optional}.
1106: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1108: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1115: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1117: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1124: 	 * Returns <jk>true</jk> if this class extends from {@link Set}.
1126: 	 * @return <jk>true</jk> if this class extends from {@link Set}.
1129: 		return cc == COLLECTION && info.isChildOf(Set.class);
1133: 	 * Returns <jk>true</jk> if this class extends from {@link List}.
1135: 	 * @return <jk>true</jk> if this class extends from {@link List}.
1138: 		return cc == COLLECTION && info.isChildOf(List.class);
1142: 	 * Returns <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1144: 	 * @return <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1147: 		return cc == ARRAY && this.innerClass == byte[].class;
1151: 	 * Returns <jk>true</jk> if this class is {@link Class}.
1153: 	 * @return <jk>true</jk> if this class is {@link Class}.
1156: 		return cc == ClassCategory.CLASS;
1160: 	 * Returns <jk>true</jk> if this class is {@link Method}.
1162: 	 * @return <jk>true</jk> if this class is {@link Method}.
1169: 	 * Returns <jk>true</jk> if this class is an {@link Enum}.
1171: 	 * @return <jk>true</jk> if this class is an {@link Enum}.
1178: 	 * Returns <jk>true</jk> if this class is an array.
1180: 	 * @return <jk>true</jk> if this class is an array.
1187: 	 * Returns <jk>true</jk> if this class is a bean.
1189: 	 * @return <jk>true</jk> if this class is a bean.
1196: 	 * Returns <jk>true</jk> if this class is {@link Object}.
1198: 	 * @return <jk>true</jk> if this class is {@link Object}.
1205: 	 * Returns <jk>true</jk> if this class is not {@link Object}.
1207: 	 * @return <jk>true</jk> if this class is not {@link Object}.
1214: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Number}.
1216: 	 * @return <jk>true</jk> if this class is a subclass of {@link Number}.
1223: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1225: 	 * @return <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1232: 	 * Returns <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1234: 	 * @return <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1237: 		return innerClass == Float.class || innerClass == float.class;
1241: 	 * Returns <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1243: 	 * @return <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1246: 		return innerClass == Double.class || innerClass == double.class;
1250: 	 * Returns <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1252: 	 * @return <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1255: 		return innerClass == Short.class || innerClass == short.class;
1259: 	 * Returns <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1261: 	 * @return <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1264: 		return innerClass == Integer.class || innerClass == int.class;
1268: 	 * Returns <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1270: 	 * @return <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1273: 		return innerClass == Long.class || innerClass == long.class;
1279: 	 * @param c The class to test against.
1282: 	public boolean isType(Class<?> c) {
1287: 	 * Returns <jk>true</jk> if this class is a {@link Boolean}.
1289: 	 * @return <jk>true</jk> if this class is a {@link Boolean}.
1296: 	 * Returns <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1298: 	 * @return <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1305: 	 * Returns <jk>true</jk> if this class is a {@link String}.
1307: 	 * @return <jk>true</jk> if this class is a {@link String}.
1314: 	 * Returns <jk>true</jk> if this class is a {@link Character}.
1316: 	 * @return <jk>true</jk> if this class is a {@link Character}.
1323: 	 * Returns <jk>true</jk> if this class is a primitive.
1325: 	 * @return <jk>true</jk> if this class is a primitive.
1332: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1334: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1341: 	 * Returns <jk>true</jk> if this class is a {@link Date}.
1343: 	 * @return <jk>true</jk> if this class is a {@link Date}.
1346: 		return cc == DATE && info.isChildOf(Date.class);
1350: 	 * Returns <jk>true</jk> if this class is a {@link Calendar}.
1352: 	 * @return <jk>true</jk> if this class is a {@link Calendar}.
1355: 		return cc == DATE && info.isChildOf(Calendar.class);
1359: 	 * Returns <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1361: 	 * @return <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1368: 	 * Returns <jk>true</jk> if this class is a {@link Reader}.
1370: 	 * @return <jk>true</jk> if this class is a {@link Reader}.
1377: 	 * Returns <jk>true</jk> if this class is an {@link InputStream}.
1379: 	 * @return <jk>true</jk> if this class is an {@link InputStream}.
1386: 	 * Returns <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1388: 	 * @return <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1432: 	 * @return <jk>true</jk> if instance of this class can be null.
1441: 	 * Returns <jk>true</jk> if this class is abstract.
1443: 	 * @return <jk>true</jk> if this class is abstract.
1450: 	 * Returns <jk>true</jk> if this class is an inner class.
1452: 	 * @return <jk>true</jk> if this class is an inner class.
1459: 	 * All public methods on this class including static methods.
1464: 	 * @return The public methods on this class.
1471: 	 * Returns the {@link PojoSwap} associated with this class that's the best match for the specified session.
1475: 	 * 	<br>If multiple swaps are associated with a class, only the first one with a matching media type will
1478: 	 * 	The {@link PojoSwap} associated with this class, or <jk>null</jk> if there are no POJO swaps associated with
1479: 	 * 	this class.
1500: 	 * Returns the builder swap associated with this class.
1503: 	 * @return The builder swap associated with this class, or <jk>null</jk> if it doesn't exist.
1510: 	 * Returns the {@link BeanMeta} associated with this class.
1513: 	 * 	The {@link BeanMeta} associated with this class, or <jk>null</jk> if there is no bean meta associated with
1514: 	 * 	this class.
1521: 	 * Returns the no-arg constructor for this class.
1523: 	 * @return The no-arg constructor for this class, or <jk>null</jk> if it does not exist.
1530: 	 * Returns the interface proxy invocation handler for this class.
1539: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1541: 	 * @return <jk>true</jk> if a new instance of this class can be constructed.
1556: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1557: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1558: 	 * the defining class.
1561: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1563: 	 * 	<jk>true</jk> if a new instance of this class can be created within the context of the specified outer object.
1572: 	 * Returns <jk>true</jk> if this class can be instantiated as a bean.
1573: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1574: 	 * the defining class.
1577: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1592: 	 * Returns <jk>true</jk> if this class can call the {@link #newInstanceFromString(Object, String)} method.
1595: 	 * 	The outer class object for non-static member classes.
1597: 	 * @return <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1604: 				return outer != null && stringConstructor.hasParamTypes(outer.getClass(), String.class);
1633: 	 * Returns the reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1635: 	 * @return The reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1662: 	 * @return The default value, or <jk>null</jk> if this class type is not a primitive.
1698: 	 * Create a new instance of the main class of this declared type from a <c>String</c> input.
1701: 	 * In order to use this method, the class must have one of the following methods:
1709: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1718: 			return (T)Enum.valueOf((Class<? extends Enum>)this.innerClass, arg);
1734: 		throw new InstantiationError("No string constructor or valueOf(String) method found for class '"+getInnerClass().getName()+"'");
1738: 	 * Create a new instance of the main class of this declared type.
1752: 			return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] { getInnerClass(), java.io.Serializable.class }, h);
1762: 	 * 	The instance of the owning object of the member class instance.
1763: 	 * 	Can be <jk>null</jk> if instantiating a non-member or static class.
1777: 	 * @param cm The class meta to compare to.
1778: 	 * @return <jk>true</jk> if the specified class-meta is equivalent to this one.
1792: 	 * Same as {@link #toString()} except use simple class names.
1794: 	 * @param simple Print simple class names only (no package).
1805: 	 * @param simple Print simple class names only (no package).
1819: 			return sb.append(BeanMap.class.getName()).append('<').append(n).append('>');
1826: 	 * Returns <jk>true</jk> if the specified object is an instance of this class.
1829: 	 * This is a simple comparison on the base class itself and not on any generic parameters.
1832: 	 * @return <jk>true</jk> if the specified object is an instance of this class.
1841: 	 * Returns a readable name for this class (e.g. <js>"java.lang.String"</js>, <js>"boolean[]"</js>).
1843: 	 * @return The readable name for this class.
1850: 	 * Shortcut for calling {@link Class#getName()} on the inner class of this metadata.
1852: 	 * @return The  name of the inner class.
1859: 	 * Shortcut for calling {@link Class#getSimpleName()} on the inner class of this metadata.
1861: 	 * @return The simple name of the inner class.
1868: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1870: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1873: 		return hasMutaterFrom(Reader.class);
1877: 	 * Returns the transform for this class for creating instances from a Reader.
1882: 		return getFromMutater(Reader.class);
1886: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1888: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1891: 		return hasMutaterFrom(InputStream.class);
1895: 	 * Returns the transform for this class for creating instances from an InputStream.
1900: 		return getFromMutater(InputStream.class);
1904: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1906: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1913: 	 * Returns the transform for this class for creating instances from a String.
1922: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1924: 	 * @param c The class type to convert from.
1925: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1927: 	public boolean hasMutaterFrom(Class<?> c) {
1932: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1934: 	 * @param c The class type to convert from.
1935: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1942: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1944: 	 * @param c The class type to convert from.
1945: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1947: 	public boolean hasMutaterTo(Class<?> c) {
1952: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1954: 	 * @param c The class type to convert from.
1955: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1962: 	 * Transforms the specified object into an instance of this class.
1974: 	 * Transforms the specified object into an instance of this class.
1977: 	 * @param c The class
1981: 	public <O> O mutateTo(Object o, Class<O> c) {
1987: 	 * Transforms the specified object into an instance of this class.
1990: 	 * @param c The class
1998: 	 * Returns the transform for this class for creating instances from other object types.
2000: 	 * @param c The transform-from class.
2004: 	public <I> Mutater<I,T> getFromMutater(Class<I> c) {
2018: 	 * Returns the transform for this class for creating instances from other object types.
2020: 	 * @param c The transform-from class.
2024: 	public <O> Mutater<T,O> getToMutater(Class<O> c) {
2041: 	 * @return <jk>true</jk> if the inner class has the annotation.
2043: 	public boolean hasAnnotation(Class<? extends Annotation> a) {
2051: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2053: 	public <A extends Annotation> A getLastAnnotation(Class<A> a) {
2058: 	 * Returns all annotations of the specified type defined on the specified class or parent classes/interfaces in parent-to-child order.
2065: 	public <A extends Annotation> List<A> getAnnotations(Class<A> a) {
15: import static org.apache.juneau.ClassMeta.ClassCategory.*;
16: import static org.apache.juneau.internal.ClassUtils.*;
58: @Bean(bpi="innerClass,classCategory,elementType,keyType,valueType,notABeanReason,initException,beanMeta")
67: 	final ClassInfo info;
86: 	private final Object primitiveDefault;                  // Default value for primitive type classes.
97: 	private final ClassMeta<?>
109: 	private final ClassMeta<?>[] args;                      // Arg types if this is an array of args.
123: 	 * @param implClass
142: 		this.innerClass = innerClass;
143: 		this.info = ClassInfo.of(innerClass);
150: 			if (beanContext != null && beanContext.cmCache != null && isCacheable(innerClass))
151: 				beanContext.cmCache.put(innerClass, this);
153: 			ClassMetaBuilder<T> builder = new ClassMetaBuilder(innerClass, beanContext, implClass, beanFilter, pojoSwaps, childPojoSwaps, example);
177: 			this.isMemberClass = builder.isMemberClass;
179: 			this.implClass = builder.implClass;
188: 		} catch (ClassMetaRuntimeException e) {
198: 	 * Generated classes shouldn't be cacheable to prevent needlessly filling up the cache.
202: 		char x = n.charAt(n.length()-1);  // All generated classes appear to end with digits.
225: 		this.innerClass = mainType.innerClass;
227: 		this.implClass = mainType.implClass;
239: 		this.isMemberClass = mainType.isMemberClass;
269: 		this.info = ClassInfo.of(innerClass);
271: 		this.implClass = null;
283: 		this.isMemberClass = false;
309: 		ClassInfo ci;
312: 		ClassCategory cc = ClassCategory.OTHER;
328: 		ClassMeta<?>
353: 			this.innerClass = innerClass;
357: 			this.implClass = implClass;
358: 			ClassInfo ici = ClassInfo.of(implClass);
369: 			ci = ClassInfo.of(c);
372: 				innerClass = this.innerClass = ci.inner();
438: 			isMemberClass = ci.isMemberClass() && ci.isNotStatic();
441: 			// fromString() must be checked before valueOf() so that Enum classes can create their own
468: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
474: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
483: 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of ...(16 bytes skipped)...
493: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and hav...(22 bytes skipped)...
499: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have ...(20 bytes skipped)...
520: 					List<ClassInfo> pt = cs.getParamTypes();
523: 					} else if (pt.size() == (isMemberClass ? 2 : 1)) {
524: 						ClassInfo arg = pt.get(isMemberClass ? 1 : 0);
538: 				ClassInfo x = implClass == null ? ci : ici;
549: 				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
557: 					elementType = findClassMeta(innerClass.getComponentType());
561: 					ClassMeta[] parameters = findParameters();
573: 					ClassMeta[] parameters = findParameters();
587: 						newMeta = new BeanMeta(ClassMeta.this, bc, beanFilter, null);
612: 			if (beanMeta != null && bc != null && bc.isUseInterfaceProxies() && innerClass.isInterface())
692: 					return new AnnotationBeanFilterBuilder(innerClass, ba).build();
726: 			ClassInfo ci = ClassInfo.of(c);
750: 		private ClassMeta<?>[] findParameters() {
751: 			return beanContext.findParameters(innerClass, innerClass);
760: 	public ClassInfo getInfo() {
857: 			PojoSwap<?,?> s = childSwapMap.get(normalClass);
860: 					if (s == null && f.getNormalClass().isParentOf(normalClass))
864: 				PojoSwap<?,?> s2 = childSwapMap.putIfAbsent(normalClass, s);
884: 			PojoSwap<?,?> s = childUnswapMap.get(swapClass);
887: 					if (s == null && f.getSwapClass().isParentOf(swapClass))
891: 				PojoSwap<?,?> s2 = childUnswapMap.putIfAbsent(swapClass, s);
908: 	 * Note that this also returns the 1-arg constructor for non-static member classes.
916: 		ClassInfo ci = ClassInfo.of(c);
919: 		boolean isMemberClass = ci.isMemberClass() && ci.isNotStatic();
921: 			if (cc.hasNumParams(isMemberClass ? 1 : 0) && cc.isVisible(v) && cc.isNotDeprecated())
933: 		return innerClass;
999: 					Object o = Array.newInstance(getElementType().innerClass, 1);
1018: 			throw new ClassMetaRuntimeException(e);
1028: 	public ClassMeta<?> getElementType() {
1037: 	public ClassMeta<?> getKeyType() {
1046: 	public ClassMeta<?> getValueType() {
1328: 		return innerClass.isPrimitive();
1408: 	public ClassMeta<?>[] getArgs() {
1419: 	public ClassMeta<?> getArg(int index) {
1435: 		if (innerClass.isPrimitive())
1455: 		return isMemberClass;
1544: 		if (isMemberClass)
1566: 		if (isMemberClass)
1567: 			return outer != null && noArgConstructor != null && noArgConstructor.hasParamTypes(outer.getClass());
1586: 		if (isMemberClass)
1587: 			return outer != null && beanMeta.constructor.hasParamTypes(outer.getClass());
1596: 	 * 	Can be <jk>null</jk> for non-member or static classes.
1603: 			if (isMemberClass)
1730: 			if (isMemberClass)
1746: 			return (T)Array.newInstance(getInnerClass().getComponentType(), 0);
1754: 			return (T)Array.newInstance(this.elementType.innerClass,0);
1759: 	 * Same as {@link #newInstance()} except for instantiating non-static member classes.
1768: 		if (isMemberClass)
1780: 	public boolean same(ClassMeta<?> cm) {
1809: 		String n = innerClass.getName();
1836: 			return info.isParentOf(o.getClass()) || (isPrimitive() && info.getPrimitiveWrapper() == o.getClass());
1855: 		return innerClass.getName();
1864: 		return innerClass.getSimpleName();
1937: 	public boolean hasMutaterFrom(ClassMeta<?> c) {
1938: 		return getFromMutater(c.getInnerClass()) != null;
1957: 	public boolean hasMutaterTo(ClassMeta<?> c) {
1958: 		return getToMutater(c.getInnerClass()) != null;
1969: 		Mutater t = getFromMutater(o.getClass());
1993: 	public <O> O mutateTo(Object o, ClassMeta<O> c) {
1994: 		return mutateTo(o, c.getInnerClass());
2009: 			t = Mutaters.get(c, innerClass);
2029: 			t = Mutaters.get(innerClass, c);
2038: 	 * Shortcut for calling <code>getInnerClass().getAnnotation(a) != <jk>null</jk></code>.
2048: 	 * Shortcut for calling <c>getInnerClass().getAnnotation(a)</c>.
2071: 		return innerClass.hashCode();
2076: 		if (o == null || ! (o instanceof ClassMeta))
2078: 		ClassMeta<?> o2 = (ClassMeta<?>)o;
2079: 		return o2.innerClass.equals(innerClass);
91: 		childSwapMap,                                        // Maps normal subclasses to PojoSwaps.
92: 		childUnswapMap;                                      // Maps swap subclasses to PojoSwaps.
602: 			} catch (NoClassDefFoundError e) {
747: 			return beanContext.getClassMeta(c, false);
798: 	 * This allows interfaces to define subclasses with type names.
947: 		return (ps == null ? this : ps.getSwapClassMeta(session));
github.com/apache/activemq-artemis:artemis-protocols/artemis-amqp-protocol/src/main/java/org/apache/activemq/artemis/protocol/amqp/broker/KMPNeedle.java: [ master, ]
30:    private final byte[] needle;
27: final class KMPNeedle {
32:    private KMPNeedle(byte[] needle) {
24: ...(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
33:       Objects.requireNonNull(needle);
34:       this.needle = needle;
35:       this.jumpTable = createJumpTable(needle);
38:    private static int[] createJumpTable(byte[] needle) {
39:       final int[] jumpTable = new int[needle.length + 1];
41:       for (int i = 1; i < needle.length; i++) {
42:          while (j > 0 && needle[j] != needle[i]) {
45:          if (needle[j] == needle[i]) {
63:     * the remaining haystack to be processed is < of the remaining needle to be matched.
71:       final int needleLength = needle.length;
80:          while (j > 0 && needle[j] != value) {
84:          if (needle[j] == value) {
97:    public static KMPNeedle of(byte[] needle) {
98:       return new KMPNeedle(needle);
72:       int remainingNeedle = needleLength;
75:          if (remainingNeedle > remainingHayStack) {
82:             remainingNeedle = needleLength - j;
86:             remainingNeedle--;
87:             assert remainingNeedle >= 0;
89:          if (j == needleLength) {
90:             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/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/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/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, ]
912: 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_; }
522:   static RawClass* weak_serialization_reference_class() {
756:   static RawClass* class_class_;           // Class of the Class vm object.
1332:   RawClass::ClassLoadingState class_loading_state() const {
1349:   bool is_synthesized_class() const {
1354:   bool is_enum_class() const { return EnumBit::decode(raw_ptr()->state_bits_); }
1766:   RawClass* patched_class() const { return raw_ptr()->patched_class_; }
1767:   RawClass* origin_class() const { return raw_ptr()->origin_class_; }
4658:   RawClass* toplevel_class() const { return raw_ptr()->toplevel_class_; }
8005:   virtual RawClass* type_class() const {
1199:   bool IsNullClass() const { return id() == kNullCid; }
1202:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1205:   bool IsVoidClass() const { return id() == kVoidCid; }
1208:   bool IsNeverClass() const { return id() == kNeverCid; }
1211:   bool IsObjectClass() const { return id() == kInstanceCid; }
1220:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1223:   bool IsClosureClass() const { return id() == kClosureCid; }
1224:   static bool IsClosureClass(RawClass* cls) {
1230:   bool IsTypedefClass() const { return signature_function() != Object::null(); }
1667:   class ClassFinalizedBits : public BitField<uint32_t,
1671:   class ClassLoadingBits : public BitField<uint32_t,
1760:   kCurrentClass,  // Consider type params of current class only.
1764: class PatchClass : public Object {
4484: class ClassDictionaryIterator : public DictionaryIterator {
5066:   RawArray* classes_cache() const { return raw_ptr()->classes_cache_; }
7054:   intptr_t SizeFromClass() const {
7593:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
7837:   virtual bool HasTypeClass() const {
7996:   virtual bool HasTypeClass() const {
8078:   virtual bool HasTypeClass() const { return false; }
303: #define DEFINE_CLASS_TESTER(clazz)                                             \
757:   static RawClass* dynamic_class_;         // Class of the 'dynamic' type.
758:   static RawClass* void_class_;            // Class of the 'void' type.
759:   static RawClass* never_class_;           // Class of the 'Never' type.
760:   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
761:   static RawClass* patch_class_class_;     // Class of the PatchClass vm object.
762:   static RawClass* function_class_;        // Class of the Function vm object.
763:   static RawClass* closure_data_class_;    // Class of ClosureData vm obj.
764:   static RawClass* signature_data_class_;  // Class of SignatureData vm obj.
765:   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
766:   static RawClass* ffi_trampoline_data_class_;  // Class of FfiTrampolineData
768:   static RawClass* field_class_;                // Class of the Field vm object.
769:   static RawClass* script_class_;     // Class of the Script vm object.
770:   static RawClass* library_class_;    // Class of the Library vm object.
771:   static RawClass* namespace_class_;  // Class of Namespace vm object.
772:   static RawClass* kernel_program_info_class_;  // Class of KernelProgramInfo vm
774:   static RawClass* code_class_;                 // Class of the Code vm object.
775:   static RawClass* bytecode_class_;      // Class of the Bytecode vm object.
776:   static RawClass* instructions_class_;  // Class of the Instructions vm object.
778:       instructions_section_class_;       // Class of InstructionsSection.
779:   static RawClass* object_pool_class_;   // Class of the ObjectPool vm object.
780:   static RawClass* pc_descriptors_class_;   // Class of PcDescriptors vm object.
781:   static RawClass* code_source_map_class_;  // Class of CodeSourceMap vm object.
783:       compressed_stackmaps_class_;             // Class of CompressedStackMaps.
784:   static RawClass* var_descriptors_class_;     // Class of LocalVarDescriptors.
785:   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
786:   static RawClass* deopt_info_class_;          // Class of DeoptInfo.
787:   static RawClass* context_class_;           // Class of the Context vm object.
788:   static RawClass* context_scope_class_;     // Class of ContextScope vm object.
789:   static RawClass* dyncalltypecheck_class_;  // Class of ParameterTypeCheck.
790:   static RawClass* singletargetcache_class_;  // Class of SingleTargetCache.
791:   static RawClass* unlinkedcall_class_;       // Class of UnlinkedCall.
793:       monomorphicsmiablecall_class_;  // Class of MonomorphicSmiableCall.
794:   static RawClass* icdata_class_;     // Class of ICData.
795:   static RawClass* megamorphic_cache_class_;    // Class of MegamorphiCache.
796:   static RawClass* subtypetestcache_class_;     // Class of SubtypeTestCache.
797:   static RawClass* api_error_class_;            // Class of ApiError.
798:   static RawClass* language_error_class_;       // Class of LanguageError.
799:   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
800:   static RawClass* unwind_error_class_;         // Class of UnwindError.
802:   static RawClass* weak_serialization_reference_class_;
4506:   Class& toplevel_class_;
7816:   static intptr_t type_class_id_offset() {
8002:   virtual classid_t type_class_id() const {
8079:   virtual classid_t type_class_id() const { return kIllegalCid; }
295:   intptr_t GetClassId() const {
560:   static const ClassId kClassId = kObjectCid;
1192:   RawGrowableObjectArray* direct_subclasses() const {
1649:     kClassFinalizedPos = 2,
1650:     kClassFinalizedSize = 2,
1651:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1652:     kClassLoadingSize = 2,
1655:     kSynthesizedClassBit,
1677:   class SynthesizedClassBit
2201:   RawICData* AsUnaryClassChecks() const {
5777:   classid_t TargetClassId() const { return TargetClassIdOf(raw()); }
5778:   static classid_t TargetClassIdOf(const RawWeakSerializationReference* raw) {
5816:   static classid_t UnwrappedClassIdOf(const Object& obj) {
5826:   static classid_t UnwrappedClassIdOf(RawObject* obj) {
6206:   classid_t OwnerClassId() const { return OwnerClassIdOf(raw()); }
6207:   static classid_t OwnerClassIdOf(RawCode* raw) {
6766:     kClassIdIndex,
6830:     kInstanceClassIdOrFunction = 1,
8085:   bool IsClassTypeParameter() const {
8858:   static const ClassId kClassId = kOneByteStringCid;
8985:   static const ClassId kClassId = kTwoByteStringCid;
9058:   static const ClassId kClassId = kExternalOneByteStringCid;
9145:   static const ClassId kClassId = kExternalTwoByteStringCid;
9434:   static const ClassId kClassId = kImmutableArrayCid;
10997: 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_;
523:     return weak_serialization_reference_class_;
550:   template <class FakeObject>
575:     //   core impl class name shown -> _OneByteString
703:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
721:     // Indicates this class cannot be extended by dart code.
727:   static void RegisterClass(const Class& cls,
730:   static void RegisterPrivateClass(const Class& cls,
801:   // Class of WeakSerializationReference.
808:   friend void ClassTable::Register(const Class& cls);
810:   friend class Closure;
811:   friend class SnapshotReader;
812:   friend class InstanceDeserializationCluster;
813:   friend class OneByteString;
814:   friend class TwoByteString;
815:   friend class ExternalOneByteString;
816:   friend class ExternalTwoByteString;
817:   friend class Thread;
820:   friend class Reusable##name##HandleScope;
828: class PassiveObject : public Object {
876: // The first string in the triplet is a type name (usually a class).
881: enum class Nullability : int8_t {
888: enum class TypeEquality {
897: enum class NNBDMode {
905: enum class NNBDCompiledMode {
1024:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1025:   // to this class.
1028:   // The NNBD mode of the library declaring this class.
1045:   // This class represents a typedef if the signature function is not null.
1051:   // Return the Type with type parameters declared by this class filled in with
1057:   // class preceded by the type arguments declared for superclasses, etc.
1059:   // class B<T, S>
1060:   // class C<R> extends B<R, int>
1088:   // Return a TypeParameter if the type_name is a type parameter of this class.
1093:   // the super class.
1096:   // Return true if this class declares type parameters.
1099:   // If this class is parameterized, each instance has a type_arguments field.
1113:         compiler::target::Class::kNoTypeArguments) {
1114:       return compiler::target::Class::kNoTypeArguments;
1126:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1128:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1130:       target_value = RTN::Class::kNoTypeArguments;
1161:   // The super type of this class, Object type if not explicitly specified.
1171:   // Asserts that the class of the super type has been resolved.
1184:   // Returns the list of classes directly implementing this class.
1188:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1191:   // Returns the list of classes having this class as direct superclass.
1195:   void AddDirectSubclass(const Class& subclass) const;
1198:   // Check if this class represents the class of null.
1201:   // Check if this class represents the 'dynamic' class.
1204:   // Check if this class represents the 'void' class.
1207:   // Check if this class represents the 'Never' class.
1210:   // Check if this class represents the 'Object' class.
1213:   // Check if this class represents the 'Function' class.
1216:   // Check if this class represents the 'Future' class.
1219:   // Check if this class represents the 'FutureOr' class.
1222:   // Check if this class represents the 'Closure' class.
1229:   // Check if this class represents a typedef class.
1240:   static bool IsSubtypeOf(const Class& cls,
1246:   // Check if this is the top level class.
1254:   // Returns an array of instance and static fields defined by this class.
1260:   // If this is a dart:internal.ClassID class, then inject our own const
1265:   // Returns an array of all instance fields of this class and its superclasses
1281:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1337:     return class_loading_state() >= RawClass::kDeclarationLoaded;
1342:     return class_loading_state() >= RawClass::kTypeFinalized;
1352:   void set_is_synthesized_class() const;
1355:   void set_is_enum_class() const;
1373:   // Tests if this is a mixin application class which was desugared
1374:   // to a normal class by kernel mixin transformation
1476:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1501:   // class and return the resulting value, or an error object if evaluating the
1511:   // Load class declaration (super type, interfaces, type parameters and
1517:   // Allocate a class used for VM internal objects.
1518:   template <class FakeObject, class TargetFakeObject>
1519:   static RawClass* New(Isolate* isolate, bool register_class = true);
1526:                        bool register_class = true);
1532:   static RawClass* NewStringClass(intptr_t class_id, Isolate* isolate);
1535:   static RawClass* NewTypedDataClass(intptr_t class_id, Isolate* isolate);
1538:   static RawClass* NewTypedDataViewClass(intptr_t class_id, Isolate* isolate);
1541:   static RawClass* NewExternalTypedDataClass(intptr_t class_id,
1545:   static RawClass* NewPointerClass(intptr_t class_id, Isolate* isolate);
1548:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1552:   void DisableCHAOptimizedCode(const Class& subclass);
1558:   // Return the list of code objects that were compiled using CHA of this class.
1559:   // These code objects will be invalidated if new subclasses of this class
1568:                    const Class& old_enum) const;
1570:                              const Class& old_cls) const;
1573:                                      const Class& new_cls) const;
1574:   void CopyCanonicalConstants(const Class& old_cls) const;
1575:   void CopyDeclarationType(const Class& old_cls) const;
1576:   void CheckReload(const Class& replacement,
1624:   // Caches the declaration type of this class.
1627:   bool CanReloadFinalized(const Class& replacement,
1629:   bool CanReloadPreFinalized(const Class& replacement,
1633:   bool RequiresInstanceMorphing(const Class& replacement) const;
1635:   template <class FakeInstance, class TargetFakeInstance>
1665:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1666:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1675:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1676:   class PatchBit : public BitField<uint32_t, bool, kPatchBit, 1> {};
1679:   class FieldsMarkedNullableBit
1681:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1682:   class TransformedMixinApplicationBit
1684:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1685:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1686:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1719:   // Calculates number of type arguments of this class.
1724:   // Assigns empty array to all raw class array fields.
1737:   // Allocate an instance class which has a VM implementation.
1738:   template <class FakeInstance, class TargetFakeInstance>
1741:                        bool register_class = true,
1744:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1747:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1748:   friend class AbstractType;
1749:   friend class Instance;
1750:   friend class Object;
1751:   friend class Type;
1752:   friend class InterpreterHelpers;
1753:   friend class Intrinsifier;
1754:   friend class ProgramWalker;
1759:   kAny,           // Consider type params of current class and functions.
1791:     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
1794:   static RawPatchClass* New(const Class& patched_class,
1795:                             const Class& origin_class);
1797:   static RawPatchClass* New(const Class& patched_class, const Script& source);
1800:   void set_patched_class(const Class& value) const;
1801:   void set_origin_class(const Class& value) const;
1807:   friend class Class;
1810: class ParameterTypeCheck : public Object {
1842:   friend class Class;
1845: class SingleTargetCache : public Object {
1875:   friend class Class;
1878: class MonomorphicSmiableCall : public Object {
1904:   friend class Class;
1907: class UnlinkedCall : public Object {
1930:   friend class Class;
1933: class CallSiteData : public Object {
1954:   friend class ICData;
1955:   friend class MegamorphicCache;
1963: class ICData : public CallSiteData {
2145:   // Used for unoptimized static calls when no class-ids are checked.
2150:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2152:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2158:   // Adds sorted so that Smi is the first class-id. Use only for
2160:   void AddReceiverCheck(intptr_t receiver_class_id,
2172:                   GrowableArray<intptr_t>* class_ids,
2174:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2178:                           intptr_t* class_id,
2215:   bool HasReceiverClassId(intptr_t class_id) const;
2287:   friend class FlowGraphSerializer;  // For is_megamorphic()
2336:   class NumArgsTestedBits : public BitField<uint32_t,
2340:   class TrackingExactnessBit : public BitField<uint32_t,
2344:   class DeoptReasonBits : public BitField<uint32_t,
2348:   class RebindRuleBits : public BitField<uint32_t,
2352:   class MegamorphicBit
2355:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2385:   friend class CallSiteResetter;
2386:   friend class CallTargets;
2387:   friend class Class;
2388:   friend class Deserializer;
2389:   friend class ICDataTestTask;
2390:   friend class Interpreter;
2391:   friend class Serializer;
2392:   friend class SnapshotWriter;
2414: class Function : public Object {
2432:   // owner class of this function, then its signature type is a parameterized
2481:   // parameter of this function and R is a type parameter of class C, the owner
2487:   // parameter of this function and R is a type parameter of class C, the owner
2499:   // generic functions or class type parameters.
2513:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3370:       const Class& klass = Class::Handle(Owner());
3416:   // The owner is the scope class of the function type.
3423:   static RawFunction* NewEvalFunction(const Class& owner,
3474: // a hoisted check class instruction.
3489:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3512:   // static: Considered during class-side or top-level resolution rather than
3611:   class KindBits : public BitField<uint32_t,
3616:   class RecognizedBits : public BitField<uint32_t,
3620:   class ModifierBits : public BitField<uint32_t,
3626:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3663:   friend class Class;
3664:   friend class SnapshotWriter;
3665:   friend class Parser;  // For set_eval_script.
3668:   friend class RawFunction;
3669:   friend class ClassFinalizer;  // To reset parent_function.
3670:   friend class Type;            // To adjust parent_function.
3673: class ClosureData : public Object {
3697:   friend class Class;
3698:   friend class Function;
3699:   friend class HeapProfiler;
3702: class SignatureData : public Object {
3720:   friend class Class;
3721:   friend class Function;
3722:   friend class HeapProfiler;
3725: class RedirectionData : public Object {
3732:   // The type specifies the class and type arguments of the target constructor.
3747:   friend class Class;
3748:   friend class Function;
3749:   friend class HeapProfiler;
3752: enum class EntryPointPragma {
3760: class FfiTrampolineData : public Object {
3788:   friend class Class;
3789:   friend class Function;
3790:   friend class HeapProfiler;
3793: class Field : public Object {
3953:   // Called during class finalization.
3976:   RawClass* Origin() const;  // Either mixin class, or same as owner().
3981:   // Used by class finalizer, otherwise initialized in constructor.
4080:   // Return class id that any non-null value read from this field is guaranteed
4081:   // to have or kDynamicCid if such class id is not known.
4191:   // assumptions about guarded class id and nullability of this field.
4268:   friend class Interpreter;              // Access to bit field.
4269:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4289:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4290:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4291:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4292:   class HasNontrivialInitializerBit
4294:   class UnboxingCandidateBit
4296:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4297:   class DoubleInitializedBit
4299:   class InitializerChangedAfterInitializatonBit
4304:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4305:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4306:   class GenericCovariantImplBit
4308:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4309:   class IsExtensionMemberBit
4311:   class NeedsLoadGuardBit
4313:   class HasInitializerBit
4315:   class IsNonNullableIntBit
4356:   friend class Class;
4357:   friend class HeapProfiler;
4358:   friend class RawField;
4359:   friend class FieldSerializationCluster;
4360:   friend class FieldDeserializationCluster;
4363: class Script : public Object {
4459:   friend class Class;
4460:   friend class Precompiler;
4463: class DictionaryIterator : public ValueObject {
4479:   friend class ClassDictionaryIterator;
4480:   friend class LibraryPrefixIterator;
4488:     // one top-level class per library left, not an array to iterate over.
4497:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4500:   // Returns a non-null raw class.
4511: class LibraryPrefixIterator : public DictionaryIterator {
4521: class Library : public Object {
4578:   void AddClass(const Class& cls) const;
4613:   void AddAnonymousClass(const Class& cls) const;
4617:   void AddClassMetadata(const Class& cls,
4659:   void set_toplevel_class(const Class& value) const;
4864:   // Lookup class in the core lib which also contains various VM
4866:   static RawClass* LookupCoreClass(const String& class_name);
4870:                                   const char* class_name,
4945:   friend class Bootstrap;
4946:   friend class Class;
4947:   friend class Debugger;
4948:   friend class DictionaryIterator;
4949:   friend class Isolate;
4950:   friend class LibraryDeserializationCluster;
4951:   friend class Namespace;
4952:   friend class Object;
4953:   friend class Precompiler;
4958: class Namespace : public Object {
4988:   friend class Class;
4989:   friend class Precompiler;
4992: class KernelProgramInfo : public Object {
5071:                         const Class& klass) const;
5082:   friend class Class;
5088: class ObjectPool : public Object {
5210:   friend class Class;
5211:   friend class Object;
5212:   friend class RawObjectPool;
5215: class Instructions : public Object {
5224:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5225:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5346:   friend class Class;
5347:   friend class Code;
5348:   friend class AssemblyImageWriter;
5349:   friend class BlobImageWriter;
5350:   friend class ImageWriter;
5355: class InstructionsSection : public Object {
5378:   friend class Class;
5381: class LocalVarDescriptors : public Object {
5416:   friend class Class;
5417:   friend class Object;
5420: class PcDescriptors : public Object {
5460:   class Iterator : ValueObject {
5509:     friend class PcDescriptors;
5554:   friend class Class;
5555:   friend class Object;
5558: class CodeSourceMap : public Object {
5600:   friend class Class;
5601:   friend class Object;
5604: class CompressedStackMaps : public Object {
5680:   friend class Class;
5681:   friend class CompressedStackMapsIterator;  // For PayloadByte
5682:   friend class StackMapEntry;                // For PayloadByte
5685: class ExceptionHandlers : public Object {
5734:   friend class Class;
5735:   friend class Object;
5758: // but instead contain only the class ID of the original target.
5762: class WeakSerializationReference : public Object {
5819:   // Gets the class ID of the underlying object from a WSR, or the class ID of
5846:   friend class Class;
5849: class Code : public Object {
6057:   enum class PoolAttachment {
6062:   class KindField : public BitField<intptr_t, CallKind, 0, 2> {};
6063:   class EntryPointField
6065:   class OffsetField
6090:   class Comments : public ZoneAllocated {
6114:     friend class Code;
6192:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6324:   friend class RawObject;  // For RawObject::SizeFromClass().
6325:   friend class RawCode;
6334:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6338:   class ForceOptimizedBit
6341:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6342:   class PtrOffBits
6345:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6432:   friend class Class;
6433:   friend class CodeTestHelper;
6434:   friend class SnapshotWriter;
6435:   friend class StubCode;     // for set_object_pool
6436:   friend class Precompiler;  // for set_object_pool
6437:   friend class FunctionSerializationCluster;
6438:   friend class CodeSerializationCluster;
6439:   friend class CodeDeserializationCluster;
6440:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6441:   friend class StubCode;               // for set_object_pool
6442:   friend class MegamorphicCacheTable;  // for set_object_pool
6443:   friend class CodePatcher;            // for set_instructions
6444:   friend class ProgramVisitor;         // for set_instructions
6447:   friend class RawFunction;
6448:   friend class CallSiteResetter;
6449:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6452: class Bytecode : public Object {
6563:   class SlowFindRawBytecodeVisitor : public FindObjectVisitor {
6590:   friend class BytecodeDeserializationCluster;
6591:   friend class RawObject;  // For RawObject::SizeFromClass().
6592:   friend class RawBytecode;
6595:   friend class Class;
6596:   friend class SnapshotWriter;
6599: class Context : public Object {
6664:   friend class Class;
6665:   friend class Object;
6668: // The ContextScope class makes it possible to delay the compilation of a local
6678: class ContextScope : public Object {
6755:   friend class Class;
6756:   friend class Object;
6759: class MegamorphicCache : public CallSiteData {
6793:   void Insert(const Smi& class_id, const Object& target) const;
6804:   friend class Class;
6805:   friend class MegamorphicCacheTable;
6806:   friend class ProgramVisitor;
6812:   void InsertLocked(const Smi& class_id, const Object& target) const;
6816:                               const Smi& class_id,
6826: class SubtypeTestCache : public Object {
6840:   void AddCheck(const Object& instance_class_id_or_function,
6848:                 Object* instance_class_id_or_function,
6881:   friend class Class;
6882:   friend class Serializer;
6883:   friend class Deserializer;
6886: class Error : public Object {
6894: class ApiError : public Error {
6913:   friend class Class;
6916: class LanguageError : public Error {
6979:   friend class Class;
6982: class UnhandledException : public Error {
7011:   friend class Class;
7012:   friend class ObjectStore;
7015: class UnwindError : public Error {
7035:   friend class Class;
7038: // Instance is the base class for all instance objects (aka the Object class
7040: class Instance : public Object {
7056:     const Class& cls = Class::Handle(clazz());
7133:   // class implementing a 'call' method, return true and set the function
7156:       const Class& method_cls,
7172:   static RawInstance* New(const Class& cls, Heap::Space space = Heap::kNew);
7180:   // only the class_id is different. So, it is safe to use subtype instances in
7220:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7231:   static RawInstance* NewFromCidAndSize(SharedClassTable* shared_class_table,
7237:   friend class ByteBuffer;
7238:   friend class Class;
7239:   friend class Closure;
7240:   friend class Pointer;
7241:   friend class DeferredObject;
7242:   friend class RegExp;
7243:   friend class SnapshotWriter;
7244:   friend class StubCode;
7245:   friend class TypedDataView;
7246:   friend class InstanceSerializationCluster;
7247:   friend class InstanceDeserializationCluster;
7248:   friend class ClassDeserializationCluster;  // vtable
7249:   friend class InstanceMorpher;
7250:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7253: class LibraryPrefix : public Instance {
7288:   friend class Class;
7292: class TypeArguments : public Instance {
7363:   // a raw (null) function type arguments, i.e. consider each class type
7432:       const Class& instantiator_class,
7451:   // Add the class name and URI of each type argument of this vector to the uris
7458:   // type from the various type argument vectors (class instantiator, function,
7535:   // If raw_instantiated is true, consider each class type parameter to be first
7550:   friend class AbstractType;
7551:   friend class Class;
7552:   friend class ClearTypeHashVisitor;
7553:   friend class Object;
7558: class AbstractType : public Instance {
7594:   virtual classid_t type_class_id() const;
7595:   virtual RawClass* type_class() const;
7620:   // instantiation. Consider a class C<T> declaring a non-generic method
7622:   // generic function bar<B> as argument and its function type refers to class
7691:   // Add the class name and URI of each occuring type to the uris
7697:   // The name of this type's class, i.e. without the type argument names of this
7705:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
7708:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
7717:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
7730:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
7748:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
7751:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
7766:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
7803:   friend class Class;
7804:   friend class Function;
7805:   friend class TypeArguments;
7808: // A Type consists of a class, possibly parameterized with type
7811: // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type, as
7814: class Type : public AbstractType {
7817:     return OFFSET_OF(RawType, type_class_id_);
7838:     ASSERT(type_class_id() != kIllegalCid);
7845:   virtual classid_t type_class_id() const;
7846:   virtual RawClass* type_class() const;
7847:   void set_type_class(const Class& value) const;
7860:   // canonicalization (passed-in cls must match type_class()).
7861:   bool IsDeclarationTypeOf(const Class& cls) const;
7865:   // However, in case of a generic typedef, they document how the typedef class
7948:   // The finalized type of the given non-parameterized class.
7949:   static RawType* NewNonParameterizedType(const Class& type_class);
7951:   static RawType* New(const Class& clazz,
7970:   friend class Class;
7971:   friend class TypeArguments;
7972:   friend class ClearTypeHashVisitor;
7979: class TypeRef : public AbstractType {
8003:     return AbstractType::Handle(type()).type_class_id();
8006:     return AbstractType::Handle(type()).type_class();
8050:   friend class Class;
8053: // A TypeParameter represents a type parameter of a parameterized class.
8057: // the class HashMap<K, V>. At compile time, the TypeParameter is not
8060: // as type argument (rather than type parameter) of the parameterized class.
8063: class TypeParameter : public AbstractType {
8080:   classid_t parameterized_class_id() const;
8081:   RawClass* parameterized_class() const;
8086:     return parameterized_class_id() != kFunctionCid;
8133:   // Only one of parameterized_class and parameterized_function is non-null.
8134:   static RawTypeParameter* New(const Class& parameterized_class,
8147:   void set_parameterized_class(const Class& value) const;
8157:   friend class Class;
8158:   friend class ClearTypeHashVisitor;
8161: class Number : public Instance {
8178:   friend class Class;
8181: class Integer : public Number {
8254:   friend class Class;
8257: class Smi : public Integer {
8291:   static RawClass* Class();
8314:     // Indicates this class cannot be extended by dart code.
8321:   friend class Api;  // For ValueFromRaw
8322:   friend class Class;
8323:   friend class Object;
8324:   friend class ReusableSmiHandleScope;
8325:   friend class Thread;
8328: class SmiTraits : AllStatic {
8340: class Mint : public Integer {
8370:   friend class Integer;
8380:   friend class Class;
8381:   friend class Number;
8384: // Class Double represents class Double in corelib_impl, which implements
8385: // abstract class double in corelib.
8386: class Double : public Number {
8417:   friend class Class;
8418:   friend class Number;
8422: class String : public Instance {
8442:   class CodePointIterator : public ValueObject {
8742:   friend class Class;
8743:   friend class Symbols;
8744:   friend class StringSlice;  // SetHash
8746:   friend class CharArray;     // SetHash
8747:   friend class ConcatString;  // SetHash
8748:   friend class OneByteString;
8749:   friend class TwoByteString;
8750:   friend class ExternalOneByteString;
8751:   friend class ExternalTwoByteString;
8752:   friend class RawOneByteString;
8753:   friend class RODataSerializationCluster;  // SetHash
8754:   friend class Pass2Visitor;                // Stack "handle"
8757: class OneByteString : public AllStatic {
8890:   friend class Class;
8891:   friend class String;
8892:   friend class Symbols;
8893:   friend class ExternalOneByteString;
8894:   friend class SnapshotReader;
8895:   friend class StringHasher;
8896:   friend class Utf8;
8899: class TwoByteString : public AllStatic {
9015:   friend class Class;
9016:   friend class String;
9017:   friend class SnapshotReader;
9018:   friend class Symbols;
9021: class ExternalOneByteString : public AllStatic {
9101:     // Indicates this class cannot be extended by dart code.
9105:   friend class Class;
9106:   friend class String;
9107:   friend class SnapshotReader;
9108:   friend class Symbols;
9109:   friend class Utf8;
9112: class ExternalTwoByteString : public AllStatic {
9188:     // Indicates this class cannot be extended by dart code.
9192:   friend class Class;
9193:   friend class String;
9194:   friend class SnapshotReader;
9195:   friend class Symbols;
9198: // Class Bool implements Dart core class bool.
9199: class Bool : public Instance {
9228:   friend class Class;
9229:   friend class Object;  // To initialize the true and false values.
9232: class Array : public Instance {
9340:   // Make the array immutable to Dart code by switching the class pointer
9378:   static RawArray* New(intptr_t class_id,
9417:   friend class Class;
9418:   friend class ImmutableArray;
9419:   friend class Interpreter;
9420:   friend class Object;
9421:   friend class String;
9424: class ImmutableArray : public AllStatic {
9444:     // Indicates this class cannot be extended by dart code.
9452:   friend class Class;
9455: class GrowableObjectArray : public Instance {
9562:   friend class Array;
9563:   friend class Class;
9566: class Float32x4 : public Instance {
9597:   friend class Class;
9600: class Int32x4 : public Instance {
9630:   friend class Class;
9633: class Float64x2 : public Instance {
9658:   friend class Class;
9661: class PointerBase : public Instance {
9668: class TypedDataBase : public PointerBase {
9733:   friend class Class;
9748: class TypedData : public TypedDataBase {
9799:   static intptr_t MaxElements(intptr_t class_id) {
9800:     ASSERT(RawObject::IsTypedDataClassId(class_id));
9801:     return (kSmiMax / ElementSizeInBytes(class_id));
9804:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
9805:     ASSERT(RawObject::IsTypedDataClassId(class_id));
9807:            ElementSizeInBytes(class_id);
9810:   static RawTypedData* New(intptr_t class_id,
9875:   // Therefore this method is private and the call-sites in this class need to
9884:   friend class Class;
9885:   friend class CompressedStackMapsIterator;
9886:   friend class ExternalTypedData;
9887:   friend class TypedDataView;
9890: class ExternalTypedData : public TypedDataBase {
9932:   static intptr_t MaxElements(intptr_t class_id) {
9933:     ASSERT(RawObject::IsExternalTypedDataClassId(class_id));
9934:     return (kSmiMax / ElementSizeInBytes(class_id));
9938:       intptr_t class_id,
9968:   friend class Class;
9971: class TypedDataView : public TypedDataBase {
9973:   static RawTypedDataView* New(intptr_t class_id,
9975:   static RawTypedDataView* New(intptr_t class_id,
10042:   friend class Class;
10043:   friend class Object;
10044:   friend class TypedDataViewDeserializationCluster;
10047: class ByteBuffer : public AllStatic {
10065: class Pointer : public Instance {
10103:   friend class Class;
10106: class DynamicLibrary : public Instance {
10132:   friend class Class;
10139: class LinkedHashMap : public Instance {
10221:   class Iterator : ValueObject {
10265:   friend class Class;
10266:   friend class LinkedHashMapDeserializationCluster;
10269: class Closure : public Instance {
10335:   friend class Class;
10338: class Capability : public Instance {
10349:   friend class Class;
10352: class ReceivePort : public Instance {
10369:   friend class Class;
10372: class SendPort : public Instance {
10392:   friend class Class;
10397: class TransferableTypedDataPeer {
10424: class TransferableTypedData : public Instance {
10436:   friend class Class;
10440: class StackTrace : public Instance {
10497:   friend class Class;
10498:   friend class Debugger;
10501: class RegExpFlags {
10551: class RegExp : public Instance {
10570:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
10571:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
10705:   friend class Class;
10708: class WeakProperty : public Instance {
10737:   friend class Class;
10740: class MirrorReference : public Instance {
10769:   friend class Class;
10772: class UserTag : public Instance {
10805:   friend class Class;
10808: // Represents abstract FutureOr class in dart:async.
10809: class FutureOr : public Instance {
10825:   friend class Class;
10832:     return Smi::Class();
10835:   return Isolate::Current()->class_table()->At(raw()->GetClassId());
10979:                                 const Smi& class_id,
10982:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
11055: // This helper class can then be used via
11090: class ArrayOfTuplesView {
11094:   class Iterator;
11096:   class TupleView {
11120:     friend class Iterator;
11123:   class Iterator {
11173:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
153:   static const ClassId kClassId = k##object##Cid;                              \
299:   inline RawClass* clazz() const;
564:     // Internal names are the true names of classes, fields,
568:     // The names of core implementation classes (like _OneByteString)
573:     //   private constructor        -> _MyClass@6b3832b.
574:     //   private named constructor  -> _MyClass@6b3832b.named
584:     //   _MyClass@6b3832b.      -> _MyClass
585:     //   _MyClass@6b3832b.named -> _MyClass.named
591:     // the names of core implementation classes are remapped to their
596:     //   _MyClass@6b3832b.      -> _MyClass
597:     //   _MyClass@6b3832b.named -> _MyClass.named
777:   static RawClass*
782:   static RawClass*
792:   static RawClass*
934:   static intptr_t host_instance_size(RawClass* clazz) {
937:   static intptr_t target_instance_size(RawClass* clazz) {
1006:     return RawObject::ClassIdTag::is_valid(value);
1013:   static intptr_t id_offset() { return OFFSET_OF(RawClass, id_); }
1015:     return OFFSET_OF(RawClass, num_type_arguments_);
1026:   RawClass* Mixin() const;
1053:   // in superclass clauses.
1067:     return OFFSET_OF(RawClass, declaration_type_);
1085:     return OFFSET_OF(RawClass, type_parameters_);
1150:     return OFFSET_OF(RawClass, host_type_arguments_field_offset_in_words_);
1155:     return OFFSET_OF(RawClass, target_type_arguments_field_offset_in_words_);
1168:     return OFFSET_OF(RawClass, super_type_);
1172:   // |original_classes| only has an effect when reloading. If true and we
1173:   // are reloading, it will prefer the original classes to the replacement
1174:   // classes.
1175:   RawClass* SuperClass(bool original_classes = false) const;
1214:   bool IsDartFunctionClass() const;
1217:   bool IsFutureClass() const;
1232:   static bool IsInFullSnapshot(RawClass* cls) {
1267:   // |original_classes| only has an effect when reloading. If true and we
1268:   // are reloading, it will prefer the original classes to the replacement
1269:   // classes.
1270:   RawArray* OffsetToFieldMap(bool original_classes = false) const;
1319:     return RoundedAllocationSize(sizeof(RawClass));
1333:     return ClassLoadingBits::decode(raw_ptr()->state_bits_);
1358:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1359:            RawClass::kFinalized;
1364:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1365:            RawClass::kPreFinalized;
1407:     return RawClass::BinaryDeclarationOffset::decode(
1413:                     RawClass::BinaryDeclarationOffset::update(
1458:     return RawClass::IsDeclaredInBytecode::decode(
1466:                     RawClass::IsDeclaredInBytecode::update(
1521:   // Allocate instance classes.
1522:   static RawClass* New(const Library& lib,
1527:   static RawClass* NewNativeWrapper(const Library& library,
1531:   // Allocate the raw string classes.
1534:   // Allocate the raw TypedData classes.
1537:   // Allocate the raw TypedDataView/ByteDataView classes.
1540:   // Allocate the raw ExternalTypedData classes.
1544:   // Allocate the raw Pointer classes.
1583:   static int32_t host_instance_size_in_words(const RawClass* cls) {
1587:   static int32_t target_instance_size_in_words(const RawClass* cls) {
1595:   static int32_t host_next_field_offset_in_words(const RawClass* cls) {
1599:   static int32_t target_next_field_offset_in_words(const RawClass* cls) {
1608:       const RawClass* cls) {
1613:       const RawClass* cls) {
1636:   static RawClass* NewCommon(intptr_t index);
1668:                                              RawClass::ClassFinalizedState,
1672:                                            RawClass::ClassLoadingState,
1720:   // This includes type arguments of a superclass and takes overlapping
1739:   static RawClass* New(intptr_t id,
1745:   static RawClass* NewInstanceClass();
1757: // Classification of type genericity according to type parameter owners.
1787:     return RoundedAllocationSize(sizeof(RawPatchClass));
1789:   static bool IsInFullSnapshot(RawPatchClass* cls) {
1804:   static RawPatchClass* New();
1806:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1881:   classid_t expected_cid() const { return raw_ptr()->expected_cid_; }
1887:   static RawMonomorphicSmiableCall* New(classid_t expected_cid,
1958: // Object holding information about an IC: test classes and their
2023:   V(CheckClass)                                                                \
2060:   // Call site classification that is helpful for hot-reload. Call sites with
2304:   // to list the call site's observed receiver classes and targets.
2504:   RawClass* Owner() const;
2506:   RawClass* origin() const;
3473: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3480:   V(ProhibitsHoistingCheckClass)                                               \
3975:   RawClass* Owner() const;
4493:   ClassDictionaryIterator(const Library& library,
4501:   RawClass* GetNextClass();
4504:   void MoveToNextClass();
4508:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4585:   RawClass* LookupClass(const String& name) const;
4586:   RawClass* LookupClassAllowPrivate(const String& name) const;
4587:   RawClass* SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4588:   RawClass* LookupLocalClass(const String& name) const;
4841:   // Eagerly compile all classes and functions in the library.
4844:   // Finalize all classes in all libraries.
4865:   // helper methods and classes. Allow look up of private classes.
5002:                                    const Array& classes_cache,
5067:   void set_classes_cache(const Array& cache) const;
5068:   RawClass* LookupClass(Thread* thread, const Smi& name_index) const;
5069:   RawClass* InsertClass(Thread* thread,
7232:                                         classid_t cid,
7345:   // Names of internal classes are mapped to their public interfaces.
7556: // AbstractType is an abstract superclass.
7684:   // Names of internal classes are mapped to their public interfaces.
7699:   RawString* ClassName() const;
7998:            AbstractType::Handle(type()).HasTypeClass();
9693:   static intptr_t ElementSizeInBytes(classid_t cid) {
9697:   static TypedDataElementType ElementType(classid_t cid) {
10014:     const classid_t cid = typed_data.GetClassId();
10750:   RawClass* GetClassReferent() const;
10829: RawClass* Object::clazz() const {
11088: //     classes (e.g. 'Code', 'Smi', 'Object')
297:                                   : raw()->GetClassId();
327:   // Object::DictionaryName() returns String::null(). Only subclasses
1052:   // dynamic and type parameters declared in superclasses filled in as declared
1193:     return raw_ptr()->direct_subclasses_;
1196:   void ClearDirectSubclasses() const;
1350:     return SynthesizedClassBit::decode(raw_ptr()->state_bits_);
1653:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1669:                                              kClassFinalizedPos,
1670:                                              kClassFinalizedSize> {};
1673:                                            kClassLoadingPos,
1674:                                            kClassLoadingSize> {};
1678:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
2177:   void GetOneClassCheckAt(intptr_t index,
2183:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2184:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2200:   RawICData* AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2202:     return AsUnaryClassChecksForArgNr(0);
2204:   RawICData* AsUnaryClassChecksForCid(intptr_t cid,
2211:   RawICData* AsUnaryClassChecksSortedByCount() const;
3371:       return RawObject::IsTypedDataViewClassId(klass.id());
4845:   static RawError* FinalizeAllClasses();
4889:   void EnsureTopLevelClassIsFinalized() const;
4909:   void InitClassDictionary() const;
5784:     return TargetOf(raw)->GetClassId();
5817:     return UnwrappedClassIdOf(obj.raw());
5822:   // UnwrappedClassOf(Wrap(r)) == UnwrappedClassOf(r) for all raw objects r,
5827:     if (!obj->IsWeakSerializationReference()) return obj->GetClassId();
5828:     return TargetClassIdOf(WeakSerializationReference::RawCast(obj));
6208:     return WeakSerializationReference::UnwrappedClassIdOf(raw->ptr()->owner_);
6819:   static inline RawObject* GetClassId(const Array& array, intptr_t index);
7047:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7557: // Subclasses of AbstractType are Type and TypeParameter.
8561:     return raw()->GetClassId() == kOneByteStringCid;
8565:     return raw()->GetClassId() == kTwoByteStringCid;
8569:     return raw()->GetClassId() == kExternalOneByteStringCid;
8573:     return raw()->GetClassId() == kExternalTwoByteStringCid;
8577:     return RawObject::IsExternalStringClassId(raw()->GetClassId());
9291:   bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
9682:     return ElementSizeInBytes(raw()->GetClassId()) * Length();
9686:     return ElementType(raw()->GetClassId());
9690:     return element_size(ElementType(raw()->GetClassId()));
9700:     } else if (RawObject::IsTypedDataClassId(cid)) {
9704:     } else if (RawObject::IsTypedDataViewClassId(cid)) {
9709:       ASSERT(RawObject::IsExternalTypedDataClassId(cid));
9863:     intptr_t cid = obj.raw()->GetClassId();
9864:     return RawObject::IsTypedDataClassId(cid);
9948:     intptr_t cid = obj.raw()->GetClassId();
9949:     return RawObject::IsExternalTypedDataClassId(cid);
9995:     intptr_t cid = data.raw()->GetClassId();
9996:     ASSERT(RawObject::IsTypedDataClassId(cid) ||
9997:            RawObject::IsExternalTypedDataClassId(cid));
9998:     return RawObject::IsExternalTypedDataClassId(cid);
10015:     ASSERT(RawObject::IsTypedDataClassId(cid) ||
10016:            RawObject::IsExternalTypedDataClassId(cid));
10116:     intptr_t cid = obj.raw()->GetClassId();
10117:     return RawObject::IsFfiDynamicLibraryClassId(cid);
10842:   intptr_t cid = value->GetClassIdMayBeSmi();
10998:   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/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);
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 ?
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
chromium.googlesource.com/chromium/src/third_party:polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
skia.googlesource.com/buildbot:autoroll/package-lock.json: [ master, ]
1456:             "needle": "^2.2.1",
2559:         "xml-char-classes": "^1.0.0"
1437:         "needle": {
3982:     "xml-char-classes": {
3984:       "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 ?
github.com/apache/trafficcontrol:traffic_portal/app/src/package-lock.json: [ master, ]
1251:                         "needle": "^2.2.1",
100:                 "class-utils": "^0.3.5",
718:                 "posix-character-classes": "^0.1.0",
384:         "class-utils": {
386:             "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1234:                 "needle": {
2213:         "posix-character-classes": {
2215:             "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.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",
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:     load_raw = &CLASS eight_bit_load_raw;
7671:       load_raw = &CLASS eight_bit_load_raw;
7677:       load_raw = &CLASS kodak_radc_load_raw;
7683:       load_raw = &CLASS kodak_radc_load_raw;
7690: 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
7696:       write_thumb = &CLASS layer_thumb;
7700:       load_raw = &CLASS eight_bit_load_raw;
7707:     load_raw = &CLASS kodak_radc_load_raw;
7720:     load_raw = &CLASS quicktake_100_load_raw;