Found 138364 results in 4391 files, showing top 50 files (show more).
github.com/apache/juneau:juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java: [ master, ]
65: 		MAP, COLLECTION, CLASS, METHOD, NUMBER, DECIMAL, BOOLEAN, CHAR, DATE, ARRAY, ENUM, OTHER, CHARSEQ, STR, OBJ, URI, BEANMAP,...(43 bytes skipped)...
61: public final class ClassMeta<T> implements Type {
64: 	enum ClassCategory {
68: 	final Class<T> innerClass;                              // The class being wrapped.
71: 	private final Class<? extends T> implClass;             // The implementation class to use if this is an interface.
87: 		isMemberClass;                                       // True if this is a non-static member class.
143: 	ClassMeta(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps, Object example) {
226: 	ClassMeta(ClassMeta<T> mainType, ClassMeta<?> keyType, ClassMeta<?> valueType, ClassMeta<?> elementType) {
269: 	ClassMeta(ClassMeta<?>[] args) {
309: 	private final class ClassMetaBuilder<T> {
310: 		Class<T> innerClass;
312: 		Class<? extends T> implClass;
317: 			isMemberClass = false,
354: 		ClassMetaBuilder(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps, Object example) {
934: 	public Class<T> getInnerClass() {
1157: 	public boolean isClass() {
1474: 	public boolean isMemberClass() {
748: 		private ClassMeta<?> findClassMeta(Class<?> c) {
813: 	public ClassCategory getClassCategory() {
947: 	public ClassMeta<?> getSerializedClassMeta(BeanSession session) {
41:  * A wrapper class around the {@link Class} object that provides cached information about that class.
44:  * Instances of this class can be created through the {@link BeanContext#getClassMeta(Class)} method.
47:  * The {@link BeanContext} class will cache and reuse instances of this class except for the following class types:
55:  * This class is tied to the {@link BeanContext} class because it's that class that makes the determination of what is
58:  * @param <T> The class type of the wrapped class.
63: 	/** Class categories. */
72: 	private final ClassCategory cc;                         // The class category.
75: 		noArgConstructor,                                    // The no-arg constructor for this class (if it has one).
85: 		isDelegate,                                          // True if this class extends Delegate.
86: 		isAbstract,                                          // True if this class is abstract.
91: ...(4 bytes skipped)...vate final PojoSwap<?,?>[] childPojoSwaps;           // Any PojoSwaps where the normal type is a subclass of this class.
92: 	private final ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
100: 		elementType,                                         // If ARRAY or COLLECTION, the element class type.
101: 		keyType,                                             // If MAP, the key class type.
102: 		valueType;                                           // If MAP, the value class type.
103: 	private final BeanMeta<T> beanMeta;                     // The bean meta for this bean class (if it's a bean).
105: ...(7 bytes skipped)...ropertyName,                                    // The property name of the _type property for this class and subclasses.
107: 		dictionaryName;                                      // The dictionary name of this class if it has one.
109: 	private final InvocationHandler invocationHandler;      // The invocation handler for this class (if it has one).
110: 	private final BeanRegistry beanRegistry;                // The bean registry of this class meta (if it has one).
113: 	private final Map<Class<?>,Mutater<?,T>> fromMutaters = new ConcurrentHashMap<>();
114: 	private final Map<Class<?>,Mutater<T,?>> toMutaters = new ConcurrentHashMap<>();
121: 	 * Construct a new {@code ClassMeta} based on the specified {@link Class}.
123: 	 * @param innerClass The class being wrapped.
126: 	 * 	For interfaces and abstract classes, this represents the "real" class to instantiate.
129: 	 * 	The {@link BeanFilter} programmatically associated with this class.
132: 	 * 	The {@link PojoSwap} programmatically associated with this class.
135: 	 * 	The child {@link PojoSwap PojoSwaps} programmatically associated with this class.
136: 	 * 	These are the <c>PojoSwaps</c> that have normal classes that are subclasses of this class.
140: 	 * 	Used for delayed initialization when the possibility of class reference loops exist.
151: 			// We always immediately add this class meta to the bean context cache so that we can resolve recursive references.
202: 	private static boolean isCacheable(Class<?> c) {
224: 	 * Used for creating Map and Collection class metas that shouldn't be cached.
270: 		this.innerClass = (Class<T>) Object[].class;
345: 		ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
370: 			Class<T> c = innerClass;
388: 				else if (c == void.class || c == Void.class)
391: 				if (ci.isChildOf(Delegate.class))
394: 				if (c == Object.class)
398: 				else if (c.equals(Class.class))
399: 					cc = ClassCategory.CLASS;
400: 				else if (ci.isChildOf(Method.class))
402: 				else if (ci.isChildOf(CharSequence.class)) {
403: 					if (c.equals(String.class))
408: 				else if (ci.isChildOf(Number.class)) {
409: 					if (ci.isChildOfAny(Float.class, Double.class))
414: 				else if (ci.isChildOf(Collection.class))
416: 				else if (ci.isChildOf(Map.class)) {
417: 					if (ci.isChildOf(BeanMap.class))
422: 				else if (c == Character.class)
424: 				else if (c == Boolean.class)
426: 				else if (ci.isChildOfAny(Date.class, Calendar.class))
430: 				else if (ci.isChildOfAny(URL.class, URI.class) || bc.hasAnnotation(org.apache.juneau.annotation.URI.class, c))
432: 				else if (ci.isChildOf(Reader.class))
434: 				else if (ci.isChildOf(InputStream.class))
436: 				else if (ci.is(Optional.class))
446: 			// parse() is used by the java logging Level class.
447: 			// forName() is used by Class and Charset
451: ...(23 bytes skipped)...C, PUBLIC, NOT_DEPRECATED) && m.hasName(methodName) && m.hasReturnType(c) && m.hasParamTypes(String.class)) {
461: ...(8 bytes skipped)...m.isAll(PUBLIC, NOT_DEPRECATED, STATIC) && m.hasName("example") && m.hasFuzzyParamTypes(BeanSession.class)) {
468: 				if (bc.hasAnnotation(ParentProperty.class, f)) {
474: 				if (bc.hasAnnotation(NameProperty.class, f)) {
483: 				if (bc.hasAnnotation(Example.class, f)) {
493: 				if (bc.hasAnnotation(ParentProperty.class, m)) {
499: 				if (bc.hasAnnotation(NameProperty.class, m)) {
508: 				if (bc.hasAnnotation(Example.class, m)) {
509: 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
510: 						throw new Class...(22 bytes skipped)..., "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
523: 					if (pt.size() == (isMemberClass ? 1 : 0) && c != Object.class && ! isAbstract) {
527: 						if (arg.is(String.class))
539: 			if (innerClass != Object.class) {
568: 						keyType = findClassMeta(Object.class);
569: 						valueType = findClassMeta(Object.class);
579: 						elementType = findClassMeta(Object.class);
618: 				for (Bean b : bc.getAnnotations(Bean.class, c)) {
631: 				for (Example e : bc.getAnnotations(Example.class, c))
654: 						Iterator<? extends Enum> i = EnumSet.allOf((Class<? extends Enum>)c).iterator();
670: 					case CLASS:
687: 			this.stringMutater = Mutaters.get(String.class, c);
692: 				List<Bean> ba = info.getAnnotations(Bean.class, bc);
704: 				for (Swap swap : bc.getAnnotations(Swap.class, innerClass))
706: 				for (Swaps swaps : bc.getAnnotations(Swaps.class, innerClass))
725: 			Class<?> c = s.value();
726: 			if (c == Null.class)
730: 			if (ci.isChildOf(PojoSwap.class)) {
731: 				PojoSwap ps = castOrCreate(PojoSwap.class, c);
739: 			if (ci.isChildOf(Surrogate.class)) {
745: 			throw new ClassMetaRuntimeException(c, "Invalid swap class ''{0}'' specified.  Must extend from PojoSwap or Surrogate.", c);
758: 	 * Returns the {@link ClassInfo} wrapper for the underlying class.
760: 	 * @return The {@link ClassInfo} wrapper for the underlying class, never <jk>null</jk>.
767: 	 * Returns the type property name associated with this class and subclasses.
773: 	 * 	The type property name associated with this bean class, or <jk>null</jk> if there is no explicit type
781: 	 * Returns the bean dictionary name associated with this class.
787: 	 * 	The type name associated with this bean class, or <jk>null</jk> if there is no type name defined or this
795: 	 * Returns the bean registry for this class.
799: 	 * defined on the class, regardless of whether the class is an actual bean.
802: 	 * @return The bean registry for this class, or <jk>null</jk> if no bean registry is associated with it.
809: 	 * Returns the category of this class.
811: 	 * @return The category of this class.
818: 	 * Returns <jk>true</jk> if this class is a superclass of or the same as the specified class.
820: 	 * @param c The comparison class.
821: 	 * @return <jk>true</jk> if this class is a superclass of or the same as the specified class.
823: 	public boolean isAssignableFrom(Class<?> c) {
828: 	 * Returns <jk>true</jk> if this class is a subclass of or the same as the specified class.
830: 	 * @param c The comparison class.
831: 	 * @return <jk>true</jk> if this class is a subclass of or the same as the specified class.
833: 	public boolean isInstanceOf(Class<?> c) {
838: 	 * Returns <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
844: 	 * @return <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
851: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the normal class of one of the
852: 	 * child POJO swaps associated with this class.
854: 	 * @param normalClass The normal class being resolved.
857: 	protected PojoSwap<?,?> getChildPojoSwapForSwap(Class<?> normalClass) {
878: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the swap class of one of the child
879: 	 * POJO swaps associated with this class.
881: 	 * @param swapClass The swap class being resolved.
884: 	protected PojoSwap<?,?> getChildPojoSwapForUnswap(Class<?> swapClass) {
905: 	 * Locates the no-arg constructor for the specified class.
909: 	 * If class is abstract, always returns <jk>null</jk>.
912: 	 * @param c The class from which to locate the no-arg constructor.
917: 	protected static <T> Constructor<? extends T> findNoArgConstructor(Class<?> c, Visibility v) {
930: 	 * Returns the {@link Class} object that this class type wraps.
932: 	 * @return The wrapped class object.
939: 	 * Returns the serialized (swapped) form of this class if there is an {@link PojoSwap} associated with it.
944: 	 * @return The serialized class type, or this object if no swap is associated with the class.
953: 	 * Returns the example of this class.
958: 	 * @return The serialized class type, or this object if no swap is associated with the class.
1025: 	 * For array and {@code Collection} types, returns the class type of the components of the array or
1028: 	 * @return The element class type, or <jk>null</jk> if this class is not an array or Collection.
1035: 	 * For {@code Map} types, returns the class type of the keys of the {@code Map}.
1037: 	 * @return The key class type, or <jk>null</jk> if this class is not a Map.
1044: 	 * For {@code Map} types, returns the class type of the values of the {@code Map}.
1046: 	 * @return The value class type, or <jk>null</jk> if this class is not a Map.
1053: 	 * Returns <jk>true</jk> if this class implements {@link Delegate}, meaning it's a representation of some other
1056: 	 * @return <jk>true</jk> if this class implements {@link Delegate}.
1063: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map}.
1065: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map}.
1072: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1074: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1081: 	 * Returns <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1083: 	 * @return <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1090: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection}.
1092: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection}.
1099: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Optional}.
1101: 	 * @return <jk>true</jk> if this class is a subclass of {@link Optional}.
1108: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1110: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1117: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1119: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1126: 	 * Returns <jk>true</jk> if this class extends from {@link Set}.
1128: 	 * @return <jk>true</jk> if this class extends from {@link Set}.
1131: 		return cc == COLLECTION && info.isChildOf(Set.class);
1135: 	 * Returns <jk>true</jk> if this class extends from {@link List}.
1137: 	 * @return <jk>true</jk> if this class extends from {@link List}.
1140: 		return cc == COLLECTION && info.isChildOf(List.class);
1144: 	 * Returns <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1146: 	 * @return <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1149: 		return cc == ARRAY && this.innerClass == byte[].class;
1153: 	 * Returns <jk>true</jk> if this class is {@link Class}.
1155: 	 * @return <jk>true</jk> if this class is {@link Class}.
1158: 		return cc == ClassCategory.CLASS;
1162: 	 * Returns <jk>true</jk> if this class is {@link Method}.
1164: 	 * @return <jk>true</jk> if this class is {@link Method}.
1171: 	 * Returns <jk>true</jk> if this class is an {@link Enum}.
1173: 	 * @return <jk>true</jk> if this class is an {@link Enum}.
1180: 	 * Returns <jk>true</jk> if this class is an array.
1182: 	 * @return <jk>true</jk> if this class is an array.
1189: 	 * Returns <jk>true</jk> if this class is a bean.
1191: 	 * @return <jk>true</jk> if this class is a bean.
1198: 	 * Returns <jk>true</jk> if this class is {@link Object}.
1200: 	 * @return <jk>true</jk> if this class is {@link Object}.
1207: 	 * Returns <jk>true</jk> if this class is not {@link Object}.
1209: 	 * @return <jk>true</jk> if this class is not {@link Object}.
1216: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Number}.
1218: 	 * @return <jk>true</jk> if this class is a subclass of {@link Number}.
1225: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1227: 	 * @return <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1234: 	 * Returns <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1236: 	 * @return <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1239: 		return innerClass == Float.class || innerClass == float.class;
1243: 	 * Returns <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1245: 	 * @return <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1248: 		return innerClass == Double.class || innerClass == double.class;
1252: 	 * Returns <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1254: 	 * @return <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1257: 		return innerClass == Short.class || innerClass == short.class;
1261: 	 * Returns <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1263: 	 * @return <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1266: 		return innerClass == Integer.class || innerClass == int.class;
1270: 	 * Returns <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1272: 	 * @return <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1275: 		return innerClass == Long.class || innerClass == long.class;
1281: 	 * @param c The class to test against.
1284: 	public boolean isType(Class<?> c) {
1289: 	 * Returns <jk>true</jk> if this class is a {@link Boolean}.
1291: 	 * @return <jk>true</jk> if this class is a {@link Boolean}.
1298: 	 * Returns <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1300: 	 * @return <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1307: 	 * Returns <jk>true</jk> if this class is a {@link String}.
1309: 	 * @return <jk>true</jk> if this class is a {@link String}.
1316: 	 * Returns <jk>true</jk> if this class is a {@link Character}.
1318: 	 * @return <jk>true</jk> if this class is a {@link Character}.
1325: 	 * Returns <jk>true</jk> if this class is a primitive.
1327: 	 * @return <jk>true</jk> if this class is a primitive.
1334: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1336: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1343: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1345: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1348: 		return cc == DATE || info.isChildOf(Temporal.class);
1352: 	 * Returns <jk>true</jk> if this class is a {@link Date}.
1354: 	 * @return <jk>true</jk> if this class is a {@link Date}.
1357: 		return cc == DATE && info.isChildOf(Date.class);
1361: 	 * Returns <jk>true</jk> if this class is a {@link Temporal}.
1363: 	 * @return <jk>true</jk> if this class is a {@link Temporal}.
1366: 		return info.isChildOf(Temporal.class);
1370: 	 * Returns <jk>true</jk> if this class is a {@link Calendar}.
1372: 	 * @return <jk>true</jk> if this class is a {@link Calendar}.
1375: 		return cc == DATE && info.isChildOf(Calendar.class);
1379: 	 * Returns <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1381: 	 * @return <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1388: 	 * Returns <jk>true</jk> if this class is a {@link Reader}.
1390: 	 * @return <jk>true</jk> if this class is a {@link Reader}.
1397: 	 * Returns <jk>true</jk> if this class is an {@link InputStream}.
1399: 	 * @return <jk>true</jk> if this class is an {@link InputStream}.
1406: 	 * Returns <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1408: 	 * @return <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1452: 	 * @return <jk>true</jk> if instance of this class can be null.
1461: 	 * Returns <jk>true</jk> if this class is abstract.
1463: 	 * @return <jk>true</jk> if this class is abstract.
1470: 	 * Returns <jk>true</jk> if this class is an inner class.
1472: 	 * @return <jk>true</jk> if this class is an inner class.
1479: 	 * All public methods on this class including static methods.
1484: 	 * @return The public methods on this class.
1491: 	 * Returns the {@link PojoSwap} associated with this class that's the best match for the specified session.
1495: 	 * 	<br>If multiple swaps are associated with a class, only the first one with a matching media type will
1498: 	 * 	The {@link PojoSwap} associated with this class, or <jk>null</jk> if there are no POJO swaps associated with
1499: 	 * 	this class.
1520: 	 * Returns the builder swap associated with this class.
1523: 	 * @return The builder swap associated with this class, or <jk>null</jk> if it doesn't exist.
1530: 	 * Returns the {@link BeanMeta} associated with this class.
1533: 	 * 	The {@link BeanMeta} associated with this class, or <jk>null</jk> if there is no bean meta associated with
1534: 	 * 	this class.
1541: 	 * Returns the no-arg constructor for this class.
1543: 	 * @return The no-arg constructor for this class, or <jk>null</jk> if it does not exist.
1550: 	 * Returns the interface proxy invocation handler for this class.
1559: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1561: 	 * @return <jk>true</jk> if a new instance of this class can be constructed.
1576: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1577: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1578: 	 * the defining class.
1581: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1583: 	 * 	<jk>true</jk> if a new instance of this class can be created within the context of the specified outer object.
1592: 	 * Returns <jk>true</jk> if this class can be instantiated as a bean.
1593: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1594: 	 * the defining class.
1597: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1612: 	 * Returns <jk>true</jk> if this class can call the {@link #newInstanceFromString(Object, String)} method.
1615: 	 * 	The outer class object for non-static member classes.
1617: 	 * @return <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1624: 				return outer != null && stringConstructor.hasParamTypes(outer.getClass(), String.class);
1653: 	 * Returns the reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1655: 	 * @return The reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1682: 	 * @return The default value, or <jk>null</jk> if this class type is not a primitive.
1718: 	 * Create a new instance of the main class of this declared type from a <c>String</c> input.
1721: 	 * In order to use this method, the class must have one of the following methods:
1729: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1738: 			return (T)Enum.valueOf((Class<? extends Enum>)this.innerClass, arg);
1754: 		throw new InstantiationError("No string constructor or valueOf(String) method found for class '"+getInnerClass().getName()+"'");
1758: 	 * Create a new instance of the main class of this declared type.
1772: 			return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] { getInnerClass(), java.io.Serializable.class }, h);
1782: 	 * 	The instance of the owning object of the member class instance.
1783: 	 * 	Can be <jk>null</jk> if instantiating a non-member or static class.
1797: 	 * @param cm The class meta to compare to.
1798: 	 * @return <jk>true</jk> if the specified class-meta is equivalent to this one.
1812: 	 * Same as {@link #toString()} except use simple class names.
1814: 	 * @param simple Print simple class names only (no package).
1825: 	 * @param simple Print simple class names only (no package).
1839: 			return sb.append(BeanMap.class.getName()).append('<').append(n).append('>');
1846: 	 * Returns <jk>true</jk> if the specified object is an instance of this class.
1849: 	 * This is a simple comparison on the base class itself and not on any generic parameters.
1852: 	 * @return <jk>true</jk> if the specified object is an instance of this class.
1861: 	 * Returns a readable name for this class (e.g. <js>"java.lang.String"</js>, <js>"boolean[]"</js>).
1863: 	 * @return The readable name for this class.
1870: 	 * Shortcut for calling {@link Class#getName()} on the inner class of this metadata.
1872: 	 * @return The  name of the inner class.
1879: 	 * Shortcut for calling {@link Class#getSimpleName()} on the inner class of this metadata.
1881: 	 * @return The simple name of the inner class.
1888: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1890: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1893: 		return hasMutaterFrom(Reader.class);
1897: 	 * Returns the transform for this class for creating instances from a Reader.
1902: 		return getFromMutater(Reader.class);
1906: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1908: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1911: 		return hasMutaterFrom(InputStream.class);
1915: 	 * Returns the transform for this class for creating instances from an InputStream.
1920: 		return getFromMutater(InputStream.class);
1924: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1926: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1933: 	 * Returns the transform for this class for creating instances from a String.
1942: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1944: 	 * @param c The class type to convert from.
1945: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1947: 	public boolean hasMutaterFrom(Class<?> c) {
1952: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1954: 	 * @param c The class type to convert from.
1955: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1962: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1964: 	 * @param c The class type to convert from.
1965: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1967: 	public boolean hasMutaterTo(Class<?> c) {
1972: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1974: 	 * @param c The class type to convert from.
1975: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1982: 	 * Transforms the specified object into an instance of this class.
1994: 	 * Transforms the specified object into an instance of this class.
1997: 	 * @param c The class
2001: 	public <O> O mutateTo(Object o, Class<O> c) {
2007: 	 * Transforms the specified object into an instance of this class.
2010: 	 * @param c The class
2018: 	 * Returns the transform for this class for creating instances from other object types.
2020: 	 * @param c The transform-from class.
2024: 	public <I> Mutater<I,T> getFromMutater(Class<I> c) {
2038: 	 * Returns the transform for this class for creating instances from other object types.
2040: 	 * @param c The transform-from class.
2044: 	public <O> Mutater<T,O> getToMutater(Class<O> c) {
2061: 	 * @return <jk>true</jk> if the inner class has the annotation.
2063: 	public boolean hasAnnotation(Class<? extends Annotation> a) {
2071: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2073: 	public <A extends Annotation> A getLastAnnotation(Class<A> a) {
2078: 	 * Returns all annotations of the specified type defined on the specified class or parent classes/interfaces in parent-to-child order.
2085: 	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.*;
60: @Bean(bpi="innerClass,classCategory,elementType,keyType,valueType,notABeanReason,initException,beanMeta")
69: 	final ClassInfo info;
88: 	private final Object primitiveDefault;                  // Default value for primitive type classes.
99: 	private final ClassMeta<?>
111: 	private final ClassMeta<?>[] args;                      // Arg types if this is an array of args.
125: 	 * @param implClass
144: 		this.innerClass = innerClass;
145: 		this.info = ClassInfo.of(innerClass);
152: 			if (beanContext != null && beanContext.cmCache != null && isCacheable(innerClass))
153: 				beanContext.cmCache.put(innerClass, this);
155: 			ClassMetaBuilder<T> builder = new ClassMetaBuilder(innerClass, beanContext, implClass, beanFilter, swaps, childPojoSwaps, example);
179: 			this.isMemberClass = builder.isMemberClass;
181: 			this.implClass = builder.implClass;
190: 		} catch (ClassMetaRuntimeException e) {
200: 	 * Generated classes shouldn't be cacheable to prevent needlessly filling up the cache.
204: 		char x = n.charAt(n.length()-1);  // All generated classes appear to end with digits.
227: 		this.innerClass = mainType.innerClass;
229: 		this.implClass = mainType.implClass;
241: 		this.isMemberClass = mainType.isMemberClass;
271: 		this.info = ClassInfo.of(innerClass);
273: 		this.implClass = null;
285: 		this.isMemberClass = false;
311: 		ClassInfo ci;
314: 		ClassCategory cc = ClassCategory.OTHER;
330: 		ClassMeta<?>
355: 			this.innerClass = innerClass;
359: 			this.implClass = implClass;
360: 			ClassInfo ici = ClassInfo.of(implClass);
371: 			ci = ClassInfo.of(c);
374: 				innerClass = this.innerClass = ci.inner();
440: 			isMemberClass = ci.isMemberClass() && ci.isNotStatic();
443: 			// fromString() must be checked before valueOf() so that Enum classes can create their own
470: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
476: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
485: 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of ...(16 bytes skipped)...
495: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and hav...(22 bytes skipped)...
501: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have ...(20 bytes skipped)...
522: 					List<ClassInfo> pt = cs.getParamTypes();
525: 					} else if (pt.size() == (isMemberClass ? 2 : 1)) {
526: 						ClassInfo arg = pt.get(isMemberClass ? 1 : 0);
540: 				ClassInfo x = implClass == null ? ci : ici;
551: 				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
559: 					elementType = findClassMeta(innerClass.getComponentType());
563: 					ClassMeta[] parameters = findParameters();
575: 					ClassMeta[] parameters = findParameters();
589: 						newMeta = new BeanMeta(ClassMeta.this, bc, beanFilter, null);
614: 			if (beanMeta != null && bc != null && bc.isUseInterfaceProxies() && innerClass.isInterface())
694: 					return new AnnotationBeanFilterBuilder(innerClass, ba).build();
728: 			ClassInfo ci = ClassInfo.of(c);
752: 		private ClassMeta<?>[] findParameters() {
753: 			return beanContext.findParameters(innerClass, innerClass);
762: 	public ClassInfo getInfo() {
859: 			PojoSwap<?,?> s = childSwapMap.get(normalClass);
862: 					if (s == null && f.getNormalClass().isParentOf(normalClass))
866: 				PojoSwap<?,?> s2 = childSwapMap.putIfAbsent(normalClass, s);
886: 			PojoSwap<?,?> s = childUnswapMap.get(swapClass);
889: 					if (s == null && f.getSwapClass().isParentOf(swapClass))
893: 				PojoSwap<?,?> s2 = childUnswapMap.putIfAbsent(swapClass, s);
910: 	 * Note that this also returns the 1-arg constructor for non-static member classes.
918: 		ClassInfo ci = ClassInfo.of(c);
921: 		boolean isMemberClass = ci.isMemberClass() && ci.isNotStatic();
923: 			if (cc.hasNumParams(isMemberClass ? 1 : 0) && cc.isVisible(v) && cc.isNotDeprecated())
935: 		return innerClass;
1001: 					Object o = Array.newInstance(getElementType().innerClass, 1);
1020: 			throw new ClassMetaRuntimeException(e);
1030: 	public ClassMeta<?> getElementType() {
1039: 	public ClassMeta<?> getKeyType() {
1048: 	public ClassMeta<?> getValueType() {
1330: 		return innerClass.isPrimitive();
1428: 	public ClassMeta<?>[] getArgs() {
1439: 	public ClassMeta<?> getArg(int index) {
1455: 		if (innerClass.isPrimitive())
1475: 		return isMemberClass;
1564: 		if (isMemberClass)
1586: 		if (isMemberClass)
1587: 			return outer != null && noArgConstructor != null && noArgConstructor.hasParamTypes(outer.getClass());
1606: 		if (isMemberClass)
1607: 			return outer != null && beanMeta.constructor.hasParamTypes(outer.getClass());
1616: 	 * 	Can be <jk>null</jk> for non-member or static classes.
1623: 			if (isMemberClass)
1750: 			if (isMemberClass)
1766: 			return (T)Array.newInstance(getInnerClass().getComponentType(), 0);
1774: 			return (T)Array.newInstance(this.elementType.innerClass,0);
1779: 	 * Same as {@link #newInstance()} except for instantiating non-static member classes.
1788: 		if (isMemberClass)
1800: 	public boolean same(ClassMeta<?> cm) {
1829: 		String n = innerClass.getName();
1856: 			return info.isParentOf(o.getClass()) || (isPrimitive() && info.getPrimitiveWrapper() == o.getClass());
1875: 		return innerClass.getName();
1884: 		return innerClass.getSimpleName();
1957: 	public boolean hasMutaterFrom(ClassMeta<?> c) {
1958: 		return getFromMutater(c.getInnerClass()) != null;
1977: 	public boolean hasMutaterTo(ClassMeta<?> c) {
1978: 		return getToMutater(c.getInnerClass()) != null;
1989: 		Mutater t = getFromMutater(o.getClass());
2013: 	public <O> O mutateTo(Object o, ClassMeta<O> c) {
2014: 		return mutateTo(o, c.getInnerClass());
2029: 			t = Mutaters.get(c, innerClass);
2049: 			t = Mutaters.get(innerClass, c);
2058: 	 * Shortcut for calling <code>getInnerClass().getAnnotation(a) != <jk>null</jk></code>.
2068: 	 * Shortcut for calling <c>getInnerClass().getAnnotation(a)</c>.
2091: 		return innerClass.hashCode();
2096: 		return (o instanceof ClassMeta) && eq(this, (ClassMeta<?>)o, (x,y)->eq(x.innerClass, y.innerClass));
93: 		childSwapMap,                                        // Maps normal subclasses to PojoSwaps.
94: 		childUnswapMap;                                      // Maps swap subclasses to PojoSwaps.
604: 			} catch (NoClassDefFoundError e) {
749: 			return beanContext.getClassMeta(c, false);
800: 	 * This allows interfaces to define subclasses with type names.
949: 		return (ps == null ? this : ps.getSwapClassMeta(session));
github.com/googlecreativelab/pattern-radio:kubernetes/tools/classifier_clustering/package-lock.json: [ master, ]
1590:             "needle": "^2.2.1",
1573:         "needle": {
2:   "name": "classification_pooling",
github.com/kubernetes/minikube:site/package-lock.json: [ master, ]
1127:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
643:         "posix-character-classes": "^0.1.0",
388:     "class-utils": {
390:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1108:         "needle": {
2138:     "posix-character-classes": {
2140:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
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/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/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/dart-lang/sdk:runtime/vm/object.h: [ master, ]
930: class Class : public Object {
468:   static ClassPtr class_class() { return class_class_; }
469:   static ClassPtr dynamic_class() { return dynamic_class_; }
470:   static ClassPtr void_class() { return void_class_; }
471:   static ClassPtr type_arguments_class() { return type_arguments_class_; }
472:   static ClassPtr patch_class_class() { return patch_class_class_; }
473:   static ClassPtr function_class() { return function_class_; }
474:   static ClassPtr closure_data_class() { return closure_data_class_; }
475:   static ClassPtr signature_data_class() { return signature_data_class_; }
476:   static ClassPtr redirection_data_class() { return redirection_data_class_; }
477:   static ClassPtr ffi_trampoline_data_class() {
480:   static ClassPtr field_class() { return field_class_; }
481:   static ClassPtr script_class() { return script_class_; }
482:   static ClassPtr library_class() { return library_class_; }
483:   static ClassPtr namespace_class() { return namespace_class_; }
484:   static ClassPtr kernel_program_info_class() {
487:   static ClassPtr code_class() { return code_class_; }
488:   static ClassPtr bytecode_class() { return bytecode_class_; }
489:   static ClassPtr instructions_class() { return instructions_class_; }
490:   static ClassPtr instructions_section_class() {
493:   static ClassPtr object_pool_class() { return object_pool_class_; }
494:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }
495:   static ClassPtr code_source_map_class() { return code_source_map_class_; }
496:   static ClassPtr compressed_stackmaps_class() {
499:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }
500:   static ClassPtr exception_handlers_class() {
503:   static ClassPtr deopt_info_class() { return deopt_info_class_; }
504:   static ClassPtr context_class() { return context_class_; }
505:   static ClassPtr context_scope_class() { return context_scope_class_; }
506:   static ClassPtr api_error_class() { return api_error_class_; }
507:   static ClassPtr language_error_class() { return language_error_class_; }
508:   static ClassPtr unhandled_exception_class() {
511:   static ClassPtr unwind_error_class() { return unwind_error_class_; }
512:   static ClassPtr dyncalltypecheck_class() { return dyncalltypecheck_class_; }
513:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }
514:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }
515:   static ClassPtr monomorphicsmiablecall_class() {
518:   static ClassPtr icdata_class() { return icdata_class_; }
519:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }
520:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }
521:   static ClassPtr loadingunit_class() { return loadingunit_class_; }
522:   static ClassPtr weak_serialization_reference_class() {
776:   static ClassPtr class_class_;           // Class of the Class vm object.
1352:   ClassLayout::ClassLoadingState class_loading_state() const {
1366:   bool is_synthesized_class() const {
1371:   bool is_enum_class() const { return EnumBit::decode(raw_ptr()->state_bits_); }
1790:   ClassPtr patched_class() const { return raw_ptr()->patched_class_; }
1791:   ClassPtr origin_class() const { return raw_ptr()->origin_class_; }
4853:   ClassPtr toplevel_class() const { return raw_ptr()->toplevel_class_; }
8319:   virtual ClassPtr type_class() const {
1216:   bool IsNullClass() const { return id() == kNullCid; }
1219:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1222:   bool IsVoidClass() const { return id() == kVoidCid; }
1225:   bool IsNeverClass() const { return id() == kNeverCid; }
1228:   bool IsObjectClass() const { return id() == kInstanceCid; }
1237:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1240:   bool IsClosureClass() const { return id() == kClosureCid; }
1241:   static bool IsClosureClass(ClassPtr cls) {
1247:   bool IsTypedefClass() const { return signature_function() != Object::null(); }
1691:   class ClassFinalizedBits : public BitField<uint32_t,
1695:   class ClassLoadingBits : public BitField<uint32_t,
1784:   kCurrentClass,  // Consider type params of current class only.
1788: class PatchClass : public Object {
4684: class ClassDictionaryIterator : public DictionaryIterator {
5272:   ArrayPtr classes_cache() const { return raw_ptr()->classes_cache_; }
7343:   intptr_t SizeFromClass() const {
7883:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
8143:   virtual bool HasTypeClass() const {
8310:   virtual bool HasTypeClass() const {
8397:   virtual bool HasTypeClass() const { return false; }
307: #define DEFINE_CLASS_TESTER(clazz)                                             \
777:   static ClassPtr dynamic_class_;         // Class of the 'dynamic' type.
778:   static ClassPtr void_class_;            // Class of the 'void' type.
779:   static ClassPtr type_arguments_class_;  // Class of TypeArguments vm object.
780:   static ClassPtr patch_class_class_;     // Class of the PatchClass vm object.
781:   static ClassPtr function_class_;        // Class of the Function vm object.
782:   static ClassPtr closure_data_class_;    // Class of ClosureData vm obj.
783:   static ClassPtr signature_data_class_;  // Class of SignatureData vm obj.
784:   static ClassPtr redirection_data_class_;  // Class of RedirectionData vm obj.
785:   static ClassPtr ffi_trampoline_data_class_;  // Class of FfiTrampolineData
787:   static ClassPtr field_class_;                // Class of the Field vm object.
788:   static ClassPtr script_class_;               // Class of the Script vm object.
789:   static ClassPtr library_class_;    // Class of the Library vm object.
790:   static ClassPtr namespace_class_;  // Class of Namespace vm object.
791:   static ClassPtr kernel_program_info_class_;  // Class of KernelProgramInfo vm
793:   static ClassPtr code_class_;                 // Class of the Code vm object.
794:   static ClassPtr bytecode_class_;      // Class of the Bytecode vm object.
795:   static ClassPtr instructions_class_;  // Class of the Instructions vm object.
796:   static ClassPtr instructions_section_class_;  // Class of InstructionsSection.
797:   static ClassPtr object_pool_class_;      // Class of the ObjectPool vm object.
798:   static ClassPtr pc_descriptors_class_;   // Class of PcDescriptors vm object.
799:   static ClassPtr code_source_map_class_;  // Class of CodeSourceMap vm object.
800:   static ClassPtr compressed_stackmaps_class_;  // Class of CompressedStackMaps.
801:   static ClassPtr var_descriptors_class_;       // Class of LocalVarDescriptors.
802:   static ClassPtr exception_handlers_class_;    // Class of ExceptionHandlers.
803:   static ClassPtr deopt_info_class_;            // Class of DeoptInfo.
804:   static ClassPtr context_class_;            // Class of the Context vm object.
805:   static ClassPtr context_scope_class_;      // Class of ContextScope vm object.
806:   static ClassPtr dyncalltypecheck_class_;   // Class of ParameterTypeCheck.
807:   static ClassPtr singletargetcache_class_;  // Class of SingleTargetCache.
808:   static ClassPtr unlinkedcall_class_;       // Class of UnlinkedCall.
810:       monomorphicsmiablecall_class_;         // Class of MonomorphicSmiableCall.
811:   static ClassPtr icdata_class_;             // Class of ICData.
812:   static ClassPtr megamorphic_cache_class_;  // Class of MegamorphiCache.
813:   static ClassPtr subtypetestcache_class_;   // Class of SubtypeTestCache.
814:   static ClassPtr loadingunit_class_;        // Class of LoadingUnit.
815:   static ClassPtr api_error_class_;          // Class of ApiError.
816:   static ClassPtr language_error_class_;     // Class of LanguageError.
817:   static ClassPtr unhandled_exception_class_;  // Class of UnhandledException.
818:   static ClassPtr unwind_error_class_;         // Class of UnwindError.
820:   static ClassPtr weak_serialization_reference_class_;
2441:   bool include_class_name = true;
4706:   Class& toplevel_class_;
8120:   static intptr_t type_class_id_offset() {
8316:   virtual classid_t type_class_id() const {
8398:   virtual classid_t type_class_id() const { return kIllegalCid; }
8411:   static intptr_t parameterized_class_id_offset() {
299:   intptr_t GetClassId() const {
560:   static const ClassId kClassId = kObjectCid;
1209:   GrowableObjectArrayPtr direct_subclasses() const {
1674:     kClassFinalizedPos = 2,
1675:     kClassFinalizedSize = 2,
1676:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1677:     kClassLoadingSize = 2,
1679:     kSynthesizedClassBit,
1700:   class SynthesizedClassBit
2221:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }
2457:   static NameFormattingParams DisambiguatedWithoutClassName(
6021:   classid_t TargetClassId() const { return TargetClassIdOf(raw()); }
6022:   static classid_t TargetClassIdOf(const WeakSerializationReferencePtr raw) {
6060:   static classid_t UnwrappedClassIdOf(const Object& obj) {
6070:   static classid_t UnwrappedClassIdOf(ObjectPtr obj) {
6450:   classid_t OwnerClassId() const { return OwnerClassIdOf(raw()); }
6451:   static classid_t OwnerClassIdOf(CodePtr raw) {
7015:     kClassIdIndex,
7078:     kInstanceClassIdOrFunction = 1,
8404:   bool IsClassTypeParameter() const {
9216:   static const ClassId kClassId = kOneByteStringCid;
9344:   static const ClassId kClassId = kTwoByteStringCid;
9425:   static const ClassId kClassId = kExternalOneByteStringCid;
9520:   static const ClassId kClassId = kExternalTwoByteStringCid;
9813:   static const ClassId kClassId = kImmutableArrayCid;
11398: ObjectPtr MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
45: class Assembler;
49: class Program;
50: class TreeNode;
53: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
54: CLASS_LIST(DEFINE_FORWARD_DECLARATION)
56: class Api;
57: class ArgumentsDescriptor;
58: class Closure;
59: class Code;
60: class DeoptInstr;
61: class DisassemblyFormatter;
62: class FinalizablePersistentHandle;
63: class FlowGraphCompiler;
64: class HierarchyInfo;
65: class LocalScope;
66: class CodeStatistics;
67: class IsolateGroupReloadContext;
69: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
73: class Symbols;
74: class BaseTextBuffer;
213:   friend class SnapshotReader;
227:   friend class Object;
236:   friend class StackFrame;                                                     \
237:   friend class Thread;
261:   friend class Object;                                                         \
262:   friend class StackFrame;                                                     \
263:   friend class Thread;
280: class Object {
306: // Class testers.
309:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
310: #undef DEFINE_CLASS_TESTER
478:     return ffi_trampoline_data_class_;
485:     return kernel_program_info_class_;
491:     return instructions_section_class_;
497:     return compressed_stackmaps_class_;
501:     return exception_handlers_class_;
509:     return unhandled_exception_class_;
516:     return monomorphicsmiablecall_class_;
523:     return weak_serialization_reference_class_;
550:   template <class FakeObject>
575:     //   core impl class name shown -> _OneByteString
604:   // class which has the same name as an already existing function, or
611:   enum class NameDisambiguation {
721:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
739:     // Indicates this class cannot be extended by dart code.
745:   static void RegisterClass(const Class& cls,
748:   static void RegisterPrivateClass(const Class& cls,
819:   // Class of WeakSerializationReference.
826:   friend void ClassTable::Register(const Class& cls);
828:   friend class Closure;
829:   friend class SnapshotReader;
830:   friend class InstanceDeserializationCluster;
831:   friend class OneByteString;
832:   friend class TwoByteString;
833:   friend class ExternalOneByteString;
834:   friend class ExternalTwoByteString;
835:   friend class Thread;
838:   friend class Reusable##name##HandleScope;
846: class PassiveObject : public Object {
894: // The first string in the triplet is a type name (usually a class).
899: enum class Nullability : int8_t {
907: enum class TypeEquality {
915: enum class NNBDMode {
923: enum class NNBDCompiledMode {
1044:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1045:   // to this class.
1048:   // The NNBD mode of the library declaring this class.
1065:   // This class represents a typedef if the signature function is not null.
1071:   // Return the Type with type parameters declared by this class filled in with
1077:   // class preceded by the type arguments declared for superclasses, etc.
1079:   // class B<T, S>
1080:   // class C<R> extends B<R, int>
1105:   // Return a TypeParameter if the type_name is a type parameter of this class.
1110:   // the super class.
1113:   // Return true if this class declares type parameters.
1116:   // If this class is parameterized, each instance has a type_arguments field.
1130:         compiler::target::Class::kNoTypeArguments) {
1131:       return compiler::target::Class::kNoTypeArguments;
1143:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1145:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1147:       target_value = RTN::Class::kNoTypeArguments;
1178:   // The super type of this class, Object type if not explicitly specified.
1188:   // Asserts that the class of the super type has been resolved.
1201:   // Returns the list of classes directly implementing this class.
1205:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1208:   // Returns the list of classes having this class as direct superclass.
1212:   void AddDirectSubclass(const Class& subclass) const;
1215:   // Check if this class represents the class of null.
1218:   // Check if this class represents the 'dynamic' class.
1221:   // Check if this class represents the 'void' class.
1224:   // Check if this class represents the 'Never' class.
1227:   // Check if this class represents the 'Object' class.
1230:   // Check if this class represents the 'Function' class.
1233:   // Check if this class represents the 'Future' class.
1236:   // Check if this class represents the 'FutureOr' class.
1239:   // Check if this class represents the 'Closure' class.
1246:   // Check if this class represents a typedef class.
1257:   static bool IsSubtypeOf(const Class& cls,
1264:   // Check if this is the top level class.
1272:   // Returns an array of instance and static fields defined by this class.
1278:   // If this is a dart:internal.ClassID class, then inject our own const
1283:   // Returns an array of all instance fields of this class and its superclasses
1299:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1357:     return class_loading_state() >= ClassLayout::kDeclarationLoaded;
1362:     return class_loading_state() >= ClassLayout::kTypeFinalized;
1369:   void set_is_synthesized_class() const;
1372:   void set_is_enum_class() const;
1398:   // Tests if this is a mixin application class which was desugared
1399:   // to a normal class by kernel mixin transformation
1501:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1526:   // class and return the resulting value, or an error object if evaluating the
1536:   // Load class declaration (super type, interfaces, type parameters and
1543:   // Allocate a class used for VM internal objects.
1544:   template <class FakeObject, class TargetFakeObject>
1545:   static ClassPtr New(Isolate* isolate, bool register_class = true);
1552:                       bool register_class = true);
1558:   static ClassPtr NewStringClass(intptr_t class_id, Isolate* isolate);
1561:   static ClassPtr NewTypedDataClass(intptr_t class_id, Isolate* isolate);
1564:   static ClassPtr NewTypedDataViewClass(intptr_t class_id, Isolate* isolate);
1567:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,
1571:   static ClassPtr NewPointerClass(intptr_t class_id, Isolate* isolate);
1574:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1578:   void DisableCHAOptimizedCode(const Class& subclass);
1584:   // Return the list of code objects that were compiled using CHA of this class.
1585:   // These code objects will be invalidated if new subclasses of this class
1594:                    const Class& old_enum) const;
1596:                              const Class& old_cls) const;
1599:                                      const Class& new_cls) const;
1600:   void CopyCanonicalConstants(const Class& old_cls) const;
1601:   void CopyDeclarationType(const Class& old_cls) const;
1602:   void CheckReload(const Class& replacement,
1649:   // Caches the declaration type of this class.
1652:   bool CanReloadFinalized(const Class& replacement,
1654:   bool CanReloadPreFinalized(const Class& replacement,
1658:   bool RequiresInstanceMorphing(const Class& replacement) const;
1660:   template <class FakeInstance, class TargetFakeInstance>
1689:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1690:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1699:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1702:   class FieldsMarkedNullableBit
1704:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1705:   class TransformedMixinApplicationBit
1707:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1708:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1709:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1742:   // Calculates number of type arguments of this class.
1747:   // Assigns empty array to all raw class array fields.
1760:   // Allocate an instance class which has a VM implementation.
1761:   template <class FakeInstance, class TargetFakeInstance>
1764:                       bool register_class = true,
1767:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1770:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1771:   friend class AbstractType;
1772:   friend class Instance;
1773:   friend class Object;
1774:   friend class Type;
1775:   friend class InterpreterHelpers;
1776:   friend class Intrinsifier;
1777:   friend class ProgramWalker;
1778:   friend class Precompiler;
1783:   kAny,           // Consider type params of current class and functions.
1815:     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
1818:   static PatchClassPtr New(const Class& patched_class,
1819:                            const Class& origin_class);
1821:   static PatchClassPtr New(const Class& patched_class, const Script& source);
1824:   void set_patched_class(const Class& value) const;
1825:   void set_origin_class(const Class& value) const;
1831:   friend class Class;
1834: class ParameterTypeCheck : public Object {
1866:   friend class Class;
1869: class SingleTargetCache : public Object {
1899:   friend class Class;
1902: class MonomorphicSmiableCall : public Object {
1928:   friend class Class;
1931: class CallSiteData : public Object {
1950:   friend class ICData;
1951:   friend class MegamorphicCache;
1954: class UnlinkedCall : public CallSiteData {
1970:   friend class ICData;  // For set_*() methods.
1975:   friend class Class;
1983: class ICData : public CallSiteData {
2165:   // Used for unoptimized static calls when no class-ids are checked.
2170:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2172:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2178:   // Adds sorted so that Smi is the first class-id. Use only for
2180:   void AddReceiverCheck(intptr_t receiver_class_id,
2192:                   GrowableArray<intptr_t>* class_ids,
2194:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2198:                           intptr_t* class_id,
2233:   bool HasReceiverClassId(intptr_t class_id) const;
2305:   friend class FlowGraphSerializer;  // For is_megamorphic()
2354:   class NumArgsTestedBits : public BitField<uint32_t,
2358:   class TrackingExactnessBit : public BitField<uint32_t,
2362:   class DeoptReasonBits : public BitField<uint32_t,
2366:   class RebindRuleBits : public BitField<uint32_t,
2370:   class MegamorphicBit
2373:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2403:   friend class CallSiteResetter;
2404:   friend class CallTargets;
2405:   friend class Class;
2406:   friend class VMDeserializationRoots;
2407:   friend class ICDataTestTask;
2408:   friend class Interpreter;
2409:   friend class VMSerializationRoots;
2410:   friend class SnapshotWriter;
2437:   // By default function name includes the name of the enclosing class if any.
2438:   // However in some contexts this information is redundant and class name
2439:   // is already known. In this case setting |include_class_name| to false
2460:     params.include_class_name = false;
2467:     params.include_class_name = false;
2473: class Function : public Object {
2493:   // owner class of this function, then its signature type is a parameterized
2544:   // parameter of this function and R is a type parameter of class C, the owner
2550:   // parameter of this function and R is a type parameter of class C, the owner
2562:   // generic functions or class type parameters.
2576:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3556:       const Class& klass = Class::Handle(Owner());
3602:   // The owner is the scope class of the function type.
3609:   static FunctionPtr NewEvalFunction(const Class& owner,
3661: // a hoisted check class instruction.
3676:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3699:   // static: Considered during class-side or top-level resolution rather than
3799:   class KindBits : public BitField<uint32_t,
3804:   class RecognizedBits : public BitField<uint32_t,
3808:   class ModifierBits : public BitField<uint32_t,
3814:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3851:   friend class Class;
3852:   friend class SnapshotWriter;
3853:   friend class Parser;  // For set_eval_script.
3854:   friend class ProgramVisitor;  // For set_parameter_names.
3857:   friend class FunctionLayout;
3858:   friend class ClassFinalizer;  // To reset parent_function.
3859:   friend class Type;            // To adjust parent_function.
3862: class ClosureData : public Object {
3886:   friend class Class;
3887:   friend class Function;
3888:   friend class HeapProfiler;
3891: class SignatureData : public Object {
3909:   friend class Class;
3910:   friend class Function;
3911:   friend class HeapProfiler;
3914: class RedirectionData : public Object {
3921:   // The type specifies the class and type arguments of the target constructor.
3936:   friend class Class;
3937:   friend class Function;
3938:   friend class HeapProfiler;
3941: enum class EntryPointPragma {
3949: class FfiTrampolineData : public Object {
3977:   friend class Class;
3978:   friend class Function;
3979:   friend class HeapProfiler;
3982: class Field : public Object {
4146:   // Called during class finalization.
4173:   ClassPtr Origin() const;  // Either mixin class, or same as owner().
4178:   // Used by class finalizer, otherwise initialized in constructor.
4271:   // Return class id that any non-null value read from this field is guaranteed
4272:   // to have or kDynamicCid if such class id is not known.
4386:   // assumptions about guarded class id and nullability of this field.
4468:   friend class Interpreter;              // Access to bit field.
4469:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4489:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4490:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4491:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4492:   class HasNontrivialInitializerBit
4494:   class UnboxingCandidateBit
4496:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4497:   class DoubleInitializedBit
4499:   class InitializerChangedAfterInitializatonBit
4504:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4505:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4506:   class GenericCovariantImplBit
4508:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4509:   class IsExtensionMemberBit
4511:   class NeedsLoadGuardBit
4513:   class HasInitializerBit
4515:   class IsNonNullableIntBit
4556:   friend class Class;
4557:   friend class HeapProfiler;
4558:   friend class FieldLayout;
4559:   friend class FieldSerializationCluster;
4560:   friend class FieldDeserializationCluster;
4563: class Script : public Object {
4660:   friend class Class;
4661:   friend class Precompiler;
4664: class DictionaryIterator : public ValueObject {
4680:   friend class ClassDictionaryIterator;
4688:     // one top-level class per library left, not an array to iterate over.
4697:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4700:   // Returns a non-null raw class.
4711: class Library : public Object {
4773:   void AddClass(const Class& cls) const;
4808:   void AddAnonymousClass(const Class& cls) const;
4812:   void AddClassMetadata(const Class& cls,
4854:   void set_toplevel_class(const Class& value) const;
5070:   // Lookup class in the core lib which also contains various VM
5072:   static ClassPtr LookupCoreClass(const String& class_name);
5076:                                  const char* class_name,
5151:   friend class Bootstrap;
5152:   friend class Class;
5153:   friend class Debugger;
5154:   friend class DictionaryIterator;
5155:   friend class Isolate;
5156:   friend class LibraryDeserializationCluster;
5157:   friend class Namespace;
5158:   friend class Object;
5159:   friend class Precompiler;
5164: class Namespace : public Object {
5194:   friend class Class;
5195:   friend class Precompiler;
5198: class KernelProgramInfo : public Object {
5277:                        const Class& klass) const;
5286:   friend class Class;
5292: class ObjectPool : public Object {
5428:   friend class Class;
5429:   friend class Object;
5430:   friend class ObjectPoolLayout;
5433: class Instructions : public Object {
5442:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5443:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5568:   friend class Class;
5569:   friend class Code;
5570:   friend class AssemblyImageWriter;
5571:   friend class BlobImageWriter;
5572:   friend class ImageWriter;
5577: class InstructionsSection : public Object {
5600:   friend class Class;
5603: class LocalVarDescriptors : public Object {
5639:   friend class Class;
5640:   friend class Object;
5643: class PcDescriptors : public Object {
5683:   class Iterator : ValueObject {
5733:     friend class PcDescriptors;
5778:   friend class Class;
5779:   friend class Object;
5782: class CodeSourceMap : public Object {
5824:   friend class Class;
5825:   friend class Object;
5828: class CompressedStackMaps : public Object {
5904:   friend class Class;
5905:   friend class CompressedStackMapsIterator;  // For PayloadByte
5906:   friend class StackMapEntry;                // For PayloadByte
5909: class ExceptionHandlers : public Object {
5958:   friend class Class;
5959:   friend class Object;
5967: class ImageHeader : public Object {
5973:   // all access to the contents is handled by methods on the Image class.
6002: // but instead contain only the class ID of the original target.
6006: class WeakSerializationReference : public Object {
6063:   // Gets the class ID of the underlying object from a WSR, or the class ID of
6090:   friend class Class;
6093: class Code : public Object {
6301:   enum class PoolAttachment {
6306:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};
6307:   class EntryPointField
6309:   class OffsetField
6334:   class Comments : public ZoneAllocated {
6358:     friend class Code;
6436:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6569:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6570:   friend class CodeLayout;
6579:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6583:   class ForceOptimizedBit
6586:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6587:   class PtrOffBits
6590:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6677:   friend class Class;
6678:   friend class CodeTestHelper;
6679:   friend class SnapshotWriter;
6680:   friend class StubCode;     // for set_object_pool
6681:   friend class Precompiler;  // for set_object_pool
6682:   friend class FunctionSerializationCluster;
6683:   friend class CodeSerializationCluster;
6684:   friend class CodeDeserializationCluster;
6685:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6686:   friend class StubCode;               // for set_object_pool
6687:   friend class MegamorphicCacheTable;  // for set_object_pool
6688:   friend class CodePatcher;            // for set_instructions
6689:   friend class ProgramVisitor;         // for set_instructions
6692:   friend class FunctionLayout;
6693:   friend class CallSiteResetter;
6694:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6697: class Bytecode : public Object {
6806:   class SlowFindRawBytecodeVisitor : public FindObjectVisitor {
6833:   friend class BytecodeDeserializationCluster;
6834:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6835:   friend class BytecodeLayout;
6838:   friend class Class;
6839:   friend class SnapshotWriter;
6842: class Context : public Object {
6912:   friend class Class;
6913:   friend class Object;
6916: // The ContextScope class makes it possible to delay the compilation of a local
6926: class ContextScope : public Object {
7004:   friend class Class;
7005:   friend class Object;
7008: class MegamorphicCache : public CallSiteData {
7042:   void Insert(const Smi& class_id, const Object& target) const;
7053:   friend class Class;
7054:   friend class MegamorphicCacheTable;
7055:   friend class ProgramVisitor;
7061:   void InsertLocked(const Smi& class_id, const Object& target) const;
7065:                               const Smi& class_id,
7074: class SubtypeTestCache : public Object {
7088:   void AddCheck(const Object& instance_class_id_or_function,
7096:                 Object* instance_class_id_or_function,
7129:   friend class Class;
7130:   friend class VMSerializationRoots;
7131:   friend class VMDeserializationRoots;
7134: class LoadingUnit : public Object {
7173:   friend class Class;
7176: class Error : public Object {
7184: class ApiError : public Error {
7202:   friend class Class;
7205: class LanguageError : public Error {
7268:   friend class Class;
7271: class UnhandledException : public Error {
7300:   friend class Class;
7301:   friend class ObjectStore;
7304: class UnwindError : public Error {
7324:   friend class Class;
7327: // Instance is the base class for all instance objects (aka the Object class
7329: class Instance : public Object {
7345:     const Class& cls = Class::Handle(clazz());
7416:   // class implementing a 'call' method, return true and set the function
7439:       const Class& method_cls,
7455:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);
7463:   // only the class_id is different. So, it is safe to use subtype instances in
7509:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7520:   static InstancePtr NewFromCidAndSize(SharedClassTable* shared_class_table,
7526:   friend class ByteBuffer;
7527:   friend class Class;
7528:   friend class Closure;
7529:   friend class Pointer;
7530:   friend class DeferredObject;
7531:   friend class RegExp;
7532:   friend class SnapshotWriter;
7533:   friend class StubCode;
7534:   friend class TypedDataView;
7535:   friend class InstanceSerializationCluster;
7536:   friend class InstanceDeserializationCluster;
7537:   friend class ClassDeserializationCluster;  // vtable
7538:   friend class InstanceMorpher;
7539:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7542: class LibraryPrefix : public Instance {
7581:   friend class Class;
7585: class TypeArguments : public Instance {
7664:   // a raw (null) function type arguments, i.e. consider each class type
7721:       const Class& instantiator_class,
7740:   // Add the class name and URI of each type argument of this vector to the uris
7747:   // type from the various type argument vectors (class instantiator, function,
7825:   // If raw_instantiated is true, consider each class type parameter to be first
7840:   friend class AbstractType;
7841:   friend class Class;
7842:   friend class ClearTypeHashVisitor;
7843:   friend class Object;
7848: class AbstractType : public Instance {
7884:   virtual classid_t type_class_id() const;
7885:   virtual ClassPtr type_class() const;
7910:   // instantiation. Consider a class C<T> declaring a non-generic method
7912:   // generic function bar<B> as argument and its function type refers to class
7984:   // Add the class name and URI of each occuring type to the uris
7990:   // The name of this type's class, i.e. without the type argument names of this
7998:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
8001:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
8010:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
8026:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
8044:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
8047:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
8062:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
8107:   friend class Class;
8108:   friend class Function;
8109:   friend class TypeArguments;
8112: // A Type consists of a class, possibly parameterized with type
8115: // Caution: 'TypePtr' denotes a 'raw' pointer to a VM object of class Type, as
8118: class Type : public AbstractType {
8121:     return OFFSET_OF(TypeLayout, type_class_id_);
8144:     ASSERT(type_class_id() != kIllegalCid);
8151:   virtual classid_t type_class_id() const;
8152:   virtual ClassPtr type_class() const;
8153:   void set_type_class(const Class& value) const;
8166:   // canonicalization (passed-in cls must match type_class()).
8167:   bool IsDeclarationTypeOf(const Class& cls) const;
8171:   // However, in case of a generic typedef, they document how the typedef class
8262:   // The finalized type of the given non-parameterized class.
8263:   static TypePtr NewNonParameterizedType(const Class& type_class);
8265:   static TypePtr New(const Class& clazz,
8284:   friend class Class;
8285:   friend class TypeArguments;
8286:   friend class ClearTypeHashVisitor;
8293: class TypeRef : public AbstractType {
8317:     return AbstractType::Handle(type()).type_class_id();
8320:     return AbstractType::Handle(type()).type_class();
8364:   friend class Class;
8367: // A TypeParameter represents a type parameter of a parameterized class.
8371: // the class HashMap<K, V>. At compile time, the TypeParameter is not
8374: // as type argument (rather than type parameter) of the parameterized class.
8377: class TypeParameter : public AbstractType {
8399:   classid_t parameterized_class_id() const;
8400:   ClassPtr parameterized_class() const;
8405:     return parameterized_class_id() != kFunctionCid;
8412:     return OFFSET_OF(TypeParameterLayout, parameterized_class_id_);
8458:   // Only one of parameterized_class and parameterized_function is non-null.
8459:   static TypeParameterPtr New(const Class& parameterized_class,
8472:   void set_parameterized_class(const Class& value) const;
8482:   friend class Class;
8483:   friend class ClearTypeHashVisitor;
8486: class Number : public Instance {
8503:   friend class Class;
8506: class Integer : public Number {
8579:   friend class Class;
8582: class Smi : public Integer {
8616:   static ClassPtr Class();
8637:     // Indicates this class cannot be extended by dart code.
8644:   friend class Api;  // For ValueFromRaw
8645:   friend class Class;
8646:   friend class Object;
8647:   friend class ReusableSmiHandleScope;
8648:   friend class Thread;
8651: class SmiTraits : AllStatic {
8663: class Mint : public Integer {
8693:   friend class Integer;
8703:   friend class Class;
8704:   friend class Number;
8707: // Class Double represents class Double in corelib_impl, which implements
8708: // abstract class double in corelib.
8709: class Double : public Number {
8740:   friend class Class;
8741:   friend class Number;
8745: class String : public Instance {
8766:   class CodePointIterator : public ValueObject {
9073:   friend class Class;
9074:   friend class Symbols;
9075:   friend class StringSlice;  // SetHash
9077:   friend class CharArray;     // SetHash
9078:   friend class ConcatString;  // SetHash
9079:   friend class OneByteString;
9080:   friend class TwoByteString;
9081:   friend class ExternalOneByteString;
9082:   friend class ExternalTwoByteString;
9083:   friend class OneByteStringLayout;
9084:   friend class RODataSerializationCluster;  // SetHash
9085:   friend class Pass2Visitor;                // Stack "handle"
9089: class StringHasher : ValueObject {
9114: class OneByteString : public AllStatic {
9248:   friend class Class;
9249:   friend class String;
9250:   friend class Symbols;
9251:   friend class ExternalOneByteString;
9252:   friend class SnapshotReader;
9253:   friend class StringHasher;
9254:   friend class Utf8;
9257: class TwoByteString : public AllStatic {
9374:   friend class Class;
9375:   friend class String;
9376:   friend class StringHasher;
9377:   friend class SnapshotReader;
9378:   friend class Symbols;
9381: class ExternalOneByteString : public AllStatic {
9468:     // Indicates this class cannot be extended by dart code.
9472:   friend class Class;
9473:   friend class String;
9474:   friend class StringHasher;
9475:   friend class SnapshotReader;
9476:   friend class Symbols;
9477:   friend class Utf8;
9480: class ExternalTwoByteString : public AllStatic {
9563:     // Indicates this class cannot be extended by dart code.
9567:   friend class Class;
9568:   friend class String;
9569:   friend class StringHasher;
9570:   friend class SnapshotReader;
9571:   friend class Symbols;
9574: // Class Bool implements Dart core class bool.
9575: class Bool : public Instance {
9604:   friend class Class;
9605:   friend class Object;  // To initialize the true and false values.
9608: class Array : public Instance {
9721:   // Make the array immutable to Dart code by switching the class pointer
9757:   static ArrayPtr New(intptr_t class_id,
9796:   friend class Class;
9797:   friend class ImmutableArray;
9798:   friend class Interpreter;
9799:   friend class Object;
9800:   friend class String;
9803: class ImmutableArray : public AllStatic {
9823:     // Indicates this class cannot be extended by dart code.
9831:   friend class Class;
9834: class GrowableObjectArray : public Instance {
9941:   friend class Array;
9942:   friend class Class;
9945: class Float32x4 : public Instance {
9976:   friend class Class;
9979: class Int32x4 : public Instance {
10009:   friend class Class;
10012: class Float64x2 : public Instance {
10037:   friend class Class;
10040: class PointerBase : public Instance {
10047: class TypedDataBase : public PointerBase {
10112:   friend class Class;
10127: class TypedData : public TypedDataBase {
10178:   static intptr_t MaxElements(intptr_t class_id) {
10179:     ASSERT(IsTypedDataClassId(class_id));
10180:     return (kSmiMax / ElementSizeInBytes(class_id));
10183:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
10184:     ASSERT(IsTypedDataClassId(class_id));
10186:            ElementSizeInBytes(class_id);
10189:   static TypedDataPtr New(intptr_t class_id,
10254:   // Therefore this method is private and the call-sites in this class need to
10263:   friend class Class;
10264:   friend class CompressedStackMapsIterator;
10265:   friend class ExternalTypedData;
10266:   friend class TypedDataView;
10269: class ExternalTypedData : public TypedDataBase {
10311:   static intptr_t MaxElements(intptr_t class_id) {
10312:     ASSERT(IsExternalTypedDataClassId(class_id));
10313:     return (kSmiMax / ElementSizeInBytes(class_id));
10317:       intptr_t class_id,
10347:   friend class Class;
10350: class TypedDataView : public TypedDataBase {
10352:   static TypedDataViewPtr New(intptr_t class_id,
10354:   static TypedDataViewPtr New(intptr_t class_id,
10419:   friend class Class;
10420:   friend class Object;
10421:   friend class TypedDataViewDeserializationCluster;
10424: class ByteBuffer : public AllStatic {
10442: class Pointer : public Instance {
10480:   friend class Class;
10483: class DynamicLibrary : public Instance {
10509:   friend class Class;
10516: class LinkedHashMap : public Instance {
10602:   class Iterator : ValueObject {
10646:   friend class Class;
10647:   friend class LinkedHashMapDeserializationCluster;
10650: class Closure : public Instance {
10725:   friend class Class;
10728: class Capability : public Instance {
10739:   friend class Class;
10742: class ReceivePort : public Instance {
10759:   friend class Class;
10762: class SendPort : public Instance {
10782:   friend class Class;
10787: class TransferableTypedDataPeer {
10814: class TransferableTypedData : public Instance {
10826:   friend class Class;
10830: class StackTrace : public Instance {
10884:   friend class Class;
10885:   friend class Debugger;
10888: class RegExpFlags {
10938: class RegExp : public Instance {
10957:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
10958:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
11092:   friend class Class;
11095: class WeakProperty : public Instance {
11124:   friend class Class;
11127: class MirrorReference : public Instance {
11156:   friend class Class;
11159: class UserTag : public Instance {
11192:   friend class Class;
11195: // Represents abstract FutureOr class in dart:async.
11196: class FutureOr : public Instance {
11212:   friend class Class;
11219:     return Smi::Class();
11222:   return Isolate::Current()->class_table()->At(raw()->GetClassId());
11380:                                 const Smi& class_id,
11383:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
11473: // This helper class can then be used via
11508: class ArrayOfTuplesView {
11512:   class Iterator;
11514:   class TupleView {
11540:     friend class Iterator;
11543:   class Iterator {
11593:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
155:   static const ClassId kClassId = k##object##Cid;                              \
303:   inline ClassPtr 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
809:   static ClassPtr
952:   static intptr_t host_instance_size(ClassPtr clazz) {
955:   static intptr_t target_instance_size(ClassPtr clazz) {
1024:     return ObjectLayout::ClassIdTag::is_valid(value);
1028:     ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());
1031:   static intptr_t id_offset() { return OFFSET_OF(ClassLayout, id_); }
1033:     return OFFSET_OF(ClassLayout, num_type_arguments_);
1046:   ClassPtr Mixin() const;
1073:   // in superclass clauses.
1087:     return OFFSET_OF(ClassLayout, declaration_type_);
1167:     return OFFSET_OF(ClassLayout, host_type_arguments_field_offset_in_words_);
1172:     return OFFSET_OF(ClassLayout, target_type_arguments_field_offset_in_words_);
1185:     return OFFSET_OF(ClassLayout, super_type_);
1189:   // |original_classes| only has an effect when reloading. If true and we
1190:   // are reloading, it will prefer the original classes to the replacement
1191:   // classes.
1192:   ClassPtr SuperClass(bool original_classes = false) const;
1231:   bool IsDartFunctionClass() const;
1234:   bool IsFutureClass() const;
1249:   static bool IsInFullSnapshot(ClassPtr cls) {
1285:   // |original_classes| only has an effect when reloading. If true and we
1286:   // are reloading, it will prefer the original classes to the replacement
1287:   // classes.
1288:   ArrayPtr OffsetToFieldMap(bool original_classes = false) const;
1339:     return RoundedAllocationSize(sizeof(ClassLayout));
1353:     return ClassLoadingBits::decode(raw_ptr()->state_bits_);
1375:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1376:                ClassLayout::kFinalized ||
1377:            ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1378:                ClassLayout::kAllocateFinalized;
1383:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1384:            ClassLayout::kAllocateFinalized;
1389:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1390:            ClassLayout::kPreFinalized;
1432:     return ClassLayout::BinaryDeclarationOffset::decode(
1438:                     ClassLayout::BinaryDeclarationOffset::update(
1483:     return ClassLayout::IsDeclaredInBytecode::decode(
1491:                     ClassLayout::IsDeclaredInBytecode::update(
1547:   // Allocate instance classes.
1548:   static ClassPtr New(const Library& lib,
1553:   static ClassPtr NewNativeWrapper(const Library& library,
1557:   // Allocate the raw string classes.
1560:   // Allocate the raw TypedData classes.
1563:   // Allocate the raw TypedDataView/ByteDataView classes.
1566:   // Allocate the raw ExternalTypedData classes.
1570:   // Allocate the raw Pointer classes.
1609:   static int32_t host_instance_size_in_words(const ClassPtr cls) {
1613:   static int32_t target_instance_size_in_words(const ClassPtr cls) {
1621:   static int32_t host_next_field_offset_in_words(const ClassPtr cls) {
1625:   static int32_t target_next_field_offset_in_words(const ClassPtr cls) {
1633:   static int32_t host_type_arguments_field_offset_in_words(const ClassPtr cls) {
1638:       const ClassPtr cls) {
1661:   static ClassPtr NewCommon(intptr_t index);
1692:                                              ClassLayout::ClassFinalizedState,
1696:                                            ClassLayout::ClassLoadingState,
1743:   // This includes type arguments of a superclass and takes overlapping
1762:   static ClassPtr New(intptr_t id,
1768:   static ClassPtr NewInstanceClass();
1781: // Classification of type genericity according to type parameter owners.
1830:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1905:   classid_t expected_cid() const { return raw_ptr()->expected_cid_; }
1911:   static MonomorphicSmiableCallPtr New(classid_t expected_cid,
1978: // Object holding information about an IC: test classes and their
2043:   V(CheckClass)                                                                \
2080:   // Call site classification that is helpful for hot-reload. Call sites with
2322:   // to list the call site's observed receiver classes and targets.
2567:   ClassPtr Owner() const;
2569:   ClassPtr origin() const;
3660: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3667:   V(ProhibitsHoistingCheckClass)                                               \
4172:   ClassPtr Owner() const;
4693:   ClassDictionaryIterator(const Library& library,
4701:   ClassPtr GetNextClass();
4704:   void MoveToNextClass();
4708:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4780:   ClassPtr LookupClass(const String& name) const;
4781:   ClassPtr LookupClassAllowPrivate(const String& name) const;
4782:   ClassPtr SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4783:   ClassPtr LookupLocalClass(const String& name) const;
4927:            ((value >= 0) && (value < std::numeric_limits<classid_t>::max())));
5047:   // Eagerly compile all classes and functions in the library.
5050:   // Finalize all classes in all libraries.
5071:   // helper methods and classes. Allow look up of private classes.
5208:                                   const Array& classes_cache,
5273:   void set_classes_cache(const Array& cache) const;
5274:   ClassPtr LookupClass(Thread* thread, const Smi& name_index) const;
5275:   ClassPtr InsertClass(Thread* thread,
7521:                                        classid_t cid,
7644:   // Names of internal classes are mapped to their public interfaces.
7846: // AbstractType is an abstract superclass.
7974:   // Names of internal classes are mapped to their public interfaces.
7992:   StringPtr ClassName() const;
8312:            AbstractType::Handle(type()).HasTypeClass();
10072:   static intptr_t ElementSizeInBytes(classid_t cid) {
10076:   static TypedDataElementType ElementType(classid_t cid) {
10392:     const classid_t cid = typed_data.GetClassId();
11137:   ClassPtr GetClassReferent() const;
11216: ClassPtr Object::clazz() const {
11506: //     classes (e.g. 'Code', 'Smi', 'Object')
301:                                   : raw()->ptr()->GetClassId();
331:   // Object::DictionaryName() returns String::null(). Only subclasses
1072:   // dynamic and type parameters declared in superclasses filled in as declared
1210:     return raw_ptr()->direct_subclasses_;
1213:   void ClearDirectSubclasses() const;
1367:     return SynthesizedClassBit::decode(raw_ptr()->state_bits_);
1678:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1693:                                              kClassFinalizedPos,
1694:                                              kClassFinalizedSize> {};
1697:                                            kClassLoadingPos,
1698:                                            kClassLoadingSize> {};
1701:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
1811:     return RoundedAllocationSize(sizeof(PatchClassLayout));
1813:   static bool IsInFullSnapshot(PatchClassPtr cls) {
1828:   static PatchClassPtr New();
2197:   void GetOneClassCheckAt(intptr_t index,
2203:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2204:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2220:   ICDataPtr AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2222:   ICDataPtr AsUnaryClassChecksForCid(intptr_t cid,
2229:   ICDataPtr AsUnaryClassChecksSortedByCount() const;
3557:       return IsTypedDataViewClassId(klass.id());
5051:   static ErrorPtr FinalizeAllClasses();
5095:   void EnsureTopLevelClassIsFinalized() const;
5115:   void InitClassDictionary() const;
6028:     return TargetOf(raw)->GetClassId();
6061:     return UnwrappedClassIdOf(obj.raw());
6066:   // UnwrappedClassOf(Wrap(r)) == UnwrappedClassOf(r) for all raw objects r,
6071:     if (!obj->IsWeakSerializationReference()) return obj->GetClassId();
6072:     return TargetClassIdOf(WeakSerializationReference::RawCast(obj));
6452:     return WeakSerializationReference::UnwrappedClassIdOf(raw->ptr()->owner_);
7068:   static inline ObjectPtr GetClassId(const Array& array, intptr_t index);
7336:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7847: // Subclasses of AbstractType are Type and TypeParameter.
8893:     return raw()->GetClassId() == kOneByteStringCid;
8897:     return raw()->GetClassId() == kTwoByteStringCid;
8901:     return raw()->GetClassId() == kExternalOneByteStringCid;
8905:     return raw()->GetClassId() == kExternalTwoByteStringCid;
8909:     return IsExternalStringClassId(raw()->GetClassId());
9668:   bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
10061:     return ElementSizeInBytes(raw()->GetClassId()) * Length();
10065:     return ElementType(raw()->GetClassId());
10069:     return element_size(ElementType(raw()->GetClassId()));
10079:     } else if (IsTypedDataClassId(cid)) {
10083:     } else if (IsTypedDataViewClassId(cid)) {
10088:       ASSERT(IsExternalTypedDataClassId(cid));
10242:     intptr_t cid = obj.raw()->GetClassId();
10243:     return IsTypedDataClassId(cid);
10327:     intptr_t cid = obj.raw()->GetClassId();
10328:     return IsExternalTypedDataClassId(cid);
10374:     intptr_t cid = data.raw()->GetClassId();
10375:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10376:     return IsExternalTypedDataClassId(cid);
10393:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10493:     intptr_t cid = obj.raw()->GetClassId();
10494:     return IsFfiDynamicLibraryClassId(cid);
11229:   intptr_t cid = value->GetClassIdMayBeSmi();
11399:   return array.At((index * kEntryLength) + kClassIdIndex);
11452:   switch (str->GetClassId()) {
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/google/skia:modules/canvaskit/package-lock.json: [ master, ]
1560:             "needle": "^2.2.1",
403:         "class-utils": "^0.3.5",
1030:         "posix-character-classes": "^0.1.0",
645:     "class-utils": {
647:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1541:         "needle": {
2711:     "posix-character-classes": {
2713:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/paymentservice/package-lock.json: [ master, ]
1058:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
112:             "create-error-class": "^3.0.2",
566:     "create-error-class": {
568:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1043:         "needle": {
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/currencyservice/package-lock.json: [ master, ]
1036:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
120:             "create-error-class": "^3.0.2",
529:     "create-error-class": {
531:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1021:         "needle": {
github.com/kubernetes/website: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/apache/activemq:activemq-web/src/main/resources/org/apache/activemq/web/prototype.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/skia:modules/canvaskit/package-lock.json: [ master, ] Duplicate result
skia.googlesource.com/skia:modules/canvaskit/package-lock.json: [ master, ] Duplicate result
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
13274: const Class = function(info, mixin) {
6658:  function superPropertiesClass(constructor) {
11598: DomApiNative.prototype.classList;
12968:     static _finalizeClass() {
229:  * Wraps an ES6 class expression mixin such that the mixin is only applied
234:  * @param {T} mixin ES6 class expression mixin to wrap
257:     // copy inherited mixin set from the extended class, or the base class
283: class Debouncer {
1761: class DomModule extends HTMLElement {
2399:  * Element class mixin that provides basic meta-programming for creating one
2404:  * once at class definition time to create property accessors for properties
2413:  * @summary Element class mixin for reacting to property changes from
2419:      * @param {function(new:T)} superClass Class to apply mixin to.
2430:   class PropertiesChanged extends superClass {
2879:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
2996:  * Element class mixin that provides basic meta-programming for creating one
3005:  * -   Implement the `_propertiesChanged` callback on the class.
3006:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
3022:  * @summary Element class mixin for reacting to property changes from
3042:   class PropertyAccessors extends base {
3361:  * @summary Element class mixin that provides basic template parsing and stamping
3366:      * @param {function(new:T)} superClass Class to apply mixin to.
3376:   class TemplateStamp extends superClass {
4197:  * @param {Function} constructor Class that `_parseTemplate` is currently
4234:  * @param {Function} constructor Class that `_parseTemplate` is currently
4764:  * Element class mixin that provides meta-programming for Polymer's template
4768:  * property effects to an element class:
4795:  * @summary Element class mixin that provides meta-programming for Polymer's
4816:   class PropertyEffects extends propertyEffectsBase {
5381:      * Runs each class of effects for the batch of changed properties in
5944:     // -- static class methods ------------
6113:      *   bound template for the class. When true (as passed from
6316:           // when a class$ binding's initial literal value is set.
6317:           if (name == 'class' && node.hasAttribute('class')) {
6542: class HostStack {
6590:  * Registers a class prototype for telemetry purposes.
6652:   * Returns the super class constructor for the given class, if it is an
6656:   * @return {?PropertiesMixinConstructor} Super class constructor
6661:    // Note, the `PropertiesMixin` class below only refers to the class
6671:   * given class. Properties not in object format are converted to at
6701:  class PropertiesMixin extends base {
6736:     * Finalize an element class. This includes ensuring property
6738:     * `finalize` and finalizes the class constructor.
6754:     * @return {Object} Object containing properties for this class
6846:  * Element class mixin that provides the core API for Polymer's meta-programming
6851:  * used to configure Polymer's features for the class:
6887:  * The base class provides default implementations for the following standard
6906:  * @property importPath {string} Set to the value of the class's static
6910:  * @summary Element class mixin that provides the core API for Polymer's
6929:    * @param {PolymerElementConstructor} constructor Element class
6930:    * @return {PolymerElementProperties} Flattened properties for this class
6952:    * @param {PolymerElementConstructor} constructor Element class
6953:    * @return {Array} Array containing own observers for the given class
7016:    * @param {!PolymerElement} proto Element class prototype to add accessors
7070:    * @param {PolymerElementConstructor} klass Element class
7141:   class PolymerElement extends polymerElementBase {
7199:      *   this class
7224:      * Note that when subclassing, if the super class overrode the default
7229:      * If a subclass would like to modify the super class template, it should
7235:      *   class MySubClass extends MySuperClass {
7251:       // - constructor.template (this getter): the template for the class.
7253:       //     dom-module, or from the super class's template (or can be overridden
7303:      * @return {string} The import path for this element class
7337:      * Overrides the default `PropertyAccessors` to ensure class
7617:  * Class representing a static string value which can be used to filter
7618:  * strings by asseting that they have been created via this class. The
7621: class LiteralString {
7688:  *         <div class="shadowed">${this.partialTemplate}</div>
7716:  * Base class that provides the core API for Polymer's meta-programming
7726:  * @summary Custom element base class that provides the core API for Polymer's
7763:  * Element class mixin to skip strict dirty-checking for objects and arrays
7798:  * @summary Element class mixin to skip strict dirty-checking for objects
7808:   class MutableData extends superClass {
7837:  * Element class mixin to add the optional ability to skip strict
7873:  * @summary Element class mixin to optionally skip strict dirty-checking
7883:   class OptionalMutableData extends superClass {
7936: // Base class for HTMLTemplateElement extension that has property effects
7938: // class only because Babel (incorrectly) requires super() in the class
7980:  * Base class for TemplateInstance.
7985: const templateInstanceBase = PropertyEffects(class {});
7993: class TemplateInstanceBase extends templateInstanceBase {
8215:  * @suppress {missingProperties} class.prototype is not defined for some reason
8231:    * Anonymous class created by the templatize
8235:   let klass = class extends templatizerBase { };
8244:  * @suppress {missingProperties} class.prototype is not defined for some reason
8249:     // Provide data API and property effects on memoized template class
8259:         class TemplatizedTemplate extends templatizedBase {};
8329:  * Returns an anonymous `PropertyEffects` class bound to the
8330:  * `<template>` provided.  Instancing the class will result in the
8350:  *    method on the generated class should be called to forward host
8359:  * - `mutableData`: When `true`, the generated class will skip strict
8389:  * `templatize()` return the same class for all duplicates of a template.
8390:  * The class returned from `templatize()` is generated only once using
8402:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
8420:   // Get memoized base class for the prototypical template, which
8433:   // Subclass base class and add reference for this specific template
8435:   let klass = class TemplateInstance extends baseClass {};
8550: class DomIf extends PolymerElement {
8867: class StyleNode {
9500: class MixinMap {
9533: class ApplyShim {
10109: class CustomStyleInterface {
10234: class ApplyShimInterface {
10446:  * Element class mixin that provides API for adding Polymer's cross-platform
10456:  * @summary Element class mixin that provides API for adding Polymer's
10463:      * @param {function(new:T)} superClass Class to apply mixin to.
10472:       class GestureEventListeners extends superClass {
10943:  * Class that listens for changes (additions or removals) to
10964:  * class TestSelfObserve extends PolymerElement {
10980:  * @summary Class that listens for changes (additions or removals) to
10984: let FlattenedNodesObserver = class {
11264:  * Node API wrapper class returned from `Polymer.dom.(target)` when
11269: class DomApiNative {
11482:  * Event API wrapper class returned from `dom.(target)` when
11485: class EventApi {
11613:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
11719:  * Element class mixin that provides Polymer's "legacy" API intended to be
11730:  * @summary Element class mixin that provides Polymer's "legacy" API
11760:   class LegacyElement extends legacyElementBase {
11778:      *  closure for some reason even in a static method, rather than the class
11862:      * add support for class initialization via the `_registered` callback.
11888:      * Users may override this method to perform class registration time
11890:      * only once for the class.
12591:      * Toggles a CSS class on or off.
12593:      * @param {string} name CSS class name
12594:      * @param {boolean=} bool Boolean to force the class on or off.
12595:      *    When unspecified, the state of the class will be reversed.
12818:  * Applies a "legacy" behavior or array of behaviors to the provided class.
12827:  * @param {function(new:T)} klass Element class.
12828:  * @return {?} Returns a new Element class extended by the
12858: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
12859: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
12931:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
12932:   made. The list of behaviors was previously made into one generated class per
12937:   The generated class is directly tied to the info object and behaviors
12952:  * @param {function(new:HTMLElement)} Base base class to extend with info object
12954:  * @return {function(new:HTMLElement)} Generated class
12960:   // manages behavior and lifecycle processing (filled in after class definition)
12965:   class PolymerGenerated extends Base {
13047:       // only proceed if the generated class' prototype has not been registered.
13053:         // copy properties onto the generated class lazily if we're optimizing,
13058:         // and not the generated class prototype; if the element has been
13174:     // NOTE: ensure the behavior is extending a class with
13181:     // get flattened, deduped list of behaviors *not* already on super class
13205:  * Generates a class that extends `LegacyElement` based on the
13209:  * to the generated class.
13268:  *   to become class methods.
13270:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
13272:  * @return {function(new:HTMLElement)} Generated class
13276:     console.warn('Polymer.Class requires `info` argument');
13386:  * Legacy class factory and registration helper for defining Polymer
13391:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
13392:  *     customElements.define(info.is, Class(info));
13394:  * See `Class` for details on valid legacy metadata format for `info`.
13400:  *   to become class methods.
13401:  * @return {function(new: HTMLElement)} Generated class
13405:   // if input is a `class` (aka a function with a prototype), use the prototype
13411:     klass = Polymer.Class(info);
13417: Polymer.Class = Class;
13493:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
13499:    * @param {boolean=} mutableData When `true`, the generated class will skip
13518:    * returned is an instance of the anonymous class generated by `templatize`
13591: class DomBind extends domBindBase {
13735:  * class EmployeeList extends PolymerElement {
13806: class DomRepeat extends domRepeatBase {
14456:   class ArraySelectorMixin extends elementBase {
14774:  * class EmployeeList extends PolymerElement {
14827: class ArraySelector extends baseArraySelector {
14972: class CustomStyle extends HTMLElement {
2403:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
2420:      * @return {function(new:T)} superClass with mixin applied.
2422:     (superClass) => {
2426:    * @mixinClass
3025: const PropertyAccessors = dedupingMixin(superClass => {
3033:    const base = PropertiesChanged(superClass);
3037:    * @mixinClass
3367:      * @return {function(new:T)} superClass with mixin applied.
3369:     (superClass) => {
3373:    * @mixinClass
4798: const PropertyEffects = dedupingMixin(superClass => {
4807:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
4811:    * @mixinClass
5249:      * Overrides superclass implementation.
6261:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6295:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6356:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6642: const PropertiesMixin = dedupingMixin(superClass => {
6649:  const base = PropertiesChanged(superClass);
6696:   * @mixinClass
6706:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6718:     * Finalizes an element definition, including ensuring any super classes
6721:     * `_finalizeClass` to finalize each constructor in the prototype chain.
6726:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6731:        this._finalizeClass();
6742:    static _finalizeClass() {
6751:     * from super classes. Properties not in object format are converted to
6760:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6973:    * these values may not be changed. For example, a subclass cannot
7009:    * reflectToAttribute property not do so in a subclass. We've chosen to
7011:    * For example, a readOnly effect generates a special setter. If a subclass
7136:    * @mixinClass
7152:      * Override of PropertiesMixin _finalizeClass to create observers and
7156:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7158:     static _finalizeClass() {
7159:       super._finalizeClass();
7225:      * implementation and the subclass would like to provide an alternate
7240:      *         subContent.textContent = 'This came from MySubClass';
7258:       //     constructor.template, saved in _finalizeClass(). Note that before
7271:           // Next look for superclass template (call the super impl this
7272:           // way so that `this` points to the superclass)
7567:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7583:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7801: const MutableData = dedupingMixin(superClass => {
7805:    * @mixinClass
7876: const OptionalMutableData = dedupingMixin(superClass => {
7879:    * @mixinClass
7971: // Applies a DataTemplate subclass to a <template> instance
8217: function createTemplatizerClass(template, templateInfo, options) {
8250:     let klass = templateInfo.templatizeTemplateClass;
8258:       klass = templateInfo.templatizeTemplateClass =
8426:   let baseClass = templateInfo.templatizeInstanceClass;
8427:   if (!baseClass) {
8428:     baseClass = createTemplatizerClass(template, templateInfo, options);
8429:     templateInfo.templatizeInstanceClass = baseClass;
8502:  * Forces several classes of asynchronously queued tasks to flush:
9366:         // remove build comment so it is not needlessly copied into every element instance
10464:      * @return {function(new:T)} superClass with mixin applied.
10466:     (superClass) => {
10469:        * @mixinClass
11622:   // Note, `classList` is here only for legacy compatibility since it does not
11625:     'classList'
11657:   // Properties that should return the logical, not composed tree. Note, `classList`
11664:     'childNodes', 'children', 'classList'
11755:    * @mixinClass
12600:     toggleClass(name, bool, node) {
12603:         bool = !node.classList.contains(name);
12606:         node.classList.add(name);
12608:         node.classList.remove(name);
12928: /* Note about construction and extension of legacy classes.
12934:   manually. Note, there may *still* be multiple generated classes in the
12939:   behaviors not active on the superclass. In order to call through to the
12947:   and not `_finalizeClass`.
12967:     // explicitly not calling super._finalizeClass
12969:       // if calling via a subclass that hasn't been generated, pass through to super
12971:         super._finalizeClass();
13051:         // ensure superclass is registered first.
14441: let ArraySelectorMixin = dedupingMixin(superClass => {
14448:   let elementBase = ElementMixin(superClass);
14452:    * @mixinClass
3212:      * `__dataProto`, and it is up to the subclasser to decide how/when
6850:  * Subclassers may provide the following static getters to return metadata
6975:    * by subclasses.
7008:    * effects via subclassing. For example, a user might want to make a
12833:   return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
12958: function GenerateClassFromInfo(info, Base, behaviors) {
13280:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
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",
chromium.googlesource.com/chromium/src/third_party:polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
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;
7725:     load_raw = &CLASS kodak_radc_load_raw;
7744:     load_raw = &CLASS rollei_load_raw;
7751:     load_raw = &CLASS eight_bit_load_raw;
7758:     load_raw = &CLASS eight_bit_load_raw;
7763:     load_raw = &CLASS eight_bit_load_raw;
7767:     load_raw = &CLASS unpacked_load_raw;
7772:     load_raw = &CLASS casio_qv5700_load_raw;
7836:   if (load_raw == &CLASS kodak_jpeg_load_raw) {
7858: void CLASS apply_profile (char *input, char *output)
7908: void CLASS convert_to_rgb()
8026: void CLASS fuji_rotate()
8064: void CLASS stretch()
8101: int CLASS flip_index (int row, int col)
8109: void CLASS gamma_lut (uchar lut[0x10000])
8154: void CLASS tiff_set (ushort *ntag,
8173: void CLASS tiff_head (struct tiff_hdr *th, int full)
8247: void CLASS jpeg_thumb (FILE *tfp)
8269: void CLASS write_ppm_tiff (FILE *ofp)
8311: int CLASS main (int argc, char **argv)
8496:     write_fun = &CLASS write_ppm_tiff;
8513:     if (load_raw == &CLASS kodak_ycbcr_load_raw) {
8638:     if (write_fun == &CLASS jpeg_thumb)
8640:     else if (output_tiff && write_fun == &CLASS write_ppm_tiff)
246:   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js: [ master, ]
1237:     "class" : {
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
1098:     var classValue = node.getAttribute("class");
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +
1442:     "class" : {
1614:     var xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vcard ')]";
1623:     xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vevent ')]";
65:     if (Microformats[name].classNa