Found 188791 results in 4671 files, showing top 50 files (show more).
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/dart-lang/sdk:runtime/vm/object.h: [ master, ]
1025: class Class : public Object {
503:   static ClassPtr class_class() { return class_class_; }
504:   static ClassPtr dynamic_class() { return dynamic_class_; }
505:   static ClassPtr void_class() { return void_class_; }
506:   static ClassPtr type_parameters_class() { return type_parameters_class_; }
507:   static ClassPtr type_arguments_class() { return type_arguments_class_; }
508:   static ClassPtr patch_class_class() { return patch_class_class_; }
509:   static ClassPtr function_class() { return function_class_; }
510:   static ClassPtr closure_data_class() { return closure_data_class_; }
511:   static ClassPtr ffi_trampoline_data_class() {
514:   static ClassPtr field_class() { return field_class_; }
515:   static ClassPtr script_class() { return script_class_; }
516:   static ClassPtr library_class() { return library_class_; }
517:   static ClassPtr namespace_class() { return namespace_class_; }
518:   static ClassPtr kernel_program_info_class() {
521:   static ClassPtr code_class() { return code_class_; }
522:   static ClassPtr instructions_class() { return instructions_class_; }
523:   static ClassPtr instructions_section_class() {
526:   static ClassPtr instructions_table_class() {
529:   static ClassPtr object_pool_class() { return object_pool_class_; }
530:   static ClassPtr pc_descriptors_class() { return pc_descriptors_class_; }
531:   static ClassPtr code_source_map_class() { return code_source_map_class_; }
532:   static ClassPtr compressed_stackmaps_class() {
535:   static ClassPtr var_descriptors_class() { return var_descriptors_class_; }
536:   static ClassPtr exception_handlers_class() {
539:   static ClassPtr context_class() { return context_class_; }
540:   static ClassPtr context_scope_class() { return context_scope_class_; }
541:   static ClassPtr sentinel_class() { return sentinel_class_; }
542:   static ClassPtr api_error_class() { return api_error_class_; }
543:   static ClassPtr language_error_class() { return language_error_class_; }
544:   static ClassPtr unhandled_exception_class() {
547:   static ClassPtr unwind_error_class() { return unwind_error_class_; }
548:   static ClassPtr singletargetcache_class() { return singletargetcache_class_; }
549:   static ClassPtr unlinkedcall_class() { return unlinkedcall_class_; }
550:   static ClassPtr monomorphicsmiablecall_class() {
553:   static ClassPtr icdata_class() { return icdata_class_; }
554:   static ClassPtr megamorphic_cache_class() { return megamorphic_cache_class_; }
555:   static ClassPtr subtypetestcache_class() { return subtypetestcache_class_; }
556:   static ClassPtr loadingunit_class() { return loadingunit_class_; }
557:   static ClassPtr weak_serialization_reference_class() {
560:   static ClassPtr weak_array_class() { return weak_array_class_; }
854:   static ClassPtr class_class_;
1591:   UntaggedClass::ClassLoadingState class_loading_state() const {
1606:   bool is_synthesized_class() const {
1612:   bool is_enum_class() const { return EnumBit::decode(state_bits()); }
1654:   bool is_mixin_class() const { return MixinClassBit::decode(state_bits()); }
1657:   bool is_base_class() const { return BaseClassBit::decode(state_bits()); }
1660:   bool is_interface_class() const {
2092:   ClassPtr patched_class() const { return untag()->patched_class(); }
2093:   ClassPtr origin_class() const { return untag()->origin_class(); }
4965:   ClassPtr toplevel_class() const { return untag()->toplevel_class(); }
1439:   bool IsNullClass() const { return id() == kNullCid; }
1442:   bool IsDynamicClass() const { return id() == kDynamicCid; }
1445:   bool IsVoidClass() const { return id() == kVoidCid; }
1448:   bool IsNeverClass() const { return id() == kNeverCid; }
1451:   bool IsObjectClass() const { return id() == kInstanceCid; }
1460:   bool IsFutureOrClass() const { return id() == kFutureOrCid; }
1463:   bool IsClosureClass() const { return id() == kClosureCid; }
1464:   static bool IsClosureClass(ClassPtr cls) {
1469:   bool IsRecordClass() const {
1954:   class ClassFinalizedBits : public BitField<uint32_t,
1958:   class ClassLoadingBits : public BitField<uint32_t,
2086:   kCurrentClass,  // Consider type params of current class only.
2090: class PatchClass : public Object {
4812: class ClassDictionaryIterator : public DictionaryIterator {
5312:   ArrayPtr classes_cache() const { return untag()->classes_cache(); }
7717:   intptr_t SizeFromClass() const {
8568:   virtual bool HasTypeClass() const { return type_class_id() != kIllegalCid; }
8868:   virtual bool HasTypeClass() const {
9025:   virtual bool HasTypeClass() const { return false; }
9309:   virtual bool HasTypeClass() const { return false; }
11040:   virtual bool HasTypeClass() const { return false; }
341: #define DEFINE_CLASS_TESTER(clazz)                                             \
855:   static ClassPtr dynamic_class_;
856:   static ClassPtr void_class_;
857:   static ClassPtr type_parameters_class_;
858:   static ClassPtr type_arguments_class_;
859:   static ClassPtr patch_class_class_;
860:   static ClassPtr function_class_;
861:   static ClassPtr closure_data_class_;
862:   static ClassPtr ffi_trampoline_data_class_;
863:   static ClassPtr field_class_;
864:   static ClassPtr script_class_;
865:   static ClassPtr library_class_;
866:   static ClassPtr namespace_class_;
867:   static ClassPtr kernel_program_info_class_;
868:   static ClassPtr code_class_;
869:   static ClassPtr instructions_class_;
870:   static ClassPtr instructions_section_class_;
871:   static ClassPtr instructions_table_class_;
872:   static ClassPtr object_pool_class_;
873:   static ClassPtr pc_descriptors_class_;
874:   static ClassPtr code_source_map_class_;
875:   static ClassPtr compressed_stackmaps_class_;
876:   static ClassPtr var_descriptors_class_;
877:   static ClassPtr exception_handlers_class_;
878:   static ClassPtr context_class_;
879:   static ClassPtr context_scope_class_;
880:   static ClassPtr sentinel_class_;
881:   static ClassPtr singletargetcache_class_;
882:   static ClassPtr unlinkedcall_class_;
883:   static ClassPtr monomorphicsmiablecall_class_;
884:   static ClassPtr icdata_class_;
885:   static ClassPtr megamorphic_cache_class_;
886:   static ClassPtr subtypetestcache_class_;
887:   static ClassPtr loadingunit_class_;
888:   static ClassPtr api_error_class_;
889:   static ClassPtr language_error_class_;
890:   static ClassPtr unhandled_exception_class_;
891:   static ClassPtr unwind_error_class_;
892:   static ClassPtr weak_serialization_reference_class_;
893:   static ClassPtr weak_array_class_;
2775:   bool include_class_name = true;
4834:   Class& toplevel_class_;
9027:   virtual classid_t type_class_id() const { return kIllegalCid; }
9310:   virtual classid_t type_class_id() const { return kIllegalCid; }
11042:   virtual classid_t type_class_id() const { return kIllegalCid; }
333:   intptr_t GetClassId() const {
596:   static const ClassId kClassId = kObjectCid;
1423:   GrowableObjectArrayPtr direct_subclasses() const {
1428:   GrowableObjectArrayPtr direct_subclasses_unsafe() const {
1479:   static intptr_t GetClassId(ClassPtr cls) {
1922:     kClassFinalizedPos = 2,
1923:     kClassFinalizedSize = 2,
1924:     kClassLoadingPos = kClassFinalizedPos + kClassFinalizedSize,  // = 4
1925:     kClassLoadingSize = 2,
1927:     kSynthesizedClassBit,
1937:     kMixinClassBit,
1938:     kBaseClassBit,
1939:     kInterfaceClassBit,
1963:   class SynthesizedClassBit
1974:   class MixinClassBit : public BitField<uint32_t, bool, kMixinClassBit, 1> {};
1975:   class BaseClassBit : public BitField<uint32_t, bool, kBaseClassBit, 1> {};
1976:   class InterfaceClassBit
2514:   ICDataPtr AsUnaryClassChecks() const { return AsUnaryClassChecksForArgNr(0); }
2791:   static NameFormattingParams DisambiguatedWithoutClassName(
6867:   classid_t OwnerClassId() const { return OwnerClassIdOf(ptr()); }
6868:   static classid_t OwnerClassIdOf(CodePtr raw) {
7334:     kClassIdIndex,
9316:   bool IsClassTypeParameter() const { return !IsFunctionTypeParameter(); }
10149:   static const ClassId kClassId = kOneByteStringCid;
10273:   static const ClassId kClassId = kTwoByteStringCid;
10351:   static const ClassId kClassId = kExternalOneByteStringCid;
10440:   static const ClassId kClassId = kExternalTwoByteStringCid;
10742:   static const ClassId kClassId = kImmutableArrayCid;
11853:   static const ClassId kClassId = kConstMapCid;
11954:   static const ClassId kClassId = kConstSetCid;
13033: 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 CallSiteResetter;
67: class CodeStatistics;
68: class IsolateGroupReloadContext;
69: class ObjectGraphCopier;
70: class FunctionTypeMapping;
71: class NativeArguments;
73: #define REUSABLE_FORWARD_DECLARATION(name) class Reusable##name##HandleScope;
77: class Symbols;
78: class BaseTextBuffer;
87: // ContainsCompressedPointers() returns the same value for AllStatic class and
88: // class used for handles.
233:   friend class object##MessageSerializationCluster;                            \
234:   friend class object##MessageDeserializationCluster;
250:   friend class Object;
261:   friend class StackFrame;                                                     \
262:   friend class Thread;                                                         \
287:   friend class Object;                                                         \
288:   friend class StackFrame;                                                     \
289:   friend class Thread;                                                         \
307: class Object {
340: // Class testers.
352:   CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
353: #undef DEFINE_CLASS_TESTER
451:   V(Class, null_class)                                                         \
512:     return ffi_trampoline_data_class_;
519:     return kernel_program_info_class_;
524:     return instructions_section_class_;
527:     return instructions_table_class_;
533:     return compressed_stackmaps_class_;
537:     return exception_handlers_class_;
545:     return unhandled_exception_class_;
551:     return monomorphicsmiablecall_class_;
558:     return weak_serialization_reference_class_;
586:   template <class FakeObject>
611:     //   core impl class name shown -> _OneByteString
640:   // class which has the same name as an already existing function, or
647:   enum class NameDisambiguation {
684:   // Explicit cast to silence -Wdynamic-class-memaccess.
805:   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
825:     // Indicates this class cannot be extended by dart code.
834:   static void RegisterClass(const Class& cls,
837:   static void RegisterPrivateClass(const Class& cls,
899:   friend void ClassTable::Register(const Class& cls);
901:   friend class Closure;
902:   friend class InstanceDeserializationCluster;
903:   friend class ObjectGraphCopier;  // For Object::InitializeObject
904:   friend class Simd128MessageDeserializationCluster;
905:   friend class OneByteString;
906:   friend class TwoByteString;
907:   friend class ExternalOneByteString;
908:   friend class ExternalTwoByteString;
909:   friend class Thread;
912:   friend class Reusable##name##HandleScope;
944: class PassiveObject : public Object {
989: // The first string in the triplet is a type name (usually a class).
994: enum class Nullability : uint8_t {
1002: enum class TypeEquality {
1010: enum class NNBDMode {
1018: enum class NNBDCompiledMode {
1133:   // If the interface of this class has a single concrete implementation, either
1140:   // propagated to this class's superclass and interfaces.
1141:   bool NoteImplementor(const Class& implementor) const;
1156:   // The mixin for this class if one exists. Otherwise, returns a raw pointer
1157:   // to this class.
1160:   // The NNBD mode of the library declaring this class.
1201:   // declared by this class.
1209:   // instance of this class, parameterized with declared
1210:   // type parameters of this class.
1243:   // Includes type arguments of the super class.
1246:   // Return true if this class declares type parameters.
1259:   // If this class is parameterized, each instance has a type_arguments field.
1274:         compiler::target::Class::kNoTypeArguments) {
1275:       return compiler::target::Class::kNoTypeArguments;
1287:         target_value_in_bytes == RTN::Class::kNoTypeArguments) {
1289:              target_value_in_bytes == RTN::Class::kNoTypeArguments);
1291:       target_value = RTN::Class::kNoTypeArguments;
1316:   // The super type of this class, Object type if not explicitly specified.
1326:   // Asserts that the class of the super type has been resolved.
1327:   // If |class_table| is provided it will be used to resolve class id to the
1328:   // actual class object, instead of using current class table on the isolate
1330:   ClassPtr SuperClass(ClassTable* class_table = nullptr) const;
1342:   // type class. If [this] and [cls] are the same class, then the path is empty.
1351:                            const Class& cls,
1355:                            const Class& cls,
1364:   // class as [type]. If [this] is the type class of [type], then the path is
1369:   // class given type arguments for an instance of [this].
1371:   // Note: There may be multiple paths to [type]'s type class, but the result of
1384:   // If [this] is a subtype of a type with type class [cls], then this
1387:   // class type parameters corresponding to the type parameters of [this].
1391:   // If [this] is not a subtype of a type with type class [cls], returns null.
1392:   TypePtr GetInstantiationOf(Zone* zone, const Class& cls) const;
1395:   // where [cls] is the type class of [type], n is the number of type arguments
1397:   // free class type parameters corresponding to the type parameters of [this].
1401:   // If [this] is not a subtype of a type with type class [cls], returns null.
1405:   // Returns the list of classes directly implementing this class.
1418:   void AddDirectImplementor(const Class& subclass, bool is_mixin) const;
1422:   // Returns the list of classes having this class as direct superclass.
1435:   void AddDirectSubclass(const Class& subclass) const;
1438:   // Check if this class represents the class of null.
1441:   // Check if this class represents the 'dynamic' class.
1444:   // Check if this class represents the 'void' class.
1447:   // Check if this class represents the 'Never' class.
1450:   // Check if this class represents the 'Object' class.
1453:   // Check if this class represents the 'Function' class.
1456:   // Check if this class represents the 'Future' class.
1459:   // Check if this class represents the 'FutureOr' class.
1462:   // Check if this class represents the 'Closure' class.
1468:   // Check if this class represents the 'Record' class.
1487:       const Class& cls,
1494:   // Check if this is the top level class.
1502:   // Returns an array of instance and static fields defined by this class.
1512:   intptr_t FindFieldIndex(const Field& needle) const;
1515:   // If this is a dart:internal.ClassID class, then inject our own const
1520:   // Returns an array of all instance fields of this class and its superclasses
1522:   // If |class_table| is provided it will be used to resolve super classes by
1523:   // class id, instead of the current class_table stored in the isolate.
1524:   ArrayPtr OffsetToFieldMap(ClassTable* class_table = nullptr) const;
1541:   intptr_t FindFunctionIndex(const Function& needle) const;
1543:   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
1581:   // Returns true if any class implements this interface via `implements`.
1583:   // instances of this class or its subclasses.
1596:     return class_loading_state() >= UntaggedClass::kDeclarationLoaded;
1602:     return class_loading_state() >= UntaggedClass::kTypeFinalized;
1609:   void set_is_synthesized_class() const;
1610:   void set_is_synthesized_class_unsafe() const;
1613:   void set_is_enum_class() const;
1640:   // Tests if this is a mixin application class which was desugared
1641:   // to a normal class by kernel mixin transformation
1655:   void set_is_mixin_class() const;
1658:   void set_is_base_class() const;
1663:   void set_is_interface_class() const;
1722:   intptr_t FindInvocationDispatcherFunctionIndex(const Function& needle) const;
1749:   // class and return the resulting value, or an error object if evaluating the
1759:   // Load class declaration (super type, interfaces, type parameters and
1766:   // Allocate a class used for VM internal objects.
1767:   template <class FakeObject, class TargetFakeObject>
1768:   static ClassPtr New(IsolateGroup* isolate_group, bool register_class = true);
1775:                       bool register_class = true);
1781:   static ClassPtr NewStringClass(intptr_t class_id,
1785:   static ClassPtr NewTypedDataClass(intptr_t class_id,
1789:   static ClassPtr NewTypedDataViewClass(intptr_t class_id,
1792:       intptr_t class_id,
1796:   static ClassPtr NewExternalTypedDataClass(intptr_t class_id,
1800:   static ClassPtr NewPointerClass(intptr_t class_id,
1805:   // TODO(srdjan): Also register kind of CHA optimization (e.g.: leaf class,
1809:   void DisableCHAOptimizedCode(const Class& subclass);
1815:   // Return the list of code objects that were compiled using CHA of this class.
1816:   // These code objects will be invalidated if new subclasses of this class
1826:                              const Class& old_cls) const;
1829:                                      const Class& new_cls) const;
1830:   void CopyCanonicalConstants(const Class& old_cls) const;
1831:   void CopyDeclarationType(const Class& old_cls) const;
1832:   void CheckReload(const Class& replacement,
1877:   void MarkFieldBoxedDuringReload(ClassTable* class_table,
1889:   // Caches the declaration type of this class.
1899:   bool CanReloadFinalized(const Class& replacement,
1901:   bool CanReloadPreFinalized(const Class& replacement,
1905:   bool RequiresInstanceMorphing(ClassTable* class_table,
1906:                                 const Class& replacement) const;
1908:   template <class FakeInstance, class TargetFakeInstance>
1941:     // Whether instances of the class cannot be sent across ports.
1944:     //    - class is marked with `@pramga('vm:isolate-unsendable')
1945:     //    - super class / super interface classes are marked as unsendable.
1946:     //    - class has native fields.
1948:     // True if this class has `@pramga('vm:isolate-unsendable') annotation or
1949:     // base class or implemented interfaces has this bit.
1952:   class ConstBit : public BitField<uint32_t, bool, kConstBit, 1> {};
1953:   class ImplementedBit : public BitField<uint32_t, bool, kImplementedBit, 1> {};
1962:   class AbstractBit : public BitField<uint32_t, bool, kAbstractBit, 1> {};
1965:   class FieldsMarkedNullableBit
1967:   class EnumBit : public BitField<uint32_t, bool, kEnumBit, 1> {};
1968:   class TransformedMixinApplicationBit
1970:   class IsAllocatedBit : public BitField<uint32_t, bool, kIsAllocatedBit, 1> {};
1971:   class IsLoadedBit : public BitField<uint32_t, bool, kIsLoadedBit, 1> {};
1972:   class HasPragmaBit : public BitField<uint32_t, bool, kHasPragmaBit, 1> {};
1973:   class SealedBit : public BitField<uint32_t, bool, kSealedBit, 1> {};
1978:   class FinalBit : public BitField<uint32_t, bool, kFinalBit, 1> {};
1979:   class IsIsolateUnsendableBit
1981:   class IsIsolateUnsendableDueToPragmaBit
2027:     ASSERT(is_finalized());  // This bit is initialized in class finalizer.
2043:   // Calculates number of type arguments of this class.
2048:   // Assigns empty array to all raw class array fields.
2062:   // Allocate an instance class which has a VM implementation.
2063:   template <class FakeInstance, class TargetFakeInstance>
2066:                       bool register_class = true,
2069:   // Helper that calls 'Class::New<Instance>(kIllegalCid)'.
2072:   FINAL_HEAP_OBJECT_IMPLEMENTATION(Class, Object);
2073:   friend class AbstractType;
2074:   friend class Instance;
2075:   friend class Object;
2076:   friend class Type;
2077:   friend class Intrinsifier;
2078:   friend class ProgramWalker;
2079:   friend class Precompiler;
2080:   friend class ClassFinalizer;
2085:   kAny,           // Consider type params of current class and functions.
2117:     return Class::IsInFullSnapshot(cls->untag()->patched_class());
2120:   static PatchClassPtr New(const Class& patched_class,
2121:                            const Class& origin_class);
2123:   static PatchClassPtr New(const Class& patched_class, const Script& source);
2126:   void set_patched_class(const Class& value) const;
2127:   void set_origin_class(const Class& value) const;
2133:   friend class Class;
2136: class SingleTargetCache : public Object {
2166:   friend class Class;
2169: class MonomorphicSmiableCall : public Object {
2190:   friend class Class;
2193: class CallSiteData : public Object {
2222:   friend class ICData;
2223:   friend class MegamorphicCache;
2226: class UnlinkedCall : public CallSiteData {
2242:   friend class ICData;  // For set_*() methods.
2247:   friend class Class;
2279: class ICData : public CallSiteData {
2449:   // Ensures there is a check for [class_ids].
2454:   void EnsureHasCheck(const GrowableArray<intptr_t>& class_ids,
2458:   // Adds one more class test to ICData. Length of 'classes' must be equal to
2460:   void AddCheck(const GrowableArray<intptr_t>& class_ids,
2466:   // Ensures there is a receiver check for [receiver_class_id].
2472:       intptr_t receiver_class_id,
2478:   // Adds sorted so that Smi is the first class-id. Use only for
2480:   void AddReceiverCheck(intptr_t receiver_class_id,
2489:                   GrowableArray<intptr_t>* class_ids,
2491:   void GetClassIdsAt(intptr_t index, GrowableArray<intptr_t>* class_ids) const;
2495:                           intptr_t* class_id,
2524:   bool HasReceiverClassId(intptr_t class_id) const;
2645:   void AddCheckInternal(const GrowableArray<intptr_t>& class_ids,
2648:   void AddReceiverCheckInternal(intptr_t receiver_class_id,
2687:   class NumArgsTestedBits : public BitField<uint32_t,
2691:   class TrackingExactnessBit : public BitField<uint32_t,
2695:   class DeoptReasonBits : public BitField<uint32_t,
2699:   class RebindRuleBits : public BitField<uint32_t,
2703:   class MegamorphicBit
2706:   class ReceiverCannotBeSmiBit : public BitField<uint32_t,
2739:   friend class CallSiteResetter;
2740:   friend class CallTargets;
2741:   friend class Class;
2742:   friend class VMDeserializationRoots;
2743:   friend class ICDataTestTask;
2744:   friend class VMSerializationRoots;
2771:   // By default function name includes the name of the enclosing class if any.
2772:   // However in some contexts this information is redundant and class name
2773:   // is already known. In this case setting |include_class_name| to false
2794:     params.include_class_name = false;
2801:     params.include_class_name = false;
2807: class Function : public Object {
2873:   // parameter of this function and R is a type parameter of class C, the owner
2879:   // parameter of this function and R is a type parameter of class C, the owner
2888:   // generic functions or class type parameters.
2904:   NNBDMode nnbd_mode() const { return Class::Handle(origin()).nnbd_mode(); }
3749:       const Class& klass = Class::Handle(Owner());
3758:       const Class& klass = Class::Handle(Owner());
3886:   class Name##Bit : public BitField<uint8_t, bool, k##Name##Pos, 1> {};
3915:   // static: Considered during class-side or top-level resolution rather than
4021:   class KindBits : public BitField<uint32_t,
4026:   class RecognizedBits : public BitField<uint32_t,
4030:   class ModifierBits : public BitField<uint32_t,
4036:   class name##Bit : public BitField<uint32_t, bool, k##name##Bit, 1> {};
4078:   friend class Class;
4079:   friend class Parser;  // For set_eval_script.
4082:   friend class UntaggedFunction;
4083:   friend class ClassFinalizer;  // To reset parent_function.
4084:   friend class Type;            // To adjust parent_function.
4085:   friend class Precompiler;     // To access closure data.
4086:   friend class ProgramVisitor;  // For set_parameter_types/names.
4089: class ClosureData : public Object {
4120:   friend class Class;
4121:   friend class Function;
4122:   friend class Precompiler;  // To wrap parent functions in WSRs.
4125: enum class EntryPointPragma {
4133: class FfiTrampolineData : public Object {
4160:   friend class Class;
4161:   friend class Function;
4164: class Field : public Object {
4267:   // Called during class finalization.
4291:   ClassPtr Origin() const;  // Either mixin class, or same as owner().
4298:   // Used by class finalizer, otherwise initialized in constructor.
4402:   // Return class id that any non-null value read from this field is guaranteed
4403:   // to have or kDynamicCid if such class id is not known.
4522:   // assumptions about guarded class id and nullability of this field.
4598:   friend class StoreFieldInstr;  // Generated code access to bit field.
4616:   class ConstBit : public BitField<uint16_t, bool, kConstBit, 1> {};
4617:   class StaticBit : public BitField<uint16_t, bool, kStaticBit, 1> {};
4618:   class FinalBit : public BitField<uint16_t, bool, kFinalBit, 1> {};
4619:   class HasNontrivialInitializerBit
4621:   class UnboxedBit : public BitField<uint16_t, bool, kUnboxedBit, 1> {};
4622:   class ReflectableBit : public BitField<uint16_t, bool, kReflectableBit, 1> {};
4623:   class InitializerChangedAfterInitializationBit
4628:   class HasPragmaBit : public BitField<uint16_t, bool, kHasPragmaBit, 1> {};
4629:   class CovariantBit : public BitField<uint16_t, bool, kCovariantBit, 1> {};
4630:   class GenericCovariantImplBit
4632:   class IsLateBit : public BitField<uint16_t, bool, kIsLateBit, 1> {};
4633:   class IsExtensionMemberBit
4635:   class NeedsLoadGuardBit
4637:   class HasInitializerBit
4671:   friend class Class;
4672:   friend class UntaggedField;
4673:   friend class FieldSerializationCluster;
4674:   friend class FieldDeserializationCluster;
4677: class Script : public Object {
4788:   friend class Class;
4789:   friend class Precompiler;
4792: class DictionaryIterator : public ValueObject {
4808:   friend class ClassDictionaryIterator;
4816:     // one top-level class per library left, not an array to iterate over.
4825:     return (next_ix_ < size_) || !toplevel_class_.IsNull();
4828:   // Returns a non-null raw class.
4839: class Library : public Object {
4902:   void AddClass(const Class& cls) const;
4938:   void AddAnonymousClass(const Class& cls) const;
4966:   void set_toplevel_class(const Class& value) const;
5141:   // Lookup class in the core lib which also contains various VM
5143:   static ClassPtr LookupCoreClass(const String& class_name);
5147:                                  const char* class_name,
5219:   friend class Bootstrap;
5220:   friend class Class;
5221:   friend class Debugger;
5222:   friend class DictionaryIterator;
5223:   friend class Isolate;
5224:   friend class LibraryDeserializationCluster;
5225:   friend class Namespace;
5226:   friend class Object;
5227:   friend class Precompiler;
5232: class Namespace : public Object {
5256:   friend class Class;
5257:   friend class Precompiler;
5260: class KernelProgramInfo : public Object {
5317:                        const Class& klass) const;
5323:   friend class Class;
5329: class ObjectPool : public Object {
5466:   friend class Class;
5467:   friend class Object;
5468:   friend class UntaggedObjectPool;
5471: class Instructions : public Object {
5480:   class SizeBits : public BitField<uint32_t, uint32_t, kSizePos, kSizeSize> {};
5481:   class FlagsBits : public BitField<uint32_t, bool, kFlagsPos, kFlagsSize> {};
5616:     // because there are no subclasses for the Instructions class, and the sizes
5656:   friend class Class;
5657:   friend class Code;
5658:   friend class AssemblyImageWriter;
5659:   friend class BlobImageWriter;
5660:   friend class ImageWriter;
5673: class InstructionsSection : public Object {
5694:   // There are no public instance methods for the InstructionsSection class, as
5695:   // all access to the contents is handled by methods on the Image class.
5703:   friend class Class;
5709: class InstructionsTable : public Object {
5773:   friend class Class;
5774:   friend class Deserializer;
5777: class LocalVarDescriptors : public Object {
5815:   friend class Class;
5816:   friend class Object;
5819: class PcDescriptors : public Object {
5852:   class Iterator : public ValueObject {
5908:     friend class PcDescriptors;
5953:   friend class Class;
5954:   friend class Object;
5957: class CodeSourceMap : public Object {
6001:   friend class Class;
6002:   friend class Object;
6005: class CompressedStackMaps : public Object {
6070:   class RawPayloadHandle {
6120:   class Iterator {
6288:     friend class StackMapEntry;
6302:   friend class Class;
6305: class ExceptionHandlers : public Object {
6364:   friend class Class;
6365:   friend class Object;
6389: class WeakSerializationReference : public Object {
6421:   friend class Class;
6424: class WeakArray : public Object {
6486:   friend class Class;
6487:   friend class Object;
6490: class Code : public Object {
6716:   enum class PoolAttachment {
6721:   class KindField : public BitField<intptr_t, CallKind, 0, 3> {};
6722:   class EntryPointField
6724:   class OffsetField
6750:   class Comments : public ZoneAllocated, public CodeComments {
6773:     friend class Code;
6852:   // a Function. It is up to the caller to guarantee it isn't a stub, class,
7001:   friend class UntaggedObject;  // For UntaggedObject::SizeFromClass().
7002:   friend class UntaggedCode;
7014:   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
7018:   class ForceOptimizedBit
7021:   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
7027:   class DiscardedBit : public BitField<int32_t, bool, kDiscardedBit, 1> {};
7029:   class PtrOffBits
7108:   friend class Class;
7109:   friend class CodeTestHelper;
7110:   friend class StubCode;     // for set_object_pool
7111:   friend class Precompiler;  // for set_object_pool
7112:   friend class FunctionSerializationCluster;
7113:   friend class CodeSerializationCluster;
7114:   friend class CodeDeserializationCluster;
7115:   friend class Deserializer;           // for InitializeCachedEntryPointsFrom
7116:   friend class StubCode;               // for set_object_pool
7117:   friend class MegamorphicCacheTable;  // for set_object_pool
7118:   friend class CodePatcher;            // for set_instructions
7119:   friend class ProgramVisitor;         // for set_instructions
7122:   friend class UntaggedFunction;
7123:   friend class CallSiteResetter;
7124:   friend class CodeKeyValueTrait;  // for UncheckedEntryPointOffset
7125:   friend class InstanceCall;       // for StorePointerUnaligned
7126:   friend class StaticCall;         // for StorePointerUnaligned
7129: class Context : public Object {
7193:   friend class Class;
7194:   friend class Object;
7197: // The ContextScope class makes it possible to delay the compilation of a local
7207: class ContextScope : public Object {
7298:   friend class Class;
7299:   friend class Object;
7302: // Class of special sentinel values:
7313: class Sentinel : public Object {
7323:   friend class Class;
7324:   friend class Object;
7327: class MegamorphicCache : public CallSiteData {
7361:   void EnsureContains(const Smi& class_id, const Object& target) const;
7362:   ObjectPtr Lookup(const Smi& class_id) const;
7369:   friend class Class;
7370:   friend class MegamorphicCacheTable;
7371:   friend class ProgramVisitor;
7376:   void InsertLocked(const Smi& class_id, const Object& target) const;
7378:   ObjectPtr LookupLocked(const Smi& class_id) const;
7380:   void InsertEntryLocked(const Smi& class_id, const Object& target) const;
7384:                               const Smi& class_id,
7393: class SubtypeTestCache : public Object {
7408:   void AddCheck(const Object& instance_class_id_or_signature,
7417:                 Object* instance_class_id_or_signature,
7429:                        Object* instance_class_id_or_signature,
7444:   bool HasCheck(const Object& instance_class_id_or_signature,
7499:   friend class Class;
7500:   friend class VMSerializationRoots;
7501:   friend class VMDeserializationRoots;
7504: class LoadingUnit : public Object {
7547:   friend class Class;
7550: class Error : public Object {
7558: class ApiError : public Error {
7576:   friend class Class;
7579: class LanguageError : public Error {
7642:   friend class Class;
7645: class UnhandledException : public Error {
7674:   friend class Class;
7675:   friend class ObjectStore;
7678: class UnwindError : public Error {
7698:   friend class Class;
7701: // Instance is the base class for all instance objects (aka the Object class
7703: class Instance : public Object {
7719:     const Class& cls = Class::Handle(clazz());
7746:   // instance's class and all its superclasses.
7793:   // class implementing a 'call' method, return true and set the function
7816:       const Class& method_cls,
7832:   static InstancePtr New(const Class& cls, Heap::Space space = Heap::kNew);
7833:   static InstancePtr NewAlreadyFinalized(const Class& cls,
7842:   // only the class_id is different. So, it is safe to use subtype instances in
7893:   // They are needed due to the extraction of the class in IsValidFieldOffset.
7920:   friend class ByteBuffer;
7921:   friend class Class;
7922:   friend class Closure;
7923:   friend class Pointer;
7924:   friend class DeferredObject;
7925:   friend class FlowGraphSerializer;
7926:   friend class FlowGraphDeserializer;
7927:   friend class RegExp;
7928:   friend class StubCode;
7929:   friend class TypedDataView;
7930:   friend class InstanceSerializationCluster;
7931:   friend class InstanceDeserializationCluster;
7932:   friend class ClassDeserializationCluster;  // vtable
7933:   friend class InstanceMorpher;
7934:   friend class Obfuscator;  // RawGetFieldAtOffset, RawSetFieldAtOffset
7937: class LibraryPrefix : public Instance {
7972:   friend class Class;
7977: class TypeParameters : public Object {
8023:              bool are_class_type_parameters,
8051:   friend class Class;
8052:   friend class ClassFinalizer;
8053:   friend class FlowGraphSerializer;
8054:   friend class FlowGraphDeserializer;
8055:   friend class Function;
8056:   friend class FunctionType;
8057:   friend class Object;
8058:   friend class Precompiler;
8062: class TypeArguments : public Instance {
8142:   // a raw (null) function type arguments, i.e. consider each class type
8206:       const Class& instantiator_class,
8225:                                              const Class& cls) const;
8232:   // Use [GetInstanceTypeArguments] on a class or a type if full vector is
8235:                                                const Class& cls) const;
8237:   // Add the class name and URI of each type argument of this vector to the uris
8244:   // type from the various type argument vectors (class instantiator, function,
8268:   class Cache : public ValueObject {
8454:     friend class TypeArguments;  // For asserts against data_.
8504:   // If raw_instantiated is true, consider each class type parameter to be first
8518:   friend class AbstractType;
8519:   friend class Class;
8520:   friend class ClearTypeHashVisitor;
8521:   friend class Object;
8526: class AbstractType : public Instance {
8569:   virtual classid_t type_class_id() const;
8570:   virtual ClassPtr type_class() const;
8591:   // instantiation. Consider a class C<T> declaring a non-generic method
8593:   // generic function bar<B> as argument and its function type refers to class
8665:   // Add the class name and URI of each occurring type to the uris
8672:   // The name of this type's class, i.e. without the type argument names of this
8677:   bool IsDynamicType() const { return type_class_id() == kDynamicCid; }
8680:   bool IsVoidType() const { return type_class_id() == kVoidCid; }
8692:   bool IsObjectType() const { return type_class_id() == kInstanceCid; }
8713:   bool IsBoolType() const { return type_class_id() == kBoolCid; }
8734:   bool IsNumberType() const { return type_class_id() == kNumberCid; }
8737:   bool IsSmiType() const { return type_class_id() == kSmiCid; }
8740:   bool IsMintType() const { return type_class_id() == kMintCid; }
8758:   bool IsFutureOrType() const { return type_class_id() == kFutureOrCid; }
8773:   // Returns true if this type has a type class permitted by SendPort.send for
8823:   // NextFieldOffset() are required to register class _AbstractType.
8855:   friend class Class;
8856:   friend class ClearTypeHashVisitor;
8857:   friend class Function;
8858:   friend class TypeArguments;
8861: // A Type consists of a class, possibly parameterized with type
8863: class Type : public AbstractType {
8869:     ASSERT(type_class_id() != kIllegalCid);
8873:   virtual classid_t type_class_id() const;
8874:   virtual ClassPtr type_class() const;
8875:   void set_type_class(const Class& value) const;
8894:   // canonicalization (passed-in cls must match type_class()).
8895:   bool IsDeclarationTypeOf(const Class& cls) const;
8986:   // The finalized type of the given non-parameterized class.
8987:   static TypePtr NewNonParameterizedType(const Class& type_class);
8989:   static TypePtr New(const Class& clazz,
8998:   void set_type_class_id(intptr_t id) const;
9003:   friend class Class;
9004:   friend class TypeArguments;
9010: class FunctionType : public AbstractType {
9292:   friend class Class;
9293:   friend class Function;
9296: // A TypeParameter represents a type parameter of a parameterized class.
9300: // the class HashMap<K, V>. At compile time, the TypeParameter is not
9303: // as type argument (rather than type parameter) of the parameterized class.
9306: class TypeParameter : public AbstractType {
9326:   classid_t parameterized_class_id() const;
9327:   void set_parameterized_class_id(classid_t value) const;
9328:   ClassPtr parameterized_class() const;
9379:   static const char* CanonicalNameCString(bool is_class_type_parameter,
9387:   // 'owner' is a Class or FunctionType.
9401:   friend class Class;
9404: class Number : public Instance {
9412:   friend class Class;
9415: class Integer : public Number {
9487:   friend class Class;
9490: class Smi : public Integer {
9519:   static ClassPtr Class();
9545:     // Indicates this class cannot be extended by dart code.
9552:   friend class Api;  // For ValueFromRaw
9553:   friend class Class;
9554:   friend class Object;
9555:   friend class ReusableSmiHandleScope;
9556:   friend class Thread;
9559: class SmiTraits : AllStatic {
9571: class Mint : public Integer {
9602:   friend class Integer;
9603:   friend class MintMessageDeserializationCluster;
9613:   friend class Class;
9614:   friend class Number;
9617: // Class Double represents class Double in corelib_impl, which implements
9618: // abstract class double in corelib.
9619: class Double : public Number {
9651:   friend class Class;
9652:   friend class Number;
9656: class Symbol : public AllStatic {
9658:   static bool IsSymbolCid(Thread* thread, classid_t class_id);
9664: class String : public Instance {
9687:   class CodePointIterator : public ValueObject {
10009:   friend class Class;
10010:   friend class Symbols;
10011:   friend class StringSlice;  // SetHash
10013:   friend class CharArray;     // SetHash
10014:   friend class ConcatString;  // SetHash
10015:   friend class OneByteString;
10016:   friend class TwoByteString;
10017:   friend class ExternalOneByteString;
10018:   friend class ExternalTwoByteString;
10019:   friend class UntaggedOneByteString;
10020:   friend class RODataSerializationCluster;  // SetHash
10021:   friend class Pass2Visitor;                // Stack "handle"
10025: class StringHasher : public ValueObject {
10050: class OneByteString : public AllStatic {
10175:   friend class Class;
10176:   friend class ExternalOneByteString;
10177:   friend class FlowGraphSerializer;
10178:   friend class ImageWriter;
10179:   friend class String;
10180:   friend class StringHasher;
10181:   friend class Symbols;
10182:   friend class Utf8;
10183:   friend class OneByteStringMessageSerializationCluster;
10184:   friend class Deserializer;
10185:   friend class JSONWriter;
10188: class TwoByteString : public AllStatic {
10297:   friend class Class;
10298:   friend class FlowGraphSerializer;
10299:   friend class ImageWriter;
10300:   friend class String;
10301:   friend class StringHasher;
10302:   friend class Symbols;
10303:   friend class TwoByteStringMessageSerializationCluster;
10304:   friend class JSONWriter;
10307: class ExternalOneByteString : public AllStatic {
10388:     // Indicates this class cannot be extended by dart code.
10392:   friend class Class;
10393:   friend class String;
10394:   friend class StringHasher;
10395:   friend class Symbols;
10396:   friend class Utf8;
10397:   friend class JSONWriter;
10400: class ExternalTwoByteString : public AllStatic {
10477:     // Indicates this class cannot be extended by dart code.
10481:   friend class Class;
10482:   friend class String;
10483:   friend class StringHasher;
10484:   friend class Symbols;
10485:   friend class JSONWriter;
10493: // Class Bool implements Dart core class bool.
10494: class Bool : public Instance {
10516:   friend class Class;
10517:   friend class Object;  // To initialize the true and false values.
10520: class Array : public Instance {
10653:   // Make the array immutable to Dart code by switching the class pointer
10700:   static ArrayPtr New(intptr_t class_id,
10703:   static ArrayPtr NewUninitialized(intptr_t class_id,
10727:   friend class Class;
10728:   friend class ImmutableArray;
10729:   friend class Object;
10730:   friend class String;
10731:   friend class MessageDeserializer;
10734: class ImmutableArray : public AllStatic {
10752:     // Indicates this class cannot be extended by dart code.
10760:   friend class Class;
10763: class GrowableObjectArray : public Instance {
10864:   friend class Array;
10865:   friend class Class;
10868: class Float32x4 : public Instance {
10901:   friend class Class;
10904: class Int32x4 : public Instance {
10934:   friend class Class;
10937: class Float64x2 : public Instance {
10964:   friend class Class;
10968: class RecordShape {
11038: class RecordType : public AbstractType {
11112:   friend class Class;
11113:   friend class ClassFinalizer;
11114:   friend class Record;
11117: class Record : public Instance {
11193:   friend class Class;
11194:   friend class Object;
11197: class PointerBase : public Instance {
11204: class TypedDataBase : public PointerBase {
11304:   friend class Class;
11319: class TypedData : public TypedDataBase {
11369:   static intptr_t MaxElements(intptr_t class_id) {
11370:     ASSERT(IsTypedDataClassId(class_id));
11371:     return (kSmiMax / ElementSizeInBytes(class_id));
11374:   static intptr_t MaxNewSpaceElements(intptr_t class_id) {
11375:     ASSERT(IsTypedDataClassId(class_id));
11377:            ElementSizeInBytes(class_id);
11380:   static TypedDataPtr New(intptr_t class_id,
11402:   // Therefore this method is private and the call-sites in this class need to
11410:   friend class Class;
11411:   friend class ExternalTypedData;
11412:   friend class TypedDataView;
11415: class ExternalTypedData : public TypedDataBase {
11429:   static intptr_t MaxElements(intptr_t class_id) {
11430:     ASSERT(IsExternalTypedDataClassId(class_id));
11431:     return (kSmiMax / ElementSizeInBytes(class_id));
11435:       intptr_t class_id,
11465:   friend class Class;
11468: class TypedDataView : public TypedDataBase {
11470:   static TypedDataViewPtr New(intptr_t class_id,
11472:   static TypedDataViewPtr New(intptr_t class_id,
11536:   friend class Class;
11537:   friend class Object;
11538:   friend class TypedDataViewDeserializationCluster;
11541: class ByteBuffer : public AllStatic {
11567: class Pointer : public Instance {
11601:   friend class Class;
11604: class DynamicLibrary : public Instance {
11630:   friend class Class;
11633: class LinkedHashBase : public Instance {
11753:   friend class Class;
11754:   friend class ImmutableLinkedHashBase;
11755:   friend class LinkedHashBaseDeserializationCluster;
11758: class ImmutableLinkedHashBase : public AllStatic {
11772: class Map : public LinkedHashBase {
11779:   static MapPtr NewDefault(intptr_t class_id = kMapCid,
11781:   static MapPtr New(intptr_t class_id,
11794:   class Iterator : public ValueObject {
11832:   static MapPtr NewUninitialized(intptr_t class_id,
11835:   friend class Class;
11836:   friend class ConstMap;
11837:   friend class MapDeserializationCluster;
11843: class ConstMap : public AllStatic {
11859:     // Indicates this class cannot be extended by dart code.
11867:   friend class Class;
11875: class Set : public LinkedHashBase {
11882:   static SetPtr NewDefault(intptr_t class_id = kSetCid,
11884:   static SetPtr New(intptr_t class_id,
11897:   class Iterator : public ValueObject {
11933:   static SetPtr NewUninitialized(intptr_t class_id,
11936:   friend class Class;
11937:   friend class ConstSet;
11938:   friend class SetDeserializationCluster;
11944: class ConstSet : public AllStatic {
11960:     // Indicates this class cannot be extended by dart code.
11968:   friend class Class;
11971: class Closure : public Instance {
12068:   friend class Class;
12072: class Capability : public Instance {
12083:   friend class Class;
12087: class ReceivePort : public Instance {
12121:   friend class Class;
12125: class SendPort : public Instance {
12145:   friend class Class;
12150: class TransferableTypedDataPeer {
12177: class TransferableTypedData : public Instance {
12187:   friend class Class;
12190: class DebuggerStackTrace;
12193: class StackTrace : public Instance {
12247:   friend class Class;
12248:   friend class DebuggerStackTrace;
12251: class SuspendState : public Instance {
12340:   friend class Class;
12343: class RegExpFlags {
12397: class RegExp : public Instance {
12416:   class TypeBits : public BitField<int8_t, RegExType, kTypePos, kTypeSize> {};
12417:   class GlobalBit : public BitField<int8_t, bool, kFlagsPos, 1> {};
12418:   class IgnoreCaseBit : public BitField<int8_t, bool, GlobalBit::kNextBit, 1> {
12420:   class MultiLineBit
12422:   class UnicodeBit : public BitField<int8_t, bool, MultiLineBit::kNextBit, 1> {
12424:   class DotAllBit : public BitField<int8_t, bool, UnicodeBit::kNextBit, 1> {};
12426:   class FlagsBits : public BitField<int8_t, int8_t, kFlagsPos, kFlagsSize> {};
12571:   friend class Class;
12575: class WeakProperty : public Instance {
12603:   friend class Class;
12607: class WeakReference : public Instance {
12629:   friend class Class;
12632: class FinalizerBase;
12633: class FinalizerEntry : public Instance {
12697:   friend class Class;
12700: class FinalizerBase : public Instance {
12732:   friend class Class;
12735: class Finalizer : public FinalizerBase {
12754:   friend class Class;
12757: class NativeFinalizer : public FinalizerBase {
12780:   friend class Class;
12783: class MirrorReference : public Instance {
12814:   friend class Class;
12817: class UserTag : public Instance {
12859:   friend class Class;
12862: // Represents abstract FutureOr class in dart:async.
12863: class FutureOr : public Instance {
12879:   friend class Class;
12886:     return Smi::Class();
12888:   return IsolateGroup::Current()->class_table()->At(ptr()->GetClassId());
13026:                                 const Smi& class_id,
13029:   array.SetAt((index * kEntryLength) + kClassIdIndex, class_id);
13098: // This helper class can then be used via
13133: class ArrayOfTuplesView {
13137:   class Iterator;
13139:   class TupleView {
13165:     friend class Iterator;
13168:   class Iterator {
86: // For AllStatic classes like OneByteString. Checks that
187:   static const ClassId kClassId = k##object##Cid;                              \
337:   inline ClassPtr clazz() const;
600:     // Internal names are the true names of classes, fields,
604:     // The names of core implementation classes (like _OneByteString)
609:     //   private constructor        -> _MyClass@6b3832b.
610:     //   private named constructor  -> _MyClass@6b3832b.named
620:     //   _MyClass@6b3832b.      -> _MyClass
621:     //   _MyClass@6b3832b.named -> _MyClass.named
627:     // the names of core implementation classes are remapped to their
632:     //   _MyClass@6b3832b.      -> _MyClass
633:     //   _MyClass@6b3832b.named -> _MyClass.named
1048:   static intptr_t host_instance_size(ClassPtr clazz) {
1051:   static intptr_t target_instance_size(ClassPtr clazz) {
1123:     return UntaggedObject::ClassIdTag::is_valid(value);
1127:     ASSERT(value >= 0 && value < std::numeric_limits<classid_t>::max());
1130:   static intptr_t id_offset() { return OFFSET_OF(UntaggedClass, id_); }
1145:     return OFFSET_OF(UntaggedClass, num_type_arguments_);
1158:   ClassPtr Mixin() const;
1205:     return OFFSET_OF(UntaggedClass, declaration_type_);
1313:     return OFFSET_OF(UntaggedClass, host_type_arguments_field_offset_in_words_);
1323:     return OFFSET_OF(UntaggedClass, super_type_);
1353:                            bool consider_only_super_classes = false) const;
1356:                            bool consider_only_super_classes = false) const {
1358:                                consider_only_super_classes);
1376:                            bool consider_only_super_classes = false) const;
1379:                            bool consider_only_super_classes = false) const {
1381:                                consider_only_super_classes);
1454:   bool IsDartFunctionClass() const;
1457:   bool IsFutureClass() const;
1473:   static bool IsInFullSnapshot(ClassPtr cls) {
1578:     return RoundedAllocationSize(sizeof(UntaggedClass));
1592:     return ClassLoadingBits::decode(state_bits());
1616:     return ClassFinalizedBits::decode(state_bits()) ==
1617:                UntaggedClass::kFinalized ||
1618:            ClassFinalizedBits::decode(state_bits()) ==
1619:                UntaggedClass::kAllocateFinalized;
1625:     return ClassFinalizedBits::decode(state_bits()) ==
1626:            UntaggedClass::kAllocateFinalized;
1631:     return ClassFinalizedBits::decode(state_bits()) ==
1632:            UntaggedClass::kPreFinalized;
1684:   static uint16_t NumNativeFieldsOf(ClassPtr clazz) {
1687:   static bool IsIsolateUnsendable(ClassPtr clazz) {
1690:   static bool IsIsolateUnsendableDueToPragma(ClassPtr clazz) {
1770:   // Allocate instance classes.
1771:   static ClassPtr New(const Library& lib,
1776:   static ClassPtr NewNativeWrapper(const Library& library,
1780:   // Allocate the raw string classes.
1784:   // Allocate the raw TypedData classes.
1788:   // Allocate the raw TypedDataView/ByteDataView classes.
1791:   static ClassPtr NewUnmodifiableTypedDataViewClass(
1795:   // Allocate the raw ExternalTypedData classes.
1799:   // Allocate the raw Pointer classes.
1839:   static int32_t host_instance_size_in_words(const ClassPtr cls) {
1843:   static int32_t target_instance_size_in_words(const ClassPtr cls) {
1851:   static int32_t host_next_field_offset_in_words(const ClassPtr cls) {
1855:   static int32_t target_next_field_offset_in_words(const ClassPtr cls) {
1863:   static int32_t host_type_arguments_field_offset_in_words(const ClassPtr cls) {
1868:       const ClassPtr cls) {
1909:   static ClassPtr NewCommon(intptr_t index);
1955:                                              UntaggedClass::ClassFinalizedState,
1959:                                            UntaggedClass::ClassLoadingState,
2044:   // This includes type arguments of a superclass and takes overlapping
2064:   static ClassPtr New(intptr_t id,
2070:   static ClassPtr NewInstanceClass();
2083: // Classification of type genericity according to type parameter owners.
2113:     return RoundedAllocationSize(sizeof(UntaggedPatchClass));
2132:   FINAL_HEAP_OBJECT_IMPLEMENTATION(PatchClass, Object);
2171:   classid_t expected_cid() const { return untag()->expected_cid_; }
2177:   static MonomorphicSmiableCallPtr New(classid_t expected_cid,
2250: // Object holding information about an IC: test classes and their
2321:   V(CheckClass)                                                                \
2358:   // Call site classification that is helpful for hot-reload. Call sites with
2656:   // to list the call site's observed receiver classes and targets.
2895:   ClassPtr Owner() const;
2897:   ClassPtr origin() const;
4290:   ClassPtr Owner() const;
4413:     StoreNonPointer<ClassIdTagType, ClassIdTagType, std::memory_order_relaxed>(
4504:     return LoadNonPointer<ClassIdTagType, std::memory_order_relaxed>(
4508:     StoreNonPointer<ClassIdTagType, ClassIdTagType, std::memory_order_relaxed>(
4821:   ClassDictionaryIterator(const Library& library,
4829:   ClassPtr GetNextClass();
4832:   void MoveToNextClass();
4836:   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
4910:   ClassPtr LookupClass(const String& name) const;
4911:   ClassPtr LookupClassAllowPrivate(const String& name) const;
4912:   ClassPtr SlowLookupClassAllowMultiPartPrivate(const String& name) const;
4913:   ClassPtr LookupLocalClass(const String& name) const;
5050:            ((value >= 0) && (value < std::numeric_limits<classid_t>::max())));
5120:   // Eagerly compile all classes and functions in the library.
5123:   // Finalize all classes in all libraries.
5142:   // helper methods and classes. Allow look up of private classes.
5270:                                   const Array& classes_cache,
5313:   void set_classes_cache(const Array& cache) const;
5314:   ClassPtr LookupClass(Thread* thread, const Smi& name_index) const;
5315:   ClassPtr InsertClass(Thread* thread,
8123:   // Names of internal classes are mapped to their public interfaces.
8231:   // all positions of superclass type parameters blank.
8524: // AbstractType is an abstract superclass.
8653:   // Names of internal classes are mapped to their public interfaces.
8674:   StringPtr ClassName() const;
8995:   // Takes an intptr_t since the cids of some classes are larger than will fit
8996:   // in ClassIdTagType. This allows us to guard against that case, instead of
11229:   static intptr_t ElementSizeInBytes(classid_t cid) {
11233:   static TypedDataElementType ElementType(classid_t cid) {
11510:     const classid_t cid = typed_data.GetClassId();
12793:   ClassPtr GetClassReferent() const;
12883: ClassPtr Object::clazz() const {
13131: //     classes (e.g. 'Code', 'Smi', 'Object')
120:         HandleImpl(Thread::Current()->zone(), object::null(), kClassId));      \
123:     return static_cast<object&>(HandleImpl(zone, object::null(), kClassId));   \
127:         HandleImpl(Thread::Current()->zone(), ptr, kClassId));                 \
130:     return static_cast<object&>(HandleImpl(zone, ptr, kClassId));              \
134:         ZoneHandleImpl(Thread::Current()->zone(), object::null(), kClassId));  \
138:         ZoneHandleImpl(zone, object::null(), kClassId));                       \
142:         ZoneHandleImpl(Thread::Current()->zone(), ptr, kClassId));             \
145:     return static_cast<object&>(ZoneHandleImpl(zone, ptr, kClassId));          \
148:     return static_cast<object*>(ReadOnlyHandleImpl(kClassId));                 \
192:     obj->setPtr(ptr, kClassId);                                                \
335:                                   : ptr()->untag()->GetClassId();
377:   // Object::DictionaryName() returns String::null(). Only subclasses
1426:     return direct_subclasses_unsafe();
1429:     return untag()->direct_subclasses();
1434:   void set_direct_subclasses(const GrowableObjectArray& subclasses) const;
1465:     return GetClassId(cls) == kClosureCid;
1607:     return SynthesizedClassBit::decode(state_bits());
1661:     return InterfaceClassBit::decode(state_bits());
1881:   void SetUserVisibleNameInClassTable();
1926:     kAbstractBit = kClassLoadingPos + kClassLoadingSize,  // = 6
1956:                                              kClassFinalizedPos,
1957:                                              kClassFinalizedSize> {};
1960:                                            kClassLoadingPos,
1961:                                            kClassLoadingSize> {};
1964:       : public BitField<uint32_t, bool, kSynthesizedClassBit, 1> {};
1977:       : public BitField<uint32_t, bool, kInterfaceClassBit, 1> {};
2115:   static bool IsInFullSnapshot(PatchClassPtr cls) {
2130:   static PatchClassPtr New();
2494:   void GetOneClassCheckAt(intptr_t index,
2500:   intptr_t GetReceiverClassIdAt(intptr_t index) const;
2501:   intptr_t GetClassIdAt(intptr_t index, intptr_t arg_nr) const;
2513:   ICDataPtr AsUnaryClassChecksForArgNr(intptr_t arg_nr) const;
2520:   ICDataPtr AsUnaryClassChecksSortedByCount() const;
3750:       return IsTypedDataViewClassId(klass.id());
3759:       return IsUnmodifiableTypedDataViewClassId(klass.id());
5124:   static ErrorPtr FinalizeAllClasses();
5166:   void EnsureTopLevelClassIsFinalized() const;
5191:   void InitClassDictionary() const;
5611:     ASSERT_EQUAL(a->GetClassId(), kInstructionsCid);
5612:     ASSERT_EQUAL(b->GetClassId(), kInstructionsCid);
6873:     return owner->GetClassId();
7387:   static inline ObjectPtr GetClassId(const Array& array, intptr_t index);
7710:   // Subclasses where 1 and 3 coincide may also define a plain Equals, e.g.,
8525: // Subclasses of AbstractType are Type and TypeParameter.
8776:   bool IsTypeClassAllowedBySpawnUri() const;
9376:     return CanonicalNameCString(IsClassTypeParameter(), base(), index());
9823:     return ptr()->GetClassId() == kOneByteStringCid;
9827:     return ptr()->GetClassId() == kTwoByteStringCid;
9831:     return ptr()->GetClassId() == kExternalOneByteStringCid;
9835:     return ptr()->GetClassId() == kExternalTwoByteStringCid;
9839:     return IsExternalStringClassId(ptr()->GetClassId());
10600:   bool IsImmutable() const { return ptr()->GetClassId() == kImmutableArrayCid; }
11218:     return ElementSizeInBytes(ptr()->GetClassId()) * Length();
11222:     return ElementType(ptr()->GetClassId());
11226:     return element_size(ElementType(ptr()->GetClassId()));
11236:     } else if (IsTypedDataClassId(cid)) {
11240:     } else if (IsTypedDataViewClassId(cid)) {
11244:     } else if (IsExternalTypedDataClassId(cid)) {
11249:       ASSERT(IsUnmodifiableTypedDataViewClassId(cid));
11390:     intptr_t cid = obj.ptr()->GetClassId();
11391:     return IsTypedDataClassId(cid);
11445:     intptr_t cid = obj.ptr()->GetClassId();
11446:     return IsExternalTypedDataClassId(cid);
11492:     intptr_t cid = data.ptr()->GetClassId();
11493:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
11494:     return IsExternalTypedDataClassId(cid);
11511:     ASSERT(IsTypedDataClassId(cid) || IsExternalTypedDataClassId(cid));
11614:     intptr_t cid = obj.ptr()->GetClassId();
11615:     return IsFfiDynamicLibraryClassId(cid);
11679:     return GetClassId() == kConstMapCid || GetClassId() == kConstSetCid;
12894:   intptr_t cid = value->GetClassIdMayBeSmi();
13034:   return array.At((index * kEntryLength) + kClassIdIndex);
13077:   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/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/kubernetes/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/googlearchive/caja:third_party/js/sunspider-benchmark/parse-only/concat-jquery-mootools-prototype.js: [ master, ]
2246: 	Expr.find.CLASS = function(match, context, isXML) {
3214: 	"class": "className",
5928: 	'class': 'className',
10691:         'class': 'className',
5425: 	var newClass = function(){
5437: 	newClass.prototype.constructor = newClass;
6957: 		var m, parsed = {classes: [], pseudos: [], attributes: []};
7118: 	byClass: function(self, klass){
8438:       var subclass = function() { };
8439:       subclass.prototype = parent.prototype;
10209:   classNames: function(element) {
10550:       className: 'class',
12641:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
12665: Element.ClassNames.prototype = {
10213:   hasClassName: function(element, className) {
10220:   addClassName: function(element, className) {
10227:   removeClassName: function(element, className) {
10234:   toggleClassName: function(element, className) {
710: 		// internal only, use addClass("class")
718: 		// internal only, use removeClass("class")
728: 		// internal only, use hasClass("class")
1658: 		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
1667: 		"class": "className",
1773: 		CLASS: function(match, curLoop, inplace, result, not, isXML){
2007: 		CLASS: function(elem, match){
2008: 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
2203: 	div.innerHTML = "<p class='TEST'></p>";
2233: 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
2239: 	// Safari caches class attributes, doesn't catch changes (in 3.2)
2245: 	Expr.order.splice(1, 0, "CLASS");
2686: 			// Filter the functions by class
4391: 	- Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2...(102 bytes skipped)...
5414: Script: Class.js
5415: 	Contains the Class Function for easily creating, extending, and implementing reusable Classes.
5421: function Class(params){
5436: 	newClass.constructor = Class;
5471: new Native({name: 'Class', initialize: Class}).extend({
5496: Class.implement({
5505: 		var mutator = Class.Mutators[key];
5518: 				proto[key] = Class.wrap(this, key, value);
5541: Class.Mutators = {
5546: 		this.prototype = Class.instantiate(parent);
5558: 			if (item instanceof Function) item = Class.instantiate(item);
5568: Script: Class.Extras.js
5575: var Chain = new Class({
5595: var Events = new Class({
5653: var Options = new Class({
7338: 	Class for creating, loading, and saving browser Cookies.
7347: var Cookie = new Class({
7414: var Swiff = new Class({
7513: var Fx = new Class({
7646: Fx.CSS = new Class({
7780: Fx.Tween = new Class({
7877: Fx.Morph = new Class({
8040: 	Powerful all purpose Request Class. Uses XMLHTTPRequest.
8046: var Request = new Class({
8235: 	Extends the basic Request Class with additional methods for interacting with HTML responses.
8241: Request.HTML = new Class({
8355: 	Extends the basic Request Class with additional methods for sending and receiving JSON data.
8361: Request.JSON = new Class({
8423: var Class = {
8433:     Object.extend(klass, Class.Methods);
8456: Class.Methods = {
8673: var PeriodicalExecuter = Class.create({
8939: var Template = Class.create({
9376: var Hash = Class.create(Enumerable, (function() {
9473: var ObjectRange = Class.create(Enumerable, {
9547: Ajax.Base = Class.create({
9569: Ajax.Request = Class.create(Ajax.Base, {
9742: Ajax.Response = Class.create({
9816: Ajax.Updater = Class.create(Ajax.Request, {
9852: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
10060:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
11100: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
11104: var Selector = Class.create({
11292:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
11592:       var needle = ' ' + className + ' ';
11596:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
12083: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
12100: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
12106: Form.Observer = Class.create(Abstract.TimedObserver, {
12114: Abstract.EventObserver = Class.create({
12153: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
12159: Form.EventObserver = Class.create(Abstract.EventObserver, {
12631:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
12664: Element.ClassNames = Class.create();
405: 	hasClass: function( selector ) {
709: 	className: {
711: 		add: function( elem, classNames ) {
712: 			jQuery.each((classNames || "").split(/\s+/), function(i, className){
713: 				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
714: 					elem.className += (elem.className ? " " : "") + className;
719: 		remove: function( elem, classNames ) {
721: 				elem.className = classNames !== undefined ?
722: 					jQuery.grep(elem.className.split(/\s+/), function(className){
723: 						return !jQuery.className.has( classNames, className );
729: 		has: function( elem, className ) {
730: 			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
1225: 	addClass: function( classNames ) {
1226: 		jQuery.className.add( this, classNames );
1229: 	removeClass: function( classNames ) {
1230: 		jQuery.className.remove( this, classNames );
1233: 	toggleClass: function( classNames, state ) {
1235: 			state = !jQuery.className.has( this, classNames );
1236: 		jQuery.className[ state ? "add" : "remove" ]( this, classNames );
1782: 					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
2235: 	// Opera can't find a second classname (in 9.6)
2240: 	div.lastChild.className = "e";
5427: 		if (newClass._prototyping) return this;
5434: 	newClass.implement(params);
5439: 	return newClass;
5569: 	Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
6041: 	hasClass: function(className){
6042: 		return this.className.contains(className, ' ');
6045: 	addClass: function(className){
6046: 		if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
6050: 	removeClass: function(className){
6051: 		this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)'), '$1');
6055: 	toggleClass: function(className){
6056: 		return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
6961: 				parsed.classes.push(cn);
6970: 		if (!parsed.classes.length) delete parsed.classes;
6973: 		if (!parsed.classes && !parsed.attributes && !parsed.pseudos) parsed = null;
6985: 		if (parsed.classes){
6986: 			for (i = parsed.classes.length; i--; i){
6987: 				var cn = parsed.classes[i];
6988: 				if (!Selectors.Filters.byClass(item, cn)) return false;
7119: 		return (self.className && self.className.contains(klass, ' '));
7464: 			properties.classid = 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000';
7507: 	Contains the basic animation logic to be extended by all other Fx Classes.
7942: 	Contains a set of advanced transitions to be used with any of the Fx Classes.
8434:     klass.superclass = parent;
8440:       klass.prototype = new subclass;
8458:     var ancestor   = this.superclass && this.superclass.prototype;
10210:     return new Element.ClassNames(element);
10215:     var elementClassName = element.className;
10216:     return (elementClassName.length > 0 && (elementClassName == className ||
10217:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
10222:     if (!element.hasClassName(className))
10223:       element.className += (element.className ? ' ' : '') + className;
10229:     element.className = element.className.replace(
10230:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
10236:     return element[element.hasClassName(className) ?
10237:       'removeClassName' : 'addClassName'](className);
11023:   function findDOMClass(tagName) {
11055:       var klass = findDOMClass(tag);
11386:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
11414:     className:    /^\.([\w\-\*]+)(\b|$)/,
11427:     className: function(element, matches) {
11585:     className: function(nodes, root, className, combinator) {
11587:       return Selector.handlers.byClassName(nodes, root, className);
11590:     byClassName: function(nodes, root, className) {
11594:         nodeClassName = node.className;
12635:   function(element, className) {
12636:     className = className.toString().strip();
12637:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
12639:   } : function(element, className) {
12640:     className = className.toString().strip();
12642:     if (!classNames && !className) return elements;
12645:     className = ' ' + className + ' ';
12648:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
12649:           (classNames && classNames.all(function(name) {
12657:   return function(className, parentElement) {
12658:     return $(parentElement || document.body).getElementsByClassName(className);
12671:     this.element.className.split(/\s+/).select(function(name) {
12676:   set: function(className) {
12677:     this.element.className = className;
12680:   add: function(classNameToAdd) {
12681:     if (this.include(classNameToAdd)) return;
12682:     this.set($A(this).concat(classNameToAdd).join(' '));
12685:   remove: function(classNameToRemove) {
12686:     if (!this.include(classNameToRemove)) return;
12687:     this.set($A(this).without(classNameToRemove).join(' '));
12695: Object.extend(Element.ClassNames.prototype, Enumerable);
2231: if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
2236: 	if ( div.getElementsByClassName("e").length === 0 )
2242: 	if ( div.getElementsByClassName("e").length === 1 )
2247: 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
2248: 			return context.getElementsByClassName(match[1]);
4686: 			return (!window.opera) ? false : ((arguments.callee.caller) ? 960 : ((document.getElementsByClassName) ? 950 : 925));
4698: 			return (document.getBoxObjectFor == undefined) ? false : ((document.getElementsByClassName) ? 19 : 18);
8435:     klass.subclasses = [];
8441:       parent.subclasses.push(klass);
11428:       return Element.hasClassName(element, matches[1]);
11593:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
11595:         if (nodeClassName.length == 0) continue;
12629: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
12634:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
chromium.googlesource.com/graphics-book:js/nomnoml.js: [ main, ]
114:         CLASS: buildStyle({ visual: 'class' }, { center: true, bold: true }),
660:     class Classifier {
640:         function layoutClassifier(clas, config) {
1395:         function isAstClassifier(obj) {
1440:         function transformClassifier(entity) {
52:     function hasSubstring(haystack, needle) {
53:         if (needle === '')
57:         return haystack.indexOf(needle) !== -1;
106:             visual: conf.visual || 'class',
111:         ABSTRACT: buildStyle({ visual: 'class' }, { center: true, italic: true }),
120:         INSTANCE: buildStyle({ visual: 'class' }, { center: true, underline: true }),
126:         REFERENCE: buildStyle({ visual: 'class', dashed: true }, { center: true }),
194:         class: box,
387:         class: function (node, x, y, config, g) {
641:             var style = config.styles[clas.type] || styles.CLASS;
647:         layoutCompartment(ast, 0, styles.CLASS);
651:     class Compartment {
658:     class Relation {
746:     symbols_: {"error":2,"root":3,"compartment":4,"EOF":5,"SEP":6,"slot":7,"IDENT":8,"class":9,"association":10,"parts":11,"|":12,"[":13,"]":14,"$accept":0,"$end":1},
787:                var type = 'CLASS';
1352:                 visual: (last(styleDef.match('visual=([^ ]*)') || []) || 'class'),
1605:             var style = config.styles[node.type] || styles.CLASS;
1615:             var drawNode = visualizers[style.visual] || visualizers.class;
1905:         class Element {
1949:         class GroupElement extends Element {
2183:     class ImportDepthError extends Error {
780:                  throw new Error('line '+_$[$0].first_line+': Classifiers must be separated by a relation or a line break')
1442:             return new Classifier(entity.type, entity.id, compartments);
2243:     exports.Classifier = Classifier;
534:             c.nodes.forEach((e) => layoutClassifier(e, styledConfig));
1404:             var rawClassifiers = [];
1410:                     rawClassifiers.push(p.start);
1411:                     rawClassifiers.push(p.end);
1421:                 if (isAstClassifier(p)) {
1422:                     rawClassifiers.push(p);
1425:             var allClassifiers = rawClassifiers
1426:                 .map(transformClassifier)
1428:             var uniqClassifiers = uniqueBy(allClassifiers, 'name');
1438:             return new Compartment(lines, uniqClassifiers, uniqRelations);
chromium.googlesource.com/chromium/src:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
13940: const Class = function(info, mixin) {
6629:  function superPropertiesClass(constructor) {
12268: DomApiNative.prototype.classList;
13638:     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 {
1738: class DomModule extends HTMLElement {
2370:  * Element class mixin that provides basic meta-programming for creating one
2375:  * once at class definition time to create property accessors for properties
2384:  * @summary Element class mixin for reacting to property changes from
2390:      * @param {function(new:T)} superClass Class to apply mixin to.
2401:   class PropertiesChanged extends superClass {
2850:         if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
2967:  * Element class mixin that provides basic meta-programming for creating one
2976:  * -   Implement the `_propertiesChanged` callback on the class.
2977:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
2993:  * @summary Element class mixin for reacting to property changes from
3013:   class PropertyAccessors extends base {
3332:  * @summary Element class mixin that provides basic template parsing and stamping
3337:      * @param {function(new:T)} superClass Class to apply mixin to.
3347:   class TemplateStamp extends superClass {
4168:  * @param {Function} constructor Class that `_parseTemplate` is currently
4205:  * @param {Function} constructor Class that `_parseTemplate` is currently
4735:  * Element class mixin that provides meta-programming for Polymer's template
4739:  * property effects to an element class:
4766:  * @summary Element class mixin that provides meta-programming for Polymer's
4787:   class PropertyEffects extends propertyEffectsBase {
5352:      * Runs each class of effects for the batch of changed properties in
5915:     // -- static class methods ------------
6084:      *   bound template for the class. When true (as passed from
6287:           // when a class$ binding's initial literal value is set.
6288:           if (name == 'class' && node.hasAttribute('class')) {
6513: class HostStack {
6561:  * Registers a class prototype for telemetry purposes.
6623:   * Returns the super class constructor for the given class, if it is an
6627:   * @return {?PropertiesMixinConstructor} Super class constructor
6632:    // Note, the `PropertiesMixin` class below only refers to the class
6642:   * given class. Properties not in object format are converted to at
6672:  class PropertiesMixin extends base {
6707:     * Finalize an element class. This includes ensuring property
6709:     * `finalize` and finalizes the class constructor.
6725:     * @return {Object} Object containing properties for this class
6817:  * Element class mixin that provides the core API for Polymer's meta-programming
6822:  * used to configure Polymer's features for the class:
6858:  * The base class provides default implementations for the following standard
6877:  * @property importPath {string} Set to the value of the class's static
6881:  * @summary Element class mixin that provides the core API for Polymer's
6900:    * @param {PolymerElementConstructor} constructor Element class
6901:    * @return {PolymerElementProperties} Flattened properties for this class
6923:    * @param {PolymerElementConstructor} constructor Element class
6924:    * @return {Array} Array containing own observers for the given class
6987:    * @param {!PolymerElement} proto Element class prototype to add accessors
7041:    * @param {PolymerElementConstructor} klass Element class
7107:   class PolymerElement extends polymerElementBase {
7165:      *   this class
7190:      * Note that when subclassing, if the super class overrode the default
7195:      * If a subclass would like to modify the super class template, it should
7201:      *   class MySubClass extends MySuperClass {
7217:       // - constructor.template (this getter): the template for the class.
7219:       //     dom-module, or from the super class's template (or can be overridden
7269:      * @return {string} The import path for this element class
7303:      * Overrides the default `PropertyAccessors` to ensure class
7568:  * Class representing a static string value which can be used to filter
7569:  * strings by asseting that they have been created via this class. The
7572: class LiteralString {
7639:  *         <div class="shadowed">${this.partialTemplate}</div>
7667:  * Base class that provides the core API for Polymer's meta-programming
7677:  * @summary Custom element base class that provides the core API for Polymer's
7714:  * Element class mixin to skip strict dirty-checking for objects and arrays
7749:  * @summary Element class mixin to skip strict dirty-checking for objects
7759:   class MutableData extends superClass {
7788:  * Element class mixin to add the optional ability to skip strict
7824:  * @summary Element class mixin to optionally skip strict dirty-checking
7834:   class OptionalMutableData extends superClass {
7887: // Base class for HTMLTemplateElement extension that has property effects
7889: // class only because Babel (incorrectly) requires super() in the class
7931:  * Base class for TemplateInstance.
7936: const templateInstanceBase = PropertyEffects(class {});
7944: class TemplateInstanceBase extends templateInstanceBase {
8166:  * @suppress {missingProperties} class.prototype is not defined for some reason
8182:    * Anonymous class created by the templatize
8186:   let klass = class extends templatizerBase { };
8195:  * @suppress {missingProperties} class.prototype is not defined for some reason
8200:     // Provide data API and property effects on memoized template class
8210:         class TemplatizedTemplate extends templatizedBase {};
8280:  * Returns an anonymous `PropertyEffects` class bound to the
8281:  * `<template>` provided.  Instancing the class will result in the
8301:  *    method on the generated class should be called to forward host
8310:  * - `mutableData`: When `true`, the generated class will skip strict
8340:  * `templatize()` return the same class for all duplicates of a template.
8341:  * The class returned from `templatize()` is generated only once using
8353:  * @return {function(new:TemplateInstanceBase)} Generated class bound to the template
8365:   // Get memoized base class for the prototypical template, which
8378:   // Subclass base class and add reference for this specific template
8380:   let klass = class TemplateInstance extends baseClass {};
8495: class DomIf extends PolymerElement {
8795:  * class EmployeeList extends PolymerElement {
8866: class DomRepeat extends domRepeatBase {
9537: class StyleNode {
10170: class MixinMap {
10203: class ApplyShim {
10779: class CustomStyleInterface$1 {
10904: class ApplyShimInterface {
11116:  * Element class mixin that provides API for adding Polymer's cross-platform
11126:  * @summary Element class mixin that provides API for adding Polymer's
11133:      * @param {function(new:T)} superClass Class to apply mixin to.
11142:       class GestureEventListeners extends superClass {
11613:  * Class that listens for changes (additions or removals) to
11634:  * class TestSelfObserve extends PolymerElement {
11650:  * @summary Class that listens for changes (additions or removals) to
11654: let FlattenedNodesObserver = class {
11934:  * Node API wrapper class returned from `Polymer.dom.(target)` when
11939: class DomApiNative {
12152:  * Event API wrapper class returned from `dom.(target)` when
12155: class EventApi {
12283:   class Wrapper extends window['ShadyDOM']['Wrapper'] {}
12389:  * Element class mixin that provides Polymer's "legacy" API intended to be
12400:  * @summary Element class mixin that provides Polymer's "legacy" API
12430:   class LegacyElement extends legacyElementBase {
12448:      *  closure for some reason even in a static method, rather than the class
12532:      * add support for class initialization via the `_registered` callback.
12558:      * Users may override this method to perform class registration time
12560:      * only once for the class.
13261:      * Toggles a CSS class on or off.
13263:      * @param {string} name CSS class name
13264:      * @param {boolean=} bool Boolean to force the class on or off.
13265:      *    When unspecified, the state of the class will be reversed.
13488:  * Applies a "legacy" behavior or array of behaviors to the provided class.
13497:  * @param {function(new:T)} klass Element class.
13498:  * @return {?} Returns a new Element class extended by the
13528: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
13529: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
13601:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
13602:   made. The list of behaviors was previously made into one generated class per
13607:   The generated class is directly tied to the info object and behaviors
13622:  * @param {function(new:HTMLElement)} Base base class to extend with info object
13624:  * @return {function(new:HTMLElement)} Generated class
13630:   // manages behavior and lifecycle processing (filled in after class definition)
13635:   class PolymerGenerated extends Base {
13717:       // only proceed if the generated class' prototype has not been registered.
13724:         // and not the generated class prototype; if the element has been
13840:     // NOTE: ensure the behavior is extending a class with
13847:     // get flattened, deduped list of behaviors *not* already on super class
13871:  * Generates a class that extends `LegacyElement` based on the
13875:  * to the generated class.
13934:  *   to become class methods.
13936:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
13938:  * @return {function(new:HTMLElement)} Generated class
13942:     console.warn('Polymer.Class requires `info` argument');
14052:  * Legacy class factory and registration helper for defining Polymer
14057:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
14058:  *     customElements.define(info.is, Class(info));
14060:  * See `Class` for details on valid legacy metadata format for `info`.
14066:  *   to become class methods.
14067:  * @return {function(new: HTMLElement)} Generated class
14071:   // if input is a `class` (aka a function with a prototype), use the prototype
14077:     klass = Polymer.Class(info);
14083: Polymer.Class = Class;
14159:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
14165:    * @param {boolean=} mutableData When `true`, the generated class will skip
14184:    * returned is an instance of the anonymous class generated by `templatize`
14257: class DomBind extends domBindBase {
14394:   class ArraySelectorMixin extends elementBase {
14712:  * class EmployeeList extends PolymerElement {
14765: class ArraySelector extends baseArraySelector {
14910: class CustomStyle extends HTMLElement {
2374:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
2391:      * @return {function(new:T)} superClass with mixin applied.
2393:     (superClass) => {
2397:    * @mixinClass
2996: const PropertyAccessors = dedupingMixin(superClass => {
3004:    const base = PropertiesChanged(superClass);
3008:    * @mixinClass
3338:      * @return {function(new:T)} superClass with mixin applied.
3340:     (superClass) => {
3344:    * @mixinClass
4769: const PropertyEffects = dedupingMixin(superClass => {
4778:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
4782:    * @mixinClass
5220:      * Overrides superclass implementation.
6232:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6266:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6327:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6613: const PropertiesMixin = dedupingMixin(superClass => {
6620:  const base = PropertiesChanged(superClass);
6667:   * @mixinClass
6677:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6689:     * Finalizes an element definition, including ensuring any super classes
6692:     * `_finalizeClass` to finalize each constructor in the prototype chain.
6697:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6702:        this._finalizeClass();
6713:    static _finalizeClass() {
6722:     * from super classes. Properties not in object format are converted to
6731:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
6944:    * these values may not be changed. For example, a subclass cannot
6980:    * reflectToAttribute property not do so in a subclass. We've chosen to
6982:    * For example, a readOnly effect generates a special setter. If a subclass
7102:    * @mixinClass
7118:      * Override of PropertiesMixin _finalizeClass to create observers and
7122:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7124:     static _finalizeClass() {
7125:       super._finalizeClass();
7191:      * implementation and the subclass would like to provide an alternate
7206:      *         subContent.textContent = 'This came from MySubClass';
7224:       //     constructor.template, saved in _finalizeClass(). Note that before
7237:           // Next look for superclass template (call the super impl this
7238:           // way so that `this` points to the superclass)
7530:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7546:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7752: const MutableData = dedupingMixin(superClass => {
7756:    * @mixinClass
7827: const OptionalMutableData = dedupingMixin(superClass => {
7830:    * @mixinClass
7922: // Applies a DataTemplate subclass to a <template> instance
8168: function createTemplatizerClass(template, templateInfo, options) {
8201:     let klass = templateInfo.templatizeTemplateClass;
8209:       klass = templateInfo.templatizeTemplateClass =
8371:   let baseClass = templateInfo.templatizeInstanceClass;
8372:   if (!baseClass) {
8373:     baseClass = createTemplatizerClass(template, templateInfo, options);
8374:     templateInfo.templatizeInstanceClass = baseClass;
8447:  * Forces several classes of asynchronously queued tasks to flush:
10036:         // remove build comment so it is not needlessly copied into every element instance
11134:      * @return {function(new:T)} superClass with mixin applied.
11136:     (superClass) => {
11139:        * @mixinClass
12292:   // Note, `classList` is here only for legacy compatibility since it does not
12295:     'classList'
12327:   // Properties that should return the logical, not composed tree. Note, `classList`
12334:     'childNodes', 'children', 'classList'
12425:    * @mixinClass
13270:     toggleClass(name, bool, node) {
13273:         bool = !node.classList.contains(name);
13276:         node.classList.add(name);
13278:         node.classList.remove(name);
13598: /* Note about construction and extension of legacy classes.
13604:   manually. Note, there may *still* be multiple generated classes in the
13609:   behaviors not active on the superclass. In order to call through to the
13617:   and not `_finalizeClass`.
13637:     // explicitly not calling super._finalizeClass
13639:       // if calling via a subclass that hasn't been generated, pass through to super
13641:         super._finalizeClass();
13721:         // ensure superclass is registered first.
14379: let ArraySelectorMixin = dedupingMixin(superClass => {
14386:   let elementBase = ElementMixin(superClass);
14390:    * @mixinClass
3183:      * `__dataProto`, and it is up to the subclasser to decide how/when
6821:  * Subclassers may provide the following static getters to return metadata
6946:    * by subclasses.
6979:    * effects via subclassing. For example, a user might want to make a
13503:   return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
13628: function GenerateClassFromInfo(info, Base, behaviors) {
13946:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
chromium.googlesource.com/ios-chromium-mirror:third_party/polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ] Duplicate result
github.com/ampproject/amp.dev:pixi/cloud-function/package-lock.json: [ future, ]
938: 				"needle": "bin/needle"
1147: 				"needle": "^2.5.2",
2371: 				"needle": "^2.5.2",
1401: 				"mkdirp-classic": "^0.5.2",
2570: 				"mkdirp-classic": "^0.5.2",
928: 		"node_modules/needle": {
930: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz",
944: 		"node_modules/needle/node_modules/debug": {
2220: 		"needle": {
2222: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz",
907: 		"node_modules/mkdirp-classic": {
909: 			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
2205: 		"mkdirp-classic": {
2207: 			"resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
chromium.googlesource.com/chromium/src/third_party:polymer/v3_0/components-chromium/polymer/polymer_bundled.js: [ master, ]
14200: const Class = function(info, mixin) {
7194:  function superPropertiesClass(constructor) {
12119: DomApiNative.prototype.classList;
13890:     static _finalizeClass() {
234:  * Wraps an ES6 class expression mixin such that the mixin is only applied
239:  * @param {T} mixin ES6 class expression mixin to wrap
261:       // copy inherited mixin set from the extended class, or the base class
288: class Debouncer {
1815: class DomModule extends HTMLElement {
2454:  * Element class mixin that provides basic meta-programming for creating one
2459:  * once at class definition time to create property accessors for properties
2468:  * @summary Element class mixin for reacting to property changes from
2471:  * @param {function(new:T)} superClass Class to apply mixin to.
2477:      * @param {function(new:T)} superClass Class to apply mixin to.
2488:   class PropertiesChanged extends superClass {
2962:       if (attribute === 'class' || attribute === 'name' || attribute === 'slot') {
3090:  * Element class mixin that provides basic meta-programming for creating one
3099:  * -   Implement the `_propertiesChanged` callback on the class.
3100:  * -   Call `MyClass.createPropertiesForAttributes()` **once** on the class to
3116:  * @summary Element class mixin for reacting to property changes from
3119:  * @param {function(new:T)} superClass Class to apply mixin to.
3139:   class PropertyAccessors extends base {
3560:  * @summary Element class mixin that provides basic template parsing and stamping
3565:      * @param {function(new:T)} superClass Class to apply mixin to.
3575:   class TemplateStamp extends superClass {
4631:  * @param {Function} constructor Class that `_parseTemplate` is currently
4668:  * @param {Function} constructor Class that `_parseTemplate` is currently
5213:  * Element class mixin that provides meta-programming for Polymer's template
5217:  * property effects to an element class:
5244:  * @summary Element class mixin that provides meta-programming for Polymer's
5265:   class PropertyEffects extends propertyEffectsBase {
5830:      * Runs each class of effects for the batch of changed properties in
6409:     // -- static class methods ------------
6619:      * bound template for the class. When true (as passed from
6865:           // when a class$ binding's initial literal value is set.
6866:           if (name == 'class' && node.hasAttribute('class')) {
7123:  * Registers a class prototype for telemetry purposes.
7175:  * @param {function(new:T)} superClass Class to apply mixin to.
7188:   * Returns the super class constructor for the given class, if it is an
7192:   * @return {?PropertiesMixinConstructor} Super class constructor
7197:    // Note, the `PropertiesMixin` class below only refers to the class
7207:   * given class. Properties not in object format are converted to at
7237:  class PropertiesMixin extends base {
7274:     * Finalize an element class. This includes ensuring property
7276:     * `finalize` and finalizes the class constructor.
7293:     * @return {Object} Object containing properties for this class
7387:  * Element class mixin that provides the core API for Polymer's meta-programming
7392:  * used to configure Polymer's features for the class:
7428:  * The base class provides default implementations for the following standard
7447:  * @property importPath {string} Set to the value of the class's static
7451:  * @summary Element class mixin that provides the core API for Polymer's
7454:  * @param {function(new:T)} superClass Class to apply mixin to.
7473:    * @param {PolymerElementConstructor} constructor Element class
7474:    * @return {PolymerElementProperties} Flattened properties for this class
7496:    * @param {PolymerElementConstructor} constructor Element class
7497:    * @return {Array} Array containing own observers for the given class
7560:    * @param {!PolymerElement} proto Element class prototype to add accessors
7614:    * @param {PolymerElementConstructor} klass Element class
7685:   class PolymerElement extends polymerElementBase {
7751:      *   this class
7771:      * element's `is` (note that a `_template` property on the class prototype
7774:      * class template if neither a `prototype._template` or a `dom-module` for
7775:      * the class's `is` was found).
7781:      * Note that when subclassing, if the super class overrode the default
7786:      * If a subclass would like to modify the super class template, it should
7792:      *   class MySubClass extends MySuperClass {
7809:       // - constructor.template (this getter): the template for the class.
7811:       //     dom-module, or from the super class's template (or can be overridden
7874:      * @return {string} The import path for this element class
7909:      * Overrides the default `PropertyAccessors` to ensure class
8212:  * Class representing a static string value which can be used to filter
8213:  * strings by asseting that they have been created via this class. The
8216: class LiteralString {
8296:  *         <div class="shadowed">${this.partialTemplate}</div>
8347:  * Base class that provides the core API for Polymer's meta-programming
8357:  * @summary Custom element base class that provides the core API for Polymer's
8707:   class ArraySelectorMixin extends elementBase {
9025:  * class EmployeeList extends PolymerElement {
9078: class ArraySelector extends baseArraySelector {
9173:  * Element class mixin to skip strict dirty-checking for objects and arrays
9208:  * @summary Element class mixin to skip strict dirty-checking for objects
9211:  * @param {function(new:T)} superClass Class to apply mixin to.
9221:   class MutableData extends superClass {
9250:  * Element class mixin to add the optional ability to skip strict
9286:  * @summary Element class mixin to optionally skip strict dirty-checking
9296:   class OptionalMutableData extends superClass {
9350: // Base class for HTMLTemplateElement extension that has property effects
9352: // class only because Babel (incorrectly) requires super() in the class
9394:  * Base class for TemplateInstance.
9400: const templateInstanceBase = PropertyEffects(class {});
9450: class TemplateInstanceBase extends templateInstanceBase {
9640:  * @suppress {missingProperties} class.prototype is not defined for some reason
9656:    * Anonymous class created by the templatize
9660:   let klass = class extends templatizerBase { };
9672:  * @suppress {missingProperties} class.prototype is not defined for some reason
9682:     // Provide data API and property effects on memoized template class
9697:         class TemplatizedTemplate extends templatizedBase {}
9706:         // Create a cached subclass of the base custom element class onto which
9712:         class TemplatizedTemplateExtension extends templatizedBase {}
9807:  * Returns an anonymous `PropertyEffects` class bound to the
9808:  * `<template>` provided.  Instancing the class will result in the
9828:  *    method on the generated class should be called to forward host
9837:  * - `mutableData`: When `true`, the generated class will skip strict
9867:  * `templatize()` return the same class for all duplicates of a template.
9868:  * The class returned from `templatize()` is generated only once using
9880:  * @return {function(new:TemplateInstanceBase, Object=)} Generated class bound
9898:   // Get memoized base class for the prototypical template, which
9912:   // Subclass base class and add reference for this specific template
9914:   let klass = class TemplateInstance extends baseClass {};
9986:  * @summary Base class for dom-if element; subclassed into concrete
9989: class DomIfBase extends PolymerElement {
10225:   // Ideally these would be annotated as abstract methods in an abstract class,
10284: class DomIfLegacy extends DomIfBase {
10504:  * class EmployeeList extends PolymerElement {
10575: class DomRepeat extends domRepeatBase {
11267:  * Element class mixin that provides API for adding Polymer's cross-platform
11277:  * @summary Element class mixin that provides API for adding Polymer's
11280:  * @param {function(new:T)} superClass Class to apply mixin to.
11289:   class GestureEventListeners extends superClass {
11461:  * Class that listens for changes (additions or removals) to
11482:  * class TestSelfObserve extends PolymerElement {
11498:  * @summary Class that listens for changes (additions or removals) to
11502: let FlattenedNodesObserver = class {
11782:  * Node API wrapper class returned from `Polymer.dom.(target)` when
11787: class DomApiNative {
12003:  * Event API wrapper class returned from `dom.(target)` when
12006: class EventApi {
12134:   class Wrapper extends window.ShadyDOM['Wrapper'] {}
12359:  * Element class mixin that allows the element to boot up in a non-enabled
12372:  * Note, this mixin must be applied on top of any element class that
12376:  *     MyClass = DisableUpgradeMixin(class extends BaseClass {...});
12382:  * @param {function(new:T)} superClass Class to apply mixin to.
12406:   class DisableUpgradeClass extends superClass {
12512:  * Element class mixin that provides Polymer's "legacy" API intended to be
12523:  * @summary Element class mixin that provides Polymer's "legacy" API
12568:   class LegacyElement extends legacyElementBase {
12593:      *  closure for some reason even in a static method, rather than the class
12763:      * add support for class initialization via the `_registered` callback.
12803:      * Users may override this method to perform class registration time
12805:      * only once for the class.
13510:      * Toggles a CSS class on or off.
13512:      * @param {string} name CSS class name
13513:      * @param {boolean=} bool Boolean to force the class on or off.
13514:      *    When unspecified, the state of the class will be reversed.
13737:  * Applies a "legacy" behavior or array of behaviors to the provided class.
13746:  * @param {function(new:T)} klass Element class.
13747:  * @return {?} Returns a new Element class extended by the
13777: // the element prototype becomes (oldest) (1) PolymerElement, (2) class(C),
13778: // (3) class(A), (4) class(B), (5) class(Polymer({...})).
13852:   When calling `Polymer` or `mixinBehaviors`, the generated class below is
13853:   made. The list of behaviors was previously made into one generated class per
13858:   The generated class is directly tied to the info object and behaviors
13873:  * @param {function(new:HTMLElement)} Base base class to extend with info object
13875:  * @return {function(new:HTMLElement)} Generated class
13881:   // manages behavior and lifecycle processing (filled in after class definition)
13886:   class PolymerGenerated extends Base {
13973:       // only proceed if the generated class' prototype has not been registered.
13979:         // copy properties onto the generated class lazily if we're optimizing,
13984:         // and not the generated class prototype; if the element has been
14100:     // NOTE: ensure the behavior is extending a class with
14107:     // get flattened, deduped list of behaviors *not* already on super class
14131:  * Generates a class that extends `LegacyElement` based on the
14135:  * to the generated class.
14194:  *   to become class methods.
14196:  * @param {function(T):T} mixin Optional mixin to apply to legacy base class
14198:  * @return {function(new:HTMLElement)} Generated class
14202:     console.warn('Polymer.Class requires `info` argument');
14312:  * Legacy class factory and registration helper for defining Polymer
14317:  *     import {Class} from '@polymer/polymer/polymer_bundled.min.js';
14318:  *     customElements.define(info.is, Class(info));
14320:  * See `Class` for details on valid legacy metadata format for `info`.
14326:  *   to become class methods.
14327:  * @return {function(new: HTMLElement)} Generated class
14331:   // if input is a `class` (aka a function with a prototype), use the prototype
14337:     klass = Polymer.Class(info);
14339:   // Copy opt out for `legacyNoObservedAttributes` from info object to class.
14347: Polymer.Class = Class;
14423:    * Generates an anonymous `TemplateInstance` class (stored as `this.ctor`)
14429:    * @param {boolean=} mutableData When `true`, the generated class will skip
14449:    * returned is an instance of the anonymous class generated by `templatize`
14522: class DomBind extends domBindBase {
14682: class CustomStyle extends HTMLElement {
2458:  * For basic usage of this mixin, call `MyClass.createProperties(props)`
2472:  * @return {function(new:T)} superClass with mixin applied.
2478:      * @return {function(new:T)} superClass with mixin applied.
2480:     (superClass) => {
2484:    * @mixinClass
3120:  * @return {function(new:T)} superClass with mixin applied.
3122: const PropertyAccessors = dedupingMixin(superClass => {
3130:    const base = PropertiesChanged(superClass);
3134:    * @mixinClass
3566:      * @return {function(new:T)} superClass with mixin applied.
3568:     (superClass) => {
3572:    * @mixinClass
4036:  *   extending a superclass map onto this subclass
4892:       // Note, className needs style scoping so this needs wrapping.
4895:       if (target === 'className') {
5247: const PropertyEffects = dedupingMixin(superClass => {
5256:   const propertyEffectsBase = TemplateStamp(PropertyAccessors(superClass));
5260:    * @mixinClass
5589:         // Note, className needs style scoping so this needs wrapping.
5590:         if (prop === 'className') {
6740:       // ensures we don't needlessly run effects for an element's initial
6805:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6843:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
6912:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7176:  * @return {function(new:T)} superClass with mixin applied.
7178: const PropertiesMixin = dedupingMixin(superClass => {
7185:  const base = PropertiesChanged(superClass);
7232:   * @mixinClass
7242:     * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7255:     * Finalizes an element definition, including ensuring any super classes
7258:     * `_finalizeClass` to finalize each constructor in the prototype chain.
7264:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
7269:        this._finalizeClass();
7281:    static _finalizeClass() {
7290:     * from super classes. Properties not in object format are converted to
7300:        const superCtor = superPropertiesClass(/** @type {!PropertiesMixinConstructor} */(this));
7455:  * @return {function(new:T)} superClass with mixin applied.
7517:    * these values may not be changed. For example, a subclass cannot
7553:    * reflectToAttribute property not do so in a subclass. We've chosen to
7555:    * For example, a readOnly effect generates a special setter. If a subclass
7680:    * @mixinClass
7697:      * Override of PropertiesMixin _finalizeClass to create observers and
7701:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
7704:     static _finalizeClass() {
7707:       polymerElementBase._finalizeClass.call(this);
7773:      * element semantics; a subclass will subsequently fall back to its super
7782:      * implementation and the subclass would like to provide an alternate
7797:      *         subContent.textContent = 'This came from MySubClass';
7816:       //     constructor.template, saved in _finalizeClass(). Note that before
7841:           // Next look for superclass template (call the super impl this
7842:           // way so that `this` points to the superclass)
8153:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8173:      * @suppress {missingProperties} Interfaces in closure do not inherit statics, but classes do
8692: let ArraySelectorMixin = dedupingMixin(superClass => {
8699:   let elementBase = ElementMixin(superClass);
8703:    * @mixinClass
9097:  * Forces several classes of asynchronously queued tasks to flush:
9212:  * @return {function(new:T)} superClass with mixin applied.
9214: const MutableData = dedupingMixin(superClass => {
9218:    * @mixinClass
9289: const OptionalMutableData = dedupingMixin(superClass => {
9292:    * @mixinClass
9385: // Applies a DataTemplate subclass to a <template> instance
9642: function createTemplatizerClass(template, templateInfo, options) {
9683:     let klass = templateInfo.templatizeTemplateClass;
9698:         klass = templateInfo.templatizeTemplateClass = TemplatizedTemplate;
9713:         klass = templateInfo.templatizeTemplateClass =
9741:       // Swizzle the cached subclass prototype onto the custom element
9904:   let baseClass = templateInfo.templatizeInstanceClass;
9905:   if (!baseClass) {
9906:     baseClass = createTemplatizerClass(template, templateInfo, options);
9907:     templateInfo.templatizeInstanceClass = baseClass;
10229:    * Abstract API to be implemented by subclass: Returns true if a template
10238:    * Abstract API to be implemented by subclass: Returns the child nodes stamped
10248:    * Abstract API to be implemented by subclass: Creates an instance of the
10258:    * Abstract API to be implemented by subclass: Removes nodes created by an
10267:    * Abstract API to be implemented by subclass: Shows or hides any template
11281:  * @return {function(new:T)} superClass with mixin applied.
11283: const GestureEventListeners = dedupingMixin((superClass) => {
11286:    * @mixinClass
12143:   // Note, `classList` is here only for legacy compatibility since it does not
12146:     'classList'
12189:   // Properties that should return the logical, not composed tree. Note, `classList`
12196:     'childNodes', 'children', 'classList', 'shadowRoot'
12200:     'textContent', 'innerHTML', 'className'
12361:  * designed to be used with element classes like PolymerElement that perform
12383:  * @return {function(new:T)} superClass with mixin applied.
12392:   const superClass = ElementMixin(base);
12399:   let observedAttributesGetter = findObservedAttributesGetter(superClass);
12403:    * @mixinClass
12494:   return DisableUpgradeClass;
12563:    * @mixinClass
13519:     toggleClass(name, bool, node) {
13522:         bool = !node.classList.contains(name);
13525:         node.classList.add(name);
13527:         node.classList.remove(name);
13849: /* Note about construction and extension of legacy classes.
13855:   manually. Note, there may *still* be multiple generated classes in the
13860:   behaviors not active on the superclass. In order to call through to the
13868:   and not `_finalizeClass`.
13888:     // explicitly not calling super._finalizeClass
13891:       // if calling via a subclass that hasn't been generated, pass through to super
13895:         Base._finalizeClass.call(this);
13977:         // ensure superclass is registered first.
3319:      * `__dataProto`, and it is up to the subclasser to decide how/when
7391:  * Subclassers may provide the following static getters to return metadata
7519:    * by subclasses.
7552:    * effects via subclassing. For example, a user might want to make a
10149:    * Subclasses should implement the following methods called here:
13752:   return GenerateClassFromInfo({}, LegacyElementMixin(klass), behaviors);
13879: function GenerateClassFromInfo(info, Base, behaviors) {
14206:   klass = GenerateClassFromInfo(info, klass, info.behaviors);
android.googlesource.com/platform/external/free-image:Source/LibRawLite/dcraw/dcraw.c: [ master, ]
153: #define CLASS
99:    access them are prefixed with "CLASS".  Note that a thread-safe
100:    C++ class cannot have non-const static local variables.
217: int CLASS fc (int row, int col)
243: 	      char *needle, size_t needlelen)
247:     if (!memcmp (c, needle, needlelen))
254: void CLASS merror (void *ptr, char *where)
261: void CLASS derror()
273: ushort CLASS sget2 (uchar *s)
281: ushort CLASS get2()
288: unsigned CLASS sget4 (uchar *s)
297: unsigned CLASS get4()
304: unsigned CLASS getint (int type)
309: float CLASS int_to_float (int i)
316: double CLASS getreal (int type)
340: void CLASS read_shorts (ushort *pixel, int count)
347: void CLASS canon_black (double dark[2])
361: void CLASS canon_600_fixed_wb (int temp)
382: int CLASS canon_600_color (int ratio[2], int mar)
411: void CLASS canon_600_auto_wb()
453: void CLASS canon_600_coeff()
477: void CLASS canon_600_load_raw()
518: void CLASS remove_zeroes()
535: int CLASS canon_s2is()
546: void CLASS canon_a5_load_raw()
573: unsigned CLASS getbits (int nbits)
592: void CLASS init_decoder()
624: uchar * CLASS make_decoder (const uchar *source, int level)
650: void CLASS crw_init_tables (unsigned table)
720: int CLASS canon_has_lowbits()
735: void CLASS canon_compressed_load_raw()
817:   struct CLASS decode *huff[6];
821: int CLASS ljpeg_start (struct jhead *jh, int info_only)
873: int CLASS ljpeg_diff (struct decode *dindex)
888: ushort * CLASS ljpeg_row (int jrow, struct jhead *jh)
925: void CLASS lossless_jpeg_load_raw()
970: void CLASS canon_sraw_load_raw()
1037: void CLASS adobe_copy_pixel (int row, int col, ushort **rp)
1061: void CLASS adobe_dng_load_raw_lj()
1090: void CLASS adobe_dng_load_raw_nc()
1111: void CLASS pentax_tree()
1131: void CLASS pentax_k10_load_raw()
1148: void CLASS nikon_compressed_load_raw()
1221: int CLASS nikon_is_compressed()
1236: int CLASS nikon_e995()
1254: int CLASS nikon_e2100()
1269: void CLASS nikon_3700()
1295: int CLASS minolta_z2()
1308: void CLASS nikon_e900_load_raw()
1327: void CLASS fuji_load_raw()
1353: void CLASS jpeg_thumb (FILE *tfp);
1355: void CLASS ppm_thumb (FILE *tfp)
1367: void CLASS layer_thumb (FILE *tfp)
1384: void CLASS rollei_thumb (FILE *tfp)
1402: void CLASS rollei_load_raw()
1428: int CLASS bayer (unsigned row, unsigned col)
1433: void CLASS phase_one_flat_field (int is_float, int nc)
1477: void CLASS phase_one_correct()
1601: void CLASS phase_one_load_raw()
1628: unsigned CLASS ph1_bits (int nbits)
1643: void CLASS phase_one_load_raw_c()
1694: void CLASS hasselblad_load_raw()
1726: void CLASS leaf_hdr_load_raw()
1753: void CLASS unpacked_load_raw();
1755: void CLASS sinar_4shot_load_raw()
1790: void CLASS imacon_full_load_raw()
1799: void CLASS packed_12_load_raw()
1837: void CLASS unpacked_load_raw()
1855: void CLASS nokia_load_raw()
1879: unsigned CLASS pana_bits (int nbits)
1895: void CLASS panasonic_load_raw()
1918: void CLASS olympus_e300_load_raw()
1945: void CLASS olympus_e410_load_raw()
1986: void CLASS minolta_rd175_load_raw()
2014: void CLASS casio_qv5700_load_raw()
2034: void CLASS quicktake_100_load_raw()
2101: const int * CLASS make_decoder_int (const int *source, int level)
2118: int CLASS radc_token (int tree)
2164: void CLASS kodak_radc_load_raw()
2233: void CLASS kodak_jpeg_load_raw() {}
2249: void CLASS kodak_jpeg_load_raw()
2290: void CLASS kodak_dc120_load_raw()
2306: void CLASS eight_bit_load_raw()
2331: void CLASS kodak_yrgb_load_raw()
2355: void CLASS kodak_262_load_raw()
2404: int CLASS kodak_65000_decode (short *out, int bsize)
2450: void CLASS kodak_65000_load_raw()
2466: void CLASS kodak_ycbcr_load_raw()
2493: void CLASS kodak_rgb_load_raw()
2509: void CLASS kodak_thumb_load_raw()
2519: void CLASS sony_decrypt (unsigned *data, int len, int start, int key)
2536: void CLASS sony_load_raw()
2569: void CLASS sony_arw_load_raw()
2589: void CLASS sony_arw2_load_raw()
2630: void CLASS smal_decode_segment (unsigned seg[2][2], int holes)
2696: void CLASS smal_v6_load_raw()
2709: int CLASS median4 (int *p)
2722: void CLASS fill_holes (int holes)
2748: void CLASS smal_v9_load_raw()
2770: void CLASS foveon_decoder (unsigned size, unsigned code)
2801: void CLASS foveon_thumb (FILE *tfp)
2840: void CLASS foveon_load_camf()
2854: void CLASS foveon_load_raw()
2892: const char * CLASS foveon_camf_param (const char *block, const char *param)
2914: void * CLASS foveon_camf_matrix (unsigned dim[3], const char *name)
2948: int CLASS foveon_fixed (void *ptr, int size, const char *name)
2960: float CLASS foveon_avg (short *pix, int range[2], float cfilt)
2974: short * CLASS foveon_make_curve (double max, double mul, double filt)
2993: void CLASS foveon_make_curves
3004: int CLASS foveon_apply_curve (short *curve, int i)
3012: void CLASS foveon_interpolate()
3415: void CLASS bad_pixels (char *fname)
3474: void CLASS subtract (char *fname)
3514: void CLASS pseudoinverse (double (*in)[3], double (*out)[3], int size)
3543: void CLASS cam_xyz_coeff (double cam_xyz[4][3])
3567: void CLASS colorcheck()
3660: void CLASS hat_transform (float *temp, float *base, int st, int size, int sc)
3671: void CLASS wavelet_denoise()
3746: void CLASS scale_colors()
3853: void CLASS pre_interpolate()
3887: void CLASS border_interpolate (int border)
3909: void CLASS lin_interpolate()
3955:    described in http://scien.stanford.edu/class/psych221/projects/99/tingchen/algodep/vargra.html
3960: void CLASS vng_interpolate()
4089: void CLASS ppg_interpolate()
4146: void CLASS ahd_interpolate()
4271: void CLASS median_filter()
4299: void CLASS blend_highlights()
4337: void CLASS recover_highlights()
4414: void CLASS tiff_get (unsigned base,
4425: void CLASS parse_thumb_note (int base, unsigned toff, unsigned tlen)
4438: int CLASS parse_tiff_ifd (int base);
4440: void CLASS parse_makernote (int base, int uptag)
4688:       load_raw = &CLASS olympus_e410_load_raw;
4716: void CLASS get_timestamp (int reversed)
4737: void CLASS parse_exif (int base)
4768: void CLASS parse_gps (int base)
4789: void CLASS romm_coeff (float romm_cam[3][3])
4803: void CLASS parse_mos (int offset)
4868: void CLASS linear_table (unsigned len)
4878: void CLASS parse_kodak_ifd (int base)
4909: void CLASS parse_minolta (int base);
4911: int CLASS parse_tiff_ifd (int base)
4982: 	load_raw = &CLASS panasonic_load_raw;
5033: 	  load_raw = &CLASS sinar_4shot_load_raw;
5039: 	  load_raw = &CLASS sony_arw_load_raw;
5173: 	load_raw = &CLASS imacon_full_load_raw;
5176: 	  load_raw = &CLASS unpacked_load_raw;
5284: 	load_raw = &CLASS packed_12_load_raw;
5319: void CLASS parse_tiff (int base)
5365: 	  case  8: load_raw = &CLASS eight_bit_load_raw;	break;
5366: 	  case 12: load_raw = &CLASS packed_12_load_raw;
5371: 	  case 16: load_raw = &CLASS unpacked_load_raw;		break;
5374: 	  load_raw = &CLASS olympus_e300_load_raw;
5377: 	load_raw = &CLASS lossless_jpeg_load_raw;		break;
5379: 	load_raw = &CLASS kodak_262_load_raw;			break;
5381: 	load_raw = &CLASS sony_arw2_load_raw;
5385: 	load_raw = &CLASS sony_arw_load_raw;			break;
5389: 	load_raw = &CLASS packed_12_load_raw;			break;
5391: 	load_raw = &CLASS nikon_compressed_load_raw;		break;
5393: 	load_raw = &CLASS pentax_k10_load_raw;			break;
5396: 	  case 2: load_raw = &CLASS kodak_rgb_load_raw;   filters = 0;  break;
5397: 	  case 6: load_raw = &CLASS kodak_ycbcr_load_raw; filters = 0;  break;
5398: 	  case 32803: load_raw = &CLASS kodak_65000_load_raw;
5424: 	write_thumb = &CLASS layer_thumb;
5428: 	  thumb_load_raw = &CLASS kodak_thumb_load_raw;
5430: 	  write_thumb = &CLASS ppm_thumb;
5434: 		&CLASS kodak_ycbcr_load_raw : &CLASS kodak_rgb_load_raw;
5439: void CLASS parse_minolta (int base)
5479: void CLASS parse_external_jpeg()
5529: void CLASS ciff_block_1030()
5553: void CLASS parse_ciff (int offset, int length)
5657: void CLASS parse_rollei()
5692:   write_thumb = &CLASS rollei_thumb;
5695: void CLASS parse_sinar_ia()
5720:   load_raw = &CLASS unpacked_load_raw;
5723:   write_thumb = &CLASS ppm_thumb;
5727: void CLASS parse_phase_one (int base)
5782: 	&CLASS phase_one_load_raw : &CLASS phase_one_load_raw_c;
5794: void CLASS parse_fuji (int offset)
5821: int CLASS parse_jpeg (int offset)
5847: void CLASS parse_riff()
5887: void CLASS parse_smal (int offset, int fsize)
5902:   if (ver == 6) load_raw = &CLASS smal_v6_load_raw;
5903:   if (ver == 9) load_raw = &CLASS smal_v9_load_raw;
5906: void CLASS parse_cine()
5924:     case  8:  load_raw = &CLASS eight_bit_load_raw;  break;
5925:     case 16:  load_raw = &CLASS  unpacked_load_raw;
5955: char * CLASS foveon_gets (int offset, char *str, int len)
5965: void CLASS parse_foveon()
6000: 	  write_thumb = &CLASS jpeg_thumb;
6006: 	  write_thumb = &CLASS foveon_thumb;
6054: void CLASS adobe_coeff (char *make, char *model)
6499: void CLASS simple_coeff (int index)
6519: short CLASS guess_byte_order (int words)
6542: void CLASS identify()
6633:   write_thumb = &CLASS jpeg_thumb;
6718:     load_raw = &CLASS nokia_load_raw;
6777:       load_raw = &CLASS adobe_dng_load_raw_nc;
6779:       load_raw = &CLASS adobe_dng_load_raw_lj;
6784: 	&CLASS lossless_jpeg_load_raw : &CLASS canon_compressed_load_raw;
6787:       load_raw = &CLASS packed_12_load_raw;
6792:     load_raw = &CLASS packed_12_load_raw;
6802:     load_raw = &CLASS foveon_load_raw;
6810:     load_raw = &CLASS canon_sraw_load_raw;
6818:     load_raw = &CLASS canon_600_load_raw;
6827:     load_raw = &CLASS canon_a5_load_raw;
6834:     load_raw = &CLASS canon_a5_load_raw;
6840:     load_raw = &CLASS canon_a5_load_raw;
6848:     load_raw = &CLASS canon_a5_load_raw;
6856:     load_raw = &CLASS canon_a5_load_raw;
6864:     load_raw = &CLASS canon_a5_load_raw;
6874:     load_raw = &CLASS canon_a5_load_raw;
6882:     load_raw = &CLASS canon_a5_load_raw;
6890:     load_raw = &CLASS canon_a5_load_raw;
6898:     load_raw = &CLASS canon_a5_load_raw;
6906:     load_raw = &CLASS canon_a5_load_raw;
6914:     load_raw = &CLASS canon_a5_load_raw;
6922:     load_raw = &CLASS canon_a5_load_raw;
7066:       load_raw = &CLASS packed_12_load_raw;
7089:     load_raw = &CLASS nikon_e900_load_raw;
7101:     load_raw = &CLASS nikon_e900_load_raw;
7110:     load_raw = &CLASS packed_12_load_raw;
7136:     load_raw = &CLASS packed_12_load_raw;
7157:     load_raw = &CLASS packed_12_load_raw;
7173:     load_raw = &CLASS packed_12_load_raw;
7177:     load_raw = &CLASS unpacked_load_raw;
7197:     load_raw = &CLASS fuji_load_raw;
7204:     load_raw = &CLASS minolta_rd175_load_raw;
7213:     load_raw = &CLASS unpacked_load_raw;
7218:       load_raw = &CLASS packed_12_load_raw;
7224:       load_raw = &CLASS packed_12_load_raw;
7241:       load_raw = &CLASS unpacked_load_raw;
7253:       load_raw = &CLASS eight_bit_load_raw;
7262:       load_raw = &CLASS packed_12_load_raw;
7271:     load_raw = &CLASS packed_12_load_raw;
7278:     load_raw = &CLASS packed_12_load_raw;
7285:     load_raw = &CLASS unpacked_load_raw;
7290:     load_raw = &CLASS eight_bit_load_raw;
7301:     load_raw = &CLASS unpacked_load_raw;
7309:     load_raw = &CLASS unpacked_load_raw;
7315:     load_raw = &CLASS eight_bit_load_raw;
7319:     load_raw = &CLASS eight_bit_load_raw;
7323:     load_raw = &CLASS eight_bit_load_raw;
7328: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7333:     load_raw = &CLASS unpacked_load_raw;
7342: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7350:     load_raw = &CLASS unpacked_load_raw;
7356: 	&CLASS eight_bit_load_raw : &CLASS unpacked_load_raw;
7362:     load_raw = &CLASS unpacked_load_raw;
7375:     if (load_raw == &CLASS lossless_jpeg_load_raw)
7376:       load_raw = &CLASS hasselblad_load_raw;
7397:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7406:       load_raw = &CLASS leaf_hdr_load_raw;
7442:       load_raw = &CLASS panasonic_load_raw;
7443:     if (!load_raw) load_raw = &CLASS unpacked_load_raw;
7538:     load_raw = &CLASS packed_12_load_raw;
7543:     if (load_raw == &CLASS olympus_e410_load_raw) {
7551:       if (load_raw == &CLASS unpacked_load_raw) {
7557:       if (load_raw == &CLASS unpacked_load_raw)
7569:     load_raw = &CLASS packed_12_load_raw;
7574:     load_raw = &CLASS sony_load_raw;
7582:     load_raw = &CLASS sony_load_raw;
7600:     load_raw = &CLASS kodak_yrgb_load_raw;
7618:     load_raw = &CLASS eight_bit_load_raw;
7671:       load_raw = &CLASS eight_bit_load_raw;
7677:       load_raw = &CLASS kodak_radc_load_raw;
7683:       load_raw = &CLASS kodak_radc_load_raw;
7690: 	&CLASS kodak_jpeg_load_raw : &CLASS kodak_dc120_load_raw;
7696:       write_thumb = &CLASS layer_thumb;
7700:       load_raw = &CLASS eight_bit_load_raw;
7707:     load_raw = &CLASS kodak_radc_load_raw;
7720:     load_raw = &CLASS quicktake_100_load_raw;
7725:     load_raw = &CLASS kodak_radc_load_raw;
7744:     load_raw = &CLASS rollei_load_raw;
7751:     load_raw = &CLASS eight_bit_load_raw;
7758:     load_raw = &CLASS eight_bit_load_raw;
7763:     load_raw = &CLASS eight_bit_load_raw;
7767:     load_raw = &CLASS unpacked_load_raw;
7772:     load_raw = &CLASS casio_qv5700_load_raw;
7836:   if (load_raw == &CLASS kodak_jpeg_load_raw) {
7858: void CLASS apply_profile (char *input, char *output)
7908: void CLASS convert_to_rgb()
8026: void CLASS fuji_rotate()
8064: void CLASS stretch()
8101: int CLASS flip_index (int row, int col)
8109: void CLASS gamma_lut (uchar lut[0x10000])
8154: void CLASS tiff_set (ushort *ntag,
8173: void CLASS tiff_head (struct tiff_hdr *th, int full)
8247: void CLASS jpeg_thumb (FILE *tfp)
8269: void CLASS write_ppm_tiff (FILE *ofp)
8311: int CLASS main (int argc, char **argv)
8496:     write_fun = &CLASS write_ppm_tiff;
8513:     if (load_raw == &CLASS kodak_ycbcr_load_raw) {
8638:     if (write_fun == &CLASS jpeg_thumb)
8640:     else if (output_tiff && write_fun == &CLASS write_ppm_tiff)
246:   for (c = haystack; c <= haystack + haystacklen - needlelen; c++)
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js: [ master, ]
1237:     "class" : {
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
1098:     var classValue = node.getAttribute("class");
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +