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: [](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')" +
|
|