Found 135621 results in 4221 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.
138: 	ClassMeta(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps) {
220: 	ClassMeta(ClassMeta<T> mainType, ClassMeta<?> keyType, ClassMeta<?> valueType, ClassMeta<?> elementType) {
262: 	ClassMeta(ClassMeta<?>[] args) {
301: 	private final class ClassMetaBuilder<T> {
302: 		Class<T> innerClass;
304: 		Class<? extends T> implClass;
309: 			isMemberClass = false,
345: 		ClassMetaBuilder(Class<T> innerClass, BeanContext beanContext, Class<? extends T> implClass, PojoSwap<T,?>[] swaps, PojoSwap<?,?>[] childPojoSwaps) {
938: 	public Class<T> getInnerClass() {
1144: 	public boolean isClass() {
1461: 	public boolean isMemberClass() {
752: 		private ClassMeta<?> findClassMeta(Class<?> c) {
817: 	public ClassCategory getClassCategory() {
951: 	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<?,?>>
98: 		elementType,                                         // If ARRAY or COLLECTION, the element class type.
99: 		keyType,                                             // If MAP, the key class type.
100: 		valueType;                                           // If MAP, the value class type.
101: 	private final BeanMeta<T> beanMeta;                     // The bean meta for this bean class (if it's a bean).
103: ...(7 bytes skipped)...ropertyName,                                    // The property name of the _type property for this class and subclasses.
105: 		dictionaryName;                                      // The dictionary name of this class if it has one.
107: 	private final InvocationHandler invocationHandler;      // The invocation handler for this class (if it has one).
108: 	private final BeanRegistry beanRegistry;                // The bean registry of this class meta (if it has one).
111: 	private final Map<Class<?>,Mutater<?,T>> fromMutaters = new ConcurrentHashMap<>();
112: 	private final Map<Class<?>,Mutater<T,?>> toMutaters = new ConcurrentHashMap<>();
119: 	 * Construct a new {@code ClassMeta} based on the specified {@link Class}.
121: 	 * @param innerClass The class being wrapped.
124: 	 * 	For interfaces and abstract classes, this represents the "real" class to instantiate.
127: 	 * 	The {@link PojoSwap} programmatically associated with this class.
130: 	 * 	The child {@link PojoSwap PojoSwaps} programmatically associated with this class.
131: 	 * 	These are the <c>PojoSwaps</c> that have normal classes that are subclasses of this class.
135: 	 * 	Used for delayed initialization when the possibility of class reference loops exist.
146: 			// We always immediately add this class meta to the bean context cache so that we can resolve recursive references.
196: 	private static boolean isCacheable(Class<?> c) {
218: 	 * Used for creating Map and Collection class metas that shouldn't be cached.
263: 		this.innerClass = (Class<T>) Object[].class;
337: 		ConcurrentHashMap<Class<?>,PojoSwap<?,?>>
361: 			Class<T> c = innerClass;
379: 				else if (c == void.class || c == Void.class)
382: 				if (ci.isChildOf(Delegate.class))
385: 				if (c == Object.class)
389: 				else if (c.equals(Class.class))
390: 					cc = ClassCategory.CLASS;
391: 				else if (ci.isChildOf(Method.class))
393: 				else if (ci.isChildOf(CharSequence.class)) {
394: 					if (c.equals(String.class))
399: 				else if (ci.isChildOf(Number.class)) {
400: 					if (ci.isChildOfAny(Float.class, Double.class))
405: 				else if (ci.isChildOf(Collection.class))
407: 				else if (ci.isChildOf(Map.class)) {
408: 					if (ci.isChildOf(BeanMap.class))
413: 				else if (c == Character.class)
415: 				else if (c == Boolean.class)
417: 				else if (ci.isChildOfAny(Date.class, Calendar.class))
421: 				else if (ci.isChildOfAny(URL.class, URI.class) || bc.hasAnnotation(Uri.class, c))
423: 				else if (ci.isChildOf(Reader.class))
425: 				else if (ci.isChildOf(InputStream.class))
427: 				else if (ci.is(Optional.class))
437: 			// parse() is used by the java logging Level class.
438: 			// forName() is used by Class and Charset
442: ...(23 bytes skipped)...C, PUBLIC, NOT_DEPRECATED) && m.hasName(methodName) && m.hasReturnType(c) && m.hasParamTypes(String.class)) {
452: ...(8 bytes skipped)...m.isAll(PUBLIC, NOT_DEPRECATED, STATIC) && m.hasName("example") && m.hasFuzzyParamTypes(BeanSession.class)) {
459: 				if (bc.hasAnnotation(ParentProperty.class, f)) {
465: 				if (bc.hasAnnotation(NameProperty.class, f)) {
474: 				if (bc.hasAnnotation(Example.class, f)) {
484: 				if (bc.hasAnnotation(ParentProperty.class, m)) {
490: 				if (bc.hasAnnotation(NameProperty.class, m)) {
499: 				if (bc.hasAnnotation(Example.class, m)) {
500: 					if (! (m.isStatic() && m.hasFuzzyParamTypes(BeanSession.class) && ci.isParentOf(m.getReturnType().inner())))
501: 						throw new Class...(22 bytes skipped)..., "@Example used on invalid method ''{0}''.  Must be static and return an instance of the declaring class.", m);
514: 					if (pt.size() == (isMemberClass ? 1 : 0) && c != Object.class && ! isAbstract) {
518: 						if (arg.is(String.class))
530: 			if (innerClass != Object.class) {
559: 						keyType = findClassMeta(Object.class);
560: 						valueType = findClassMeta(Object.class);
570: 						elementType = findClassMeta(Object.class);
609: 				for (Bean b : bc.getAnnotations(Bean.class, c)) {
626: 				for (Example e : bc.getAnnotations(Example.class, c))
649: 						Iterator<? extends Enum> i = EnumSet.allOf((Class<? extends Enum>)c).iterator();
665: 					case CLASS:
680: 			this.stringMutater = Mutaters.get(String.class, c);
685: 				List<Bean> ba = info.getAnnotations(Bean.class, bc);
696: 				List<Marshalled> ba = info.getAnnotations(Marshalled.class, bc);
708: 				for (Swap swap : bc.getAnnotations(Swap.class, innerClass))
710: 				for (Swaps swaps : bc.getAnnotations(Swaps.class, innerClass))
729: 			Class<?> c = s.value();
730: 			if (c == Null.class)
734: 			if (ci.isChildOf(PojoSwap.class)) {
735: 				PojoSwap ps = castOrCreate(PojoSwap.class, c);
743: 			if (ci.isChildOf(Surrogate.class)) {
749: 			throw new ClassMetaRuntimeException(c, "Invalid swap class ''{0}'' specified.  Must extend from PojoSwap or Surrogate.", c);
762: 	 * Returns the {@link ClassInfo} wrapper for the underlying class.
764: 	 * @return The {@link ClassInfo} wrapper for the underlying class, never <jk>null</jk>.
771: 	 * Returns the type property name associated with this class and subclasses.
777: 	 * 	The type property name associated with this bean class, or <jk>null</jk> if there is no explicit type
785: 	 * Returns the bean dictionary name associated with this class.
791: 	 * 	The type name associated with this bean class, or <jk>null</jk> if there is no type name defined or this
799: 	 * Returns the bean registry for this class.
803: 	 * defined on the class, regardless of whether the class is an actual bean.
806: 	 * @return The bean registry for this class, or <jk>null</jk> if no bean registry is associated with it.
813: 	 * Returns the category of this class.
815: 	 * @return The category of this class.
822: 	 * Returns <jk>true</jk> if this class is a superclass of or the same as the specified class.
824: 	 * @param c The comparison class.
825: 	 * @return <jk>true</jk> if this class is a superclass of or the same as the specified class.
827: 	public boolean isAssignableFrom(Class<?> c) {
832: 	 * Returns <jk>true</jk> if this class is a subclass of or the same as the specified class.
834: 	 * @param c The comparison class.
835: 	 * @return <jk>true</jk> if this class is a subclass of or the same as the specified class.
837: 	public boolean isInstanceOf(Class<?> c) {
842: 	 * Returns <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
848: 	 * @return <jk>true</jk> if this class or any child classes has a {@link PojoSwap} associated with it.
855: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the normal class of one of the
856: 	 * child POJO swaps associated with this class.
858: 	 * @param normalClass The normal class being resolved.
861: 	protected PojoSwap<?,?> getChildPojoSwapForSwap(Class<?> normalClass) {
882: 	 * Returns the {@link PojoSwap} where the specified class is the same/subclass of the swap class of one of the child
883: 	 * POJO swaps associated with this class.
885: 	 * @param swapClass The swap class being resolved.
888: 	protected PojoSwap<?,?> getChildPojoSwapForUnswap(Class<?> swapClass) {
909: 	 * Locates the no-arg constructor for the specified class.
913: 	 * If class is abstract, always returns <jk>null</jk>.
916: 	 * @param c The class from which to locate the no-arg constructor.
921: 	protected static <T> Constructor<? extends T> findNoArgConstructor(Class<?> c, Visibility v) {
934: 	 * Returns the {@link Class} object that this class type wraps.
936: 	 * @return The wrapped class object.
943: 	 * Returns the serialized (swapped) form of this class if there is an {@link PojoSwap} associated with it.
948: 	 * @return The serialized class type, or this object if no swap is associated with the class.
957: 	 * Returns the example of this class.
962: 	 * @return The serialized class type, or this object if no swap is associated with the class.
969: 				return session.getContext().getContext(JsonParser.class).parse(example, this);
1012: 	 * For array and {@code Collection} types, returns the class type of the components of the array or
1015: 	 * @return The element class type, or <jk>null</jk> if this class is not an array or Collection.
1022: 	 * For {@code Map} types, returns the class type of the keys of the {@code Map}.
1024: 	 * @return The key class type, or <jk>null</jk> if this class is not a Map.
1031: 	 * For {@code Map} types, returns the class type of the values of the {@code Map}.
1033: 	 * @return The value class type, or <jk>null</jk> if this class is not a Map.
1040: 	 * Returns <jk>true</jk> if this class implements {@link Delegate}, meaning it's a representation of some other
1043: 	 * @return <jk>true</jk> if this class implements {@link Delegate}.
1050: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map}.
1052: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map}.
1059: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1061: 	 * @return <jk>true</jk> if this class is a subclass of {@link Map} or it's a bean.
1068: 	 * Returns <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1070: 	 * @return <jk>true</jk> if this class is a subclass of {@link BeanMap}.
1077: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection}.
1079: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection}.
1086: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Optional}.
1088: 	 * @return <jk>true</jk> if this class is a subclass of {@link Optional}.
1095: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1097: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array.
1104: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1106: 	 * @return <jk>true</jk> if this class is a subclass of {@link Collection} or is an array or {@link Optional}.
1113: 	 * Returns <jk>true</jk> if this class extends from {@link Set}.
1115: 	 * @return <jk>true</jk> if this class extends from {@link Set}.
1118: 		return cc == COLLECTION && info.isChildOf(Set.class);
1122: 	 * Returns <jk>true</jk> if this class extends from {@link List}.
1124: 	 * @return <jk>true</jk> if this class extends from {@link List}.
1127: 		return cc == COLLECTION && info.isChildOf(List.class);
1131: 	 * Returns <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1133: 	 * @return <jk>true</jk> if this class is <code><jk>byte</jk>[]</code>.
1136: 		return cc == ARRAY && this.innerClass == byte[].class;
1140: 	 * Returns <jk>true</jk> if this class is {@link Class}.
1142: 	 * @return <jk>true</jk> if this class is {@link Class}.
1145: 		return cc == ClassCategory.CLASS;
1149: 	 * Returns <jk>true</jk> if this class is {@link Method}.
1151: 	 * @return <jk>true</jk> if this class is {@link Method}.
1158: 	 * Returns <jk>true</jk> if this class is an {@link Enum}.
1160: 	 * @return <jk>true</jk> if this class is an {@link Enum}.
1167: 	 * Returns <jk>true</jk> if this class is an array.
1169: 	 * @return <jk>true</jk> if this class is an array.
1176: 	 * Returns <jk>true</jk> if this class is a bean.
1178: 	 * @return <jk>true</jk> if this class is a bean.
1185: 	 * Returns <jk>true</jk> if this class is {@link Object}.
1187: 	 * @return <jk>true</jk> if this class is {@link Object}.
1194: 	 * Returns <jk>true</jk> if this class is not {@link Object}.
1196: 	 * @return <jk>true</jk> if this class is not {@link Object}.
1203: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Number}.
1205: 	 * @return <jk>true</jk> if this class is a subclass of {@link Number}.
1212: 	 * Returns <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1214: 	 * @return <jk>true</jk> if this class is a subclass of {@link Float} or {@link Double}.
1221: 	 * Returns <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1223: 	 * @return <jk>true</jk> if this class is either {@link Float} or <jk>float</jk>.
1226: 		return innerClass == Float.class || innerClass == float.class;
1230: 	 * Returns <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1232: 	 * @return <jk>true</jk> if this class is either {@link Double} or <jk>double</jk>.
1235: 		return innerClass == Double.class || innerClass == double.class;
1239: 	 * Returns <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1241: 	 * @return <jk>true</jk> if this class is either {@link Short} or <jk>short</jk>.
1244: 		return innerClass == Short.class || innerClass == short.class;
1248: 	 * Returns <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1250: 	 * @return <jk>true</jk> if this class is either {@link Integer} or <jk>int</jk>.
1253: 		return innerClass == Integer.class || innerClass == int.class;
1257: 	 * Returns <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1259: 	 * @return <jk>true</jk> if this class is either {@link Long} or <jk>long</jk>.
1262: 		return innerClass == Long.class || innerClass == long.class;
1268: 	 * @param c The class to test against.
1271: 	public boolean isType(Class<?> c) {
1276: 	 * Returns <jk>true</jk> if this class is a {@link Boolean}.
1278: 	 * @return <jk>true</jk> if this class is a {@link Boolean}.
1285: 	 * Returns <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1287: 	 * @return <jk>true</jk> if this class is a subclass of {@link CharSequence}.
1294: 	 * Returns <jk>true</jk> if this class is a {@link String}.
1296: 	 * @return <jk>true</jk> if this class is a {@link String}.
1303: 	 * Returns <jk>true</jk> if this class is a {@link Character}.
1305: 	 * @return <jk>true</jk> if this class is a {@link Character}.
1312: 	 * Returns <jk>true</jk> if this class is a primitive.
1314: 	 * @return <jk>true</jk> if this class is a primitive.
1321: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1323: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar}.
1330: 	 * Returns <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1332: 	 * @return <jk>true</jk> if this class is a {@link Date} or {@link Calendar} or {@link Temporal}.
1335: 		return cc == DATE || info.isChildOf(Temporal.class);
1339: 	 * Returns <jk>true</jk> if this class is a {@link Date}.
1341: 	 * @return <jk>true</jk> if this class is a {@link Date}.
1344: 		return cc == DATE && info.isChildOf(Date.class);
1348: 	 * Returns <jk>true</jk> if this class is a {@link Temporal}.
1350: 	 * @return <jk>true</jk> if this class is a {@link Temporal}.
1353: 		return info.isChildOf(Temporal.class);
1357: 	 * Returns <jk>true</jk> if this class is a {@link Calendar}.
1359: 	 * @return <jk>true</jk> if this class is a {@link Calendar}.
1362: 		return cc == DATE && info.isChildOf(Calendar.class);
1366: 	 * Returns <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1368: 	 * @return <jk>true</jk> if this class is a {@link URI} or {@link URL}.
1375: 	 * Returns <jk>true</jk> if this class is a {@link Reader}.
1377: 	 * @return <jk>true</jk> if this class is a {@link Reader}.
1384: 	 * Returns <jk>true</jk> if this class is an {@link InputStream}.
1386: 	 * @return <jk>true</jk> if this class is an {@link InputStream}.
1393: 	 * Returns <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1395: 	 * @return <jk>true</jk> if this class is {@link Void} or <jk>void</jk>.
1439: 	 * @return <jk>true</jk> if instance of this class can be null.
1448: 	 * Returns <jk>true</jk> if this class is abstract.
1450: 	 * @return <jk>true</jk> if this class is abstract.
1457: 	 * Returns <jk>true</jk> if this class is an inner class.
1459: 	 * @return <jk>true</jk> if this class is an inner class.
1466: 	 * All public methods on this class including static methods.
1471: 	 * @return The public methods on this class.
1478: 	 * Returns the {@link PojoSwap} associated with this class that's the best match for the specified session.
1482: 	 * 	<br>If multiple swaps are associated with a class, only the first one with a matching media type will
1485: 	 * 	The {@link PojoSwap} associated with this class, or <jk>null</jk> if there are no POJO swaps associated with
1486: 	 * 	this class.
1507: 	 * Returns the builder swap associated with this class.
1510: 	 * @return The builder swap associated with this class, or <jk>null</jk> if it doesn't exist.
1517: 	 * Returns the {@link BeanMeta} associated with this class.
1520: 	 * 	The {@link BeanMeta} associated with this class, or <jk>null</jk> if there is no bean meta associated with
1521: 	 * 	this class.
1528: 	 * Returns the no-arg constructor for this class.
1530: 	 * @return The no-arg constructor for this class, or <jk>null</jk> if it does not exist.
1537: 	 * Returns the interface proxy invocation handler for this class.
1546: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1548: 	 * @return <jk>true</jk> if a new instance of this class can be constructed.
1563: 	 * Returns <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1564: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1565: 	 * the defining class.
1568: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1570: 	 * 	<jk>true</jk> if a new instance of this class can be created within the context of the specified outer object.
1579: 	 * Returns <jk>true</jk> if this class can be instantiated as a bean.
1580: 	 * Returns <jk>false</jk> if this is a non-static member class and the outer object does not match the class type of
1581: 	 * the defining class.
1584: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1599: 	 * Returns <jk>true</jk> if this class can call the {@link #newInstanceFromString(Object, String)} method.
1602: 	 * 	The outer class object for non-static member classes.
1604: 	 * @return <jk>true</jk> if this class has a no-arg constructor or invocation handler.
1611: 				return outer != null && stringConstructor.hasParamTypes(outer.getClass(), String.class);
1640: 	 * Returns the reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1642: 	 * @return The reason why this class is not a bean, or <jk>null</jk> if it is a bean.
1669: 	 * @return The default value, or <jk>null</jk> if this class type is not a primitive.
1705: 	 * Create a new instance of the main class of this declared type from a <c>String</c> input.
1708: 	 * In order to use this method, the class must have one of the following methods:
1716: 	 * 	The outer class object for non-static member classes.  Can be <jk>null</jk> for non-member or static classes.
1725: 			return (T)Enum.valueOf((Class<? extends Enum>)this.innerClass, arg);
1741: 		throw new InstantiationError("No string constructor or valueOf(String) method found for class '"+getInnerClass().getName()+"'");
1745: 	 * Create a new instance of the main class of this declared type.
1759: 			return (T)Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[] { getInnerClass(), java.io.Serializable.class }, h);
1769: 	 * 	The instance of the owning object of the member class instance.
1770: 	 * 	Can be <jk>null</jk> if instantiating a non-member or static class.
1784: 	 * @param cm The class meta to compare to.
1785: 	 * @return <jk>true</jk> if the specified class-meta is equivalent to this one.
1799: 	 * Same as {@link #toString()} except use simple class names.
1801: 	 * @param simple Print simple class names only (no package).
1812: 	 * @param simple Print simple class names only (no package).
1826: 			return sb.append(BeanMap.class.getName()).append('<').append(n).append('>');
1833: 	 * Returns <jk>true</jk> if the specified object is an instance of this class.
1836: 	 * This is a simple comparison on the base class itself and not on any generic parameters.
1839: 	 * @return <jk>true</jk> if the specified object is an instance of this class.
1848: 	 * Returns a readable name for this class (e.g. <js>"java.lang.String"</js>, <js>"boolean[]"</js>).
1850: 	 * @return The readable name for this class.
1857: 	 * Shortcut for calling {@link Class#getName()} on the inner class of this metadata.
1859: 	 * @return The  name of the inner class.
1866: 	 * Shortcut for calling {@link Class#getSimpleName()} on the inner class of this metadata.
1868: 	 * @return The simple name of the inner class.
1875: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1877: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a Reader.
1880: 		return hasMutaterFrom(Reader.class);
1884: 	 * Returns the transform for this class for creating instances from a Reader.
1889: 		return getFromMutater(Reader.class);
1893: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1895: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from an InputStream.
1898: 		return hasMutaterFrom(InputStream.class);
1902: 	 * Returns the transform for this class for creating instances from an InputStream.
1907: 		return getFromMutater(InputStream.class);
1911: 	 * Returns <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1913: 	 * @return <jk>true</jk> if this class has a transform associated with it that allows it to be created from a String.
1920: 	 * Returns the transform for this class for creating instances from a String.
1929: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1931: 	 * @param c The class type to convert from.
1932: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1934: 	public boolean hasMutaterFrom(Class<?> c) {
1939: 	 * Returns <jk>true</jk> if this class can be instantiated from the specified type.
1941: 	 * @param c The class type to convert from.
1942: 	 * @return <jk>true</jk> if this class can be instantiated from the specified type.
1949: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1951: 	 * @param c The class type to convert from.
1952: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1954: 	public boolean hasMutaterTo(Class<?> c) {
1959: 	 * Returns <jk>true</jk> if this class can be transformed to the specified type.
1961: 	 * @param c The class type to convert from.
1962: 	 * @return <jk>true</jk> if this class can be transformed to the specified type.
1969: 	 * Transforms the specified object into an instance of this class.
1981: 	 * Transforms the specified object into an instance of this class.
1984: 	 * @param c The class
1988: 	public <O> O mutateTo(Object o, Class<O> c) {
1994: 	 * Transforms the specified object into an instance of this class.
1997: 	 * @param c The class
2005: 	 * Returns the transform for this class for creating instances from other object types.
2007: 	 * @param c The transform-from class.
2011: 	public <I> Mutater<I,T> getFromMutater(Class<I> c) {
2025: 	 * Returns the transform for this class for creating instances from other object types.
2027: 	 * @param c The transform-from class.
2031: 	public <O> Mutater<T,O> getToMutater(Class<O> c) {
2048: 	 * @return <jk>true</jk> if the inner class has the annotation.
2050: 	public boolean hasAnnotation(Class<? extends Annotation> a) {
2058: 	 * @return The specified annotation, or <jk>null</jk> if the class does not have the specified annotation.
2060: 	public <A extends Annotation> A getLastAnnotation(Class<A> a) {
2065: 	 * Returns all annotations of the specified type defined on the specified class or parent classes/interfaces in parent-to-child order.
2072: 	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.
97: 	private final ClassMeta<?>
109: 	private final ClassMeta<?>[] args;                      // Arg types if this is an array of args.
123: 	 * @param implClass
139: 		this.innerClass = innerClass;
140: 		this.info = ClassInfo.of(innerClass);
147: 			if (beanContext != null && beanContext.cmCache != null && isCacheable(innerClass))
148: 				beanContext.cmCache.put(innerClass, this);
150: 			ClassMetaBuilder<T> builder = new ClassMetaBuilder(innerClass, beanContext, implClass, swaps, childPojoSwaps);
173: 			this.isMemberClass = builder.isMemberClass;
175: 			this.implClass = builder.implClass;
184: 		} catch (ClassMetaRuntimeException e) {
194: 	 * Generated classes shouldn't be cacheable to prevent needlessly filling up the cache.
198: 		char x = n.charAt(n.length()-1);  // All generated classes appear to end with digits.
221: 		this.innerClass = mainType.innerClass;
223: 		this.implClass = mainType.implClass;
235: 		this.isMemberClass = mainType.isMemberClass;
264: 		this.info = ClassInfo.of(innerClass);
266: 		this.implClass = null;
278: 		this.isMemberClass = false;
303: 		ClassInfo ci;
306: 		ClassCategory cc = ClassCategory.OTHER;
322: 		ClassMeta<?>
346: 			this.innerClass = innerClass;
350: 			this.implClass = implClass;
351: 			ClassInfo ici = ClassInfo.of(implClass);
362: 			ci = ClassInfo.of(c);
365: 				innerClass = this.innerClass = ci.inner();
431: 			isMemberClass = ci.isMemberClass() && ci.isNotStatic();
434: 			// fromString() must be checked before valueOf() so that Enum classes can create their own
461: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid field ''{0}''.  Must be static.", f);
467: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid field ''{0}''.  Must be static.", f);
476: 						throw new ClassMetaRuntimeException(c, "@Example used on invalid field ''{0}''.  Must be static and an instance of ...(16 bytes skipped)...
486: 						throw new ClassMetaRuntimeException(c, "@ParentProperty used on invalid method ''{0}''.  Must not be static and hav...(22 bytes skipped)...
492: 						throw new ClassMetaRuntimeException(c, "@NameProperty used on invalid method ''{0}''.  Must not be static and have ...(20 bytes skipped)...
513: 					List<ClassInfo> pt = cs.getParamTypes();
516: 					} else if (pt.size() == (isMemberClass ? 2 : 1)) {
517: 						ClassInfo arg = pt.get(isMemberClass ? 1 : 0);
531: 				ClassInfo x = implClass == null ? ci : ici;
542: 				this.builderSwap = BuilderSwap.findSwapFromPojoClass(bc, c, bc.getBeanConstructorVisibility(), bc.getBeanMethodVisibility());
550: 					elementType = findClassMeta(innerClass.getComponentType());
554: 					ClassMeta[] parameters = findParameters();
566: 					ClassMeta[] parameters = findParameters();
580: 						newMeta = new BeanMeta(ClassMeta.this, bc, beanFilter, null);
605: 			if (beanMeta != null && bc != null && bc.isUseInterfaceProxies() && innerClass.isInterface())
687: 					return BeanFilter.create(innerClass).applyAnnotations(ba).build();
698: 					return MarshalledFilter.create(innerClass).applyAnnotations(ba).build();
732: 			ClassInfo ci = ClassInfo.of(c);
756: 		private ClassMeta<?>[] findParameters() {
757: 			return beanContext.findParameters(innerClass, innerClass);
766: 	public ClassInfo getInfo() {
863: 			PojoSwap<?,?> s = childSwapMap.get(normalClass);
866: 					if (s == null && f.getNormalClass().isParentOf(normalClass))
870: 				PojoSwap<?,?> s2 = childSwapMap.putIfAbsent(normalClass, s);
890: 			PojoSwap<?,?> s = childUnswapMap.get(swapClass);
893: 					if (s == null && f.getSwapClass().isParentOf(swapClass))
897: 				PojoSwap<?,?> s2 = childUnswapMap.putIfAbsent(swapClass, s);
914: 	 * Note that this also returns the 1-arg constructor for non-static member classes.
922: 		ClassInfo ci = ClassInfo.of(c);
925: 		boolean isMemberClass = ci.isMemberClass() && ci.isNotStatic();
927: 			if (cc.hasNumParams(isMemberClass ? 1 : 0) && cc.isVisible(v) && cc.isNotDeprecated())
939: 		return innerClass;
988: 					Object o = Array.newInstance(getElementType().innerClass, 1);
1007: 			throw new ClassMetaRuntimeException(e);
1017: 	public ClassMeta<?> getElementType() {
1026: 	public ClassMeta<?> getKeyType() {
1035: 	public ClassMeta<?> getValueType() {
1317: 		return innerClass.isPrimitive();
1415: 	public ClassMeta<?>[] getArgs() {
1426: 	public ClassMeta<?> getArg(int index) {
1442: 		if (innerClass.isPrimitive())
1462: 		return isMemberClass;
1551: 		if (isMemberClass)
1573: 		if (isMemberClass)
1574: 			return outer != null && noArgConstructor != null && noArgConstructor.hasParamTypes(outer.getClass());
1593: 		if (isMemberClass)
1594: 			return outer != null && beanMeta.constructor.hasParamTypes(outer.getClass());
1603: 	 * 	Can be <jk>null</jk> for non-member or static classes.
1610: 			if (isMemberClass)
1737: 			if (isMemberClass)
1753: 			return (T)Array.newInstance(getInnerClass().getComponentType(), 0);
1761: 			return (T)Array.newInstance(this.elementType.innerClass,0);
1766: 	 * Same as {@link #newInstance()} except for instantiating non-static member classes.
1775: 		if (isMemberClass)
1787: 	public boolean same(ClassMeta<?> cm) {
1816: 		String n = innerClass.getName();
1843: 			return info.isParentOf(o.getClass()) || (isPrimitive() && info.getPrimitiveWrapper() == o.getClass());
1862: 		return innerClass.getName();
1871: 		return innerClass.getSimpleName();
1944: 	public boolean hasMutaterFrom(ClassMeta<?> c) {
1945: 		return getFromMutater(c.getInnerClass()) != null;
1964: 	public boolean hasMutaterTo(ClassMeta<?> c) {
1965: 		return getToMutater(c.getInnerClass()) != null;
1976: 		Mutater t = getFromMutater(o.getClass());
2000: 	public <O> O mutateTo(Object o, ClassMeta<O> c) {
2001: 		return mutateTo(o, c.getInnerClass());
2016: 			t = Mutaters.get(c, innerClass);
2036: 			t = Mutaters.get(innerClass, c);
2045: 	 * Shortcut for calling <code>getInnerClass().getAnnotation(a) != <jk>null</jk></code>.
2055: 	 * Shortcut for calling <c>getInnerClass().getAnnotation(a)</c>.
2078: 		return innerClass.hashCode();
2083: 		return (o instanceof ClassMeta) && eq(this, (ClassMeta<?>)o, (x,y)->eq(x.innerClass, y.innerClass));
92: 		childSwapMap,                                        // Maps normal subclasses to PojoSwaps.
93: 		childUnswapMap;                                      // Maps swap subclasses to PojoSwaps.
595: 			} catch (NoClassDefFoundError e) {
753: 			return beanContext.getClassMeta(c, false);
804: 	 * This allows interfaces to define subclasses with type names.
953: 		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/PolymerLabs/arcs-live:concrete-storage/node_modules/grpc/node_modules/needle/README.md: [ master, ]
1: Needle
144: ### needle(method, url[, data][, options][, callback]) `(> 2.0.x)`
157: ### needle.head(url[, options][, callback])
170: ### needle.get(url[, options][, callback])
178: ### needle.post(url, data[, options][, callback])
190: ### needle.put(url, data[, options][, callback])
206: ### needle.patch(url, data[, options][, callback])
210: ### needle.delete(url, data[, options][, callback])
223: ### needle.request(method, url, data[, options][, callback])
4: [![NPM](https://nodei.co/npm/needle.png)](https://nodei.co/npm/needle/)
9: var needle = require('needle');
11: needle.get('http://www.google.com', function(error, response) {
17: Callbacks not floating your boat? Needle got your back.
25: // the callback is optional, and needle returns a `readableStream` object
27: needle
35: From version 2.0.x up, Promises are also supported. Just call `needle()` directly and you'll get a native Promise object.
38: needle('put', 'https://hacking.the.gibson/login', { password: 'god' }, { json: true })
47: With only two real dependencies, Needle supports:
61: This makes Needle an ideal alternative for performing quick HTTP requests in Node, either for API interaction, downlo...(144 bytes skipped)...
67: $ npm install needle
75: needle('get', 'https://server.com/posts/12')
84: needle.get('ifconfig.me/all.json', function(error, response, body) {
94: needle.get('https://google.com/images/logo.png').pipe(out).on('finish', function() {
99: As you can see, you can use Needle with Promises or without them. When using Promises or when a callback is passed, the response's bod...(179 bytes skipped)...
101: ...(19 bytes skipped)... passed, however, the buffering logic will be skipped but the response stream will still go through Needle's processing pipeline, so you get all the benefits of post-processing while keeping the streamishne...(25 bytes skipped)...
106: Depending on the response's Content-Type, Needle will either attempt to parse JSON or XML streams, or, if a text response was received, will ensure ...(41 bytes skipped)...
111: needle.get('http://stackoverflow.com/feeds', { compressed: true }, function(err, resp) {
126: var stream = needle.get('https://backend.server.com/everything.html', options);
146: Calling `needle()` directly returns a Promise. Besides `method` and `url`, all parameters are optional, although wh...(93 bytes skipped)...
149: needle('get', 'http://some.url.com')
155: Except from the above, all of Needle's request methods return a Readable stream, and both `options` and `callback` are optional. If pass...(126 bytes skipped)...
160: needle.head('https://my.backend.server.com', {
173: needle.get('google.com/search?q=syd+barrett', function(err, resp) {
174:   // if no http:// is found, Needle will automagically prepend it.
185: needle.post('https://my.app.com/endpoint', 'foo=bar', options, function(err, resp) {
201: needle.put('https://api.app.com/v2', nested, function(err, resp) {
218: needle.delete('https://api.app.com/messages/123', null, options, function(err, resp) {
233: needle.request('get', 'forum.com/search', params, function(err, resp) {
239: Now, if you set pass `json: true` among the options, Needle won't set your params as a querystring but instead send a JSON representation of your data through ...(97 bytes skipped)...
242: needle.request('get', 'forum.com/search', params, { json: true }, function(err, resp) {
250: The [Readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) object returned by the above request methods emits the following events, in additi...(73 bytes skipped)...
256: Emitted when the underlying [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest) emits a response event. This is after the connection is established and the hea...(146 bytes skipped)...
275: ...(74 bytes skipped)... data was consumed or an error ocurred somewhere in between. Unlike a regular stream's `end` event, Needle's `done` will be fired either on success or on failure, which is why the first argument may be an E...(28 bytes skipped)...
278: var resp = needle.get('something.worthy/of/being/streamed/by/needle');
291: Emitted when an error ocurrs. This should only happen once in the lifecycle of a Needle request.
302: ...(3 bytes skipped)... information about options that've changed, there's always [the changelog](https://github.com/tomas/needle/releases).
304:  - `agent`       : Uses an [http.Agent](https://nodejs.org/api/http.html#http_class_http_agent) of your choice, instead of the global, default one. Useful for tweaking the behaviour a...(80 bytes skipped)...
314: ...(182 bytes skipped)...p) errors on some servers that misbehave when receiving payloads of unknown size. Set it to `0` and Needle will get and set the stream's length for you, or leave unset for the default behaviour, which is no...(43 bytes skipped)...
321: ...(71 bytes skipped)...se bodies automagically. Defaults to `true`. You can also set this to 'xml' or 'json' in which case Needle will *only* parse the response if the content type matches.
336:  - `user_agent`: Sets the 'User-Agent' HTTP header. Defaults to `Needle/{version} (Node.js {node_version})`.
361:  - `follow_if_same_host`     : When true, Needle will only follow redirects that point to the same host as the original request. `false` by default....(0 bytes skipped)...
362:  - `follow_if_same_protocol` : When true, Needle will only follow redirects that point to the same protocol as the original request. `false` by defa...(4 bytes skipped)...
367: Yes sir, we have it. Needle includes a `defaults()` method, that lets you override some of the defaults for all future requests...(12 bytes skipped)...
370: needle.defaults({
376: This will override Needle's default user agent and 10-second timeout, and disable response parsing, so you don't need to pass...(38 bytes skipped)...
381: Since you can pass a custom HTTPAgent to Needle you can do all sorts of neat stuff. For example, if you want to use the [`tunnel`](https://github.c...(67 bytes skipped)...
389: needle.get('foobar.com', { agent: myAgent });
395: Unless you're running an old version of Node (< 0.11.4), by default Needle won't set the Connection header on requests, yielding Node's default behaviour of keeping the conne...(118 bytes skipped)...
397: ...(82 bytes skipped)...ime from exiting, either because of a bug or 'feature' that was changed on 0.11.4. To overcome this Needle does set the 'Connection' header to 'close' on those versions, however this also means that making ...(62 bytes skipped)...
407: needle.get('https://api.server.com', { username: 'you', password: 'secret' },
416: needle.get('https://username:password@api.server.com', function(err, resp) {
424: needle.get('other.server.com', { username: 'you', password: 'secret', auth: 'digest' },
426:     // needle prepends 'http://' to your URL, if missing
439: needle.get('api.github.com/users/tomas', options, function(err, resp, body) {
448: needle.get('https://news.ycombinator.com/rss', function(err, resp, body) {
456: needle.get('http://upload.server.com/tux.png', { output: '/tmp/tux.png' }, function(err, resp, body) {
464: needle.get('http://search.npmjs.org', { proxy: 'http://localhost:1234' }, function(err, resp, body) {
472: var stream = needle.get('http://www.as35662.net/100.log');
485: var stream = needle.get('http://jsonplaceholder.typicode.com/db', { parse: true });
504: needle.get('http://jsonplaceholder.typicode.com/db', { parse: true })
519: needle.post('http://my.other.app.com', data, { multipart: true }, function(err, resp, body) {
520:   // needle will read the file and include it in the form-data as binary
527: needle.put('https://api.app.com/v2', fs.createReadStream('myfile.txt'), function(err, resp, body) {
545: needle.post('http://somewhere.com/over/the/rainbow', data, { multipart: true }, function(err, resp, body) ...(1 bytes skipped)...
563: needle.post('http://test.com/', data, { timeout: 5000, multipart: true }, function(err, resp, body) {
582: > You can use Docker to run tests by creating a container and mounting the needle project directory on `/app`
583: > `docker create --name Needle -v /app -w /app -v /app/node_modules -i node:argon`
github.com/kubernetes/minikube:site/package-lock.json: [ master, ]
1127:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
643:         "posix-character-classes": "^0.1.0",
388:     "class-utils": {
390:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1108:         "needle": {
2138:     "posix-character-classes": {
2140:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/kubernetes/minikube:site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/angular/material-start:package-lock.json: [ master, ]
1624:             "needle": "^2.2.1",
407:         "class-utils": "^0.3.5",
1041:         "posix-character-classes": "^0.1.0",
648:     "class-utils": {
650:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1605:         "needle": {
3023:     "posix-character-classes": {
3025:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/dart-lang/sdk:runtime/vm/object.h: [ master, ]
931: class Class : public Object {
469:   static ClassPtr class_class() { return class_class_; }
470:   static ClassPtr dynamic_class() { return dynamic_class_; }
471:   static ClassPtr void_class() { return void_class_; }
472:   static ClassPtr type_arguments_class() { return type_arguments_class_; }
473:   static ClassPtr patch_class_class() { return patch_class_class_; }
474:   static ClassPtr function_class() { return function_class_; }
475:   static ClassPtr closure_data_class() { return closure_data_class_; }
476:   static ClassPtr signature_data_class() { return signature_data_class_; }
477:   static ClassPtr redirection_data_class() { return redirection_data_class_; }
478:   static ClassPtr ffi_trampoline_data_class() {
481:   static ClassPtr field_class() { return field_class_; }
482:   static ClassPtr script_class() { return script_class_; }
483:   static ClassPtr library_class() { return library_class_; }
484:   static ClassPtr namespace_class() { return namespace_class_; }
485:   static ClassPtr kernel_program_info_class() {
488:   static ClassPtr code_class() { return code_class_; }
489:   static ClassPtr bytecode_class() { return bytecode_class_; }
490:   static ClassPtr instructions_class() { return instructions_class_; }
491:   static ClassPtr instructions_section_class() {
494:   static ClassPtr object_pool_class() { return object_pool_class_; }
495:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }
496:   static ClassPtr code_source_map_class() { return code_source_map_class_; }
497:   static ClassPtr compressed_stackmaps_class() {
500:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }
501:   static ClassPtr exception_handlers_class() {
504:   static ClassPtr deopt_info_class() { return deopt_info_class_; }
505:   static ClassPtr context_class() { return context_class_; }
506:   static ClassPtr context_scope_class() { return context_scope_class_; }
507:   static ClassPtr api_error_class() { return api_error_class_; }
508:   static ClassPtr language_error_class() { return language_error_class_; }
509:   static ClassPtr unhandled_exception_class() {
512:   static ClassPtr unwind_error_class() { return unwind_error_class_; }
513:   static ClassPtr dyncalltypecheck_class() { return dyncalltypecheck_class_; }
514:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }
515:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }
516:   static ClassPtr monomorphicsmiablecall_class() {
519:   static ClassPtr icdata_class() { return icdata_class_; }
520:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }
521:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }
522:   static ClassPtr loadingunit_class() { return loadingunit_class_; }
523:   static ClassPtr weak_serialization_reference_class() {
777:   static ClassPtr class_class_;           // Class of the Class vm object.
1355:   ClassLayout::ClassLoadingState class_loading_state() const {
1369:   bool is_synthesized_class() const {
1374:   bool is_enum_class() const { return EnumBit::decode(state_bits()); }
1799:   ClassPtr patched_class() const { return raw_ptr()->patched_class_; }
1800:   ClassPtr origin_class() const { return raw_ptr()->origin_class_; }
4863:   ClassPtr toplevel_class() const { return raw_ptr()->toplevel_class_; }
8416:   virtual ClassPtr type_class() const {
1217:   bool IsNullClass() const { return id() == kNullCid; }
1220:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1223:   bool IsVoidClass() const { return id() == kVoidCid; }
1226:   bool IsNeverClass() const { return id() == kNeverCid; }
1229:   bool IsObjectClass() const { return id() == kInstanceCid; }
1238:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1241:   bool IsClosureClass() const { return id() == kClosureCid; }
1242:   static bool IsClosureClass(ClassPtr cls) {
1248:   bool IsTypedefClass() const { return signature_function() != Object::null(); }
1692:   class ClassFinalizedBits : public BitField<uint32_t,
1696:   class ClassLoadingBits : public BitField<uint32_t,
1793:   kCurrentClass,  // Consider type params of current class only.
1797: class PatchClass : public Object {
4694: class ClassDictionaryIterator : public DictionaryIterator {
5282:   ArrayPtr classes_cache() const { return raw_ptr()->classes_cache_; }
7444:   intptr_t SizeFromClass() const {
7980:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
8240:   virtual bool HasTypeClass() const {
8407:   virtual bool HasTypeClass() const {
8494:   virtual bool HasTypeClass() const { return false; }
307: #define DEFINE_CLASS_TESTER(clazz)                                             \
778:   static ClassPtr dynamic_class_;         // Class of the 'dynamic' type.
779:   static ClassPtr void_class_;            // Class of the 'void' type.
780:   static ClassPtr type_arguments_class_;  // Class of TypeArguments vm object.
781:   static ClassPtr patch_class_class_;     // Class of the PatchClass vm object.
782:   static ClassPtr function_class_;        // Class of the Function vm object.
783:   static ClassPtr closure_data_class_;    // Class of ClosureData vm obj.
784:   static ClassPtr signature_data_class_;  // Class of SignatureData vm obj.
785:   static ClassPtr redirection_data_class_;  // Class of RedirectionData vm obj.
786:   static ClassPtr ffi_trampoline_data_class_;  // Class of FfiTrampolineData
788:   static ClassPtr field_class_;                // Class of the Field vm object.
789:   static ClassPtr script_class_;               // Class of the Script vm object.
790:   static ClassPtr library_class_;    // Class of the Library vm object.
791:   static ClassPtr namespace_class_;  // Class of Namespace vm object.
792:   static ClassPtr kernel_program_info_class_;  // Class of KernelProgramInfo vm
794:   static ClassPtr code_class_;                 // Class of the Code vm object.
795:   static ClassPtr bytecode_class_;      // Class of the Bytecode vm object.
796:   static ClassPtr instructions_class_;  // Class of the Instructions vm object.
797:   static ClassPtr instructions_section_class_;  // Class of InstructionsSection.
798:   static ClassPtr object_pool_class_;      // Class of the ObjectPool vm object.
799:   static ClassPtr pc_descriptors_class_;   // Class of PcDescriptors vm object.
800:   static ClassPtr code_source_map_class_;  // Class of CodeSourceMap vm object.
801:   static ClassPtr compressed_stackmaps_class_;  // Class of CompressedStackMaps.
802:   static ClassPtr var_descriptors_class_;       // Class of LocalVarDescriptors.
803:   static ClassPtr exception_handlers_class_;    // Class of ExceptionHandlers.
804:   static ClassPtr deopt_info_class_;            // Class of DeoptInfo.
805:   static ClassPtr context_class_;            // Class of the Context vm object.
806:   static ClassPtr context_scope_class_;      // Class of ContextScope vm object.
807:   static ClassPtr dyncalltypecheck_class_;   // Class of ParameterTypeCheck.
808:   static ClassPtr singletargetcache_class_;  // Class of SingleTargetCache.
809:   static ClassPtr unlinkedcall_class_;       // Class of UnlinkedCall.
811:       monomorphicsmiablecall_class_;         // Class of MonomorphicSmiableCall.
812:   static ClassPtr icdata_class_;             // Class of ICData.
813:   static ClassPtr megamorphic_cache_class_;  // Class of MegamorphiCache.
814:   static ClassPtr subtypetestcache_class_;   // Class of SubtypeTestCache.
815:   static ClassPtr loadingunit_class_;        // Class of LoadingUnit.
816:   static ClassPtr api_error_class_;          // Class of ApiError.
817:   static ClassPtr language_error_class_;     // Class of LanguageError.
818:   static ClassPtr unhandled_exception_class_;  // Class of UnhandledException.
819:   static ClassPtr unwind_error_class_;         // Class of UnwindError.
821:   static ClassPtr weak_serialization_reference_class_;
2450:   bool include_class_name = true;
4716:   Class& toplevel_class_;
8217:   static intptr_t type_class_id_offset() {
8413:   virtual classid_t type_class_id() const {
8495:   virtual classid_t type_class_id() const { return kIllegalCid; }
8508:   static intptr_t parameterized_class_id_offset() {
299:   intptr_t GetClassId() const {
561:   static const ClassId kClassId = kObjectCid;
1210:   GrowableObjectArrayPtr direct_subclasses() const {
1675:     kClassFinalizedPos = 2,
1676:     kClassFinalizedSize = 2,
1677:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1678:     kClassLoadingSize = 2,
1680:     kSynthesizedClassBit,
1701:   class SynthesizedClassBit
2230:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }
2466:   static NameFormattingParams DisambiguatedWithoutClassName(
6122:   classid_t TargetClassId() const { return TargetClassIdOf(raw()); }
6123:   static classid_t TargetClassIdOf(const WeakSerializationReferencePtr raw) {
6161:   static classid_t UnwrappedClassIdOf(const Object& obj) {
6171:   static classid_t UnwrappedClassIdOf(ObjectPtr obj) {
6551:   classid_t OwnerClassId() const { return OwnerClassIdOf(raw()); }
6552:   static classid_t OwnerClassIdOf(CodePtr raw) {
7116:     kClassIdIndex,
7179:     kInstanceClassIdOrFunction = 1,
8501:   bool IsClassTypeParameter() const {
9315:   static const ClassId kClassId = kOneByteStringCid;
9443:   static const ClassId kClassId = kTwoByteStringCid;
9524:   static const ClassId kClassId = kExternalOneByteStringCid;
9619:   static const ClassId kClassId = kExternalTwoByteStringCid;
9915:   static const ClassId kClassId = kImmutableArrayCid;
11496: ObjectPtr MegamorphicCache::GetClassId(const Array& array, intptr_t index) {
45: class Assembler;
49: class Program;
50: class TreeNode;
53: #define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
54: CLASS_LIST(DEFINE_FORWARD_DECLARATION)
56: class Api;
57: class ArgumentsDescriptor;
58: class Closure;
59: class Code;
60: class DeoptInstr;
61: class DisassemblyFormatter;
62: class FinalizablePersistentHandle;
63: class FlowGraphCompiler;
64: class HierarchyInfo;
65: class LocalScope;
66: class CodeStatistics;
67: class IsolateGroupReloadContext;
69: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
73: class Symbols;
74: class BaseTextBuffer;
213:   friend class SnapshotReader;
227:   friend class Object;
236:   friend class StackFrame;                                                     \
237:   friend class Thread;
261:   friend class Object;                                                         \
262:   friend class StackFrame;                                                     \
263:   friend class Thread;
280: class Object {
306: // Class testers.
309:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
310: #undef DEFINE_CLASS_TESTER
479:     return ffi_trampoline_data_class_;
486:     return kernel_program_info_class_;
492:     return instructions_section_class_;
498:     return compressed_stackmaps_class_;
502:     return exception_handlers_class_;
510:     return unhandled_exception_class_;
517:     return monomorphicsmiablecall_class_;
524:     return weak_serialization_reference_class_;
551:   template <class FakeObject>
576:     //   core impl class name shown -> _OneByteString
605:   // class which has the same name as an already existing function, or
612:   enum class NameDisambiguation {
722:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
740:     // Indicates this class cannot be extended by dart code.
746:   static void RegisterClass(const Class& cls,
749:   static void RegisterPrivateClass(const Class& cls,
820:   // Class of WeakSerializationReference.
827:   friend void ClassTable::Register(const Class& cls);
829:   friend class Closure;
830:   friend class SnapshotReader;
831:   friend class InstanceDeserializationCluster;
832:   friend class OneByteString;
833:   friend class TwoByteString;
834:   friend class ExternalOneByteString;
835:   friend class ExternalTwoByteString;
836:   friend class Thread;
839:   friend class Reusable##name##HandleScope;
847: class PassiveObject : public Object {
895: // The first string in the triplet is a type name (usually a class).
900: enum class Nullability : int8_t {
908: enum class TypeEquality {
916: enum class NNBDMode {
924: enum class NNBDCompiledMode {
1045:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1046:   // to this class.
1049:   // The NNBD mode of the library declaring this class.
1066:   // This class represents a typedef if the signature function is not null.
1072:   // Return the Type with type parameters declared by this class filled in with
1078:   // class preceded by the type arguments declared for superclasses, etc.
1080:   // class B<T, S>
1081:   // class C<R> extends B<R, int>
1106:   // Return a TypeParameter if the type_name is a type parameter of this class.
1111:   // the super class.
1114:   // Return true if this class declares type parameters.
1117:   // If this class is parameterized, each instance has a type_arguments field.
1131:         compiler::target::Class::kNoTypeArguments) {
1132:       return compiler::target::Class::kNoTypeArguments;
1144:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1146:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1148:       target_value = RTN::Class::kNoTypeArguments;
1179:   // The super type of this class, Object type if not explicitly specified.
1189:   // Asserts that the class of the super type has been resolved.
1202:   // Returns the list of classes directly implementing this class.
1206:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1209:   // Returns the list of classes having this class as direct superclass.
1213:   void AddDirectSubclass(const Class& subclass) const;
1216:   // Check if this class represents the class of null.
1219:   // Check if this class represents the 'dynamic' class.
1222:   // Check if this class represents the 'void' class.
1225:   // Check if this class represents the 'Never' class.
1228:   // Check if this class represents the 'Object' class.
1231:   // Check if this class represents the 'Function' class.
1234:   // Check if this class represents the 'Future' class.
1237:   // Check if this class represents the 'FutureOr' class.
1240:   // Check if this class represents the 'Closure' class.
1247:   // Check if this class represents a typedef class.
1258:   static bool IsSubtypeOf(const Class& cls,
1265:   // Check if this is the top level class.
1273:   // Returns an array of instance and static fields defined by this class.
1283:   // If this is a dart:internal.ClassID class, then inject our own const
1288:   // Returns an array of all instance fields of this class and its superclasses
1306:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1360:     return class_loading_state() >= ClassLayout::kDeclarationLoaded;
1365:     return class_loading_state() >= ClassLayout::kTypeFinalized;
1372:   void set_is_synthesized_class() const;
1375:   void set_is_enum_class() const;
1401:   // Tests if this is a mixin application class which was desugared
1402:   // to a normal class by kernel mixin transformation
1502:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1527:   // class and return the resulting value, or an error object if evaluating the
1537:   // Load class declaration (super type, interfaces, type parameters and
1544:   // Allocate a class used for VM internal objects.
1545:   template <class FakeObject, class TargetFakeObject>
1546:   static ClassPtr New(Isolate* isolate, bool register_class = true);
1553:                       bool register_class = true);
1559:   static ClassPtr NewStringClass(intptr_t class_id, Isolate* isolate);
1562:   static ClassPtr NewTypedDataClass(intptr_t class_id, Isolate* isolate);
1565:   static ClassPtr NewTypedDataViewClass(intptr_t class_id, Isolate* isolate);
1568:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,
1572:   static ClassPtr NewPointerClass(intptr_t class_id, Isolate* isolate);
1575:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1579:   void DisableCHAOptimizedCode(const Class& subclass);
1585:   // Return the list of code objects that were compiled using CHA of this class.
1586:   // These code objects will be invalidated if new subclasses of this class
1595:                    const Class& old_enum) const;
1597:                              const Class& old_cls) const;
1600:                                      const Class& new_cls) const;
1601:   void CopyCanonicalConstants(const Class& old_cls) const;
1602:   void CopyDeclarationType(const Class& old_cls) const;
1603:   void CheckReload(const Class& replacement,
1650:   // Caches the declaration type of this class.
1653:   bool CanReloadFinalized(const Class& replacement,
1655:   bool CanReloadPreFinalized(const Class& replacement,
1659:   bool RequiresInstanceMorphing(const Class& replacement) const;
1661:   template <class FakeInstance, class TargetFakeInstance>
1690:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1691:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1700:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1703:   class FieldsMarkedNullableBit
1705:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1706:   class TransformedMixinApplicationBit
1708:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1709:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1710:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1751:   // Calculates number of type arguments of this class.
1756:   // Assigns empty array to all raw class array fields.
1769:   // Allocate an instance class which has a VM implementation.
1770:   template <class FakeInstance, class TargetFakeInstance>
1773:                       bool register_class = true,
1776:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
1779:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
1780:   friend class AbstractType;
1781:   friend class Instance;
1782:   friend class Object;
1783:   friend class Type;
1784:   friend class InterpreterHelpers;
1785:   friend class Intrinsifier;
1786:   friend class ProgramWalker;
1787:   friend class Precompiler;
1792:   kAny,           // Consider type params of current class and functions.
1824:     return Class::IsInFullSnapshot(cls->ptr()->patched_class_);
1827:   static PatchClassPtr New(const Class& patched_class,
1828:                            const Class& origin_class);
1830:   static PatchClassPtr New(const Class& patched_class, const Script& source);
1833:   void set_patched_class(const Class& value) const;
1834:   void set_origin_class(const Class& value) const;
1840:   friend class Class;
1843: class ParameterTypeCheck : public Object {
1875:   friend class Class;
1878: class SingleTargetCache : public Object {
1908:   friend class Class;
1911: class MonomorphicSmiableCall : public Object {
1937:   friend class Class;
1940: class CallSiteData : public Object {
1959:   friend class ICData;
1960:   friend class MegamorphicCache;
1963: class UnlinkedCall : public CallSiteData {
1979:   friend class ICData;  // For set_*() methods.
1984:   friend class Class;
1992: class ICData : public CallSiteData {
2174:   // Used for unoptimized static calls when no class-ids are checked.
2179:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2181:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2187:   // Adds sorted so that Smi is the first class-id. Use only for
2189:   void AddReceiverCheck(intptr_t receiver_class_id,
2201:                   GrowableArray<intptr_t>* class_ids,
2203:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2207:                           intptr_t* class_id,
2242:   bool HasReceiverClassId(intptr_t class_id) const;
2314:   friend class FlowGraphSerializer;  // For is_megamorphic()
2363:   class NumArgsTestedBits : public BitField<uint32_t,
2367:   class TrackingExactnessBit : public BitField<uint32_t,
2371:   class DeoptReasonBits : public BitField<uint32_t,
2375:   class RebindRuleBits : public BitField<uint32_t,
2379:   class MegamorphicBit
2382:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2412:   friend class CallSiteResetter;
2413:   friend class CallTargets;
2414:   friend class Class;
2415:   friend class VMDeserializationRoots;
2416:   friend class ICDataTestTask;
2417:   friend class Interpreter;
2418:   friend class VMSerializationRoots;
2419:   friend class SnapshotWriter;
2446:   // By default function name includes the name of the enclosing class if any.
2447:   // However in some contexts this information is redundant and class name
2448:   // is already known. In this case setting |include_class_name| to false
2469:     params.include_class_name = false;
2476:     params.include_class_name = false;
2482: class Function : public Object {
2503:   // owner class of this function, then its signature type is a parameterized
2554:   // parameter of this function and R is a type parameter of class C, the owner
2560:   // parameter of this function and R is a type parameter of class C, the owner
2572:   // generic functions or class type parameters.
2586:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3566:       const Class& klass = Class::Handle(Owner());
3612:   // The owner is the scope class of the function type.
3619:   static FunctionPtr NewEvalFunction(const Class& owner,
3671: // a hoisted check class instruction.
3686:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3709:   // static: Considered during class-side or top-level resolution rather than
3809:   class KindBits : public BitField<uint32_t,
3814:   class RecognizedBits : public BitField<uint32_t,
3818:   class ModifierBits : public BitField<uint32_t,
3824:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
3861:   friend class Class;
3862:   friend class SnapshotWriter;
3863:   friend class Parser;  // For set_eval_script.
3864:   friend class ProgramVisitor;  // For set_parameter_names.
3867:   friend class FunctionLayout;
3868:   friend class ClassFinalizer;  // To reset parent_function.
3869:   friend class Type;            // To adjust parent_function.
3872: class ClosureData : public Object {
3896:   friend class Class;
3897:   friend class Function;
3898:   friend class HeapProfiler;
3901: class SignatureData : public Object {
3919:   friend class Class;
3920:   friend class Function;
3921:   friend class HeapProfiler;
3924: class RedirectionData : public Object {
3931:   // The type specifies the class and type arguments of the target constructor.
3946:   friend class Class;
3947:   friend class Function;
3948:   friend class HeapProfiler;
3951: enum class EntryPointPragma {
3959: class FfiTrampolineData : public Object {
3987:   friend class Class;
3988:   friend class Function;
3989:   friend class HeapProfiler;
3992: class Field : public Object {
4156:   // Called during class finalization.
4183:   ClassPtr Origin() const;  // Either mixin class, or same as owner().
4188:   // Used by class finalizer, otherwise initialized in constructor.
4281:   // Return class id that any non-null value read from this field is guaranteed
4282:   // to have or kDynamicCid if such class id is not known.
4396:   // assumptions about guarded class id and nullability of this field.
4478:   friend class Interpreter;              // Access to bit field.
4479:   friend class StoreInstanceFieldInstr;  // Generated code access to bit field.
4499:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4500:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4501:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4502:   class HasNontrivialInitializerBit
4504:   class UnboxingCandidateBit
4506:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4507:   class DoubleInitializedBit
4509:   class InitializerChangedAfterInitializatonBit
4514:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4515:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4516:   class GenericCovariantImplBit
4518:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4519:   class IsExtensionMemberBit
4521:   class NeedsLoadGuardBit
4523:   class HasInitializerBit
4525:   class IsNonNullableIntBit
4566:   friend class Class;
4567:   friend class HeapProfiler;
4568:   friend class FieldLayout;
4569:   friend class FieldSerializationCluster;
4570:   friend class FieldDeserializationCluster;
4573: class Script : public Object {
4670:   friend class Class;
4671:   friend class Precompiler;
4674: class DictionaryIterator : public ValueObject {
4690:   friend class ClassDictionaryIterator;
4698:     // one top-level class per library left, not an array to iterate over.
4707:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4710:   // Returns a non-null raw class.
4721: class Library : public Object {
4783:   void AddClass(const Class& cls) const;
4818:   void AddAnonymousClass(const Class& cls) const;
4822:   void AddClassMetadata(const Class& cls,
4864:   void set_toplevel_class(const Class& value) const;
5080:   // Lookup class in the core lib which also contains various VM
5082:   static ClassPtr LookupCoreClass(const String& class_name);
5086:                                  const char* class_name,
5161:   friend class Bootstrap;
5162:   friend class Class;
5163:   friend class Debugger;
5164:   friend class DictionaryIterator;
5165:   friend class Isolate;
5166:   friend class LibraryDeserializationCluster;
5167:   friend class Namespace;
5168:   friend class Object;
5169:   friend class Precompiler;
5174: class Namespace : public Object {
5204:   friend class Class;
5205:   friend class Precompiler;
5208: class KernelProgramInfo : public Object {
5287:                        const Class& klass) const;
5296:   friend class Class;
5302: class ObjectPool : public Object {
5438:   friend class Class;
5439:   friend class Object;
5440:   friend class ObjectPoolLayout;
5443: class Instructions : public Object {
5452:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5453:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5607:   friend class Class;
5608:   friend class Code;
5609:   friend class AssemblyImageWriter;
5610:   friend class BlobImageWriter;
5611:   friend class ImageWriter;
5624: class InstructionsSection : public Object {
5645:   // There are no public instance methods for the InstructionsSection class, as
5646:   // all access to the contents is handled by methods on the Image class.
5654:   friend class Class;
5657: class LocalVarDescriptors : public Object {
5693:   friend class Class;
5694:   friend class Object;
5697: class PcDescriptors : public Object {
5730:   class Iterator : ValueObject {
5783:     friend class PcDescriptors;
5828:   friend class Class;
5829:   friend class Object;
5832: class CodeSourceMap : public Object {
5873:   friend class Class;
5874:   friend class Object;
5877: class CompressedStackMaps : public Object {
5945:   class Iterator : public ValueObject {
6017:     friend class StackMapEntry;
6027:   friend class Class;
6030: class ExceptionHandlers : public Object {
6079:   friend class Class;
6080:   friend class Object;
6103: // but instead contain only the class ID of the original target.
6107: class WeakSerializationReference : public Object {
6164:   // Gets the class ID of the underlying object from a WSR, or the class ID of
6191:   friend class Class;
6194: class Code : public Object {
6402:   enum class PoolAttachment {
6407:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};
6408:   class EntryPointField
6410:   class OffsetField
6435:   class Comments : public ZoneAllocated {
6459:     friend class Code;
6537:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
6670:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6671:   friend class CodeLayout;
6680:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
6684:   class ForceOptimizedBit
6687:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
6688:   class PtrOffBits
6691:   class SlowFindRawCodeVisitor : public FindObjectVisitor {
6778:   friend class Class;
6779:   friend class CodeTestHelper;
6780:   friend class SnapshotWriter;
6781:   friend class StubCode;     // for set_object_pool
6782:   friend class Precompiler;  // for set_object_pool
6783:   friend class FunctionSerializationCluster;
6784:   friend class CodeSerializationCluster;
6785:   friend class CodeDeserializationCluster;
6786:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
6787:   friend class StubCode;               // for set_object_pool
6788:   friend class MegamorphicCacheTable;  // for set_object_pool
6789:   friend class CodePatcher;            // for set_instructions
6790:   friend class ProgramVisitor;         // for set_instructions
6793:   friend class FunctionLayout;
6794:   friend class CallSiteResetter;
6795:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
6798: class Bytecode : public Object {
6907:   class SlowFindRawBytecodeVisitor : public FindObjectVisitor {
6934:   friend class BytecodeDeserializationCluster;
6935:   friend class ObjectLayout;  // For ObjectLayout::SizeFromClass().
6936:   friend class BytecodeLayout;
6939:   friend class Class;
6940:   friend class SnapshotWriter;
6943: class Context : public Object {
7013:   friend class Class;
7014:   friend class Object;
7017: // The ContextScope class makes it possible to delay the compilation of a local
7027: class ContextScope : public Object {
7105:   friend class Class;
7106:   friend class Object;
7109: class MegamorphicCache : public CallSiteData {
7143:   void Insert(const Smi& class_id, const Object& target) const;
7154:   friend class Class;
7155:   friend class MegamorphicCacheTable;
7156:   friend class ProgramVisitor;
7162:   void InsertLocked(const Smi& class_id, const Object& target) const;
7166:                               const Smi& class_id,
7175: class SubtypeTestCache : public Object {
7189:   void AddCheck(const Object& instance_class_id_or_function,
7197:                 Object* instance_class_id_or_function,
7230:   friend class Class;
7231:   friend class VMSerializationRoots;
7232:   friend class VMDeserializationRoots;
7235: class LoadingUnit : public Object {
7274:   friend class Class;
7277: class Error : public Object {
7285: class ApiError : public Error {
7303:   friend class Class;
7306: class LanguageError : public Error {
7369:   friend class Class;
7372: class UnhandledException : public Error {
7401:   friend class Class;
7402:   friend class ObjectStore;
7405: class UnwindError : public Error {
7425:   friend class Class;
7428: // Instance is the base class for all instance objects (aka the Object class
7430: class Instance : public Object {
7446:     const Class& cls = Class::Handle(clazz());
7510:   // class implementing a 'call' method, return true and set the function
7533:       const Class& method_cls,
7549:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);
7557:   // only the class_id is different. So, it is safe to use subtype instances in
7603:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7614:   static InstancePtr NewFromCidAndSize(SharedClassTable* shared_class_table,
7620:   friend class ByteBuffer;
7621:   friend class Class;
7622:   friend class Closure;
7623:   friend class Pointer;
7624:   friend class DeferredObject;
7625:   friend class RegExp;
7626:   friend class SnapshotWriter;
7627:   friend class StubCode;
7628:   friend class TypedDataView;
7629:   friend class InstanceSerializationCluster;
7630:   friend class InstanceDeserializationCluster;
7631:   friend class ClassDeserializationCluster;  // vtable
7632:   friend class InstanceMorpher;
7633:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7636: class LibraryPrefix : public Instance {
7675:   friend class Class;
7679: class TypeArguments : public Instance {
7761:   // a raw (null) function type arguments, i.e. consider each class type
7818:       const Class& instantiator_class,
7837:   // Add the class name and URI of each type argument of this vector to the uris
7844:   // type from the various type argument vectors (class instantiator, function,
7922:   // If raw_instantiated is true, consider each class type parameter to be first
7937:   friend class AbstractType;
7938:   friend class Class;
7939:   friend class ClearTypeHashVisitor;
7940:   friend class Object;
7945: class AbstractType : public Instance {
7981:   virtual classid_t type_class_id() const;
7982:   virtual ClassPtr type_class() const;
8007:   // instantiation. Consider a class C<T> declaring a non-generic method
8009:   // generic function bar<B> as argument and its function type refers to class
8081:   // Add the class name and URI of each occuring type to the uris
8087:   // The name of this type's class, i.e. without the type argument names of this
8095:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
8098:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
8107:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
8123:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
8141:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
8144:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
8159:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
8204:   friend class Class;
8205:   friend class Function;
8206:   friend class TypeArguments;
8209: // A Type consists of a class, possibly parameterized with type
8212: // Caution: 'TypePtr' denotes a 'raw' pointer to a VM object of class Type, as
8215: class Type : public AbstractType {
8218:     return OFFSET_OF(TypeLayout, type_class_id_);
8241:     ASSERT(type_class_id() != kIllegalCid);
8248:   virtual classid_t type_class_id() const;
8249:   virtual ClassPtr type_class() const;
8250:   void set_type_class(const Class& value) const;
8263:   // canonicalization (passed-in cls must match type_class()).
8264:   bool IsDeclarationTypeOf(const Class& cls) const;
8268:   // However, in case of a generic typedef, they document how the typedef class
8359:   // The finalized type of the given non-parameterized class.
8360:   static TypePtr NewNonParameterizedType(const Class& type_class);
8362:   static TypePtr New(const Class& clazz,
8381:   friend class Class;
8382:   friend class TypeArguments;
8383:   friend class ClearTypeHashVisitor;
8390: class TypeRef : public AbstractType {
8414:     return AbstractType::Handle(type()).type_class_id();
8417:     return AbstractType::Handle(type()).type_class();
8461:   friend class Class;
8464: // A TypeParameter represents a type parameter of a parameterized class.
8468: // the class HashMap<K, V>. At compile time, the TypeParameter is not
8471: // as type argument (rather than type parameter) of the parameterized class.
8474: class TypeParameter : public AbstractType {
8496:   classid_t parameterized_class_id() const;
8497:   ClassPtr parameterized_class() const;
8502:     return parameterized_class_id() != kFunctionCid;
8509:     return OFFSET_OF(TypeParameterLayout, parameterized_class_id_);
8555:   // Only one of parameterized_class and parameterized_function is non-null.
8556:   static TypeParameterPtr New(const Class& parameterized_class,
8569:   void set_parameterized_class(const Class& value) const;
8579:   friend class Class;
8580:   friend class ClearTypeHashVisitor;
8583: class Number : public Instance {
8600:   friend class Class;
8603: class Integer : public Number {
8676:   friend class Class;
8679: class Smi : public Integer {
8713:   static ClassPtr Class();
8734:     // Indicates this class cannot be extended by dart code.
8741:   friend class Api;  // For ValueFromRaw
8742:   friend class Class;
8743:   friend class Object;
8744:   friend class ReusableSmiHandleScope;
8745:   friend class Thread;
8748: class SmiTraits : AllStatic {
8760: class Mint : public Integer {
8790:   friend class Integer;
8801:   friend class Class;
8802:   friend class Number;
8805: // Class Double represents class Double in corelib_impl, which implements
8806: // abstract class double in corelib.
8807: class Double : public Number {
8839:   friend class Class;
8840:   friend class Number;
8844: class String : public Instance {
8865:   class CodePointIterator : public ValueObject {
9172:   friend class Class;
9173:   friend class Symbols;
9174:   friend class StringSlice;  // SetHash
9176:   friend class CharArray;     // SetHash
9177:   friend class ConcatString;  // SetHash
9178:   friend class OneByteString;
9179:   friend class TwoByteString;
9180:   friend class ExternalOneByteString;
9181:   friend class ExternalTwoByteString;
9182:   friend class OneByteStringLayout;
9183:   friend class RODataSerializationCluster;  // SetHash
9184:   friend class Pass2Visitor;                // Stack "handle"
9188: class StringHasher : ValueObject {
9213: class OneByteString : public AllStatic {
9347:   friend class Class;
9348:   friend class String;
9349:   friend class Symbols;
9350:   friend class ExternalOneByteString;
9351:   friend class SnapshotReader;
9352:   friend class StringHasher;
9353:   friend class Utf8;
9356: class TwoByteString : public AllStatic {
9473:   friend class Class;
9474:   friend class String;
9475:   friend class StringHasher;
9476:   friend class SnapshotReader;
9477:   friend class Symbols;
9480: class ExternalOneByteString : public AllStatic {
9567:     // Indicates this class cannot be extended by dart code.
9571:   friend class Class;
9572:   friend class String;
9573:   friend class StringHasher;
9574:   friend class SnapshotReader;
9575:   friend class Symbols;
9576:   friend class Utf8;
9579: class ExternalTwoByteString : public AllStatic {
9662:     // Indicates this class cannot be extended by dart code.
9666:   friend class Class;
9667:   friend class String;
9668:   friend class StringHasher;
9669:   friend class SnapshotReader;
9670:   friend class Symbols;
9673: // Class Bool implements Dart core class bool.
9674: class Bool : public Instance {
9703:   friend class Class;
9704:   friend class Object;  // To initialize the true and false values.
9707: class Array : public Instance {
9823:   // Make the array immutable to Dart code by switching the class pointer
9859:   static ArrayPtr New(intptr_t class_id,
9898:   friend class Class;
9899:   friend class ImmutableArray;
9900:   friend class Interpreter;
9901:   friend class Object;
9902:   friend class String;
9905: class ImmutableArray : public AllStatic {
9925:     // Indicates this class cannot be extended by dart code.
9933:   friend class Class;
9936: class GrowableObjectArray : public Instance {
10042:   friend class Array;
10043:   friend class Class;
10046: class Float32x4 : public Instance {
10077:   friend class Class;
10080: class Int32x4 : public Instance {
10110:   friend class Class;
10113: class Float64x2 : public Instance {
10138:   friend class Class;
10141: class PointerBase : public Instance {
10148: class TypedDataBase : public PointerBase {
10213:   friend class Class;
10228: class TypedData : public TypedDataBase {
10279:   static intptr_t MaxElements(intptr_t class_id) {
10280:     ASSERT(IsTypedDataClassId(class_id));
10281:     return (kSmiMax / ElementSizeInBytes(class_id));
10284:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
10285:     ASSERT(IsTypedDataClassId(class_id));
10287:            ElementSizeInBytes(class_id);
10290:   static TypedDataPtr New(intptr_t class_id,
10355:   // Therefore this method is private and the call-sites in this class need to
10364:   friend class Class;
10365:   friend class ExternalTypedData;
10366:   friend class TypedDataView;
10369: class ExternalTypedData : public TypedDataBase {
10411:   static intptr_t MaxElements(intptr_t class_id) {
10412:     ASSERT(IsExternalTypedDataClassId(class_id));
10413:     return (kSmiMax / ElementSizeInBytes(class_id));
10417:       intptr_t class_id,
10447:   friend class Class;
10450: class TypedDataView : public TypedDataBase {
10452:   static TypedDataViewPtr New(intptr_t class_id,
10454:   static TypedDataViewPtr New(intptr_t class_id,
10519:   friend class Class;
10520:   friend class Object;
10521:   friend class TypedDataViewDeserializationCluster;
10524: class ByteBuffer : public AllStatic {
10542: class Pointer : public Instance {
10580:   friend class Class;
10583: class DynamicLibrary : public Instance {
10609:   friend class Class;
10616: class LinkedHashMap : public Instance {
10702:   class Iterator : ValueObject {
10746:   friend class Class;
10747:   friend class LinkedHashMapDeserializationCluster;
10750: class Closure : public Instance {
10823:   friend class Class;
10826: class Capability : public Instance {
10837:   friend class Class;
10840: class ReceivePort : public Instance {
10857:   friend class Class;
10860: class SendPort : public Instance {
10880:   friend class Class;
10885: class TransferableTypedDataPeer {
10912: class TransferableTypedData : public Instance {
10924:   friend class Class;
10928: class StackTrace : public Instance {
10982:   friend class Class;
10983:   friend class Debugger;
10986: class RegExpFlags {
11036: class RegExp : public Instance {
11055:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
11056:   class FlagsBits : public BitField<int8_t, intptr_t, kFlagsPos, kFlagsSize> {};
11190:   friend class Class;
11193: class WeakProperty : public Instance {
11222:   friend class Class;
11225: class MirrorReference : public Instance {
11254:   friend class Class;
11257: class UserTag : public Instance {
11290:   friend class Class;
11293: // Represents abstract FutureOr class in dart:async.
11294: class FutureOr : public Instance {
11310:   friend class Class;
11317:     return Smi::Class();
11320:   return Isolate::Current()->class_table()->At(raw()->GetClassId());
11478:                                 const Smi& class_id,
11481:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
11571: // This helper class can then be used via
11606: class ArrayOfTuplesView {
11610:   class Iterator;
11612:   class TupleView {
11638:     friend class Iterator;
11641:   class Iterator {
11691:     ArrayOfTuplesView<Class::InvocationDispatcherEntry,
155:   static const ClassId kClassId = k##object##Cid;                              \
303:   inline ClassPtr clazz() const;
565:     // Internal names are the true names of classes, fields,
569:     // The names of core implementation classes (like _OneByteString)
574:     //   private constructor        -> _MyClass@6b3832b.
575:     //   private named constructor  -> _MyClass@6b3832b.named
585:     //   _MyClass@6b3832b.      -> _MyClass
586:     //   _MyClass@6b3832b.named -> _MyClass.named
592:     // the names of core implementation classes are remapped to their
597:     //   _MyClass@6b3832b.      -> _MyClass
598:     //   _MyClass@6b3832b.named -> _MyClass.named
810:   static ClassPtr
953:   static intptr_t host_instance_size(ClassPtr clazz) {
956:   static intptr_t target_instance_size(ClassPtr clazz) {
1025:     return ObjectLayout::ClassIdTag::is_valid(value);
1029:     ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());
1032:   static intptr_t id_offset() { return OFFSET_OF(ClassLayout, id_); }
1034:     return OFFSET_OF(ClassLayout, num_type_arguments_);
1047:   ClassPtr Mixin() const;
1074:   // in superclass clauses.
1088:     return OFFSET_OF(ClassLayout, declaration_type_);
1168:     return OFFSET_OF(ClassLayout, host_type_arguments_field_offset_in_words_);
1173:     return OFFSET_OF(ClassLayout, target_type_arguments_field_offset_in_words_);
1186:     return OFFSET_OF(ClassLayout, super_type_);
1190:   // |original_classes| only has an effect when reloading. If true and we
1191:   // are reloading, it will prefer the original classes to the replacement
1192:   // classes.
1193:   ClassPtr SuperClass(bool original_classes = false) const;
1232:   bool IsDartFunctionClass() const;
1235:   bool IsFutureClass() const;
1250:   static bool IsInFullSnapshot(ClassPtr cls) {
1290:   // |original_classes| only has an effect when reloading. If true and we
1291:   // are reloading, it will prefer the original classes to the replacement
1292:   // classes.
1293:   ArrayPtr OffsetToFieldMap(bool original_classes = false) const;
1346:     return RoundedAllocationSize(sizeof(ClassLayout));
1356:     return ClassLoadingBits::decode(state_bits());
1378:     return ClassFinalizedBits::decode(state_bits()) ==
1379:                ClassLayout::kFinalized ||
1380:            ClassFinalizedBits::decode(state_bits()) ==
1381:                ClassLayout::kAllocateFinalized;
1386:     return ClassFinalizedBits::decode(state_bits()) ==
1387:            ClassLayout::kAllocateFinalized;
1392:     return ClassFinalizedBits::decode(state_bits()) ==
1393:            ClassLayout::kPreFinalized;
1433:     return ClassLayout::BinaryDeclarationOffset::decode(
1439:                     ClassLayout::BinaryDeclarationOffset::update(
1484:     return ClassLayout::IsDeclaredInBytecode::decode(
1492:                     ClassLayout::IsDeclaredInBytecode::update(
1548:   // Allocate instance classes.
1549:   static ClassPtr New(const Library& lib,
1554:   static ClassPtr NewNativeWrapper(const Library& library,
1558:   // Allocate the raw string classes.
1561:   // Allocate the raw TypedData classes.
1564:   // Allocate the raw TypedDataView/ByteDataView classes.
1567:   // Allocate the raw ExternalTypedData classes.
1571:   // Allocate the raw Pointer classes.
1610:   static int32_t host_instance_size_in_words(const ClassPtr cls) {
1614:   static int32_t target_instance_size_in_words(const ClassPtr cls) {
1622:   static int32_t host_next_field_offset_in_words(const ClassPtr cls) {
1626:   static int32_t target_next_field_offset_in_words(const ClassPtr cls) {
1634:   static int32_t host_type_arguments_field_offset_in_words(const ClassPtr cls) {
1639:       const ClassPtr cls) {
1662:   static ClassPtr NewCommon(intptr_t index);
1693:                                              ClassLayout::ClassFinalizedState,
1697:                                            ClassLayout::ClassLoadingState,
1752:   // This includes type arguments of a superclass and takes overlapping
1771:   static ClassPtr New(intptr_t id,
1777:   static ClassPtr NewInstanceClass();
1790: // Classification of type genericity according to type parameter owners.
1839:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
1914:   classid_t expected_cid() const { return raw_ptr()->expected_cid_; }
1920:   static MonomorphicSmiableCallPtr New(classid_t expected_cid,
1987: // Object holding information about an IC: test classes and their
2052:   V(CheckClass)                                                                \
2089:   // Call site classification that is helpful for hot-reload. Call sites with
2331:   // to list the call site's observed receiver classes and targets.
2577:   ClassPtr Owner() const;
2579:   ClassPtr origin() const;
3670: // 'ProhibitsHoistingCheckClass' is true if this function deoptimized before on
3677:   V(ProhibitsHoistingCheckClass)                                               \
4182:   ClassPtr Owner() const;
4703:   ClassDictionaryIterator(const Library& library,
4711:   ClassPtr GetNextClass();
4714:   void MoveToNextClass();
4718:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4790:   ClassPtr LookupClass(const String& name) const;
4791:   ClassPtr LookupClassAllowPrivate(const String& name) const;
4792:   ClassPtr SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4793:   ClassPtr LookupLocalClass(const String& name) const;
4937:            ((value >= 0) && (value < std::numeric_limits<classid_t>::max())));
5057:   // Eagerly compile all classes and functions in the library.
5060:   // Finalize all classes in all libraries.
5081:   // helper methods and classes. Allow look up of private classes.
5218:                                   const Array& classes_cache,
5283:   void set_classes_cache(const Array& cache) const;
5284:   ClassPtr LookupClass(Thread* thread, const Smi& name_index) const;
5285:   ClassPtr InsertClass(Thread* thread,
7615:                                        classid_t cid,
7741:   // Names of internal classes are mapped to their public interfaces.
7943: // AbstractType is an abstract superclass.
8071:   // Names of internal classes are mapped to their public interfaces.
8089:   StringPtr ClassName() const;
8409:            AbstractType::Handle(type()).HasTypeClass();
10173:   static intptr_t ElementSizeInBytes(classid_t cid) {
10177:   static TypedDataElementType ElementType(classid_t cid) {
10492:     const classid_t cid = typed_data.GetClassId();
11235:   ClassPtr GetClassReferent() const;
11314: ClassPtr Object::clazz() const {
11604: //     classes (e.g. 'Code', 'Smi', 'Object')
301:                                   : raw()->ptr()->GetClassId();
331:   // Object::DictionaryName() returns String::null(). Only subclasses
1073:   // dynamic and type parameters declared in superclasses filled in as declared
1211:     return raw_ptr()->direct_subclasses_;
1214:   void ClearDirectSubclasses() const;
1370:     return SynthesizedClassBit::decode(state_bits());
1679:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1694:                                              kClassFinalizedPos,
1695:                                              kClassFinalizedSize> {};
1698:                                            kClassLoadingPos,
1699:                                            kClassLoadingSize> {};
1702:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
1820:     return RoundedAllocationSize(sizeof(PatchClassLayout));
1822:   static bool IsInFullSnapshot(PatchClassPtr cls) {
1837:   static PatchClassPtr New();
2206:   void GetOneClassCheckAt(intptr_t index,
2212:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2213:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2229:   ICDataPtr AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2231:   ICDataPtr AsUnaryClassChecksForCid(intptr_t cid,
2238:   ICDataPtr AsUnaryClassChecksSortedByCount() const;
3567:       return IsTypedDataViewClassId(klass.id());
5061:   static ErrorPtr FinalizeAllClasses();
5105:   void EnsureTopLevelClassIsFinalized() const;
5125:   void InitClassDictionary() const;
6129:     return TargetOf(raw)->GetClassId();
6162:     return UnwrappedClassIdOf(obj.raw());
6167:   // UnwrappedClassOf(Wrap(r)) == UnwrappedClassOf(r) for all raw objects r,
6172:     if (!obj->IsWeakSerializationReference()) return obj->GetClassId();
6173:     return TargetClassIdOf(WeakSerializationReference::RawCast(obj));
6553:     return WeakSerializationReference::UnwrappedClassIdOf(raw->ptr()->owner_);
7169:   static inline ObjectPtr GetClassId(const Array& array, intptr_t index);
7437:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
7944: // Subclasses of AbstractType are Type and TypeParameter.
8992:     return raw()->GetClassId() == kOneByteStringCid;
8996:     return raw()->GetClassId() == kTwoByteStringCid;
9000:     return raw()->GetClassId() == kExternalOneByteStringCid;
9004:     return raw()->GetClassId() == kExternalTwoByteStringCid;
9008:     return IsExternalStringClassId(raw()->GetClassId());
9772:   bool IsImmutable() const { return raw()->GetClassId() == kImmutableArrayCid; }
10162:     return ElementSizeInBytes(raw()->GetClassId()) * Length();
10166:     return ElementType(raw()->GetClassId());
10170:     return element_size(ElementType(raw()->GetClassId()));
10180:     } else if (IsTypedDataClassId(cid)) {
10184:     } else if (IsTypedDataViewClassId(cid)) {
10189:       ASSERT(IsExternalTypedDataClassId(cid));
10343:     intptr_t cid = obj.raw()->GetClassId();
10344:     return IsTypedDataClassId(cid);
10427:     intptr_t cid = obj.raw()->GetClassId();
10428:     return IsExternalTypedDataClassId(cid);
10474:     intptr_t cid = data.raw()->GetClassId();
10475:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10476:     return IsExternalTypedDataClassId(cid);
10493:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
10593:     intptr_t cid = obj.raw()->GetClassId();
10594:     return IsFfiDynamicLibraryClassId(cid);
11327:   intptr_t cid = value->GetClassIdMayBeSmi();
11497:   return array.At((index * kEntryLength) + kClassIdIndex);
11550:   switch (str->GetClassId()) {
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-planes/combined.js: [ master, ]
5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
685:  * Find elements by tag or class name.
688:  * - {string} .className Class name.
5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12064:      * tags that have a specific class name.
12069:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13797:     'intro-finale/items-needle-thread',
13798:     'intro-finale/items-needle',
15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
704:     if (params.className) {
705:       query += '.' + params.className;
710:     if (params.tagName && params.className) {
711:       var els = el.getElementsByClassName(params.className);
723:     } else if (params.className) {
724:       return el.getElementsByClassName(params.className);
727:     if (params.className) {
734:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
738:         if (el.className.match(regExp)) {
6532:                                             className: 'jsb' });
6547:                                             className: 'lsbb' });
12080:             el.className.indexOf(params.excludeClassName) == -1) {
12109:             (el.parentNode.className.indexOf('ds') != -1)) {
12121:                                             className: 'lsbb' });
12155:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12205:       // “View Google in Tablet | Classic” switcher.
709:   } else if (document.getElementsByClassName) {
12079:         if (!params.excludeClassName ||
12162:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-embedded/combined.js: [ master, ]
5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
686:  * Find elements by tag or class name.
689:  * - {string} .className Class name.
5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'
12033:      * tags that have a specific class name.
12038:      * - {string} .excluseClassName Class name we’re avoiding (optional).
13843:             nItems = ['needle', 'noodles'];
15362:     'intro-finale/items-needle-thread',
15363:     'intro-finale/items-needle',
16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
705:     if (params.className) {
706:       query += '.' + params.className;
711:     if (params.tagName && params.className) {
712:       var els = el.getElementsByClassName(params.className);
724:     } else if (params.className) {
725:       return el.getElementsByClassName(params.className);
728:     if (params.className) {
735:       var regExp = new RegExp('(^|\ )' + params.className + '(\ |$)');
739:         if (el.className.match(regExp)) {
6505:                                             className: 'jsb' });
6520:                                             className: 'lsbb' });
12049:             el.className.indexOf(params.excludeClassName) == -1) {
12078:             (el.parentNode.className.indexOf('ds') != -1)) {
12090:                                             className: 'lsbb' });
12124:       els = engine.getDomElements({ tagName: 'td', className: 'sblc' });
12174:       // “View Google in Tablet | Classic” switcher.
710:   } else if (document.getElementsByClassName) {
12048:         if (!params.excludeClassName ||
12131:                           tagName: 'li', excludeClassName: 'gbtb' });
github.com/google/skia:modules/canvaskit/package-lock.json: [ master, ]
1560:             "needle": "^2.2.1",
403:         "class-utils": "^0.3.5",
1030:         "posix-character-classes": "^0.1.0",
645:     "class-utils": {
647:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1541:         "needle": {
2711:     "posix-character-classes": {
2713:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/paymentservice/package-lock.json: [ master, ]
1058:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
112:             "create-error-class": "^3.0.2",
566:     "create-error-class": {
568:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1043:         "needle": {
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/currencyservice/package-lock.json: [ master, ]
1036:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
120:             "create-error-class": "^3.0.2",
529:     "create-error-class": {
531:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1021:         "needle": {
github.com/kubernetes/website:themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/apache/activemq:activemq-web/src/main/resources/org/apache/activemq/web/prototype.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
skia.googlesource.com/skia:modules/canvaskit/package-lock.json: [ master, ] Duplicate result
chromium.googlesource.com/skia:modules/canvaskit/package-lock.json: [ master, ] Duplicate result
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
13274: const Class = function(info, mixin) {
6658:  function superPropertiesClass(constructor) {
11598: DomApiNative.prototype.classList;
12968:     static _finalizeClass() {
229:  * Wraps an ES6 class expression mixin such that the mixin is only applied
234:  * @param {T} mixin ES6 class expression mixin to wrap
257:     // copy inherited mixin set from the extended class, or the base class
283: class Debouncer {
1761: class DomModule extends HTMLElement {
2399:  * Element class mixin that provides basic meta-programming for creating one
2404:  * once at class definition time to create property accessors for properties
2413:  * @summary Element class mixin for reacting to property changes from
2419:      * @param {function(new:T)} superClass Class to apply mixin to.
2430:   class PropertiesChanged extends superClass {
2879:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
2996:  * Element class mixin that provides basic meta-programming for creating one
3005:  * -   Implement the `_propertiesChanged` callback on the class.
3006:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
3022:  * @summary Element class mixin for reacting to property changes from
3042:   class PropertyAccessors extends base {
3361:  * @summary Element class mixin that provides basic template parsing and stamping
3366:      * @param {function(new:T)} superClass Class to apply mixin to.
3376:   class TemplateStamp extends superClass {
4197:  * @param {Function} constructor Class that `_parseTemplate` is currently
4234:  * @param {Function} constructor Class that `_parseTemplate` is currently
4764:  * Element class mixin that provides meta-programming for Polymer's template
4768:  * property effects to an element class:
4795:  * @summary Element class mixin that provides meta-programming for Polymer's
4816:   class PropertyEffects extends propertyEffectsBase {
5381:      * Runs each class of effects for the batch of changed properties in
5944:     // -- static class methods ------------
6113:      *   bound template for the class. When true (as passed from
6316:           // when a class$ binding's initial literal value is set.
6317:           if (name == 'class' && node.hasAttribute('class')) {
6542: class HostStack {
6590:  * Registers a class prototype for telemetry purposes.
6652:   * Returns the super class constructor for the given class, if it is an
6656:   * @return {?PropertiesMixinConstructor} Super class constructor
6661:    // Note, the `PropertiesMixin` class below only refers to the class
6671:   * given class. Properties not in object format are converted to at
6701:  class PropertiesMixin extends base {
6736:     * Finalize an element class. This includes ensuring property
6738:     * `finalize` and finalizes the class constructor.
6754:     * @return {Object} Object containing properties for this class
6846:  * Element class mixin that provides the core API for Polymer's meta-programming
6851:  * used to configure Polymer's features for the class:
6887:  * The base class provides default implementations for the following standard
6906:  * @property importPath {string} Set to the value of the class's static
6910:  * @summary Element class mixin that provides the core API for Polymer's
6929:    * @param {PolymerElementConstructor} constructor Element class
6930:    * @return {PolymerElementProperties} Flattened properties for this class
6952:    * @param {PolymerElementConstructor} constructor Element class
6953:    * @return {Array} Array containing own observers for the given class
7016:    * @param {!PolymerElement} proto Element class prototype to add accessors
7070:    * @param {PolymerElementConstructor} klass Element class
7141:   class PolymerElement extends polymerElementBase {
7199:      *   this class
7224:      * Note that when subclassing, if the super class overrode the default
7229:      * If a subclass would like to modify the super class template, it should
7235:      *   class MySubClass extends MySuperClass {
7251:       // - constructor.template (this getter): the template for the class.
7253:       //     dom-module, or from the super class's template (or can be overridden
7303:      * @return {string} The import path for this element class
7337:      * Overrides the default `PropertyAccessors` to ensure class
7617:  * Class representing a static string value which can be used to filter
7618:  * strings by asseting that they have been created via this class. The
7621: class LiteralString {
7688:  *         <div class="shadowed">${this.partialTemplate}</div>
7716:  * Base class that provides the core API for Polymer's meta-programming
7726:  * @summary Custom element base class that provides the core API for Polymer's
7763:  * Element class mixin to skip strict dirty-checking for objects and arrays
7798:  * @summary Element class mixin to skip strict dirty-checking for objects
7808:   class MutableData extends superClass {
7837:  * Element class mixin to add the optional ability to skip strict
7873:  * @summary Element class mixin to optionally skip strict dirty-checking
7883:   class OptionalMutableData extends superClass {
7936: // Base class for HTMLTemplateElement extension that has property effects
7938: // class only because Babel (incorrectly) requires super() in the class
7980:  * Base class for TemplateInstance.
7985: const templateInstanceBase = PropertyEffects(class {});
7993: class TemplateInstanceBase extends templateInstanceBase {
8215:  * @suppress {missingProperties} class.prototype is not defined for some reason
8231:    * Anonymous class created by the templatize
8235:   let klass = class extends templatizerBase { };
8244:  * @suppress {missingProperties} class.prototype is not defined for some reason
8249:     // Provide data API and property effects on memoized template class
8259:         class TemplatizedTemplate extends templatizedBase {};
8329:  * Returns an anonymous `PropertyEffects` class bound to the
8330:  * `<template>` provided.  Instancing the class will result in the
8350:  *    method on the generated class should be called to forward host
8359:  * - `mutableData`: When `true`, the generated class will skip strict
8389:  * `templatize()` return the same class for all duplicates of a template.
8390:  * The class returned from `templatize()` is generated only once using
8402:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
8420:   // Get memoized base class for the prototypical template, which
8433:   // Subclass base class and add reference for this specific template
8435:   let klass = class TemplateInstance extends baseClass {};
8550: class DomIf extends PolymerElement {
8867: class StyleNode {
9500: class MixinMap {
9533: class ApplyShim {
10109: class CustomStyleInterface {
10234: class ApplyShimInterface {
10446:  * Element class mixin that provides API for adding Polymer's cross-platform
10456:  * @summary Element class mixin that provides API for adding Polymer's
10463:      * @param {function(new:T)} superClass Class to apply mixin to.
10472:       class GestureEventListeners extends superClass {
10943:  * Class that listens for changes (additions or removals) to
10964:  * class TestSelfObserve extends PolymerElement {
10980:  * @summary Class that listens for changes (additions or removals) to
10984: let FlattenedNodesObserver = class {
11264:  * Node API wrapper class returned from `Polymer.dom.(target)` when
11269: class DomApiNative {
11482:  * Event API wrapper class returned from `dom.(target)` when
11485: class EventApi {
11613:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
11719:  * Element class mixin that provides Polymer's "legacy" API intended to be
11730:  * @summary Element class mixin that provides Polymer's "legacy" API
11760:   class LegacyElement extends legacyElementBase {
11778:      *  closure for some reason even in a static method, rather than the class
11862:      * add support for class initialization via the `_registered` callback.
11888:      * Users may override this method to perform class registration time
11890:      * only once for the class.
12591:      * Toggles a CSS class on or off.
12593:      * @param {string} name CSS class name
12594:      * @param {boolean=} bool Boolean to force the class on or off.
12595:      *    When unspecified, the state of the class will be reversed.
12818:  * Applies a "legacy" behavior or array of behaviors to the provided class.
12827:  * @param {function(new:T)} klass Element class.
12828:  * @return {?} Returns a new Element class extended by the
12858: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
12859: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
12931:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
12932:   made. The list of behaviors was previously made into one generated class per
12937:   The generated class is directly tied to the info object and behaviors
12952:  * @param {function(new:HTMLElement)} Base base class to extend with info object
12954:  * @return {function(new:HTMLElement)} Generated class
12960:   // manages behavior and lifecycle processing (filled in after class definition)
12965:   class PolymerGenerated extends Base {
13047:       // only proceed if the generated class' prototype has not been registered.
13053:         // copy properties onto the generated class lazily if we're optimizing,
13058:         // and not the generated class prototype; if the element has been
13174:     // NOTE: ensure the behavior is extending a class with
13181:     // get flattened, deduped list of behaviors *not* already on super class
13205:  * Generates a class that extends `LegacyElement` based on the
13209:  * to the generated class.
13268:  *   to become class methods.
13270:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
13272:  * @return {function(new:HTMLElement)} Generated class
13276:     console.warn('Polymer.Class requires `info` argument');
13386:  * Legacy class factory and registration helper for defining Polymer
13391:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
13392:  *     customElements.define(info.is, Class(info));
13394:  * See `Class` for details on valid legacy metadata format for `info`.
13400:  *   to become class methods.
13401:  * @return {function(new: HTMLElement)} Generated class
13405:   // if input is a `class` (aka a function with a prototype), use the prototype
13411:     klass = Polymer.Class(info);
13417: Polymer.Class = Class;
13493:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
13499:    * @param {boolean=} mutableData When `true`, the generated class will skip
13518:    * returned is an instance of the anonymous class generated by `templatize`
13591: class DomBind extends domBindBase {
13735:  * class EmployeeList extends PolymerElement {
13806: class DomRepeat extends domRepeatBase {
14456:   class ArraySelectorMixin extends elementBase {
14774:  * class EmployeeList extends PolymerElement {
14827: class ArraySelector extends baseArraySelector {
14972: class CustomStyle extends HTMLElement {
2403:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
2420:      * @return {function(new:T)} superClass with mixin applied.
2422:     (superClass) => {
2426:    * @mixinClass
3025: const PropertyAccessors = dedupingMixin(superClass => {
3033:    const base = PropertiesChanged(superClass);
3037:    * @mixinClass
3367:      * @return {function(new:T)} superClass with mixin applied.
3369:     (superClass) => {
3373:    * @mixinClass
4798: const PropertyEffects = dedupingMixin(superClass => {
4807:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
4811:    * @mixinClass
5249:      * Overrides superclass implementation.
6261:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6295:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6356:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6642: const PropertiesMixin = dedupingMixin(superClass => {
6649:  const base = PropertiesChanged(superClass);
6696:   * @mixinClass
6706:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6718:     * Finalizes an element definition, including ensuring any super classes
6721:     * `_finalizeClass` to finalize each constructor in the prototype chain.
6726:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6731:        this._finalizeClass();
6742:    static _finalizeClass() {
6751:     * from super classes. Properties not in object format are converted to
6760:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6973:    * these values may not be changed. For example, a subclass cannot
7009:    * reflectToAttribute property not do so in a subclass. We've chosen to
7011:    * For example, a readOnly effect generates a special setter. If a subclass
7136:    * @mixinClass
7152:      * Override of PropertiesMixin _finalizeClass to create observers and
7156:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7158:     static _finalizeClass() {
7159:       super._finalizeClass();
7225:      * implementation and the subclass would like to provide an alternate
7240:      *         subContent.textContent = 'This came from MySubClass';
7258:       //     constructor.template, saved in _finalizeClass(). Note that before
7271:           // Next look for superclass template (call the super impl this
7272:           // way so that `this` points to the superclass)
7567:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7583:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7801: const MutableData = dedupingMixin(superClass => {
7805:    * @mixinClass
7876: const OptionalMutableData = dedupingMixin(superClass => {
7879:    * @mixinClass
7971: // Applies a DataTemplate subclass to a <template> instance
8217: function createTemplatizerClass(template, templateInfo, options) {
8250:     let klass = templateInfo.templatizeTemplateClass;
8258:       klass = templateInfo.templatizeTemplateClass =
8426:   let baseClass = templateInfo.templatizeInstanceClass;
8427:   if (!baseClass) {
8428:     baseClass = createTemplatizerClass(template, templateInfo, options);
8429:     templateInfo.templatizeInstanceClass = baseClass;
8502:  * Forces several classes of asynchronously queued tasks to flush:
9366:         // remove build comment so it is not needlessly copied into every element instance
10464:      * @return {function(new:T)} superClass with mixin applied.
10466:     (superClass) => {
10469:        * @mixinClass
11622:   // Note, `classList` is here only for legacy compatibility since it does not
11625:     'classList'
11657:   // Properties that should return the logical, not composed tree. Note, `classList`
11664:     'childNodes', 'children', 'classList'
11755:    * @mixinClass
12600:     toggleClass(name, bool, node) {
12603:         bool = !node.classList.contains(name);
12606:         node.classList.add(name);
12608:         node.classList.remove(name);
12928: /* Note about construction and extension of legacy classes.
12934:   manually. Note, there may *still* be multiple generated classes in the
12939:   behaviors not active on the superclass. In order to call through to the
12947:   and not `_finalizeClass`.
12967:     // explicitly not calling super._finalizeClass
12969:       // if calling via a subclass that hasn't been generated, pass through to super
12971:         super._finalizeClass();
13051:         // ensure superclass is registered first.
14441: let ArraySelectorMixin = dedupingMixin(superClass => {
14448:   let elementBase = ElementMixin(superClass);
14452:    * @mixinClass
3212:      * `__dataProto`, and it is up to the subclasser to decide how/when
6850:  * Subclassers may provide the following static getters to return metadata
6975:    * by subclasses.
7008:    * effects via subclassing. For example, a user might want to make a
12833:   return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
12958: function GenerateClassFromInfo(info, Base, behaviors) {
13280:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
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",
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