Found 68904 results in 2684 files, showing top 50 files (show more).
github.com/kubernetes/minikube:site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
208:         "class-utils": "^0.3.5",
622:         "posix-character-classes": "^0.1.0",
378:     "class-utils": {
380:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1079:         "needle": {
2085:     "posix-character-classes": {
2087:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/kubernetes/minikube:site/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/tensorflow/playground:package-lock.json: [ master, ]
1628:             "needle": "^2.2.1",
190:         "class-utils": "^0.3.5",
1154:         "posix-character-classes": "^0.1.0",
581:     "class-utils": {
583:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1609:         "needle": {
2770:     "posix-character-classes": {
2772:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/google/nomulus:package-lock.json: [ master, ]
1276:             "needle": "^2.2.1",
132:         "class-utils": "^0.3.5",
733:         "posix-character-classes": "^0.1.0",
359:     "class-utils": {
361:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1257:         "needle": {
2293:     "posix-character-classes": {
2295:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
713:   const DeclRefExpr *Needle;
56:   class UnreachableCodeHandler : public reachable_code::Callback {
125: class LogicalErrorHandler : public CFGCallback {
183:     // Skip function calls which are qualified with a templated class.
708: /// ContainsReference - A visitor class to search for references to
709: /// a particular declaration (the needle) within any evaluated component of an
711: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
718:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
719:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
730:     if (E == Needle)
1019:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1486: class UninitValsDiagReporter : public UninitVariablesHandler {
1598: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1870: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
244:   // templated classes.
847:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
854:     case Stmt::IfStmtClass: {
864:     case Stmt::ConditionalOperatorClass: {
874:     case Stmt::BinaryOperatorClass: {
894:     case Stmt::WhileStmtClass:
901:     case Stmt::ForStmtClass:
911:     case Stmt::CXXForRangeStmtClass:
924:     case Stmt::DoStmtClass:
933:     case Stmt::CaseStmtClass:
938:     case Stmt::DefaultStmtClass:
1309:     switch (S->getStmtClass()) {
1310:     case Stmt::ForStmtClass:
1311:     case Stmt::WhileStmtClass:
1312:     case Stmt::CXXForRangeStmtClass:
1313:     case Stmt::ObjCForCollectionStmtClass:
1315:     case Stmt::DoStmtClass: {
1403:   // Classify the current code body for better warning text.
1406:   // FIXME: Should we use a common classification enum and the same set of
1441:     // Classify the weak object being accessed for better warning text.
2063:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
2064:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
2065:       .setAlwaysAdd(Stmt::BlockExprClass)
2066:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
2067:       .setAlwaysAdd(Stmt::DeclRefExprClass)
2068:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
2069:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
2070:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/llvm-mirror/llvm:utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
47:   Record *Class;
88: class SearchableTableEmitter {
532:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
655:     Enum->Class = Records.getClass(FilterClass);
656:     if (!Enum->Class)
723:     Record *Class = NameRec.second.get();
724:     if (Class->getSuperClasses().size() != 1 ||
725:         !Class->isSubClassOf(SearchableTable))
728:     StringRef TableName = Class->getName();
730:     if (!Class->isValueUnset("EnumNameField")) {
731:       StringRef NameField = Class->getValueAsString("EnumNameField");
733:       if (!Class->isValueUnset("EnumValueField"))
734:         ValueField = Class->getValueAsString("EnumValueField");
737:       Enum->Name = (Twine(Class->getName()) + "Values").str();
738:       Enum->PreprocessorGuard = Class->getName().upper();
739:       Enum->Class = Class;
747:     Table->Name = (Twine(Class->getName()) + "sList").str();
748:     Table->PreprocessorGuard = Class->getName().upper();
749:     Table->CppTypeName = Class->getName();
751:     for (const RecordVal &Field : Class->getValues()) {
767:          Class->getValueAsListOfStrings("SearchableFields")) {
623:   Record *IntrinsicClass = Records.getClass("Intrinsic");
624:   Record *InstructionClass = Records.getClass("Instruction");
627:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
629:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
636:   // Emit tables in a deterministic order to avoid needless rebuilds.
654:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
657:       PrintFatalError(EnumRec->getLoc(), Twine("Enum FilterClass '") +
658:                                              FilterClass + "' does not exist");
661:                        Records.getAllDerivedDefinitions(FilterClass));
687:                                     TableRec->getValueAsString("FilterClass")));
721:   Record *SearchableTable = Records.getClass("SearchableTable");
130:       return DI->getDef()->isSubClassOf("Intrinsic");
530:     if (TypeRec->isSubClassOf("GenericEnum")) {
722:   for (auto &NameRec : Records.getClasses()) {
chromium.googlesource.com/arc/arc:third_party/android/external/chromium/chrome/browser/sync/syncable/syncable.h: [ master, ]
1002:     EntryKernel needle;
33: class DictionaryValue;
37: class ReadTransaction;
38: class WriteNode;
39: class ReadNode;
43: class DirectoryChangeListener;
44: class Entry;
48: class DirectoryBackingStore;
179: class BaseTransaction;
180: class WriteTransaction;
181: class ReadTransaction;
182: class Directory;
183: class ScopedDirLookup;
222: // The EntryKernel class contains the actual data for an entry.
347: class Entry {
348:   friend class Directory;
438:   friend class sync_api::ReadNode;
460: class MutableEntry : public Entry {
461:   friend class WriteTransaction;
462:   friend class Directory;
520:   friend class sync_api::WriteNode;
541: class LessParentIdAndHandle;
543: class LessField;
544: class LessEntryMetaHandles {
567: // index, the traits are grouped into a class called an Indexer which
606:   class Comparator {
659: class ScopedKernelLock;
660: class IdFilter;
661: class DirectoryManager;
663: class Directory {
664:   friend class BaseTransaction;
665:   friend class Entry;
666:   friend class MutableEntry;
667:   friend class ReadTransaction;
668:   friend class ReadTransactionWithoutDB;
669:   friend class ScopedKernelLock;
670:   friend class ScopedKernelUnlock;
671:   friend class WriteTransaction;
672:   friend class SyncableDirectoryTest;
682:   class EventListenerHookup;
828:   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
1001:     // look something up in an index.  Needle in haystack metaphor.
1071: class ScopedKernelLock {
1082: class BaseTransaction {
1083:   friend class Entry;
1118: class ReadTransaction : public BaseTransaction {
1128:   friend class sync_api::ReadTransaction;
1135: class WriteTransaction : public BaseTransaction {
1136:   friend class MutableEntry;
647: // friend classes.  The in-memory indices are protected against
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js: [ master, ]
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
44: var Class = {
54:     Object.extend(klass, Class.Methods);
77: Class.Methods = {
294: var PeriodicalExecuter = Class.create({
560: var Template = Class.create({
997: var Hash = Class.create(Enumerable, (function() {
1094: var ObjectRange = Class.create(Enumerable, {
1168: Ajax.Base = Class.create({
1190: Ajax.Request = Class.create(Ajax.Base, {
1363: Ajax.Response = Class.create({
1437: Ajax.Updater = Class.create(Ajax.Request, {
1473: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1681:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2721: /* Portions of the Selector class are derived from Jack Slocum's DomQuery,
2725: var Selector = Class.create({
2913:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3213:       var needle = ' ' + className + ' ';
3217:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3704: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3721: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3727: Form.Observer = Class.create(Abstract.TimedObserver, {
3735: Abstract.EventObserver = Class.create({
3774: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3780: Form.EventObserver = Class.create(Abstract.EventObserver, {
4252:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4285: Element.ClassNames = Class.create();
55:     klass.superclass = parent;
61:       klass.prototype = new subclass;
79:     var ancestor   = this.superclass && this.superclass.prototype;
1831:     return new Element.ClassNames(element);
1836:     var elementClassName = element.className;
1837:     return (elementClassName.length > 0 && (elementClassName == className ||
1838:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1843:     if (!element.hasClassName(className))
1844:       element.className += (element.className ? ' ' : '') + className;
1850:     element.className = element.className.replace(
1851:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1857:     return element[element.hasClassName(className) ?
1858:       'removeClassName' : 'addClassName'](className);
2644:   function findDOMClass(tagName) {
2676:       var klass = findDOMClass(tag);
3007:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
3035:     className:    /^\.([\w\-\*]+)(\b|$)/,
3048:     className: function(element, matches) {
3206:     className: function(nodes, root, className, combinator) {
3208:       return Selector.handlers.byClassName(nodes, root, className);
3211:     byClassName: function(nodes, root, className) {
3215:         nodeClassName = node.className;
4256:   function(element, className) {
4257:     className = className.toString().strip();
4258:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4260:   } : function(element, className) {
4261:     className = className.toString().strip();
4263:     if (!classNames && !className) return elements;
4266:     className = ' ' + className + ' ';
4269:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4270:           (classNames && classNames.all(function(name) {
4278:   return function(className, parentElement) {
4279:     return $(parentElement || document.body).getElementsByClassName(className);
4292:     this.element.className.split(/\s+/).select(function(name) {
4297:   set: function(className) {
4298:     this.element.className = className;
4301:   add: function(classNameToAdd) {
4302:     if (this.include(classNameToAdd)) return;
4303:     this.set($A(this).concat(classNameToAdd).join(' '));
4306:   remove: function(classNameToRemove) {
4307:     if (!this.include(classNameToRemove)) return;
4308:     this.set($A(this).without(classNameToRemove).join(' '));
4316: Object.extend(Element.ClassNames.prototype, Enumerable);
56:     klass.subclasses = [];
62:       parent.subclasses.push(klass);
3049:       return Element.hasClassName(element, matches[1]);
3214:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3216:         if (nodeClassName.length == 0) continue;
4250: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4255:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/google/swiftshader:third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ]
48:   Record *Class;
89: class SearchableTableEmitter {
526:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
648:     Enum->Class = Records.getClass(FilterClass);
649:     if (!Enum->Class)
713:     Record *Class = NameRec.second.get();
714:     if (Class->getSuperClasses().size() != 1 ||
715:         !Class->isSubClassOf(SearchableTable))
718:     StringRef TableName = Class->getName();
720:     if (!Class->isValueUnset("EnumNameField")) {
721:       StringRef NameField = Class->getValueAsString("EnumNameField");
723:       if (!Class->isValueUnset("EnumValueField"))
724:         ValueField = Class->getValueAsString("EnumValueField");
727:       Enum->Name = (Twine(Class->getName()) + "Values").str();
728:       Enum->PreprocessorGuard = Class->getName().upper();
729:       Enum->Class = Class;
737:     Table->Name = (Twine(Class->getName()) + "sList").str();
738:     Table->PreprocessorGuard = Class->getName().upper();
739:     Table->CppTypeName = Class->getName();
741:     for (const RecordVal &Field : Class->getValues()) {
757:          Class->getValueAsListOfStrings("SearchableFields")) {
616:   Record *IntrinsicClass = Records.getClass("Intrinsic");
617:   Record *InstructionClass = Records.getClass("Instruction");
620:       if (IntrinsicClass && RecordTy->isSubClassOf(IntrinsicClass))
622:       else if (InstructionClass && RecordTy->isSubClassOf(InstructionClass))
629:   // Emit tables in a deterministic order to avoid needless rebuilds.
647:     StringRef FilterClass = EnumRec->getValueAsString("FilterClass");
650:       PrintFatalError(Twine("Enum FilterClass '") + FilterClass +
654:                        Records.getAllDerivedDefinitions(FilterClass));
679:                                     TableRec->getValueAsString("FilterClass")));
711:   Record *SearchableTable = Records.getClass("SearchableTable");
131:       return DI->getDef()->isSubClassOf("Intrinsic");
524:     if (TypeRec->isSubClassOf("GenericEnum")) {
712:   for (auto &NameRec : Records.getClasses()) {
chromium.googlesource.com/private/55048997-blink2:Websites/webkit.org/perf/slickspeed/frameworks/prototype.js: [ master, ]
2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
4163:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
41: var Class = {
51:     Object.extend(klass, Class.Methods);
74: Class.Methods = {
286: var PeriodicalExecuter = Class.create({
552: var Template = Class.create({
988: var Hash = Class.create(Enumerable, (function() {
1083: var ObjectRange = Class.create(Enumerable, {
1157: Ajax.Base = Class.create({
1179: Ajax.Request = Class.create(Ajax.Base, {
1352: Ajax.Response = Class.create({
1426: Ajax.Updater = Class.create(Ajax.Request, {
1462: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1667:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2696: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2700: var Selector = Class.create({
2846:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3146:       var needle = ' ' + className + ' ';
3150:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3634: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3651: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3657: Form.Observer = Class.create(Abstract.TimedObserver, {
3665: Abstract.EventObserver = Class.create({
3704: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3710: Form.EventObserver = Class.create(Abstract.EventObserver, {
4153:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4186: Element.ClassNames = Class.create();
52:     klass.superclass = parent;
58:       klass.prototype = new subclass;
76:     var ancestor   = this.superclass && this.superclass.prototype;
1817:     return new Element.ClassNames(element);
1822:     var elementClassName = element.className;
1823:     return (elementClassName.length > 0 && (elementClassName == className ||
1824:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1829:     if (!element.hasClassName(className))
1830:       element.className += (element.className ? ' ' : '') + className;
1836:     element.className = element.className.replace(
1837:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1843:     return element[element.hasClassName(className) ?
1844:       'removeClassName' : 'addClassName'](className);
2625:   function findDOMClass(tagName) {
2657:       var klass = findDOMClass(tag);
2940:     className:    'n = h.className(n, r, "#{1}", c);    c = false;',
2968:     className:    /^\.([\w\-\*]+)(\b|$)/,
2981:     className: function(element, matches) {
3139:     className: function(nodes, root, className, combinator) {
3141:       return Selector.handlers.byClassName(nodes, root, className);
3144:     byClassName: function(nodes, root, className) {
3148:         nodeClassName = node.className;
4157:   function(element, className) {
4158:     className = className.toString().strip();
4159:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4161:   } : function(element, className) {
4162:     className = className.toString().strip();
4164:     if (!classNames && !className) return elements;
4167:     className = ' ' + className + ' ';
4170:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4171:           (classNames && classNames.all(function(name) {
4179:   return function(className, parentElement) {
4180:     return $(parentElement || document.body).getElementsByClassName(className);
4193:     this.element.className.split(/\s+/).select(function(name) {
4198:   set: function(className) {
4199:     this.element.className = className;
4202:   add: function(classNameToAdd) {
4203:     if (this.include(classNameToAdd)) return;
4204:     this.set($A(this).concat(classNameToAdd).join(' '));
4207:   remove: function(classNameToRemove) {
4208:     if (!this.include(classNameToRemove)) return;
4209:     this.set($A(this).without(classNameToRemove).join(' '));
4217: Object.extend(Element.ClassNames.prototype, Enumerable);
53:     klass.subclasses = [];
59:       parent.subclasses.push(klass);
2982:       return Element.hasClassName(element, matches[1]);
3147:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3149:         if (nodeClassName.length == 0) continue;
4151: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4156:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
swiftshader.googlesource.com/SwiftShader:third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:frameworks/base/tools/apilint/apilint.py: [ master, ]
164: class Class():
355:     def parse_into_class(self, clazz):
581:     def handle_class(clazz):
668: def _skip_to_matching_class(classes, needle):
686: def _yield_until_matching_class(classes, needle):
2078:     def class_exists(api, test):
2247:     classes_with_base = []
799: def verify_class_names(clazz):
587:     def handle_missed_classes_with_base(clazz):
1075: def verify_helper_classes(clazz):
53: class Field():
93: class Argument(object):
104: class Method():
176:             V2LineParser(raw).parse_into_class(self)
184:             if "class" in raw:
185:                 self.fullname = raw[raw.index("class")+1]
191:                 raise ValueError("Funky class type %s" % (self.raw))
229: class Package():
243: class V2Tokenizer(object):
318: class V2LineParser(object):
323: ...(137 bytes skipped)...toreException AssertionError AutoCloseable Boolean BootstrapMethodError Byte Character CharSequence Class ClassCastException ClassCircularityError ClassFormatError ClassLoader Class...(258 bytes skipped)...xception IllegalMonitorStateException IllegalStateException IllegalThreadStateException IncompatibleClass...(107 bytes skipped)...ger InternalError InterruptedException Iterable LinkageError Long Math NegativeArraySizeException NoClass...(569 bytes skipped)...eadLocal Throwable TypeNotPresentException UNIXProcess UnknownError UnsatisfiedLinkError UnsupportedClassVersionError UnsupportedOperationException VerifyError VirtualMachineError Void".split())
361:         kind = self.parse_one_of("class", "interface", "@interface", "enum")
588:         for c in _yield_until_matching_class(in_classes_with_base, clazz):
589:             base_class = _skip_to_matching_class(base_classes, c)
590:             if base_class:
591:                 handle_class(base_class)
598:         base_class = _skip_to_matching_class(base_classes, clazz)
599:         if base_class:
600:             clazz.merge_from(base_class)
603:         handle_class(clazz)
646:             clazz = Class(pkg, line, raw, blame, sig_format=sig_format)
669:     """Takes a classes iterator and consumes entries until it returns the class we're looking for
671:     This relies on classes being sorted by package and class name."""
674:         if clazz.pkg.name < needle.pkg.name:
677:         if clazz.pkg.name == needle.pkg.name and clazz.fullname < needle.fullname:
678:             # We're in the right package, but not the right class yet
680:         if clazz.fullname == needle.fullname:
682:         # We ran past the right class. Send it back into the generator, then report failure.
687:     """Takes a class iterator and yields entries it until it reaches the class we're looking for.
689:     This relies on classes being sorted by package and class name."""
692:         if needle is None:
694:         elif clazz.pkg.name < needle.pkg.name:
697:         elif clazz.pkg.name == needle.pkg.name and clazz.fullname < needle.fullname:
698:             # We're in the right package, but not the right class yet
700:         elif clazz.fullname == needle.fullname:
701:             # Class found, abort.
704:             # We ran past the right class. Send it back into the iterator, then abort.
708: class Failure():
800:     """Try catching malformed class names like myMtp or MTPUser."""
806:         warn(clazz, None, "S1", "Class names with acronyms should be Mtp not MTP")
808:         error(clazz, None, "S1", "Class must start with uppercase char")
834:         error(clazz, None, "L1", "Callback class names should be singular")
836:         warn(clazz, None, "L1", "Class should be named FooCallback")
849:     If only a single method, it must match class name:
853:         if "abstract" in clazz.split and "class" in clazz.split:
863:                 error(clazz, m, "L1", "Single listener method name must match class name")
1082:             error(clazz, None, "CL4", "Inconsistent class name; should be FooService")
1094:             error(clazz, None, "CL4", "Inconsistent class name; should be FooProvider")
1106:             error(clazz, None, "CL4", "Inconsistent class name; should be FooReceiver")
1111:             error(clazz, None, "CL4", "Inconsistent class name; should be FooActivity")
1131:         warn(clazz, None, None, "Builder should be defined as inner class")
1563:             error(clazz, f, None, "Expected resource name in this class to be foo_bar_baz style")
1573:             error(clazz, f, "C7", "Expected resource name in this class to be fooBarBaz style")
1579:             error(clazz, f, "C7", "Expected resource name in this class to be FooBar_Baz style")
1776:             # This only applies if the return type is the same or a subtype of the enclosing class, but we have no
2029:     """Test if given class is interesting from an Android PoV."""
2042:     """Find all style issues in the given class."""
2107:         if not class_exists(cur, prev_clazz):
2108:             error(prev_clazz, None, None, "Class removed or incompatible change")
2145:         # Forget about class entirely when nothing new
571: def _parse_stream(f, clazz_cb=None, base_f=None, out_classes_with_base=None,
572:                   in_classes_with_base=[]):
574:     in_classes_with_base = _retry_iterator(in_classes_with_base)
577:         base_classes = _retry_iterator(_parse_stream_to_generator(base_f))
579:         base_classes = []
594:         # Before looking at clazz, let's see if there's some classes that were not present, but
596:         handle_missed_classes_with_base(clazz)
601:             if out_classes_with_base is not None:
602:                 out_classes_with_base.append(clazz)
605:     handle_missed_classes_with_base(None)
673:     for clazz in classes:
683:         classes.send(clazz)
691:     for clazz in classes:
705:             classes.send(clazz)
829:     """Verify Callback classes.
846:     """Verify Listener classes.
847:     All Listener classes must be interface.
954:             error(clazz, None, "FW8", "Parcelable classes must be final")
1076:     """Verify that helper classes are named consistently with what they extend.
1125:     """Verify builder classes.
1165:     """Catch people exposing internal classes."""
1167:         error(clazz, None, None, "Internal classes must not be exposed")
1412:     """Verifies that helper classes can't be constructed."""
1416:     # Only care about classes with default constructors
1427:         error(clazz, None, None, "Fully-static utility classes must not have constructor")
1489:     # Ignore UI classes which assume main thread
1617:     """Verifies that abstract inner classes are static."""
1621:             warn(clazz, None, None, "Abstract inner classes should be static to improve testability")
1630:         "java.lang.ClassCastException",
1718:     """Verifies that classes are AutoClosable."""
1725:             warn(clazz, m, None, "Classes that release resources should implement AutoClosable and CloseGuard")
1815:             warn(clazz, m, None, "Method should return Collection<> (or subclass) instead of raw array")
1818:                 warn(clazz, m, None, "Method argument should be Collection<> (or subclass) instead of raw array")
1848:     """Parameter classes should be 'Params'."""
1859:             error(clazz, None, None, "Classes holding a set of parameters should be called 'FooParams'")
2024:             error(clazz, c, None, "Singleton classes should use getInstance() methods")
2054: def examine_stream(stream, base_stream=None, in_classes_with_base=[], out_classes_with_base=None):
2060:                   in_classes_with_base=in_classes_with_base,
2061:                   out_classes_with_base=out_classes_with_base)
2172:             stats['new_classes'] += 1
2187:                 stats['extend_classes'] += 1
2253:                                                        out_classes_with_base=classes_with_base)
2255:             cur_fail, cur_noticed = examine_stream(f, out_classes_with_base=classes_with_base)
2262:                                                              in_classes_with_base=classes_with_base)
2264:                 prev_fail, prev_noticed = examine_stream(f, in_classes_with_base=classes_with_base)
2271:         # ignore classes unchanged from previous API level
1666:                 error(clazz, m, None, "Methods must not mention RuntimeException subclasses in throws clauses")
android.googlesource.com/platform/frameworks/base:tools/apilint/apilint.py: [ master, ] Duplicate result
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
591:   const DeclRefExpr *Needle;
62:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
179:     // Skip function calls which are qualified with a templated class.
586: /// ContainsReference - A visitor class to search for references to
587: /// a particular declaration (the needle) within any evaluated component of an
589: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
596:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
597:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
608:     if (E == Needle)
899:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1360: class UninitValsDiagReporter : public UninitVariablesHandler {
1472: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1742: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
259:   // templated classes.
727:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
734:     case Stmt::IfStmtClass: {
744:     case Stmt::ConditionalOperatorClass: {
754:     case Stmt::BinaryOperatorClass: {
774:     case Stmt::WhileStmtClass:
781:     case Stmt::ForStmtClass:
791:     case Stmt::CXXForRangeStmtClass:
804:     case Stmt::DoStmtClass:
813:     case Stmt::CaseStmtClass:
818:     case Stmt::DefaultStmtClass:
1182:     switch (S->getStmtClass()) {
1183:     case Stmt::ForStmtClass:
1184:     case Stmt::WhileStmtClass:
1185:     case Stmt::CXXForRangeStmtClass:
1186:     case Stmt::ObjCForCollectionStmtClass:
1188:     case Stmt::DoStmtClass: {
1277:   // Classify the current code body for better warning text.
1280:   // FIXME: Should we use a common classification enum and the same set of
1315:     // Classify the weak object being accessed for better warning text.
1935:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1936:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1937:       .setAlwaysAdd(Stmt::BlockExprClass)
1938:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1939:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1940:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1941:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1942:       .setAlwaysAdd(Stmt::AttributedStmtClass);
chromium.googlesource.com/native_client/pnacl-clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
579:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
122: class LogicalErrorHandler : public CFGCallback {
203:         // Skip function calls which are qualified with a templated class.
574: /// ContainsReference - A visitor class to search for references to
575: /// a particular declaration (the needle) within any evaluated component of an
577: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
582:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
584:       FoundReference(false), Needle(Needle) {}
595:     if (E == Needle)
888:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1325: class UninitValsDiagReporter : public UninitVariablesHandler {
1442: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1713: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
240:   // templated classes.
715:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
722:     case Stmt::IfStmtClass: {
732:     case Stmt::ConditionalOperatorClass: {
742:     case Stmt::BinaryOperatorClass: {
762:     case Stmt::WhileStmtClass:
769:     case Stmt::ForStmtClass:
779:     case Stmt::CXXForRangeStmtClass:
792:     case Stmt::DoStmtClass:
801:     case Stmt::CaseStmtClass:
806:     case Stmt::DefaultStmtClass:
1152:     switch (S->getStmtClass()) {
1153:     case Stmt::ForStmtClass:
1154:     case Stmt::WhileStmtClass:
1155:     case Stmt::CXXForRangeStmtClass:
1156:     case Stmt::ObjCForCollectionStmtClass:
1158:     case Stmt::DoStmtClass: {
1248:   // Classify the current code body for better warning text.
1251:   // FIXME: Should we use a common classification enum and the same set of
1286:     // Classify the weak object being accessed for better warning text.
1903:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1904:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1905:       .setAlwaysAdd(Stmt::BlockExprClass)
1906:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1907:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1908:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1909:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1910:       .setAlwaysAdd(Stmt::AttributedStmtClass);
android.googlesource.com/platform/superproject:external/clang/lib/Sema/AnalysisBasedWarnings.cpp: [ master, ] Duplicate result
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
577:   const DeclRefExpr *Needle;
63:   class UnreachableCodeHandler : public reachable_code::Callback {
121: class LogicalErrorHandler : public CFGCallback {
192:         // Skip function calls which are qualified with a templated class.
572: /// ContainsReference - A visitor class to search for references to
573: /// a particular declaration (the needle) within any evaluated component of an
575: class ContainsReference : public EvaluatedExprVisitor<ContainsReference> {
580:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
582:       FoundReference(false), Needle(Needle) {}
593:     if (E == Needle)
885:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1331: class UninitValsDiagReporter : public UninitVariablesHandler {
1454: class ThreadSafetyReporter : public clang::thread_safety::ThreadSafetyHandler {
1629: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
229:   // templated classes.
712:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
719:     case Stmt::IfStmtClass: {
729:     case Stmt::ConditionalOperatorClass: {
739:     case Stmt::BinaryOperatorClass: {
759:     case Stmt::WhileStmtClass:
766:     case Stmt::ForStmtClass:
776:     case Stmt::CXXForRangeStmtClass:
789:     case Stmt::DoStmtClass:
798:     case Stmt::CaseStmtClass:
803:     case Stmt::DefaultStmtClass:
1155:     switch (S->getStmtClass()) {
1156:     case Stmt::ForStmtClass:
1157:     case Stmt::WhileStmtClass:
1158:     case Stmt::CXXForRangeStmtClass:
1159:     case Stmt::ObjCForCollectionStmtClass:
1161:     case Stmt::DoStmtClass: {
1251:   // Classify the current code body for better warning text.
1254:   // FIXME: Should we use a common classification enum and the same set of
1291:     // Classify the weak object being accessed for better warning text.
1831:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1832:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1833:       .setAlwaysAdd(Stmt::BlockExprClass)
1834:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1835:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1836:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1837:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1838:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/bazelbuild/rules_nodejs:internal/e2e/fine_grained_deps/npm/package-lock.json: [ master, ]
768:             "needle": "^2.2.0",
97:         "class-utils": "^0.3.5",
348:         "posix-character-classes": "^0.1.0",
219:     "class-utils": {
221:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
751:         "needle": {
1518:     "posix-character-classes": {
1520:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
chromium.googlesource.com/chromium/deps/xulrunner-sdk:win/bin/modules/Microformats.js: [ master, ]
1237:     "class" : {
1098:     var classValue = node.getAttribute("class");
1155:   className: "adr",
1221:   className: "vcard",
1433:   className: "vevent",
1641:   className: "geo",
31:     function isAncestor(haystack, needle) {
32:       var parent = needle;
36:         if (parent == needle.parentNode) {
186:         xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[mfname].className + " ')";
692:       /* is a class based microformat and the passed in node is not the */
708:       /* Query the correct set of nodes (rel or class) based on the setting */
734:             xpathExpression += "contains(concat(' ', @class, ' '), ' " + Microformats[Microformats.list[j]].className + " ')";
778:         /* If we didn't find any class nodes, check to see if this property */
791:      * the innerHTML and the class name.
1038:       xpathExpression = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1179:                                               "contains(concat(' ', @class, ' '), ' post-office-box ')" +
1180:                                               " or contains(concat(' ', @class, ' '), ' street-address ')" +
1181:                                               " or contains(concat(' ', @class, ' '), ' extended-address ')" +
1182:                                               " or contains(concat(' ', @class, ' '), ' locality ')" +
1183:                                               " or contains(concat(' ', @class, ' '), ' region ')" +
1184:                                               " or contains(concat(' ', @class, ' '), ' postal-code ')" +
1185:                                               " or contains(concat(' ', @class, ' '), ' country-name')" +
1442:     "class" : {
1614:     var xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vcard ')]";
1623:     xpathExpression = "ancestor::*[contains(concat(' ', @class, ' '), ' vevent ')]";
65:     if (Microformats[name].className) {
67:                                         Microformats[name].className);
71:         var altClass = Microformats.getElementsByClassName(rootElement, Microformats[name].alternateClassName);
72:         if (altClass.length > 0) {
148:       if (Microformats[i].className) {
149:         if (Microformats.matchClass(node, Microformats[i].className)) {
185:       if (Microformats[mfname].className) {
220:         if (Microformats[i].className) {
221:           if (Microformats.matchClass(node, Microformats[i].className)) {
348:         if (!Microformats.matchClass(propnode, "value")) {
434:       if (Microformats.matchClass(propnode, "value")) {
464:         if (Microformats.matchClass(propnode, "value")) {
599:           if (!Microformats.matchClass(in_node, Microformats[microformat].className)) {
605:       if ((Microformats[microformat].className) && in_node.ownerDocument) {
696:       if (!in_mfnode.origNode && Microformats[mfname].className && in_mfnode.ownerDocument) {
728:           if (Microformats[Microformats.list[j]].className) {
826:               tempNode.className = headerNode.className;
1017:    * Retrieve elements matching all classes listed in a space-separated string.
1021:    * @param  className        A space separated list of classenames
1025:   getElementsByClassName: function getElementsByClassName(rootNode, className)
1031:       var col = rootNode.getElementsByClassName(className);
1047:       className = className.replace(/\-/g, "\\-");
1050:         if (elements[i].className.match("(^|\\s)" + className + "(\\s|$)")) {
1097:   matchClass: function matchClass(node, className) {
1099:     return (classValue && classValue.match("(^|\\s)" + className + "(\\s|$)"));
1720:           var ioService = Components.classes["@mozilla.org/network/io-service;1"].
66:       microformatNodes = Microformats.getElementsByClassName(rootElement,
68:       /* alternateClassName is for cases where a parent microformat is inferred by the children */
69:       /* If we find alternateClassName, the entire document becomes the microformat */
70:       if ((microformatNodes.length == 0) && Microformats[name].alternateClassName) {
323:         var values = Microformats.getElementsByClassName(propnode, "value");
640:             subpropnodes = Microformats.getElementsByClassName(propnode, subpropname);
714:         propnodes = Microformats.getElementsByClassName(mfnode, propname);
800:       var includes = Microformats.getElementsByClassName(in_mfnode, "include");
805:           includes = Microformats.getElementsByClassName(mfnode, "include");
1029:     if ((rootNode.ownerDocument || rootNode).getElementsByClassName) {
1030:     /* Firefox 3 - native getElementsByClassName */
1207:     var fns = Microformats.getElementsByClassName(this.node, "fn");
1416:     var summaries = Microformats.getElementsByClassName(this.node, "summary");
github.com/apache/attic-stratos:dependencies/org.wso2.carbon.ui/src/main/resources/web/admin/js/prototype-1.6.js: [ master, ]
2292:         'class': 'className',
58:       var subclass = function() { };
59:       subclass.prototype = parent.prototype;
1820:   classNames: function(element) {
2167:       className: 'class',
4126:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4150: Element.ClassNames.prototype = {
1824:   hasClassName: function(element, className) {
1831:   addClassName: function(element, className) {
1838:   removeClassName: function(element, className) {
1845:   toggleClassName: function(element, className) {
43: var Class = {
53:     Object.extend(klass, Class.Methods);
76: Class.Methods = {
287: var PeriodicalExecuter = Class.create({
551: var Template = Class.create({
986: var Hash = Class.create(Enumerable, (function() {
1102: var ObjectRange = Class.create(Enumerable, {
1176: Ajax.Base = Class.create({
1195: Ajax.Request = Class.create(Ajax.Base, {
1359: Ajax.Response = Class.create({
1430: Ajax.Updater = Class.create(Ajax.Request, {
1470: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1671:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2712: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2716: var Selector = Class.create({
2845:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3139:       var needle = ' ' + className + ' ';
3143:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3601: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3618: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3624: Form.Observer = Class.create(Abstract.TimedObserver, {
3632: Abstract.EventObserver = Class.create({
3671: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3677: Form.EventObserver = Class.create(Abstract.EventObserver, {
4116:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4149: Element.ClassNames = Class.create();
54:     klass.superclass = parent;
60:       klass.prototype = new subclass;
78:     var ancestor   = this.superclass && this.superclass.prototype;
1821:     return new Element.ClassNames(element);
1826:     var elementClassName = element.className;
1827:     return (elementClassName.length > 0 && (elementClassName == className ||
1828:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1833:     if (!element.hasClassName(className))
1834:       element.className += (element.className ? ' ' : '') + className;
1840:     element.className = element.className.replace(
1841:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1847:     return element[element.hasClassName(className) ?
1848:       'removeClassName' : 'addClassName'](className);
2642:   function findDOMClass(tagName) {
2674:       var klass = findDOMClass(tag);
2935:     className:    'n = h.className(n, r, "#{1}", c); c = false;',
2963:     className:    /^\.([\w\-\*]+)(\b|$)/,
2975:     className: function(element, matches) {
3132:     className: function(nodes, root, className, combinator) {
3134:       return Selector.handlers.byClassName(nodes, root, className);
3137:     byClassName: function(nodes, root, className) {
3141:         nodeClassName = node.className;
4120:   function(element, className) {
4121:     className = className.toString().strip();
4122:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4124:   } : function(element, className) {
4125:     className = className.toString().strip();
4127:     if (!classNames && !className) return elements;
4130:     className = ' ' + className + ' ';
4133:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4134:           (classNames && classNames.all(function(name) {
4142:   return function(className, parentElement) {
4143:     return $(parentElement || document.body).getElementsByClassName(className);
4156:     this.element.className.split(/\s+/).select(function(name) {
4161:   set: function(className) {
4162:     this.element.className = className;
4165:   add: function(classNameToAdd) {
4166:     if (this.include(classNameToAdd)) return;
4167:     this.set($A(this).concat(classNameToAdd).join(' '));
4170:   remove: function(classNameToRemove) {
4171:     if (!this.include(classNameToRemove)) return;
4172:     this.set($A(this).without(classNameToRemove).join(' '));
4180: Object.extend(Element.ClassNames.prototype, Enumerable);
55:     klass.subclasses = [];
61:       parent.subclasses.push(klass);
2976:       return Element.hasClassName(element, matches[1]);
3140:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3142:         if (nodeClassName.length == 0) continue;
4114: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4119:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
android.googlesource.com/platform/external/swiftshader:third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] Duplicate result
chromium.googlesource.com/git/chromium:sync/syncable/directory.h: [ trunk, ]
536:     EntryKernel needle;
23: class Cryptographer;
24: class UnrecoverableErrorHandler;
28: class BaseTransaction;
29: class DirectoryChangeDelegate;
30: class DirectoryBackingStore;
31: class NigoriHandler;
32: class ScopedKernelLock;
33: class TransactionObserver;
34: class WriteTransaction;
50: // index, the traits are grouped into a class called an Indexer which
53: template <typename FieldType, FieldType field_index> class LessField;
91:   class Comparator {
115: class EntryKernelLessByMetaHandle {
131: class Directory {
132:   friend class BaseTransaction;
133:   friend class Entry;
134:   friend class MutableEntry;
135:   friend class ReadTransaction;
136:   friend class ReadTransactionWithoutDB;
137:   friend class ScopedKernelLock;
138:   friend class ScopedKernelUnlock;
139:   friend class WriteTransaction;
140:   friend class SyncableDirectoryTest;
336:   template <class T> void TestAndSet(T* kernel_data, const T* data_to_set);
535:     // look something up in an index.  Needle in haystack metaphor.
chromium.googlesource.com/chromium:sync/syncable/directory.h: [ trunk, ] Duplicate result
github.com/google/kf:docs/kf.dev/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/any23:api/src/main/java/org/apache/any23/vocab/WO.java: [ master, ]
82:     public final IRI Class = createClass("Class");
281:     public final IRI Superclass = createClass("Superclass");
408:     public final IRI superclass = createProperty("superclass");
512:     private IRI createClass(String name) {
488:     public final IRI superclassName = createProperty("superclassName");
32: public class WO extends Vocabulary {
77:     /** A class is a scientific way to group related organisms 
205:      * An order is a smaller grouping than a class, but bigger than 
244:     /** Generic class defining a biological species. Further Reading:
275:      * grouping, that sits directly above a class, ranking 
341:      * associates a taxon rank with a class
343:     public final IRI clazz = createProperty("class");
423:     /** Used to specify the name of a class as part of a Taxon Name*/
54:     //CLASSES
62:     public final IRI Adaption = createClass("Adaption");
70:     public final IRI Animal_Intelligence = createClass("AnimalIntelligence");
75:     public final IRI BehaviouralPattern = createClass("BehaviouralPattern");
78:      * together, some examples of classes being jellyfish, 
79:      * reptiles and sea urchins. Classes are big groups and 
91:     public final IRI Collection = createClass("Collection");
96:     public final IRI CommunicationAdaption = createClass("CommunicationAdaption");
101:     public final IRI ConservationStatus = createClass("ConservationStatus");
109:     public final IRI EcosystemRole = createClass("EcosystemRole");
117:     public final IRI Ecozone = createClass("Ecozone");
123:     public final IRI ExtremesAdaptiation = createClass("ExtremesAdaptiation");
132:     public final IRI Family = createClass("Family");
136:     public final IRI FeedingHabit = createClass("FeedingHabit");
143:     public final IRI FreshwaterHabitat = createClass("FreshwaterHabitat");
153:     public final IRI Genus = createClass("Genus");
162:     public final IRI Habitat = createClass("Habitat");
165:      * are an intermediate rank of classification, that group together 
173:     public final IRI Infraorder = createClass("Infraorder");
183:     public final IRI Kingdom = createClass("Kingdom");
188:     public final IRI Lifecycle = createClass("Lifecycle");
192:     public final IRI LocomotionAdaption = createClass("LocomotionAdaption");
198:     public final IRI MarineHabitat = createClass("MarineHabitat");
202:     public final IRI Morphology = createClass("Morphology");
210:     public final IRI Order = createClass("Order");
217:      * further subdivided into classes, orders, families and so on. 
220:     public final IRI Phylum = createClass("Phylum");
225:     public final IRI PredationStrategy = createClass("PredationStrategy");
230:     public final IRI RedListStatus = createClass("RedListStatus");
236:     public final IRI ReproductionStrategy = createClass("ReproductionStrategy");
242:     public final IRI SocialBehaviour = createClass("SocialBehaviour");
247:     public final IRI Species = createClass("Species");
249:     /** Suborders are an intermediate classification rank - 
258:     public final IRI Suborder = createClass("Suborder");
260:     /** Subspecies are a rank of classification that is lower 
272:     public final IRI Subspecies = createClass("Subspecies");
274:     /** Superclass is an intermediate classification rank, or 
277:      * classes. The tetrapods are a superclass encompasing the 
278:      * amphibian, reptile, bird, mammal and dinosaur classes. 
279:      * Further Reading: http://en.wikipedia.org/wiki/Superclass_(biology)
280:      * http://www.bbc.co.uk/nature/superclass*/
283:     /** Superfamilies are an intermediate classification rank, 
292:     public final IRI Superfamily = createClass("Superfamily");
294:     /** Superorders are an intermediate classification rank or 
302:     public final IRI Superorder = createClass("Superorder");
306:     public final IRI SurvivalStrategy = createClass("SurvivalStrategy");
309:     public final IRI TaxonName = createClass("TaxonName");
314:     public final IRI TaxonRank= createClass("TaxonRank");
319:      * and needleleaf), plant spacing (forest, woodland, savanna) and climate.*/
320:     public final IRI TerrestrialHabitat = createClass("TerrestrialHabitat");
324:      * Tribes are mainly, but not always, used in botany to classify plants. 
327:      * as a classification rank, for example, bombini is the tribe of bumblebees.
330:     public final IRI Tribe = createClass("Tribe");
407:     /** associates a taxon rank with a superclass*/
424:     public final IRI clazzName = createProperty("className");
487:     /** Used to specify the name of a superclass as part of a Taxon Name*/
513:         return createClass(NS, name);
github.com/apache/chukwa:core/src/main/web/hicc/js/workspace/prototype.js: [ master, ]
2261:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1804:   classNames: function(element) {
2152:       className: 'class',
4112:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
4136: Element.ClassNames.prototype = {
1808:   hasClassName: function(element, className) {
1815:   addClassName: function(element, className) {
1822:   removeClassName: function(element, className) {
1829:   toggleClassName: function(element, className) {
41: var Class = {
51:     Object.extend(klass, Class.Methods);
74: Class.Methods = {
285: var PeriodicalExecuter = Class.create({
551: var Template = Class.create({
987: var Hash = Class.create(Enumerable, (function() {
1082: var ObjectRange = Class.create(Enumerable, {
1156: Ajax.Base = Class.create({
1178: Ajax.Request = Class.create(Ajax.Base, {
1342: Ajax.Response = Class.create({
1414: Ajax.Updater = Class.create(Ajax.Request, {
1450: Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
1655:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
2661: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
2665: var Selector = Class.create({
2811:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
3110:       var needle = ' ' + className + ' ';
3114:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
3583: Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
3600: Form.Element.Observer = Class.create(Abstract.TimedObserver, {
3606: Form.Observer = Class.create(Abstract.TimedObserver, {
3614: Abstract.EventObserver = Class.create({
3653: Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
3659: Form.EventObserver = Class.create(Abstract.EventObserver, {
4102:     return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
4135: Element.ClassNames = Class.create();
52:     klass.superclass = parent;
58:       klass.prototype = new subclass;
76:     var ancestor   = this.superclass && this.superclass.prototype;
1805:     return new Element.ClassNames(element);
1810:     var elementClassName = element.className;
1811:     return (elementClassName.length > 0 && (elementClassName == className ||
1812:       new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
1817:     if (!element.hasClassName(className))
1818:       element.className += (element.className ? ' ' : '') + className;
1824:     element.className = element.className.replace(
1825:       new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
1831:     return element[element.hasClassName(className) ?
1832:       'removeClassName' : 'addClassName'](className);
2590:   function findDOMClass(tagName) {
2622:       var klass = findDOMClass(tag);
2905:     className:    'n = h.className(n, r, "#{1}", c); c = false;',
2933:     className:    /^\.([\w\-\*]+)(\b|$)/,
2946:     className: function(element, matches) {
3103:     className: function(nodes, root, className, combinator) {
3105:       return Selector.handlers.byClassName(nodes, root, className);
3108:     byClassName: function(nodes, root, className) {
3112:         nodeClassName = node.className;
4106:   function(element, className) {
4107:     className = className.toString().strip();
4108:     var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
4110:   } : function(element, className) {
4111:     className = className.toString().strip();
4113:     if (!classNames && !className) return elements;
4116:     className = ' ' + className + ' ';
4119:       if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
4120:           (classNames && classNames.all(function(name) {
4128:   return function(className, parentElement) {
4129:     return $(parentElement || document.body).getElementsByClassName(className);
4142:     this.element.className.split(/\s+/).select(function(name) {
4147:   set: function(className) {
4148:     this.element.className = className;
4151:   add: function(classNameToAdd) {
4152:     if (this.include(classNameToAdd)) return;
4153:     this.set($A(this).concat(classNameToAdd).join(' '));
4156:   remove: function(classNameToRemove) {
4157:     if (!this.include(classNameToRemove)) return;
4158:     this.set($A(this).without(classNameToRemove).join(' '));
4166: Object.extend(Element.ClassNames.prototype, Enumerable);
53:     klass.subclasses = [];
59:       parent.subclasses.push(klass);
2947:       return Element.hasClassName(element, matches[1]);
3111:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
3113:         if (nodeClassName.length == 0) continue;
4100: if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
4105:   instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
github.com/google/rekall:rekall-core/rekall/scan.py: [ master, ]
170:     needle = None
171:     needle_offset = None
540:     needles = []
37: class ScannerCheck(with_metaclass(registry.MetaclassRegistry, object)):
38:     """A scanner check is a special class which is invoked on an AS to check
44:     This class is the base class for all checks.
59:         """Is the needle found at 'offset'?
63:             checked for the needle.
93: class MultiStringFinderCheck(ScannerCheck):
167: class StringCheck(ScannerCheck):
173:     def __init__(self, needle=None, needle_offset=0, **kwargs):
175:         self.needle = needle
176:         self.needle_offset = needle_offset
180:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
181:         if buffer_as.data.startswith(self.needle, buffer_offset):
182:             return self.needle
185:         # Search the rest of the buffer for the needle.
186:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
187:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)
195: class RegexCheck(ScannerCheck):
210: class _Padding(object):
216: class _BufferFragments(object):
258: class BufferASGenerator(object):
356: class BaseScanner(with_metaclass(registry.MetaclassRegistry, object)):
357:     """Base class for all scanners."""
389:         for class_name, args in self.checks:
390:             check = ScannerCheck.classes[class_name](
491: class FastStructScanner(BaseScanner):
532:             yield ("StringCheck", dict(needle=expected_bytes,
533:                                        needle_offset=rel_offset + array_offset))
536: class MultiStringScanner(BaseScanner):
553:                 needle=self.needles[0])
569: class PointerScanner(BaseScanner):
603: class ScannerGroup(BaseScanner):
640: class DiscontigScannerGroup(ScannerGroup):
653: class DebugChecker(ScannerCheck):
25: from future.utils import with_metaclass
96:     def __init__(self, needles=None, **kwargs):
100:           needles: A list of strings we search for.
103:           RuntimeError: No needles provided.
109:         if not needles:
110:             raise RuntimeError("No needles provided to search.")
114:         if max([len(x) for x in needles]) > 50:
118:         # sure all the needles are bytes too.
119:         byte_needles = [utils.SmartStr(x) for x in needles]
120:         tree = acora.AcoraBuilder(*byte_needles)
539:     # Override with the needles to check for.
542:     def __init__(self, needles=None, **kwargs):
544:         if needles is not None:
545:             self.needles = needles
550:         if len(needles) == 1:
557:                 needles=self.needles)
587:         self.needles = []
595:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))
597:         # The common string between all the needles.
599:             ("MultiStringFinderCheck", dict(needles=self.needles)),
github.com/google/docsy:userguide/package-lock.json: [ master, ] Duplicate result
github.com/firebase/oss-bot:appengine/package-lock.json: [ master, ]
1528:             "needle": "^2.2.1",
15:         "create-error-class": "^3.0.2",
309:         "class-utils": "^0.3.5",
843:         "posix-character-classes": "^0.1.0",
501:     "class-utils": {
503:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
620:     "create-error-class": {
622:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1513:         "needle": {
2383:     "posix-character-classes": {
2385:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
android.googlesource.com/platform/superproject:external/swiftshader/third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] Duplicate result
github.com/google/gvisor-website:package-lock.json: [ master, ]
1045:             "needle": "^2.2.1",
147:         "class-utils": "^0.3.5",
581:         "posix-character-classes": "^0.1.0",
329:     "class-utils": {
331:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1026:         "needle": {
2063:     "posix-character-classes": {
2065:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/google/streetview-publish-client-libraries:client_libraries/nodejs_library/package-lock.json: [ master, ]
1140:             "needle": "^2.2.1",
198:         "class-utils": "^0.3.5",
594:         "posix-character-classes": "^0.1.0",
335:     "class-utils": {
337:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1125:         "needle": {
1929:     "posix-character-classes": {
1931:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/yeoman/generator-angular:route/index.js: [ master, ]
63:     needle: '.otherwise',
66:       "  controller: '" + this.classedName + "Ctrl'" + (coffee ? "" : ","),
android.googlesource.com/platform/external/qt:Mac-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp: [ master, ]
129:     const QString needle;
70:     "class",
128:     inline KeywordHelper(const QString &word) : needle(word) {}
134:     return helper.needle < QLatin1String(kw);
139:     return QLatin1String(kw) < helper.needle;
github.com/google/docsy-example:package-lock.json: [ master, ]
1088:             "needle": "^2.2.1",
197:         "class-utils": "^0.3.5",
612:         "posix-character-classes": "^0.1.0",
368:     "class-utils": {
370:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1069:         "needle": {
2084:     "posix-character-classes": {
2086:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/google/docsy-example:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/googlesamples/functions-as-a-service:package-lock.json: [ master, ]
1274:             "needle": "^2.2.1",
251:         "class-utils": "^0.3.5",
1598:         "create-error-class": "^3.0.0",
767:         "posix-character-classes": "^0.1.0",
455:     "class-utils": {
457:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
580:     "create-error-class": {
582:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1255:         "needle": {
2357:     "posix-character-classes": {
2359:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/tensorflow/tfjs-examples:lstm-text-generation/data.js: [ master, ]
26:     needle: 'Nietzsche'
31:     needle: 'Jules Verne'
36:     needle: 'Shakespeare'
40:     needle: 'TensorFlow.js Code (Compiled, 0.11.7)'
45:  * A class for text data.
47:  * This class manages the following:
53: export class TextData {
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.6.0.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js: [ master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.0.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js: [ master, ] Duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.2.0.0/src/js/pagespeed/cssEfficiencyChecker.js: [ master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.3.0.0/src/js/pagespeed/cssEfficiencyChecker.js: [ master, ] Duplicate result
android.googlesource.com/platform/external/qt:Windows-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp: [ master, ]
129:     const QString needle;
70:     "class",
128:     inline KeywordHelper(const QString &word) : needle(word) {}
134:     return helper.needle < QLatin1String(kw);
139:     return QLatin1String(kw) < helper.needle;
chromium.googlesource.com/chromium/third_party/ffmpeg:libavfilter/vf_find_rect.c: [ master, ]
35:     AVClass *class;
42:     AVFrame *needle_frame[MAX_MIPMAPS];
59: AVFILTER_DEFINE_CLASS(find_rect);
171:             float score = compare(foc->haystack_frame[pass], foc->needle_frame[pass], x, y);
234:         av_frame_free(&foc->needle_frame[i]);
267:     foc->needle_frame[0] = av_frame_clone(foc->obj_frame);
269:         foc->needle_frame[i] = downscale(foc->needle_frame[i-1]);
270:         if (!foc->needle_frame[i])
304:     .priv_class      = &find_rect_class,
github.com/apache/openwhisk-client-js:lib/client.js: [ master, ]
22: const needle = require('needle')
27:  * This implements a request-promise-like facade over the needle
28:  * library. There are two gaps between needle and rp that need to be
30:  * needle's non-excepting >=400 statusCode responses into exceptions
50:   // this situation than needle
53:   return needle(opts.method.toLowerCase(), // needle takes e.g. 'put' not 'PUT'
72: class Client {
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.1.0.0/src/js/pagespeed/cssEfficiencyChecker.js: [ master, ]
141:   CLASS: 1,
34:  *     is one of {@code ID}, {@code CLASS}, {@code TAG}, or {@code UNIVERSAL}.
40:  *       <li>{@code CLASS} and {@code ID} selectors are given a cost of 1
42:  *         class or id.
58:  *       <li>Selectors that have an id plus a class or tag are multiplied by
61:  *       <li>Selectors that have a class and a tag are also multiplied
155:   case PAGESPEED.SelectorKey.CLASS:
156:     return 'Class';
174:  * a.foo, a b, #my-class { color:red; } -> 'a.foo, a b, #my-class'
200:  * 'a.foo, a b, #my-class' -> ['a.foo','a b','#my-class']
219:  * for the selector. See the class documentation for more information.
300:     // Selectors can only be overly qualified if they have an ID or CLASS
302:         selectorKey == PAGESPEED.SelectorKey.CLASS) {
311:       // Selectors with an ID shouldn't have CLASS refiners
316:             new PAGESPEED.Cost(2, 'ID overly qualified with class'));
320:       // Selectors with a CLASS shouldn't have ID refiners
321:       if (selectorKey == PAGESPEED.SelectorKey.CLASS) {
325:             new PAGESPEED.Cost(2, 'class overly qualified with ID'));
357:   // Look for CLASS and ID refiners
359:     selectorType = PAGESPEED.SelectorKey.CLASS;
439:   // a.class
59:  *         2 because they are needlessly requiring extra work -- the id by
71:  *     different tags, classes, and ids.
132:  * key is how Firefox classifies selectors in order to make matching more
github.com/pagespeed/page-speed:firefox_addon/branches/page-speed-1.6.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js: [ master, ] Duplicate result
github.com/apache/marmotta:libraries/kiwi/kiwi-sparql/src/main/java/org/apache/marmotta/kiwi/sparql/builder/collect/SQLProjectionFinder.java: [ master, ]
39:     private String needle;
33: public class SQLProjectionFinder extends QueryModelVisitorBase<RuntimeException> {
35:     private static Logger log = LoggerFactory.getLogger(SQLProjectionFinder.class);
43:     public SQLProjectionFinder(TupleExpr expr, String needle) {
44:         this.needle = needle;
50:         if(node.getName().equals(needle)) {
59:             if(g.equals(needle)) {
68:         if(node.getName().equals(needle)) {
77:             if(elem.getSourceName().equals(needle)) {
github.com/PolymerLabs/actor-boilerplate:package-lock.json: [ master, ]
868:             "needle": "^2.2.0",
138:         "class-utils": "^0.3.5",
1793:             "posix-character-classes": "^0.1.0",
275:     "class-utils": {
277:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
851:         "needle": {
1681:     "posix-character-classes": {
1683:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/PolymerLabs/actor-helpers:package-lock.json: [ master, ]
1359:             "needle": "^2.2.0",
139:         "class-utils": "^0.3.5",
831:         "posix-character-classes": "^0.1.0",
410:     "class-utils": {
412:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1340:         "needle": {
2597:     "posix-character-classes": {
2599:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",