Found 145794 results in 4381 files, showing top 50 files (show more).
github.com/apache/juneau:juneau-core/juneau-marshall/src/main/java/org/apache/juneau/ClassMeta.java: [ master, ]
64: 		MAP, COLLECTION, CLASS, METHOD, NUMBER, DECIMAL, BOOLEAN, CHAR, DATE, ARRAY, ENUM, OTHER, CHARSEQ, STR, OBJ, URI, BEANMAP,...(43 bytes skipped)...
60: public final class ClassMeta<T> implements Type {
63: 	enum ClassCategory {
67: 	final Class<T> innerClass;                              // The class being wrapped.
70: 	private final Class<? extends T> implClass;             // The implementation class to use if this is an interface.
86: 		isMemberClass;                                       // True if this is a non-static member class.
142: 	ClassMeta(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps, Object example) {
225: 	ClassMeta(ClassMeta<T> mainType, ClassMeta<?> keyType, ClassMeta<?> valueType, ClassMeta<?> elementType) {
268: 	ClassMeta(ClassMeta<?>[] args) {
308: 	private final class ClassMetaBuilder<T> {
309: 		Class<T> innerClass;
311: 		Class<? extends T> implClass;
316: 			isMemberClass = false,
353: 		ClassMetaBuilder(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, BeanFilter beanFilter, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps, Object example) {
933: 	public Class<T> getInnerClass() {
1156: 	public boolean isClass() {
1473: 	public boolean isMemberClass() {
747: 		private ClassMeta<?> findClassMeta(Class<?> c) {
812: 	public ClassCategory getClassCategory() {
946: 	public ClassMeta<?> getSerializedClassMeta(BeanSession session) {
40:  * A wrapper class around the {@link Class} object that provides cached information about that class.
43:  * Instances of this class can be created through the {@link BeanContext#getClassMeta(Class)} method.
46:  * The {@link BeanContext} class will cache and reuse instances of this class except for the following class types:
54:  * This class is tied to the {@link BeanContext} class because it's that class that makes the determination of what is
57:  * @param <T> The class type of the wrapped class.
62: 	/** Class categories. */
71: 	private final ClassCategory cc;                         // The class category.
74: 		noArgConstructor,                                    // The no-arg constructor for this class (if it has one).
84: 		isDelegate,                                          // True if this class extends Delegate.
85: 		isAbstract,                                          // True if this class is abstract.
90: ...(4 bytes skipped)...vate final PojoSwap<?,?>[] childPojoSwaps;           // Any PojoSwaps where the normal type is a subclass of this class.
91: 	private final ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
99: 		elementType,                                         // If ARRAY or COLLECTION, the element class type.
100: 		keyType,                                             // If MAP, the key class type.
101: 		valueType;                                           // If MAP, the value class type.
102: 	private final BeanMeta<T> beanMeta;                     // The bean meta for this bean class (if it's a bean).
104: ...(7 bytes skipped)...ropertyName,                                    // The property name of the _type property for this class and subclasses.
106: 		dictionaryName;                                      // The dictionary name of this class if it has one.
108: 	private final InvocationHandler invocationHandler;      // The invocation handler for this class (if it has one).
109: 	private final BeanRegistry beanRegistry;                // The bean registry of this class meta (if it has one).
112: 	private final Map<Class<?>,Mutater<?,T>> fromMutaters = new ConcurrentHashMap<>();
113: 	private final Map<Class<?>,Mutater<T,?>> toMutaters = new ConcurrentHashMap<>();
120: 	 * Construct a new {@code ClassMeta} based on the specified {@link Class}.
122: 	 * @param innerClass The class being wrapped.
125: 	 * 	For interfaces and abstract classes, this represents the "real" class to instantiate.
128: 	 * 	The {@link BeanFilter} programmatically associated with this class.
131: 	 * 	The {@link PojoSwap} programmatically associated with this class.
134: 	 * 	The child {@link PojoSwap PojoSwaps} programmatically associated with this class.
135: 	 * 	These are the <c>PojoSwaps</c> that have normal classes that are subclasses of this class.
139: 	 * 	Used for delayed initialization when the possibility of class reference loops exist.
150: 			// We always immediately add this class meta to the bean context cache so that we can resolve recursive references.
201: 	private static boolean isCacheable(Class<?> c) {
223: 	 * Used for creating Map and Collection class metas that shouldn't be cached.
269: 		this.innerClass = (Class<T>) Object[].class;
344: 		ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
369: 			Class<T> c = innerClass;
387: 				else if (c == void.class || c == Void.class)
390: 				if (ci.isChildOf(Delegate.class))
393: 				if (c == Object.class)
397: 				else if (c.equals(Class.class))
398: 					cc = ClassCategory.CLASS;
399: 				else if (ci.isChildOf(Method.class))
401: 				else if (ci.isChildOf(CharSequence.class)) {
402: 					if (c.equals(String.class))
407: 				else if (ci.isChildOf(Number.class)) {
408: 					if (ci.isChildOfAny(Float.class, Double.class))
413: 				else if (ci.isChildOf(Collection.class))
415: 				else if (ci.isChildOf(Map.class)) {
416: 					if (ci.isChildOf(BeanMap.class))
421: 				else if (c == Character.class)
423: 				else if (c == Boolean.class)
425: 				else if (ci.isChildOfAny(Date.class, Calendar.class))
429: 				else if (ci.isChildOfAny(URL.class, URI.class) || bc.hasAnnotation(org.apache.juneau.annotation.URI.class, c))
431: 				else if (ci.isChildOf(Reader.class))
433: 				else if (ci.isChildOf(InputStream.class))
435: 				else if (ci.is(Optional.class))
445: 			// parse() is used by the java logging Level class.
446: 			// forName() is used by Class and Charset
450: ...(23 bytes skipped)...C, PUBLIC, NOT_DEPRECATED) && m.hasName(methodName) && m.hasReturnType(c) && m.hasParamTypes(String.class)) {
460: ...(8 bytes skipped)...m.isAll(PUBLIC, NOT_DEPRECATED, STATIC) && m.hasName("example") && m.hasFuzzyParamTypes(BeanSession.class)) {
467: 				if (bc.hasAnnotation(ParentProperty.class, f)) {
473: 				if (bc.hasAnnotation(NameProperty.class, f)) {
482: 				if (bc.hasAnnotation(Example.class, f)) {
492: 				if (bc.hasAnnotation(ParentProperty.class, m)) {
498: 				if (bc.hasAnnotation(NameProperty.class, m)) {
507: 				if (bc.hasAnnotation(Example.class, m)) {
508: 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
509: 						throw new Class...(22 bytes skipped)..., "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
522: 					if (pt.size() == (isMemberClass ? 1 : 0) && c != Object.class && ! isAbstract) {
526: 						if (arg.is(String.class))
538: 			if (innerClass != Object.class) {
567: 						keyType = findClassMeta(Object.class);
568: 						valueType = findClassMeta(Object.class);
578: 						elementType = findClassMeta(Object.class);
617: 				for (Bean b : bc.getAnnotations(Bean.class, c)) {
630: 				for (Example e : bc.getAnnotations(Example.class, c))
653: 						Iterator<? extends Enum> i = EnumSet.allOf((Class<? extends Enum>)c).iterator();
669: 					case CLASS:
686: 			this.stringMutater = Mutaters.get(String.class, c);
691: 				List<Bean> ba = info.getAnnotations(Bean.class, bc);
703: 				for (Swap swap : bc.getAnnotations(Swap.class, innerClass))
705: 				for (Swaps swaps : bc.getAnnotations(Swaps.class, innerClass))
724: 			Class<?> c = s.value();
725: 			if (c == Null.class)
729: 			if (ci.isChildOf(PojoSwap.class)) {
730: 				PojoSwap ps = castOrCreate(PojoSwap.class, c);
738: 			if (ci.isChildOf(Surrogate.class)) {
744: 			throw new ClassMetaRuntimeException(c, "Invalid swap class ''{0}'' specified.  Must extend from PojoSwap or Surrogate.", c);
757: 	 * Returns the {@link ClassInfo} wrapper for the underlying class.
759: 	 * @return The {@link ClassInfo} wrapper for the underlying class, never <jk>null</jk>.
766: 	 * Returns the type property name associated with this class and subclasses.
772: 	 * 	The type property name associated with this bean class, or <jk>null</jk> if there is no explicit type
780: 	 * Returns the bean dictionary name associated with this class.
786: 	 * 	The type name associated with this bean class, or <jk>null</jk> if there is no type name defined or this
794: 	 * Returns the bean registry for this class.
798: 	 * defined on the class, regardless of whether the class is an actual bean.
801: 	 * @return The bean registry for this class, or <jk>null</jk> if no bean registry is associated with it.
808: 	 * Returns the category of this class.
810: 	 * @return The category of this class.
817: 	 * Returns <jk>true</jk> if this class is a superclass of or the same as the specified class.
819: 	 * @param c The comparison class.
820: 	 * @return <jk>true</jk> if this class is a superclass of or the same as the specified class.
822: 	public boolean isAssignableFrom(Class<?> c) {
827: 	 * Returns <jk>true</jk> if this class is a subclass of or the same as the specified class.
829: 	 * @param c The comparison class.
830: 	 * @return <jk>true</jk> if this class is a subclass of or the same as the specified class.
832: 	public boolean isInstanceOf(Class<?> c) {
837: 	 * Returns <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
843: 	 * @return <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
850: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the normal class of one of the
851: 	 * child POJO swaps associated with this class.
853: 	 * @param normalClass The normal class being resolved.
856: 	protected PojoSwap<?,?> getChildPojoSwapForSwap(Class<?> normalClass) {
877: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the swap class of one of the child
878: 	 * POJO swaps associated with this class.
880: 	 * @param swapClass The swap class being resolved.
883: 	protected PojoSwap<?,?> getChildPojoSwapForUnswap(Class<?> swapClass) {
904: 	 * Locates the no-arg constructor for the specified class.
908: 	 * If class is abstract, always returns <jk>null</jk>.
911: 	 * @param c The class from which to locate the no-arg constructor.
916: 	protected static <T> Constructor<? extends T> findNoArgConstructor(Class<?> c, Visibility v) {
929: 	 * Returns the {@link Class} object that this class type wraps.
931: 	 * @return The wrapped class object.
938: 	 * Returns the serialized (swapped) form of this class if there is an {@link PojoSwap} associated with it.
943: 	 * @return The serialized class type, or this object if no swap is associated with the class.
952: 	 * Returns the example of this class.
957: 	 * @return The serialized class type, or this object if no swap is associated with the class.
1024: 	 * For array and {@code Collection} types, returns the class type of the components of the array or
1027: 	 * @return The element class type, or <jk>null</jk> if this class is not an array or Collection.
1034: 	 * For {@code Map} types, returns the class type of the keys of the {@code Map}.
1036: 	 * @return The key class type, or <jk>null</jk> if this class is not a Map.
1043: 	 * For {@code Map} types, returns the class type of the values of the {@code Map}.
1045: 	 * @return The value class type, or <jk>null</jk> if this class is not a Map.
1052: 	 * Returns <jk>true</jk> if this class implements {@link Delegate}, meaning it's a representation of some other
1055: 	 * @return <jk>true</jk> if this class implements {@link Delegate}.
1062: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map}.
1064: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map}.
1071: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1073: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1080: 	 * Returns <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1082: 	 * @return <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1089: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection}.
1091: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection}.
1098: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Optional}.
1100: 	 * @return <jk>true</jk> if this class is a subclass of {@link Optional}.
1107: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1109: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1116: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1118: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1125: 	 * Returns <jk>true</jk> if this class extends from {@link Set}.
1127: 	 * @return <jk>true</jk> if this class extends from {@link Set}.
1130: 		return cc == COLLECTION && info.isChildOf(Set.class);
1134: 	 * Returns <jk>true</jk> if this class extends from {@link List}.
1136: 	 * @return <jk>true</jk> if this class extends from {@link List}.
1139: 		return cc == COLLECTION && info.isChildOf(List.class);
1143: 	 * Returns <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1145: 	 * @return <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1148: 		return cc == ARRAY && this.innerClass == byte[].class;
1152: 	 * Returns <jk>true</jk> if this class is {@link Class}.
1154: 	 * @return <jk>true</jk> if this class is {@link Class}.
1157: 		return cc == ClassCategory.CLASS;
1161: 	 * Returns <jk>true</jk> if this class is {@link Method}.
1163: 	 * @return <jk>true</jk> if this class is {@link Method}.
1170: 	 * Returns <jk>true</jk> if this class is an {@link Enum}.
1172: 	 * @return <jk>true</jk> if this class is an {@link Enum}.
1179: 	 * Returns <jk>true</jk> if this class is an array.
1181: 	 * @return <jk>true</jk> if this class is an array.
1188: 	 * Returns <jk>true</jk> if this class is a bean.
1190: 	 * @return <jk>true</jk> if this class is a bean.
1197: 	 * Returns <jk>true</jk> if this class is {@link Object}.
1199: 	 * @return <jk>true</jk> if this class is {@link Object}.
1206: 	 * Returns <jk>true</jk> if this class is not {@link Object}.
1208: 	 * @return <jk>true</jk> if this class is not {@link Object}.
1215: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Number}.
1217: 	 * @return <jk>true</jk> if this class is a subclass of {@link Number}.
1224: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1226: 	 * @return <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1233: 	 * Returns <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1235: 	 * @return <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1238: 		return innerClass == Float.class || innerClass == float.class;
1242: 	 * Returns <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1244: 	 * @return <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1247: 		return innerClass == Double.class || innerClass == double.class;
1251: 	 * Returns <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1253: 	 * @return <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1256: 		return innerClass == Short.class || innerClass == short.class;
1260: 	 * Returns <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1262: 	 * @return <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1265: 		return innerClass == Integer.class || innerClass == int.class;
1269: 	 * Returns <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1271: 	 * @return <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1274: 		return innerClass == Long.class || innerClass == long.class;
1280: 	 * @param c The class to test against.
1283: 	public boolean isType(Class<?> c) {
1288: 	 * Returns <jk>true</jk> if this class is a {@link Boolean}.
1290: 	 * @return <jk>true</jk> if this class is a {@link Boolean}.
1297: 	 * Returns <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1299: 	 * @return <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1306: 	 * Returns <jk>true</jk> if this class is a {@link String}.
1308: 	 * @return <jk>true</jk> if this class is a {@link String}.
1315: 	 * Returns <jk>true</jk> if this class is a {@link Character}.
1317: 	 * @return <jk>true</jk> if this class is a {@link Character}.
1324: 	 * Returns <jk>true</jk> if this class is a primitive.
1326: 	 * @return <jk>true</jk> if this class is a primitive.
1333: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1335: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1342: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1344: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1347: 		return cc == DATE || info.isChildOf(Temporal.class);
1351: 	 * Returns <jk>true</jk> if this class is a {@link Date}.
1353: 	 * @return <jk>true</jk> if this class is a {@link Date}.
1356: 		return cc == DATE && info.isChildOf(Date.class);
1360: 	 * Returns <jk>true</jk> if this class is a {@link Temporal}.
1362: 	 * @return <jk>true</jk> if this class is a {@link Temporal}.
1365: 		return info.isChildOf(Temporal.class);
1369: 	 * Returns <jk>true</jk> if this class is a {@link Calendar}.
1371: 	 * @return <jk>true</jk> if this class is a {@link Calendar}.
1374: 		return cc == DATE && info.isChildOf(Calendar.class);
1378: 	 * Returns <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1380: 	 * @return <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1387: 	 * Returns <jk>true</jk> if this class is a {@link Reader}.
1389: 	 * @return <jk>true</jk> if this class is a {@link Reader}.
1396: 	 * Returns <jk>true</jk> if this class is an {@link InputStream}.
1398: 	 * @return <jk>true</jk> if this class is an {@link InputStream}.
1405: 	 * Returns <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1407: 	 * @return <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1451: 	 * @return <jk>true</jk> if instance of this class can be null.
1460: 	 * Returns <jk>true</jk> if this class is abstract.
1462: 	 * @return <jk>true</jk> if this class is abstract.
1469: 	 * Returns <jk>true</jk> if this class is an inner class.
1471: 	 * @return <jk>true</jk> if this class is an inner class.
1478: 	 * All public methods on this class including static methods.
1483: 	 * @return The public methods on this class.
1490: 	 * Returns the {@link PojoSwap} associated with this class that's the best match for the specified session.
1494: 	 * 	<br>If multiple swaps are associated with a class, only the first one with a matching media type will
1497: 	 * 	The {@link PojoSwap} associated with this class, or <jk>null</jk> if there are no POJO swaps associated with
1498: 	 * 	this class.
1519: 	 * Returns the builder swap associated with this class.
1522: 	 * @return The builder swap associated with this class, or <jk>null</jk> if it doesn't exist.
1529: 	 * Returns the {@link BeanMeta} associated with this class.
1532: 	 * 	The {@link BeanMeta} associated with this class, or <jk>null</jk> if there is no bean meta associated with
1533: 	 * 	this class.
1540: 	 * Returns the no-arg constructor for this class.
1542: 	 * @return The no-arg constructor for this class, or <jk>null</jk> if it does not exist.
1549: 	 * Returns the interface proxy invocation handler for this class.
1558: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1560: 	 * @return <jk>true</jk> if a new instance of this class can be constructed.
1575: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1576: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1577: 	 * the defining class.
1580: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1582: 	 * 	<jk>true</jk> if a new instance of this class can be created within the context of the specified outer object.
1591: 	 * Returns <jk>true</jk> if this class can be instantiated as a bean.
1592: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1593: 	 * the defining class.
1596: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1611: 	 * Returns <jk>true</jk> if this class can call the {@link #newInstanceFromString(Object, String)} method.
1614: 	 * 	The outer class object for non-static member classes.
1616: 	 * @return <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1623: 				return outer != null && stringConstructor.hasParamTypes(outer.getClass(), String.class);
1652: 	 * Returns the reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1654: 	 * @return The reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1681: 	 * @return The default value, or <jk>null</jk> if this class type is not a primitive.
1717: 	 * Create a new instance of the main class of this declared type from a <c>String</c> input.
1720: 	 * In order to use this method, the class must have one of the following methods:
1728: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1737: 			return (T)Enum.valueOf((Class<? extends Enum>)this.innerClass, arg);
1753: 		throw new InstantiationError("No string constructor or valueOf(String) method found for class '"+getInnerClass().getName()+"'");
1757: 	 * Create a new instance of the main class of this declared type.
1771: 			return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] { getInnerClass(), java.io.Serializable.class }, h);
1781: 	 * 	The instance of the owning object of the member class instance.
1782: 	 * 	Can be <jk>null</jk> if instantiating a non-member or static class.
1796: 	 * @param cm The class meta to compare to.
1797: 	 * @return <jk>true</jk> if the specified class-meta is equivalent to this one.
1811: 	 * Same as {@link #toString()} except use simple class names.
1813: 	 * @param simple Print simple class names only (no package).
1824: 	 * @param simple Print simple class names only (no package).
1838: 			return sb.append(BeanMap.class.getName()).append('<').append(n).append('>');
1845: 	 * Returns <jk>true</jk> if the specified object is an instance of this class.
1848: 	 * This is a simple comparison on the base class itself and not on any generic parameters.
1851: 	 * @return <jk>true</jk> if the specified object is an instance of this class.
1860: 	 * Returns a readable name for this class (e.g. <js>"java.lang.String"</js>, <js>"boolean[]"</js>).
1862: 	 * @return The readable name for this class.
1869: 	 * Shortcut for calling {@link Class#getName()} on the inner class of this metadata.
1871: 	 * @return The  name of the inner class.
1878: 	 * Shortcut for calling {@link Class#getSimpleName()} on the inner class of this metadata.
1880: 	 * @return The simple name of the inner class.
1887: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1889: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1892: 		return hasMutaterFrom(Reader.class);
1896: 	 * Returns the transform for this class for creating instances from a Reader.
1901: 		return getFromMutater(Reader.class);
1905: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1907: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1910: 		return hasMutaterFrom(InputStream.class);
1914: 	 * Returns the transform for this class for creating instances from an InputStream.
1919: 		return getFromMutater(InputStream.class);
1923: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1925: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1932: 	 * Returns the transform for this class for creating instances from a String.
1941: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1943: 	 * @param c The class type to convert from.
1944: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1946: 	public boolean hasMutaterFrom(Class<?> c) {
1951: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1953: 	 * @param c The class type to convert from.
1954: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1961: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1963: 	 * @param c The class type to convert from.
1964: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1966: 	public boolean hasMutaterTo(Class<?> c) {
1971: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1973: 	 * @param c The class type to convert from.
1974: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1981: 	 * Transforms the specified object into an instance of this class.
1993: 	 * Transforms the specified object into an instance of this class.
1996: 	 * @param c The class
2000: 	public <O> O mutateTo(Object o, Class<O> c) {
2006: 	 * Transforms the specified object into an instance of this class.
2009: 	 * @param c The class
2017: 	 * Returns the transform for this class for creating instances from other object types.
2019: 	 * @param c The transform-from class.
2023: 	public <I> Mutater<I,T> getFromMutater(Class<I> c) {
2037: 	 * Returns the transform for this class for creating instances from other object types.
2039: 	 * @param c The transform-from class.
2043: 	public <O> Mutater<T,O> getToMutater(Class<O> c) {
2060: 	 * @return <jk>true</jk> if the inner class has the annotation.
2062: 	public boolean hasAnnotation(Class<? extends Annotation> a) {
2070: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2072: 	public <A extends Annotation> A getLastAnnotation(Class<A> a) {
2077: 	 * Returns all annotations of the specified type defined on the specified class or parent classes/interfaces in parent-to-child order.
2084: 	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.*;
59: @Bean(bpi="innerClass,classCategory,elementType,keyType,valueType,notABeanReason,initException,beanMeta")
68: 	final ClassInfo info;
87: 	private final Object primitiveDefault;                  // Default value for primitive type classes.
98: 	private final ClassMeta<?>
110: 	private final ClassMeta<?>[] args;                      // Arg types if this is an array of args.
124: 	 * @param implClass
143: 		this.innerClass = innerClass;
144: 		this.info = ClassInfo.of(innerClass);
151: 			if (beanContext != null && beanContext.cmCache != null && isCacheable(innerClass))
152: 				beanContext.cmCache.put(innerClass, this);
154: 			ClassMetaBuilder<T> builder = new ClassMetaBuilder(innerClass, beanContext, implClass, beanFilter, swaps, childPojoSwaps, example);
178: 			this.isMemberClass = builder.isMemberClass;
180: 			this.implClass = builder.implClass;
189: 		} catch (ClassMetaRuntimeException e) {
199: 	 * Generated classes shouldn't be cacheable to prevent needlessly filling up the cache.
203: 		char x = n.charAt(n.length()-1);  // All generated classes appear to end with digits.
226: 		this.innerClass = mainType.innerClass;
228: 		this.implClass = mainType.implClass;
240: 		this.isMemberClass = mainType.isMemberClass;
270: 		this.info = ClassInfo.of(innerClass);
272: 		this.implClass = null;
284: 		this.isMemberClass = false;
310: 		ClassInfo ci;
313: 		ClassCategory cc = ClassCategory.OTHER;
329: 		ClassMeta<?>
354: 			this.innerClass = innerClass;
358: 			this.implClass = implClass;
359: 			ClassInfo ici = ClassInfo.of(implClass);
370: 			ci = ClassInfo.of(c);
373: 				innerClass = this.innerClass = ci.inner();
439: 			isMemberClass = ci.isMemberClass() && ci.isNotStatic();
442: 			// fromString() must be checked before valueOf() so that Enum classes can create their own
469: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
475: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
484: 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of ...(16 bytes skipped)...
494: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and hav...(22 bytes skipped)...
500: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have ...(20 bytes skipped)...
521: 					List<ClassInfo> pt = cs.getParamTypes();
524: 					} else if (pt.size() == (isMemberClass ? 2 : 1)) {
525: 						ClassInfo arg = pt.get(isMemberClass ? 1 : 0);
539: 				ClassInfo x = implClass == null ? ci : ici;
550: 				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
558: 					elementType = findClassMeta(innerClass.getComponentType());
562: 					ClassMeta[] parameters = findParameters();
574: 					ClassMeta[] parameters = findParameters();
588: 						newMeta = new BeanMeta(ClassMeta.this, bc, beanFilter, null);
613: 			if (beanMeta != null && bc != null && bc.isUseInterfaceProxies() && innerClass.isInterface())
693: 					return new AnnotationBeanFilterBuilder(innerClass, ba).build();
727: 			ClassInfo ci = ClassInfo.of(c);
751: 		private ClassMeta<?>[] findParameters() {
752: 			return beanContext.findParameters(innerClass, innerClass);
761: 	public ClassInfo getInfo() {
858: 			PojoSwap<?,?> s = childSwapMap.get(normalClass);
861: 					if (s == null && f.getNormalClass().isParentOf(normalClass))
865: 				PojoSwap<?,?> s2 = childSwapMap.putIfAbsent(normalClass, s);
885: 			PojoSwap<?,?> s = childUnswapMap.get(swapClass);
888: 					if (s == null && f.getSwapClass().isParentOf(swapClass))
892: 				PojoSwap<?,?> s2 = childUnswapMap.putIfAbsent(swapClass, s);
909: 	 * Note that this also returns the 1-arg constructor for non-static member classes.
917: 		ClassInfo ci = ClassInfo.of(c);
920: 		boolean isMemberClass = ci.isMemberClass() && ci.isNotStatic();
922: 			if (cc.hasNumParams(isMemberClass ? 1 : 0) && cc.isVisible(v) && cc.isNotDeprecated())
934: 		return innerClass;
1000: 					Object o = Array.newInstance(getElementType().innerClass, 1);
1019: 			throw new ClassMetaRuntimeException(e);
1029: 	public ClassMeta<?> getElementType() {
1038: 	public ClassMeta<?> getKeyType() {
1047: 	public ClassMeta<?> getValueType() {
1329: 		return innerClass.isPrimitive();
1427: 	public ClassMeta<?>[] getArgs() {
1438: 	public ClassMeta<?> getArg(int index) {
1454: 		if (innerClass.isPrimitive())
1474: 		return isMemberClass;
1563: 		if (isMemberClass)
1585: 		if (isMemberClass)
1586: 			return outer != null && noArgConstructor != null && noArgConstructor.hasParamTypes(outer.getClass());
1605: 		if (isMemberClass)
1606: 			return outer != null && beanMeta.constructor.hasParamTypes(outer.getClass());
1615: 	 * 	Can be <jk>null</jk> for non-member or static classes.
1622: 			if (isMemberClass)
1749: 			if (isMemberClass)
1765: 			return (T)Array.newInstance(getInnerClass().getComponentType(), 0);
1773: 			return (T)Array.newInstance(this.elementType.innerClass,0);
1778: 	 * Same as {@link #newInstance()} except for instantiating non-static member classes.
1787: 		if (isMemberClass)
1799: 	public boolean same(ClassMeta<?> cm) {
1828: 		String n = innerClass.getName();
1855: 			return info.isParentOf(o.getClass()) || (isPrimitive() && info.getPrimitiveWrapper() == o.getClass());
1874: 		return innerClass.getName();
1883: 		return innerClass.getSimpleName();
1956: 	public boolean hasMutaterFrom(ClassMeta<?> c) {
1957: 		return getFromMutater(c.getInnerClass()) != null;
1976: 	public boolean hasMutaterTo(ClassMeta<?> c) {
1977: 		return getToMutater(c.getInnerClass()) != null;
1988: 		Mutater t = getFromMutater(o.getClass());
2012: 	public <O> O mutateTo(Object o, ClassMeta<O> c) {
2013: 		return mutateTo(o, c.getInnerClass());
2028: 			t = Mutaters.get(c, innerClass);
2048: 			t = Mutaters.get(innerClass, c);
2057: 	 * Shortcut for calling <code>getInnerClass().getAnnotation(a) != <jk>null</jk></code>.
2067: 	 * Shortcut for calling <c>getInnerClass().getAnnotation(a)</c>.
2090: 		return innerClass.hashCode();
2095: 		if (o == null || ! (o instanceof ClassMeta))
2097: 		ClassMeta<?> o2 = (ClassMeta<?>)o;
2098: 		return o2.innerClass.equals(innerClass);
92: 		childSwapMap,                                        // Maps normal subclasses to PojoSwaps.
93: 		childUnswapMap;                                      // Maps swap subclasses to PojoSwaps.
603: 			} catch (NoClassDefFoundError e) {
748: 			return beanContext.getClassMeta(c, false);
799: 	 * This allows interfaces to define subclasses with type names.
948: 		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/dart-lang/sdk:runtime/vm/object.h: [ master, ]
926: class Class : public Object {
466:   static ClassPtr class_class() { return class_class_; }
467:   static ClassPtr dynamic_class() { return dynamic_class_; }
468:   static ClassPtr void_class() { return void_class_; }
469:   static ClassPtr type_arguments_class() { return type_arguments_class_; }
470:   static ClassPtr patch_class_class() { return patch_class_class_; }
471:   static ClassPtr function_class() { return function_class_; }
472:   static ClassPtr closure_data_class() { return closure_data_class_; }
473:   static ClassPtr signature_data_class() { return signature_data_class_; }
474:   static ClassPtr redirection_data_class() { return redirection_data_class_; }
475:   static ClassPtr ffi_trampoline_data_class() {
478:   static ClassPtr field_class() { return field_class_; }
479:   static ClassPtr script_class() { return script_class_; }
480:   static ClassPtr library_class() { return library_class_; }
481:   static ClassPtr namespace_class() { return namespace_class_; }
482:   static ClassPtr kernel_program_info_class() {
485:   static ClassPtr code_class() { return code_class_; }
486:   static ClassPtr bytecode_class() { return bytecode_class_; }
487:   static ClassPtr instructions_class() { return instructions_class_; }
488:   static ClassPtr instructions_section_class() {
491:   static ClassPtr object_pool_class() { return object_pool_class_; }
492:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }
493:   static ClassPtr code_source_map_class() { return code_source_map_class_; }
494:   static ClassPtr compressed_stackmaps_class() {
497:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }
498:   static ClassPtr exception_handlers_class() {
501:   static ClassPtr deopt_info_class() { return deopt_info_class_; }
502:   static ClassPtr context_class() { return context_class_; }
503:   static ClassPtr context_scope_class() { return context_scope_class_; }
504:   static ClassPtr api_error_class() { return api_error_class_; }
505:   static ClassPtr language_error_class() { return language_error_class_; }
506:   static ClassPtr unhandled_exception_class() {
509:   static ClassPtr unwind_error_class() { return unwind_error_class_; }
510:   static ClassPtr dyncalltypecheck_class() { return dyncalltypecheck_class_; }
511:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }
512:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }
513:   static ClassPtr monomorphicsmiablecall_class() {
516:   static ClassPtr icdata_class() { return icdata_class_; }
517:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }
518:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }
519:   static ClassPtr weak_serialization_reference_class() {
773:   static ClassPtr class_class_;           // Class of the Class vm object.
1350:   ClassLayout::ClassLoadingState class_loading_state() const {
1367:   bool is_synthesized_class() const {
1372:   bool is_enum_class() const { return EnumBit::decode(raw_ptr()->state_bits_); }
1783:   ClassPtr patched_class() const { return raw_ptr()->patched_class_; }
1784:   ClassPtr origin_class() const { return raw_ptr()->origin_class_; }
4702:   ClassPtr toplevel_class() const { return raw_ptr()->toplevel_class_; }
8064:   virtual ClassPtr type_class() const {
1215:   bool IsNullClass() const { return id() == kNullCid; }
1218:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1221:   bool IsVoidClass() const { return id() == kVoidCid; }
1224:   bool IsNeverClass() const { return id() == kNeverCid; }
1227:   bool IsObjectClass() const { return id() == kInstanceCid; }
1236:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1239:   bool IsClosureClass() const { return id() == kClosureCid; }
1240:   static bool IsClosureClass(ClassPtr cls) {
1246:   bool IsTypedefClass() const { return signature_function() != Object::null(); }
1684:   class ClassFinalizedBits : public BitField<uint32_t,
1688:   class ClassLoadingBits : public BitField<uint32_t,
1777:   kCurrentClass,  // Consider type params of current class only.
1781: class PatchClass : public Object {
4526: class ClassDictionaryIterator : public DictionaryIterator {
5116:   ArrayPtr classes_cache() const { return raw_ptr()->classes_cache_; }
7107:   intptr_t SizeFromClass() const {
7636:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
7888:   virtual bool HasTypeClass() const {
8055:   virtual bool HasTypeClass() const {
8138:   virtual bool HasTypeClass() const { return false; }
306: #define DEFINE_CLASS_TESTER(clazz)                                             \
774:   static ClassPtr dynamic_class_;         // Class of the 'dynamic' type.
775:   static ClassPtr void_class_;            // Class of the 'void' type.
776:   static ClassPtr type_arguments_class_;  // Class of TypeArguments vm object.
777:   static ClassPtr patch_class_class_;     // Class of the PatchClass vm object.
778:   static ClassPtr function_class_;        // Class of the Function vm object.
779:   static ClassPtr closure_data_class_;    // Class of ClosureData vm obj.
780:   static ClassPtr signature_data_class_;  // Class of SignatureData vm obj.
781:   static ClassPtr redirection_data_class_;  // Class of RedirectionData vm obj.
782:   static ClassPtr ffi_trampoline_data_class_;  // Class of FfiTrampolineData
784:   static ClassPtr field_class_;                // Class of the Field vm object.
785:   static ClassPtr script_class_;               // Class of the Script vm object.
786:   static ClassPtr library_class_;    // Class of the Library vm object.
787:   static ClassPtr namespace_class_;  // Class of Namespace vm object.
788:   static ClassPtr kernel_program_info_class_;  // Class of KernelProgramInfo vm
790:   static ClassPtr code_class_;                 // Class of the Code vm object.
791:   static ClassPtr bytecode_class_;      // Class of the Bytecode vm object.
792:   static ClassPtr instructions_class_;  // Class of the Instructions vm object.
793:   static ClassPtr instructions_section_class_;  // Class of InstructionsSection.
794:   static ClassPtr object_pool_class_;      // Class of the ObjectPool vm object.
795:   static ClassPtr pc_descriptors_class_;   // Class of PcDescriptors vm object.
796:   static ClassPtr code_source_map_class_;  // Class of CodeSourceMap vm object.
797:   static ClassPtr compressed_stackmaps_class_;  // Class of CompressedStackMaps.
798:   static ClassPtr var_descriptors_class_;       // Class of LocalVarDescriptors.
799:   static ClassPtr exception_handlers_class_;    // Class of ExceptionHandlers.
800:   static ClassPtr deopt_info_class_;            // Class of DeoptInfo.
801:   static ClassPtr context_class_;            // Class of the Context vm object.
802:   static ClassPtr context_scope_class_;      // Class of ContextScope vm object.
803:   static ClassPtr dyncalltypecheck_class_;   // Class of ParameterTypeCheck.
804:   static ClassPtr singletargetcache_class_;  // Class of SingleTargetCache.
805:   static ClassPtr unlinkedcall_class_;       // Class of UnlinkedCall.
807:       monomorphicsmiablecall_class_;         // Class of MonomorphicSmiableCall.
808:   static ClassPtr icdata_class_;             // Class of ICData.
809:   static ClassPtr megamorphic_cache_class_;  // Class of MegamorphiCache.
810:   static ClassPtr subtypetestcache_class_;   // Class of SubtypeTestCache.
811:   static ClassPtr api_error_class_;          // Class of ApiError.
812:   static ClassPtr language_error_class_;     // Class of LanguageError.
813:   static ClassPtr unhandled_exception_class_;  // Class of UnhandledException.
814:   static ClassPtr unwind_error_class_;         // Class of UnwindError.
816:   static ClassPtr weak_serialization_reference_class_;
4548:   Class& toplevel_class_;
7865:   static intptr_t type_class_id_offset() {
8061:   virtual classid_t type_class_id() const {
8139:   virtual classid_t type_class_id() const { return kIllegalCid; }
298:   intptr_t GetClassId() const {
557:   static const ClassId kClassId = kObjectCid;
1208:   GrowableObjectArrayPtr direct_subclasses() const {
1666:     kClassFinalizedPos = 2,
1667:     kClassFinalizedSize = 2,
1668:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1669:     kClassLoadingSize = 2,
1672:     kSynthesizedClassBit,
1694:   class SynthesizedClassBit
2218:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }
5830:   classid_t TargetClassId() const { return TargetClassIdOf(raw()); }
5831:   static classid_t TargetClassIdOf(const WeakSerializationReferencePtr raw) {
5869:   static classid_t UnwrappedClassIdOf(const Object& obj) {
5879:   static classid_t UnwrappedClassIdOf(ObjectPtr obj) {
6259:   classid_t OwnerClassId() const { return OwnerClassIdOf(raw()); }
6260:   static classid_t OwnerClassIdOf(CodePtr raw) {
6821:     kClassIdIndex,
6884:     kInstanceClassIdOrFunction = 1,
8145:   bool IsClassTypeParameter() const {
8916:   static const ClassId kClassId = kOneByteStringCid;
9043:   static const ClassId kClassId = kTwoByteStringCid;
9116:   static const ClassId kClassId = kExternalOneByteStringCid;
9203:   static const ClassId kClassId = kExternalTwoByteStringCid;
9490:   static const ClassId kClassId = kImmutableArrayCid;
11070: ObjectPtr MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
44: class Assembler;
48: class Program;
49: class TreeNode;
52: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
53: CLASS_LIST(DEFINE_FORWARD_DECLARATION)
55: class Api;
56: class ArgumentsDescriptor;
57: class Closure;
58: class Code;
59: class DeoptInstr;
60: class DisassemblyFormatter;
61: class FinalizablePersistentHandle;
62: class FlowGraphCompiler;
63: class HierarchyInfo;
64: class LocalScope;
65: class CodeStatistics;
66: class IsolateGroupReloadContext;
68: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
72: class Symbols;
73: class ZoneTextBuffer;
212:   friend class SnapshotReader;
226:   friend class Object;
235:   friend class StackFrame;                                                     \
236:   friend class Thread;
260:   friend class Object;                                                         \
261:   friend class StackFrame;                                                     \
262:   friend class Thread;
279: class Object {
305: // Class testers.
308:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
309: #undef DEFINE_CLASS_TESTER
476:     return ffi_trampoline_data_class_;
483:     return kernel_program_info_class_;
489:     return instructions_section_class_;
495:     return compressed_stackmaps_class_;
499:     return exception_handlers_class_;
507:     return unhandled_exception_class_;
514:     return monomorphicsmiablecall_class_;
520:     return weak_serialization_reference_class_;
547:   template <class FakeObject>
572:     //   core impl class name shown -> _OneByteString
601:   // class which has the same name as an already existing function, or
608:   enum class NameDisambiguation {
718:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
736:     // Indicates this class cannot be extended by dart code.
742:   static void RegisterClass(const Class& cls,
745:   static void RegisterPrivateClass(const Class& cls,
815:   // Class of WeakSerializationReference.
822:   friend void ClassTable::Register(const Class& cls);
824:   friend class Closure;
825:   friend class SnapshotReader;
826:   friend class InstanceDeserializationCluster;
827:   friend class OneByteString;
828:   friend class TwoByteString;
829:   friend class ExternalOneByteString;
830:   friend class ExternalTwoByteString;
831:   friend class Thread;
834:   friend class Reusable##name##HandleScope;
842: class PassiveObject : public Object {
890: // The first string in the triplet is a type name (usually a class).
895: enum class Nullability : int8_t {
902: enum class TypeEquality {
911: enum class NNBDMode {
919: enum class NNBDCompiledMode {
1040:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1041:   // to this class.
1044:   // The NNBD mode of the library declaring this class.
1061:   // This class represents a typedef if the signature function is not null.
1067:   // Return the Type with type parameters declared by this class filled in with
1073:   // class preceded by the type arguments declared for superclasses, etc.
1075:   // class B<T, S>
1076:   // class C<R> extends B<R, int>
1104:   // Return a TypeParameter if the type_name is a type parameter of this class.
1109:   // the super class.
1112:   // Return true if this class declares type parameters.
1115:   // If this class is parameterized, each instance has a type_arguments field.
1129:         compiler::target::Class::kNoTypeArguments) {
1130:       return compiler::target::Class::kNoTypeArguments;
1142:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1144:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1146:       target_value = RTN::Class::kNoTypeArguments;
1177:   // The super type of this class, Object type if not explicitly specified.
1187:   // Asserts that the class of the super type has been resolved.
1200:   // Returns the list of classes directly implementing this class.
1204:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1207:   // Returns the list of classes having this class as direct superclass.
1211:   void AddDirectSubclass(const Class& subclass) const;
1214:   // Check if this class represents the class of null.
1217:   // Check if this class represents the 'dynamic' class.
1220:   // Check if this class represents the 'void' class.
1223:   // Check if this class represents the 'Never' class.
1226:   // Check if this class represents the 'Object' class.
1229:   // Check if this class represents the 'Function' class.
1232:   // Check if this class represents the 'Future' class.
1235:   // Check if this class represents the 'FutureOr' class.
1238:   // Check if this class represents the 'Closure' class.
1245:   // Check if this class represents a typedef class.
1256:   static bool IsSubtypeOf(const Class& cls,
1262:   // Check if this is the top level class.
1270:   // Returns an array of instance and static fields defined by this class.
1276:   // If this is a dart:internal.ClassID class, then inject our own const
1281:   // Returns an array of all instance fields of this class and its superclasses
1297:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1355:     return class_loading_state() >= ClassLayout::kDeclarationLoaded;
1360:     return class_loading_state() >= ClassLayout::kTypeFinalized;
1370:   void set_is_synthesized_class() const;
1373:   void set_is_enum_class() const;
1391:   // Tests if this is a mixin application class which was desugared
1392:   // to a normal class by kernel mixin transformation
1494:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1519:   // class and return the resulting value, or an error object if evaluating the
1529:   // Load class declaration (super type, interfaces, type parameters and
1535:   // Allocate a class used for VM internal objects.
1536:   template <class FakeObject, class TargetFakeObject>
1537:   static ClassPtr New(Isolate* isolate, bool register_class = true);
1544:                       bool register_class = true);
1550:   static ClassPtr NewStringClass(intptr_t class_id, Isolate* isolate);
1553:   static ClassPtr NewTypedDataClass(intptr_t class_id, Isolate* isolate);
1556:   static ClassPtr NewTypedDataViewClass(intptr_t class_id, Isolate* isolate);
1559:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,
1563:   static ClassPtr NewPointerClass(intptr_t class_id, Isolate* isolate);
1566:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1570:   void DisableCHAOptimizedCode(const Class& subclass);
1576:   // Return the list of code objects that were compiled using CHA of this class.
1577:   // These code objects will be invalidated if new subclasses of this class
1586:                    const Class& old_enum) const;
1588:                              const Class& old_cls) const;
1591:                                      const Class& new_cls) const;
1592:   void CopyCanonicalConstants(const Class& old_cls) const;
1593:   void CopyDeclarationType(const Class& old_cls) const;
1594:   void CheckReload(const Class& replacement,
1641:   // Caches the declaration type of this class.
1644:   bool CanReloadFinalized(const Class& replacement,
1646:   bool CanReloadPreFinalized(const Class& replacement,
1650:   bool RequiresInstanceMorphing(const Class& replacement) const;
1652:   template <class FakeInstance, class TargetFakeInstance>
1682:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1683:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1692:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1693:   class PatchBit : public BitField<uint32_t, bool, kPatchBit, 1> {};
1696:   class FieldsMarkedNullableBit
1698:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1699:   class TransformedMixinApplicationBit
1701:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1702:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1703:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1736:   // Calculates number of type arguments of this class.
1741:   // Assigns empty array to all raw class array fields.
1754:   // Allocate an instance class which has a VM implementation.
1755:   template <class FakeInstance, class TargetFakeInstance>
1758:                       bool register_class = true,
1761:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1764:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1765:   friend class AbstractType;
1766:   friend class Instance;
1767:   friend class Object;
1768:   friend class Type;
1769:   friend class InterpreterHelpers;
1770:   friend class Intrinsifier;
1771:   friend class ProgramWalker;
1776:   kAny,           // Consider type params of current class and functions.
1808:     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
1811:   static PatchClassPtr New(const Class& patched_class,
1812:                            const Class& origin_class);
1814:   static PatchClassPtr New(const Class& patched_class, const Script& source);
1817:   void set_patched_class(const Class& value) const;
1818:   void set_origin_class(const Class& value) const;
1824:   friend class Class;
1827: class ParameterTypeCheck : public Object {
1859:   friend class Class;
1862: class SingleTargetCache : public Object {
1892:   friend class Class;
1895: class MonomorphicSmiableCall : public Object {
1921:   friend class Class;
1924: class UnlinkedCall : public Object {
1947:   friend class Class;
1950: class CallSiteData : public Object {
1971:   friend class ICData;
1972:   friend class MegamorphicCache;
1980: class ICData : public CallSiteData {
2162:   // Used for unoptimized static calls when no class-ids are checked.
2167:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2169:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2175:   // Adds sorted so that Smi is the first class-id. Use only for
2177:   void AddReceiverCheck(intptr_t receiver_class_id,
2189:                   GrowableArray<intptr_t>* class_ids,
2191:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2195:                           intptr_t* class_id,
2230:   bool HasReceiverClassId(intptr_t class_id) const;
2302:   friend class FlowGraphSerializer;  // For is_megamorphic()
2351:   class NumArgsTestedBits : public BitField<uint32_t,
2355:   class TrackingExactnessBit : public BitField<uint32_t,
2359:   class DeoptReasonBits : public BitField<uint32_t,
2363:   class RebindRuleBits : public BitField<uint32_t,
2367:   class MegamorphicBit
2370:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2400:   friend class CallSiteResetter;
2401:   friend class CallTargets;
2402:   friend class Class;
2403:   friend class Deserializer;
2404:   friend class ICDataTestTask;
2405:   friend class Interpreter;
2406:   friend class Serializer;
2407:   friend class SnapshotWriter;
2429: class Function : public Object {
2451:   // owner class of this function, then its signature type is a parameterized
2500:   // parameter of this function and R is a type parameter of class C, the owner
2506:   // parameter of this function and R is a type parameter of class C, the owner
2518:   // generic functions or class type parameters.
2532:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3408:       const Class& klass = Class::Handle(Owner());
3454:   // The owner is the scope class of the function type.
3461:   static FunctionPtr NewEvalFunction(const Class& owner,
3512: // a hoisted check class instruction.
3527:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3550:   // static: Considered during class-side or top-level resolution rather than
3649:   class KindBits : public BitField<uint32_t,
3654:   class RecognizedBits : public BitField<uint32_t,
3658:   class ModifierBits : public BitField<uint32_t,
3664:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3701:   friend class Class;
3702:   friend class SnapshotWriter;
3703:   friend class Parser;  // For set_eval_script.
3706:   friend class FunctionLayout;
3707:   friend class ClassFinalizer;  // To reset parent_function.
3708:   friend class Type;            // To adjust parent_function.
3711: class ClosureData : public Object {
3735:   friend class Class;
3736:   friend class Function;
3737:   friend class HeapProfiler;
3740: class SignatureData : public Object {
3758:   friend class Class;
3759:   friend class Function;
3760:   friend class HeapProfiler;
3763: class RedirectionData : public Object {
3770:   // The type specifies the class and type arguments of the target constructor.
3785:   friend class Class;
3786:   friend class Function;
3787:   friend class HeapProfiler;
3790: enum class EntryPointPragma {
3798: class FfiTrampolineData : public Object {
3826:   friend class Class;
3827:   friend class Function;
3828:   friend class HeapProfiler;
3831: class Field : public Object {
3991:   // Called during class finalization.
4018:   ClassPtr Origin() const;  // Either mixin class, or same as owner().
4023:   // Used by class finalizer, otherwise initialized in constructor.
4116:   // Return class id that any non-null value read from this field is guaranteed
4117:   // to have or kDynamicCid if such class id is not known.
4231:   // assumptions about guarded class id and nullability of this field.
4311:   friend class Interpreter;              // Access to bit field.
4312:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4332:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4333:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4334:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4335:   class HasNontrivialInitializerBit
4337:   class UnboxingCandidateBit
4339:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4340:   class DoubleInitializedBit
4342:   class InitializerChangedAfterInitializatonBit
4347:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4348:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4349:   class GenericCovariantImplBit
4351:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4352:   class IsExtensionMemberBit
4354:   class NeedsLoadGuardBit
4356:   class HasInitializerBit
4358:   class IsNonNullableIntBit
4399:   friend class Class;
4400:   friend class HeapProfiler;
4401:   friend class FieldLayout;
4402:   friend class FieldSerializationCluster;
4403:   friend class FieldDeserializationCluster;
4406: class Script : public Object {
4501:   friend class Class;
4502:   friend class Precompiler;
4505: class DictionaryIterator : public ValueObject {
4521:   friend class ClassDictionaryIterator;
4522:   friend class LibraryPrefixIterator;
4530:     // one top-level class per library left, not an array to iterate over.
4539:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4542:   // Returns a non-null raw class.
4553: class LibraryPrefixIterator : public DictionaryIterator {
4563: class Library : public Object {
4622:   void AddClass(const Class& cls) const;
4657:   void AddAnonymousClass(const Class& cls) const;
4661:   void AddClassMetadata(const Class& cls,
4703:   void set_toplevel_class(const Class& value) const;
4914:   // Lookup class in the core lib which also contains various VM
4916:   static ClassPtr LookupCoreClass(const String& class_name);
4920:                                  const char* class_name,
4995:   friend class Bootstrap;
4996:   friend class Class;
4997:   friend class Debugger;
4998:   friend class DictionaryIterator;
4999:   friend class Isolate;
5000:   friend class LibraryDeserializationCluster;
5001:   friend class Namespace;
5002:   friend class Object;
5003:   friend class Precompiler;
5008: class Namespace : public Object {
5038:   friend class Class;
5039:   friend class Precompiler;
5042: class KernelProgramInfo : public Object {
5121:                        const Class& klass) const;
5130:   friend class Class;
5136: class ObjectPool : public Object {
5261:   friend class Class;
5262:   friend class Object;
5263:   friend class ObjectPoolLayout;
5266: class Instructions : public Object {
5275:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5276:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5397:   friend class Class;
5398:   friend class Code;
5399:   friend class AssemblyImageWriter;
5400:   friend class BlobImageWriter;
5401:   friend class ImageWriter;
5406: class InstructionsSection : public Object {
5429:   friend class Class;
5432: class LocalVarDescriptors : public Object {
5468:   friend class Class;
5469:   friend class Object;
5472: class PcDescriptors : public Object {
5512:   class Iterator : ValueObject {
5562:     friend class PcDescriptors;
5607:   friend class Class;
5608:   friend class Object;
5611: class CodeSourceMap : public Object {
5653:   friend class Class;
5654:   friend class Object;
5657: class CompressedStackMaps : public Object {
5733:   friend class Class;
5734:   friend class CompressedStackMapsIterator;  // For PayloadByte
5735:   friend class StackMapEntry;                // For PayloadByte
5738: class ExceptionHandlers : public Object {
5787:   friend class Class;
5788:   friend class Object;
5811: // but instead contain only the class ID of the original target.
5815: class WeakSerializationReference : public Object {
5872:   // Gets the class ID of the underlying object from a WSR, or the class ID of
5899:   friend class Class;
5902: class Code : public Object {
6110:   enum class PoolAttachment {
6115:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};
6116:   class EntryPointField
6118:   class OffsetField
6143:   class Comments : public ZoneAllocated {
6167:     friend class Code;
6245:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6379:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6380:   friend class CodeLayout;
6389:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6393:   class ForceOptimizedBit
6396:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6397:   class PtrOffBits
6400:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6487:   friend class Class;
6488:   friend class CodeTestHelper;
6489:   friend class SnapshotWriter;
6490:   friend class StubCode;     // for set_object_pool
6491:   friend class Precompiler;  // for set_object_pool
6492:   friend class FunctionSerializationCluster;
6493:   friend class CodeSerializationCluster;
6494:   friend class CodeDeserializationCluster;
6495:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6496:   friend class StubCode;               // for set_object_pool
6497:   friend class MegamorphicCacheTable;  // for set_object_pool
6498:   friend class CodePatcher;            // for set_instructions
6499:   friend class ProgramVisitor;         // for set_instructions
6502:   friend class FunctionLayout;
6503:   friend class CallSiteResetter;
6504:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6507: class Bytecode : public Object {
6616:   class SlowFindRawBytecodeVisitor : public FindObjectVisitor {
6643:   friend class BytecodeDeserializationCluster;
6644:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6645:   friend class BytecodeLayout;
6648:   friend class Class;
6649:   friend class SnapshotWriter;
6652: class Context : public Object {
6718:   friend class Class;
6719:   friend class Object;
6722: // The ContextScope class makes it possible to delay the compilation of a local
6732: class ContextScope : public Object {
6810:   friend class Class;
6811:   friend class Object;
6814: class MegamorphicCache : public CallSiteData {
6848:   void Insert(const Smi& class_id, const Object& target) const;
6859:   friend class Class;
6860:   friend class MegamorphicCacheTable;
6861:   friend class ProgramVisitor;
6867:   void InsertLocked(const Smi& class_id, const Object& target) const;
6871:                               const Smi& class_id,
6880: class SubtypeTestCache : public Object {
6894:   void AddCheck(const Object& instance_class_id_or_function,
6902:                 Object* instance_class_id_or_function,
6935:   friend class Class;
6936:   friend class Serializer;
6937:   friend class Deserializer;
6940: class Error : public Object {
6948: class ApiError : public Error {
6966:   friend class Class;
6969: class LanguageError : public Error {
7032:   friend class Class;
7035: class UnhandledException : public Error {
7064:   friend class Class;
7065:   friend class ObjectStore;
7068: class UnwindError : public Error {
7088:   friend class Class;
7091: // Instance is the base class for all instance objects (aka the Object class
7093: class Instance : public Object {
7109:     const Class& cls = Class::Handle(clazz());
7180:   // class implementing a 'call' method, return true and set the function
7203:       const Class& method_cls,
7219:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);
7227:   // only the class_id is different. So, it is safe to use subtype instances in
7273:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7284:   static InstancePtr NewFromCidAndSize(SharedClassTable* shared_class_table,
7290:   friend class ByteBuffer;
7291:   friend class Class;
7292:   friend class Closure;
7293:   friend class Pointer;
7294:   friend class DeferredObject;
7295:   friend class RegExp;
7296:   friend class SnapshotWriter;
7297:   friend class StubCode;
7298:   friend class TypedDataView;
7299:   friend class InstanceSerializationCluster;
7300:   friend class InstanceDeserializationCluster;
7301:   friend class ClassDeserializationCluster;  // vtable
7302:   friend class InstanceMorpher;
7303:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7306: class LibraryPrefix : public Instance {
7341:   friend class Class;
7345: class TypeArguments : public Instance {
7418:   // a raw (null) function type arguments, i.e. consider each class type
7475:       const Class& instantiator_class,
7494:   // Add the class name and URI of each type argument of this vector to the uris
7501:   // type from the various type argument vectors (class instantiator, function,
7578:   // If raw_instantiated is true, consider each class type parameter to be first
7593:   friend class AbstractType;
7594:   friend class Class;
7595:   friend class ClearTypeHashVisitor;
7596:   friend class Object;
7601: class AbstractType : public Instance {
7637:   virtual classid_t type_class_id() const;
7638:   virtual ClassPtr type_class() const;
7663:   // instantiation. Consider a class C<T> declaring a non-generic method
7665:   // generic function bar<B> as argument and its function type refers to class
7737:   // Add the class name and URI of each occuring type to the uris
7743:   // The name of this type's class, i.e. without the type argument names of this
7751:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
7754:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
7763:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
7779:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
7797:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
7800:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
7815:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
7852:   friend class Class;
7853:   friend class Function;
7854:   friend class TypeArguments;
7857: // A Type consists of a class, possibly parameterized with type
7860: // Caution: 'TypePtr' denotes a 'raw' pointer to a VM object of class Type, as
7863: class Type : public AbstractType {
7866:     return OFFSET_OF(TypeLayout, type_class_id_);
7889:     ASSERT(type_class_id() != kIllegalCid);
7896:   virtual classid_t type_class_id() const;
7897:   virtual ClassPtr type_class() const;
7898:   void set_type_class(const Class& value) const;
7911:   // canonicalization (passed-in cls must match type_class()).
7912:   bool IsDeclarationTypeOf(const Class& cls) const;
7916:   // However, in case of a generic typedef, they document how the typedef class
8007:   // The finalized type of the given non-parameterized class.
8008:   static TypePtr NewNonParameterizedType(const Class& type_class);
8010:   static TypePtr New(const Class& clazz,
8029:   friend class Class;
8030:   friend class TypeArguments;
8031:   friend class ClearTypeHashVisitor;
8038: class TypeRef : public AbstractType {
8062:     return AbstractType::Handle(type()).type_class_id();
8065:     return AbstractType::Handle(type()).type_class();
8109:   friend class Class;
8112: // A TypeParameter represents a type parameter of a parameterized class.
8116: // the class HashMap<K, V>. At compile time, the TypeParameter is not
8119: // as type argument (rather than type parameter) of the parameterized class.
8122: class TypeParameter : public AbstractType {
8140:   classid_t parameterized_class_id() const;
8141:   ClassPtr parameterized_class() const;
8146:     return parameterized_class_id() != kFunctionCid;
8193:   // Only one of parameterized_class and parameterized_function is non-null.
8194:   static TypeParameterPtr New(const Class& parameterized_class,
8207:   void set_parameterized_class(const Class& value) const;
8217:   friend class Class;
8218:   friend class ClearTypeHashVisitor;
8221: class Number : public Instance {
8238:   friend class Class;
8241: class Integer : public Number {
8314:   friend class Class;
8317: class Smi : public Integer {
8351:   static ClassPtr Class();
8372:     // Indicates this class cannot be extended by dart code.
8379:   friend class Api;  // For ValueFromRaw
8380:   friend class Class;
8381:   friend class Object;
8382:   friend class ReusableSmiHandleScope;
8383:   friend class Thread;
8386: class SmiTraits : AllStatic {
8398: class Mint : public Integer {
8428:   friend class Integer;
8438:   friend class Class;
8439:   friend class Number;
8442: // Class Double represents class Double in corelib_impl, which implements
8443: // abstract class double in corelib.
8444: class Double : public Number {
8475:   friend class Class;
8476:   friend class Number;
8480: class String : public Instance {
8501:   class CodePointIterator : public ValueObject {
8800:   friend class Class;
8801:   friend class Symbols;
8802:   friend class StringSlice;  // SetHash
8804:   friend class CharArray;     // SetHash
8805:   friend class ConcatString;  // SetHash
8806:   friend class OneByteString;
8807:   friend class TwoByteString;
8808:   friend class ExternalOneByteString;
8809:   friend class ExternalTwoByteString;
8810:   friend class OneByteStringLayout;
8811:   friend class RODataSerializationCluster;  // SetHash
8812:   friend class Pass2Visitor;                // Stack "handle"
8815: class OneByteString : public AllStatic {
8948:   friend class Class;
8949:   friend class String;
8950:   friend class Symbols;
8951:   friend class ExternalOneByteString;
8952:   friend class SnapshotReader;
8953:   friend class StringHasher;
8954:   friend class Utf8;
8957: class TwoByteString : public AllStatic {
9073:   friend class Class;
9074:   friend class String;
9075:   friend class SnapshotReader;
9076:   friend class Symbols;
9079: class ExternalOneByteString : public AllStatic {
9159:     // Indicates this class cannot be extended by dart code.
9163:   friend class Class;
9164:   friend class String;
9165:   friend class SnapshotReader;
9166:   friend class Symbols;
9167:   friend class Utf8;
9170: class ExternalTwoByteString : public AllStatic {
9246:     // Indicates this class cannot be extended by dart code.
9250:   friend class Class;
9251:   friend class String;
9252:   friend class SnapshotReader;
9253:   friend class Symbols;
9256: // Class Bool implements Dart core class bool.
9257: class Bool : public Instance {
9286:   friend class Class;
9287:   friend class Object;  // To initialize the true and false values.
9290: class Array : public Instance {
9398:   // Make the array immutable to Dart code by switching the class pointer
9434:   static ArrayPtr New(intptr_t class_id,
9473:   friend class Class;
9474:   friend class ImmutableArray;
9475:   friend class Interpreter;
9476:   friend class Object;
9477:   friend class String;
9480: class ImmutableArray : public AllStatic {
9500:     // Indicates this class cannot be extended by dart code.
9508:   friend class Class;
9511: class GrowableObjectArray : public Instance {
9618:   friend class Array;
9619:   friend class Class;
9622: class Float32x4 : public Instance {
9653:   friend class Class;
9656: class Int32x4 : public Instance {
9686:   friend class Class;
9689: class Float64x2 : public Instance {
9714:   friend class Class;
9717: class PointerBase : public Instance {
9724: class TypedDataBase : public PointerBase {
9789:   friend class Class;
9804: class TypedData : public TypedDataBase {
9855:   static intptr_t MaxElements(intptr_t class_id) {
9856:     ASSERT(IsTypedDataClassId(class_id));
9857:     return (kSmiMax / ElementSizeInBytes(class_id));
9860:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
9861:     ASSERT(IsTypedDataClassId(class_id));
9863:            ElementSizeInBytes(class_id);
9866:   static TypedDataPtr New(intptr_t class_id,
9931:   // Therefore this method is private and the call-sites in this class need to
9940:   friend class Class;
9941:   friend class CompressedStackMapsIterator;
9942:   friend class ExternalTypedData;
9943:   friend class TypedDataView;
9946: class ExternalTypedData : public TypedDataBase {
9988:   static intptr_t MaxElements(intptr_t class_id) {
9989:     ASSERT(IsExternalTypedDataClassId(class_id));
9990:     return (kSmiMax / ElementSizeInBytes(class_id));
9994:       intptr_t class_id,
10024:   friend class Class;
10027: class TypedDataView : public TypedDataBase {
10029:   static TypedDataViewPtr New(intptr_t class_id,
10031:   static TypedDataViewPtr New(intptr_t class_id,
10096:   friend class Class;
10097:   friend class Object;
10098:   friend class TypedDataViewDeserializationCluster;
10101: class ByteBuffer : public AllStatic {
10119: class Pointer : public Instance {
10157:   friend class Class;
10160: class DynamicLibrary : public Instance {
10186:   friend class Class;
10193: class LinkedHashMap : public Instance {
10279:   class Iterator : ValueObject {
10323:   friend class Class;
10324:   friend class LinkedHashMapDeserializationCluster;
10327: class Closure : public Instance {
10397:   friend class Class;
10400: class Capability : public Instance {
10411:   friend class Class;
10414: class ReceivePort : public Instance {
10431:   friend class Class;
10434: class SendPort : public Instance {
10454:   friend class Class;
10459: class TransferableTypedDataPeer {
10486: class TransferableTypedData : public Instance {
10498:   friend class Class;
10502: class StackTrace : public Instance {
10556:   friend class Class;
10557:   friend class Debugger;
10560: class RegExpFlags {
10610: class RegExp : public Instance {
10629:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
10630:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
10764:   friend class Class;
10767: class WeakProperty : public Instance {
10796:   friend class Class;
10799: class MirrorReference : public Instance {
10828:   friend class Class;
10831: class UserTag : public Instance {
10864:   friend class Class;
10867: // Represents abstract FutureOr class in dart:async.
10868: class FutureOr : public Instance {
10884:   friend class Class;
10891:     return Smi::Class();
10894:   return Isolate::Current()->class_table()->At(raw()->GetClassId());
11052:                                 const Smi& class_id,
11055:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
11128: // This helper class can then be used via
11163: class ArrayOfTuplesView {
11167:   class Iterator;
11169:   class TupleView {
11193:     friend class Iterator;
11196:   class Iterator {
11246:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
154:   static const ClassId kClassId = k##object##Cid;                              \
302:   inline ClassPtr clazz() const;
561:     // Internal names are the true names of classes, fields,
565:     // The names of core implementation classes (like _OneByteString)
570:     //   private constructor        -> _MyClass@6b3832b.
571:     //   private named constructor  -> _MyClass@6b3832b.named
581:     //   _MyClass@6b3832b.      -> _MyClass
582:     //   _MyClass@6b3832b.named -> _MyClass.named
588:     // the names of core implementation classes are remapped to their
593:     //   _MyClass@6b3832b.      -> _MyClass
594:     //   _MyClass@6b3832b.named -> _MyClass.named
806:   static ClassPtr
948:   static intptr_t host_instance_size(ClassPtr clazz) {
951:   static intptr_t target_instance_size(ClassPtr clazz) {
1020:     return ObjectLayout::ClassIdTag::is_valid(value);
1027:   static intptr_t id_offset() { return OFFSET_OF(ClassLayout, id_); }
1029:     return OFFSET_OF(ClassLayout, num_type_arguments_);
1042:   ClassPtr Mixin() const;
1069:   // in superclass clauses.
1083:     return OFFSET_OF(ClassLayout, declaration_type_);
1101:     return OFFSET_OF(ClassLayout, type_parameters_);
1166:     return OFFSET_OF(ClassLayout, host_type_arguments_field_offset_in_words_);
1171:     return OFFSET_OF(ClassLayout, target_type_arguments_field_offset_in_words_);
1184:     return OFFSET_OF(ClassLayout, super_type_);
1188:   // |original_classes| only has an effect when reloading. If true and we
1189:   // are reloading, it will prefer the original classes to the replacement
1190:   // classes.
1191:   ClassPtr SuperClass(bool original_classes = false) const;
1230:   bool IsDartFunctionClass() const;
1233:   bool IsFutureClass() const;
1248:   static bool IsInFullSnapshot(ClassPtr cls) {
1283:   // |original_classes| only has an effect when reloading. If true and we
1284:   // are reloading, it will prefer the original classes to the replacement
1285:   // classes.
1286:   ArrayPtr OffsetToFieldMap(bool original_classes = false) const;
1337:     return RoundedAllocationSize(sizeof(ClassLayout));
1351:     return ClassLoadingBits::decode(raw_ptr()->state_bits_);
1376:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1377:            ClassLayout::kFinalized;
1382:     return ClassFinalizedBits::decode(raw_ptr()->state_bits_) ==
1383:            ClassLayout::kPreFinalized;
1425:     return ClassLayout::BinaryDeclarationOffset::decode(
1431:                     ClassLayout::BinaryDeclarationOffset::update(
1476:     return ClassLayout::IsDeclaredInBytecode::decode(
1484:                     ClassLayout::IsDeclaredInBytecode::update(
1539:   // Allocate instance classes.
1540:   static ClassPtr New(const Library& lib,
1545:   static ClassPtr NewNativeWrapper(const Library& library,
1549:   // Allocate the raw string classes.
1552:   // Allocate the raw TypedData classes.
1555:   // Allocate the raw TypedDataView/ByteDataView classes.
1558:   // Allocate the raw ExternalTypedData classes.
1562:   // Allocate the raw Pointer classes.
1601:   static int32_t host_instance_size_in_words(const ClassPtr cls) {
1605:   static int32_t target_instance_size_in_words(const ClassPtr cls) {
1613:   static int32_t host_next_field_offset_in_words(const ClassPtr cls) {
1617:   static int32_t target_next_field_offset_in_words(const ClassPtr cls) {
1625:   static int32_t host_type_arguments_field_offset_in_words(const ClassPtr cls) {
1630:       const ClassPtr cls) {
1653:   static ClassPtr NewCommon(intptr_t index);
1685:                                              ClassLayout::ClassFinalizedState,
1689:                                            ClassLayout::ClassLoadingState,
1737:   // This includes type arguments of a superclass and takes overlapping
1756:   static ClassPtr New(intptr_t id,
1762:   static ClassPtr NewInstanceClass();
1774: // Classification of type genericity according to type parameter owners.
1823:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1898:   classid_t expected_cid() const { return raw_ptr()->expected_cid_; }
1904:   static MonomorphicSmiableCallPtr New(classid_t expected_cid,
1975: // Object holding information about an IC: test classes and their
2040:   V(CheckClass)                                                                \
2077:   // Call site classification that is helpful for hot-reload. Call sites with
2319:   // to list the call site's observed receiver classes and targets.
2523:   ClassPtr Owner() const;
2525:   ClassPtr origin() const;
3511: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3518:   V(ProhibitsHoistingCheckClass)                                               \
4017:   ClassPtr Owner() const;
4535:   ClassDictionaryIterator(const Library& library,
4543:   ClassPtr GetNextClass();
4546:   void MoveToNextClass();
4550:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4629:   ClassPtr LookupClass(const String& name) const;
4630:   ClassPtr LookupClassAllowPrivate(const String& name) const;
4631:   ClassPtr SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4632:   ClassPtr LookupLocalClass(const String& name) const;
4891:   // Eagerly compile all classes and functions in the library.
4894:   // Finalize all classes in all libraries.
4915:   // helper methods and classes. Allow look up of private classes.
5052:                                   const Array& classes_cache,
5117:   void set_classes_cache(const Array& cache) const;
5118:   ClassPtr LookupClass(Thread* thread, const Smi& name_index) const;
5119:   ClassPtr InsertClass(Thread* thread,
7285:                                        classid_t cid,
7398:   // Names of internal classes are mapped to their public interfaces.
7599: // AbstractType is an abstract superclass.
7727:   // Names of internal classes are mapped to their public interfaces.
7745:   StringPtr ClassName() const;
8057:            AbstractType::Handle(type()).HasTypeClass();
9749:   static intptr_t ElementSizeInBytes(classid_t cid) {
9753:   static TypedDataElementType ElementType(classid_t cid) {
10069:     const classid_t cid = typed_data.GetClassId();
10809:   ClassPtr GetClassReferent() const;
10888: ClassPtr Object::clazz() const {
11161: //     classes (e.g. 'Code', 'Smi', 'Object')
300:                                   : raw()->ptr()->GetClassId();
330:   // Object::DictionaryName() returns String::null(). Only subclasses
1068:   // dynamic and type parameters declared in superclasses filled in as declared
1209:     return raw_ptr()->direct_subclasses_;
1212:   void ClearDirectSubclasses() const;
1368:     return SynthesizedClassBit::decode(raw_ptr()->state_bits_);
1670:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1686:                                              kClassFinalizedPos,
1687:                                              kClassFinalizedSize> {};
1690:                                            kClassLoadingPos,
1691:                                            kClassLoadingSize> {};
1695:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
1804:     return RoundedAllocationSize(sizeof(PatchClassLayout));
1806:   static bool IsInFullSnapshot(PatchClassPtr cls) {
1821:   static PatchClassPtr New();
2194:   void GetOneClassCheckAt(intptr_t index,
2200:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2201:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2217:   ICDataPtr AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2219:   ICDataPtr AsUnaryClassChecksForCid(intptr_t cid,
2226:   ICDataPtr AsUnaryClassChecksSortedByCount() const;
3409:       return IsTypedDataViewClassId(klass.id());
4895:   static ErrorPtr FinalizeAllClasses();
4939:   void EnsureTopLevelClassIsFinalized() const;
4959:   void InitClassDictionary() const;
5837:     return TargetOf(raw)->GetClassId();
5870:     return UnwrappedClassIdOf(obj.raw());
5875:   // UnwrappedClassOf(Wrap(r)) == UnwrappedClassOf(r) for all raw objects r,
5880:     if (!obj->IsWeakSerializationReference()) return obj->GetClassId();
5881:     return TargetClassIdOf(WeakSerializationReference::RawCast(obj));
6261:     return WeakSerializationReference::UnwrappedClassIdOf(raw->ptr()->owner_);
6874:   static inline ObjectPtr GetClassId(const Array& array, intptr_t index);
7100:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7600: // Subclasses of AbstractType are Type and TypeParameter.
8620:     return raw()->GetClassId() == kOneByteStringCid;
8624:     return raw()->GetClassId() == kTwoByteStringCid;
8628:     return raw()->GetClassId() == kExternalOneByteStringCid;
8632:     return raw()->GetClassId() == kExternalTwoByteStringCid;
8636:     return IsExternalStringClassId(raw()->GetClassId());
9348:   bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
9738:     return ElementSizeInBytes(raw()->GetClassId()) * Length();
9742:     return ElementType(raw()->GetClassId());
9746:     return element_size(ElementType(raw()->GetClassId()));
9756:     } else if (IsTypedDataClassId(cid)) {
9760:     } else if (IsTypedDataViewClassId(cid)) {
9765:       ASSERT(IsExternalTypedDataClassId(cid));
9919:     intptr_t cid = obj.raw()->GetClassId();
9920:     return IsTypedDataClassId(cid);
10004:     intptr_t cid = obj.raw()->GetClassId();
10005:     return IsExternalTypedDataClassId(cid);
10051:     intptr_t cid = data.raw()->GetClassId();
10052:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10053:     return IsExternalTypedDataClassId(cid);
10070:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10170:     intptr_t cid = obj.raw()->GetClassId();
10171:     return IsFfiDynamicLibraryClassId(cid);
10901:   intptr_t cid = value->GetClassIdMayBeSmi();
11071:   return array.At((index * kEntryLength) + kClassIdIndex);
github.com/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-planes/combined.js: [ master, ]
5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
685:  * Find elements by tag or class name.
688:  * - {string} .className Class name.
5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12064:      * tags that have a specific class name.
12069:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13797:     'intro-finale/items-needle-thread',
13798:     'intro-finale/items-needle',
15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
704:     if (params.className) {
705:       query += '.' + params.className;
710:     if (params.tagName && params.className) {
711:       var els = el.getElementsByClassName(params.className);
723:     } else if (params.className) {
724:       return el.getElementsByClassName(params.className);
727:     if (params.className) {
734:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
738:         if (el.className.match(regExp)) {
6532:                                             className: 'jsb' });
6547:                                             className: 'lsbb' });
12080:             el.className.indexOf(params.excludeClassName) == -1) {
12109:             (el.parentNode.className.indexOf('ds') != -1)) {
12121:                                             className: 'lsbb' });
12155:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12205:       // “View Google in Tablet | Classic” switcher.
709:   } else if (document.getElementsByClassName) {
12079:         if (!params.excludeClassName ||
12162:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-embedded/combined.js: [ master, ]
5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
686:  * Find elements by tag or class name.
689:  * - {string} .className Class name.
5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12033:      * tags that have a specific class name.
12038:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13843:             nItems = ['needle', 'noodles'];
15362:     'intro-finale/items-needle-thread',
15363:     'intro-finale/items-needle',
16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
705:     if (params.className) {
706:       query += '.' + params.className;
711:     if (params.tagName && params.className) {
712:       var els = el.getElementsByClassName(params.className);
724:     } else if (params.className) {
725:       return el.getElementsByClassName(params.className);
728:     if (params.className) {
735:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
739:         if (el.className.match(regExp)) {
6505:                                             className: 'jsb' });
6520:                                             className: 'lsbb' });
12049:             el.className.indexOf(params.excludeClassName) == -1) {
12078:             (el.parentNode.className.indexOf('ds') != -1)) {
12090:                                             className: 'lsbb' });
12124:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12174:       // “View Google in Tablet | Classic” switcher.
710:   } else if (document.getElementsByClassName) {
12048:         if (!params.excludeClassName ||
12131:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/apache/activemq:activemq-web/src/main/resources/org/apache/activemq/web/prototype.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/chromium/chromium:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
12088: const Class = function(info, mixin) {
8388:  function superPropertiesClass(constructor) {
10431: DomApiNative.prototype.classList;
11782:     static _finalizeClass() {
325:  * Wraps an ES6 class expression mixin such that the mixin is only applied
330:  * @param {T} mixin ES6 class expression mixin to wrap
353:     // copy inherited mixin set from the extended class, or the base class
379: class Debouncer {
1857: class StyleNode {
2490: class MixinMap {
2523: class ApplyShim {
3099: class CustomStyleInterface {
3224: class ApplyShimInterface {
3491: class DomModule extends HTMLElement {
4129:  * Element class mixin that provides basic meta-programming for creating one
4134:  * once at class definition time to create property accessors for properties
4143:  * @summary Element class mixin for reacting to property changes from
4149:      * @param {function(new:T)} superClass Class to apply mixin to.
4160:   class PropertiesChanged extends superClass {
4609:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
4726:  * Element class mixin that provides basic meta-programming for creating one
4735:  * -   Implement the `_propertiesChanged` callback on the class.
4736:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
4752:  * @summary Element class mixin for reacting to property changes from
4772:   class PropertyAccessors extends base {
5091:  * @summary Element class mixin that provides basic template parsing and stamping
5096:      * @param {function(new:T)} superClass Class to apply mixin to.
5106:   class TemplateStamp extends superClass {
5927:  * @param {Function} constructor Class that `_parseTemplate` is currently
5964:  * @param {Function} constructor Class that `_parseTemplate` is currently
6494:  * Element class mixin that provides meta-programming for Polymer's template
6498:  * property effects to an element class:
6525:  * @summary Element class mixin that provides meta-programming for Polymer's
6546:   class PropertyEffects extends propertyEffectsBase {
7111:      * Runs each class of effects for the batch of changed properties in
7674:     // -- static class methods ------------
7843:      *   bound template for the class. When true (as passed from
8046:           // when a class$ binding's initial literal value is set.
8047:           if (name == 'class' && node.hasAttribute('class')) {
8272: class HostStack {
8320:  * Registers a class prototype for telemetry purposes.
8382:   * Returns the super class constructor for the given class, if it is an
8386:   * @return {?PropertiesMixinConstructor} Super class constructor
8391:    // Note, the `PropertiesMixin` class below only refers to the class
8401:   * given class. Properties not in object format are converted to at
8431:  class PropertiesMixin extends base {
8466:     * Finalize an element class. This includes ensuring property
8468:     * `finalize` and finalizes the class constructor.
8484:     * @return {Object} Object containing properties for this class
8576:  * Element class mixin that provides the core API for Polymer's meta-programming
8581:  * used to configure Polymer's features for the class:
8617:  * The base class provides default implementations for the following standard
8636:  * @property importPath {string} Set to the value of the class's static
8640:  * @summary Element class mixin that provides the core API for Polymer's
8659:    * @param {PolymerElementConstructor} constructor Element class
8660:    * @return {PolymerElementProperties} Flattened properties for this class
8682:    * @param {PolymerElementConstructor} constructor Element class
8683:    * @return {Array} Array containing own observers for the given class
8746:    * @param {!PolymerElement} proto Element class prototype to add accessors
8800:    * @param {PolymerElementConstructor} klass Element class
8871:   class PolymerElement extends polymerElementBase {
8929:      *   this class
8954:      * Note that when subclassing, if the super class overrode the default
8959:      * If a subclass would like to modify the super class template, it should
8965:      *   class MySubClass extends MySuperClass {
8981:       // - constructor.template (this getter): the template for the class.
8983:       //     dom-module, or from the super class's template (or can be overridden
9033:      * @return {string} The import path for this element class
9067:      * Overrides the default `PropertyAccessors` to ensure class
9347:  * Element class mixin that provides API for adding Polymer's cross-platform
9357:  * @summary Element class mixin that provides API for adding Polymer's
9364:      * @param {function(new:T)} superClass Class to apply mixin to.
9373:       class GestureEventListeners extends superClass {
9748:  * Class that listens for changes (additions or removals) to
9769:  * class TestSelfObserve extends PolymerElement {
9785:  * @summary Class that listens for changes (additions or removals) to
9789: let FlattenedNodesObserver = class {
10097:  * Node API wrapper class returned from `Polymer.dom.(target)` when
10102: class DomApiNative {
10315:  * Event API wrapper class returned from `dom.(target)` when
10318: class EventApi {
10446:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
10552:  * Element class mixin that provides Polymer's "legacy" API intended to be
10563:  * @summary Element class mixin that provides Polymer's "legacy" API
10593:   class LegacyElement extends legacyElementBase {
10611:      *  closure for some reason even in a static method, rather than the class
10695:      * add support for class initialization via the `_registered` callback.
10721:      * Users may override this method to perform class registration time
10723:      * only once for the class.
11424:      * Toggles a CSS class on or off.
11426:      * @param {string} name CSS class name
11427:      * @param {boolean=} bool Boolean to force the class on or off.
11428:      *    When unspecified, the state of the class will be reversed.
11672: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
11673: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
11745:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
11746:   made. The list of behaviors was previously made into one generated class per
11751:   The generated class is directly tied to the info object and behaviors
11766:  * @param {function(new:HTMLElement)} Base base class to extend with info object
11768:  * @return {function(new:HTMLElement)} Generated class
11774:   // manages behavior and lifecycle processing (filled in after class definition)
11779:   class PolymerGenerated extends Base {
11861:       // only proceed if the generated class' prototype has not been registered.
11867:         // copy properties onto the generated class lazily if we're optimizing,
11872:         // and not the generated class prototype; if the element has been
11988:     // NOTE: ensure the behavior is extending a class with
11995:     // get flattened, deduped list of behaviors *not* already on super class
12019:  * Generates a class that extends `LegacyElement` based on the
12023:  * to the generated class.
12082:  *   to become class methods.
12084:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
12086:  * @return {function(new:HTMLElement)} Generated class
12090:     console.warn('Polymer.Class requires `info` argument');
12111:  * Legacy class factory and registration helper for defining Polymer
12116:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
12117:  *     customElements.define(info.is, Class(info));
12119:  * See `Class` for details on valid legacy metadata format for `info`.
12125:  *   to become class methods.
12126:  * @return {function(new: HTMLElement)} Generated class
12130:   // if input is a `class` (aka a function with a prototype), use the prototype
12136:     klass = Polymer.Class(info);
12142: Polymer.Class = Class;
12175:  * Element class mixin to skip strict dirty-checking for objects and arrays
12210:  * @summary Element class mixin to skip strict dirty-checking for objects
12220:   class MutableData extends superClass {
12249:  * Element class mixin to add the optional ability to skip strict
12285:  * @summary Element class mixin to optionally skip strict dirty-checking
12295:   class OptionalMutableData extends superClass {
12348: // Base class for HTMLTemplateElement extension that has property effects
12350: // class only because Babel (incorrectly) requires super() in the class
12392:  * Base class for TemplateInstance.
12397: const templateInstanceBase = PropertyEffects(class {});
12405: class TemplateInstanceBase extends templateInstanceBase {
12627:  * @suppress {missingProperties} class.prototype is not defined for some reason
12643:    * Anonymous class created by the templatize
12647:   let klass = class extends templatizerBase { };
12656:  * @suppress {missingProperties} class.prototype is not defined for some reason
12661:     // Provide data API and property effects on memoized template class
12671:         class TemplatizedTemplate extends templatizedBase {};
12741:  * Returns an anonymous `PropertyEffects` class bound to the
12742:  * `<template>` provided.  Instancing the class will result in the
12762:  *    method on the generated class should be called to forward host
12771:  * - `mutableData`: When `true`, the generated class will skip strict
12801:  * `templatize()` return the same class for all duplicates of a template.
12802:  * The class returned from `templatize()` is generated only once using
12814:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
12832:   // Get memoized base class for the prototypical template, which
12845:   // Subclass base class and add reference for this specific template
12847:   let klass = class TemplateInstance extends baseClass {};
12977:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
12983:    * @param {boolean=} mutableData When `true`, the generated class will skip
13002:    * returned is an instance of the anonymous class generated by `templatize`
13075: class DomBind extends domBindBase {
13181:  * Class representing a static string value which can be used to filter
13182:  * strings by asseting that they have been created via this class. The
13185: class LiteralString {
13252:  *         <div class="shadowed">${this.partialTemplate}</div>
13280:  * Base class that provides the core API for Polymer's meta-programming
13290:  * @summary Custom element base class that provides the core API for Polymer's
13345:  * class EmployeeList extends PolymerElement {
13416: class DomRepeat extends domRepeatBase {
14052: class DomIf extends PolymerElement {
14348:   class ArraySelectorMixin extends elementBase {
14666:  * class EmployeeList extends PolymerElement {
14719: class ArraySelector extends baseArraySelector {
14864: class CustomStyle extends HTMLElement {
2356:         // remove build comment so it is not needlessly copied into every element instance
4133:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
4150:      * @return {function(new:T)} superClass with mixin applied.
4152:     (superClass) => {
4156:    * @mixinClass
4755: const PropertyAccessors = dedupingMixin(superClass => {
4763:    const base = PropertiesChanged(superClass);
4767:    * @mixinClass
5097:      * @return {function(new:T)} superClass with mixin applied.
5099:     (superClass) => {
5103:    * @mixinClass
6528: const PropertyEffects = dedupingMixin(superClass => {
6537:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
6541:    * @mixinClass
6979:      * Overrides superclass implementation.
7991:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8025:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8086:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8372: const PropertiesMixin = dedupingMixin(superClass => {
8379:  const base = PropertiesChanged(superClass);
8426:   * @mixinClass
8436:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8448:     * Finalizes an element definition, including ensuring any super classes
8451:     * `_finalizeClass` to finalize each constructor in the prototype chain.
8456:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
8461:        this._finalizeClass();
8472:    static _finalizeClass() {
8481:     * from super classes. Properties not in object format are converted to
8490:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
8703:    * these values may not be changed. For example, a subclass cannot
8739:    * reflectToAttribute property not do so in a subclass. We've chosen to
8741:    * For example, a readOnly effect generates a special setter. If a subclass
8866:    * @mixinClass
8882:      * Override of PropertiesMixin _finalizeClass to create observers and
8886:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8888:     static _finalizeClass() {
8889:       super._finalizeClass();
8955:      * implementation and the subclass would like to provide an alternate
8970:      *         subContent.textContent = 'This came from MySubClass';
8988:       //     constructor.template, saved in _finalizeClass(). Note that before
9001:           // Next look for superclass template (call the super impl this
9002:           // way so that `this` points to the superclass)
9297:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
9313:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
9365:      * @return {function(new:T)} superClass with mixin applied.
9367:     (superClass) => {
9370:        * @mixinClass
10048:  * Forces several classes of asynchronously queued tasks to flush:
10455:   // Note, `classList` is here only for legacy compatibility since it does not
10458:     'classList'
10490:   // Properties that should return the logical, not composed tree. Note, `classList`
10497:     'childNodes', 'children', 'classList'
10588:    * @mixinClass
11433:     toggleClass(name, bool, node) {
11436:         bool = !node.classList.contains(name);
11439:         node.classList.add(name);
11441:         node.classList.remove(name);
11742: /* Note about construction and extension of legacy classes.
11748:   manually. Note, there may *still* be multiple generated classes in the
11753:   behaviors not active on the superclass. In order to call through to the
11761:   and not `_finalizeClass`.
11781:     // explicitly not calling super._finalizeClass
11783:       // if calling via a subclass that hasn't been generated, pass through to super
11785:         super._finalizeClass();
11865:         // ensure superclass is registered first.
12213: const MutableData = dedupingMixin(superClass => {
12217:    * @mixinClass
12288: const OptionalMutableData = dedupingMixin(superClass => {
12291:    * @mixinClass
12383: // Applies a DataTemplate subclass to a <template> instance
12629: function createTemplatizerClass(template, templateInfo, options) {
12662:     let klass = templateInfo.templatizeTemplateClass;
12670:       klass = templateInfo.templatizeTemplateClass =
12838:   let baseClass = templateInfo.templatizeInstanceClass;
12839:   if (!baseClass) {
12840:     baseClass = createTemplatizerClass(template, templateInfo, options);
12841:     templateInfo.templatizeInstanceClass = baseClass;
14333: let ArraySelectorMixin = dedupingMixin(superClass => {
14340:   let elementBase = ElementMixin(superClass);
14344:    * @mixinClass
4942:      * `__dataProto`, and it is up to the subclasser to decide how/when
8580:  * Subclassers may provide the following static getters to return metadata
8705:    * by subclasses.
8738:    * effects via subclassing. For example, a user might want to make a
11772: function GenerateClassFromInfo(info, Base, behaviors) {
12094:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
chromium.googlesource.com/chromium/src/third_party:polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
github.com/apache/trafficcontrol:traffic_portal/app/src/package-lock.json: [ master, ]
1251:                         "needle": "^2.2.1",
100:                 "class-utils": "^0.3.5",
718:                 "posix-character-classes": "^0.1.0",
384:         "class-utils": {
386:             "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1234:                 "needle": {
2213:         "posix-character-classes": {
2215:             "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
skia.googlesource.com/buildbot:autoroll/package-lock.json: [ master, ]
1468:             "needle": "^2.2.1",
2578:         "xml-char-classes": "^1.0.0"
1449:         "needle": {
4003:     "xml-char-classes": {
4005:       "resolved": "https://registry.npmjs.org/xml-char-classes/-/xml-char-classes-1.0.0.tgz",
skia.googlesource.com/buildbot:task_scheduler/package-lock.json: [ master, ]
1376:             "needle": "^2.2.1",
2446:         "xml-char-classes": "^1.0.0"
1357:         "needle": {
3772:     "xml-char-classes": {
3774:       "resolved": "https://registry.npmjs.org/xml-char-classes/-/xml-char-classes-1.0.0.tgz",
github.com/GoogleChrome/puppeteer:src/Accessibility.ts: [ master, ]
70:     let needle = defaultRoot;
50: export class Accessibility {
72:       needle = defaultRoot.find(
75:       if (!needle) return null;
77:     if (!interestingOnly) return this.serializeTree(needle)[0];
81:     if (!interestingNodes.has(needle)) return null;
82:     return this.serializeTree(needle, interestingNodes)[0];
113: class AXNode {
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++)
android.googlesource.com/platform/superproject:external/swiftshader/third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
48:   Record *Class;
89: class SearchableTableEmitter {
526:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
648:     Enum->Class = Records.getClass(FilterClass);
649:     if (!Enum->Class)
713:     Record *Class = NameRec.second.get();
714:     if (Class->getSuperClasses().size() != 1 ||
715:         !Class->isSubClassOf(SearchableTable))
718:     StringRef TableName = Class->getName();
720:     if (!Class->isValueUnset("EnumNameField")) {
721:       StringRef NameField = Class->getValueAsString("EnumNameField");
723:       if (!Class->isValueUnset("EnumValueField"))
724:         ValueField = Class->getValueAsString("EnumValueField");
727:       Enum->Name = (Twine(Class->getName()) + "Values").str();
728:       Enum->PreprocessorGuard = Class->getName().upper();
729:       Enum->Class = Class;
737:     Table->Name = (Twine(Class->getName()) + "sList").str();
738:     Table->PreprocessorGuard = Class->getName().upper();
739:     Table->CppTypeName = Class->getName();
741:     for (const RecordVal &Field : Class->getValues()) {
757:          Class->getValueAsListOfStrings("SearchableFields")) {
616:   Record *IntrinsicClass = Records.getClass("Intrinsic");
617:   Record *InstructionClass = Records.getClass("Instruction");
620:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
622:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
629:   // Emit tables in a deterministic order to avoid needless rebuilds.
647:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
650:       PrintFatalError(Twine("Enum FilterClass '") + FilterClass +
654:                        Records.getAllDerivedDefinitions(FilterClass));
679:                                     TableRec->getValueAsString("FilterClass")));
711:   Record *SearchableTable = Records.getClass("SearchableTable");
131:       return DI->getDef()->isSubClassOf("Intrinsic");
524:     if (TypeRec->isSubClassOf("GenericEnum")) {
712:   for (auto &NameRec : Records.getClasses()) {
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].className) {
67:                                         Microformats[name].className);
72:         if (altClass.length > 0) {
148:       if (Microformats[i].className) {
149:         if (Microformats.matchClass(node, Microformats[i].className)) {
185:       if (Microformats[mfname].className) {
220:         if (Microformats[i].className) {
221:           if (Microformats.matchClass(node, Microformats[i].className)) {
348:         if (!Microformats.matchClass(propnode, "value")) {
434:       if (Microformats.matchClass(propnode, "value")) {
464:         if (Microformats.matchClass(propnode, "value")) {
599:           if (!Microformats.matchClass(in_node, Microformats[microformat].className)) {
605:       if ((Microformats[microformat].className) && in_node.ownerDocument) {
696:       if (!in_mfnode.origNode && Microformats[mfname].className && in_mfnode.ownerDocument) {
728:           if (Microformats[Microformats.list[j]].className) {
826:               tempNode.className = headerNode.className;
1017:    * Retrieve elements matching all classes listed in a space-separated string.
1021:    * @param  className        A space separated list of classenames
1025:   getElementsByClassName: function getElementsByClassName(rootNode, className)