Found 78770 results in 2921 files, showing top 50 files (show more).
github.com/llvm-mirror/llvm:utils/TableGen/SearchableTableEmitter.cpp: [ master, ] c++
48:   Record *Class;
89: class SearchableTableEmitter {
533:       Field.RecType = RecordRecTy::get(Field.Enum->Class);
655:     Enum->Class = Records.getClass(FilterClass);
656:     if (!Enum->Class)
720:     Record *Class = NameRec.second.get();
721:     if (Class->getSuperClasses().size() != 1 ||
722:         !Class->isSubClassOf(SearchableTable))
725:     StringRef TableName = Class->getName();
727:     if (!Class->isValueUnset("EnumNameField")) {
728:       StringRef NameField = Class->getValueAsString("EnumNameField");
730:       if (!Class->isValueUnset("EnumValueField"))
731:         ValueField = Class->getValueAsString("EnumValueField");
734:       Enum->Name = (Twine(Class->getName()) + "Values").str();
735:       Enum->PreprocessorGuard = Class->getName().upper();
736:       Enum->Class = Class;
744:     Table->Name = (Twine(Class->getName()) + "sList").str();
745:     Table->PreprocessorGuard = Class->getName().upper();
746:     Table->CppTypeName = Class->getName();
748:     for (const RecordVal &Field : Class->getValues()) {
764:          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(Twine("Enum FilterClass '") + FilterClass +
661:                        Records.getAllDerivedDefinitions(FilterClass));
686:                                     TableRec->getValueAsString("FilterClass")));
718:   Record *SearchableTable = Records.getClass("SearchableTable");
131:       return DI->getDef()->isSubClassOf("Intrinsic");
531:     if (TypeRec->isSubClassOf("GenericEnum")) {
719:   for (auto &NameRec : Records.getClasses()) {
github.com/GoogleCloudPlatform/skaffold:examples/nodejs/backend/package-lock.json: [ master, ] json
1106:             "needle": "^2.2.0",
116:         "class-utils": "^0.3.5",
1409:         "create-error-class": "^3.0.0",
609:         "posix-character-classes": "^0.1.0",
313:     "class-utils": {
315:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
425:     "create-error-class": {
427:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1087:         "needle": {
2116:     "posix-character-classes": {
2118:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/GoogleCloudPlatform/skaffold:integration/examples/nodejs/backend/package-lock.json: [ master, ] json Duplicate result
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ] c++
709:   const DeclRefExpr *Needle;
57:   class UnreachableCodeHandler : public reachable_code::Callback {
126: class LogicalErrorHandler : public CFGCallback {
184:     // Skip function calls which are qualified with a templated class.
704: /// ContainsReference - A visitor class to search for references to
705: /// a particular declaration (the needle) within any evaluated component of an
707: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
714:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
715:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
726:     if (E == Needle)
1014:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1483: class UninitValsDiagReporter : public UninitVariablesHandler {
1595: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1864: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
245:   // templated classes.
843:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
850:     case Stmt::IfStmtClass: {
860:     case Stmt::ConditionalOperatorClass: {
870:     case Stmt::BinaryOperatorClass: {
890:     case Stmt::WhileStmtClass:
897:     case Stmt::ForStmtClass:
907:     case Stmt::CXXForRangeStmtClass:
920:     case Stmt::DoStmtClass:
929:     case Stmt::CaseStmtClass:
934:     case Stmt::DefaultStmtClass:
1305:     switch (S->getStmtClass()) {
1306:     case Stmt::ForStmtClass:
1307:     case Stmt::WhileStmtClass:
1308:     case Stmt::CXXForRangeStmtClass:
1309:     case Stmt::ObjCForCollectionStmtClass:
1311:     case Stmt::DoStmtClass: {
1400:   // Classify the current code body for better warning text.
1403:   // FIXME: Should we use a common classification enum and the same set of
1438:     // Classify the weak object being accessed for better warning text.
2057:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
2058:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
2059:       .setAlwaysAdd(Stmt::BlockExprClass)
2060:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
2061:       .setAlwaysAdd(Stmt::DeclRefExprClass)
2062:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
2063:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
2064:       .setAlwaysAdd(Stmt::AttributedStmtClass);
chromium.googlesource.com/arc/arc:third_party/android/external/chromium/chrome/browser/sync/syncable/syncable.h: [ master, ] c++
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, ] javascript
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 ?
android.googlesource.com/platform/external/chromium:chrome/browser/sync/syncable/syncable.h: [ master, ] c++ Duplicate result
chromium.googlesource.com/private/55048997-blink2:Websites/webkit.org/perf/slickspeed/frameworks/prototype.js: [ master, ] javascript
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 ?
github.com/GoogleCloudPlatform/microservices-demo:src/paymentservice/package-lock.json: [ master, ] json
1058:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
112:             "create-error-class": "^3.0.2",
566:     "create-error-class": {
568:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1043:         "needle": {
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ] c++
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, ] c++
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, ] c++ Duplicate result
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ] c++
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/GoogleCloudPlatform/microservices-demo:src/currencyservice/package-lock.json: [ master, ] json
1036:             "needle": "^2.2.0",
56:             "create-error-class": "^3.0.2",
120:             "create-error-class": "^3.0.2",
529:     "create-error-class": {
531:       "resolved": "https://registry.npmjs.org/create-error-class/-/create-error-class-3.0.2.tgz",
1021:         "needle": {
github.com/bazelbuild/rules_nodejs:internal/e2e/fine_grained_deps/package-lock.json: [ master, ] json
756:             "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",
739:         "needle": {
1499:     "posix-character-classes": {
1501:       "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, ] javascript
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/stratos:dependencies/org.wso2.carbon.ui/src/main/resources/web/admin/js/prototype-1.6.js: [ master, ] javascript
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 ?
chromium.googlesource.com/chromium/codesearch:src:codesearch-gitlink-overlay/third_party/swiftshader/third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] c++
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()) {
github.com/apache/hawq:src/backend/optimizer/util/clauses.c: [ master, ] c
4510: 	Expr *needle;	/* This is the expression being searched */
4514:  * expression_matching_walker checks if the expression 'needle' in context is a sub-expression of hayStack.
4520: 	Assert(ctx->needle);
4527: 	if (equal(ctx->needle, hayStack))
4542: 	ctx.needle = expr1;
1419: 	 * quals, and the index machinery won't use the opclass information.  The
1420: 	 * original opclass list is NOT valid if we have commuted any cross-type
1621:  * results even with constant inputs, "nextval()" being the classic
1417: 	 * Note: we don't bother to update the opclasses list, but just set it to
1423: 	clause->opclasses = NIL;	/* XXX */
4495:         case REGCLASSOID: 
github.com/apache/incubator-hawq:src/backend/optimizer/util/clauses.c: [ master, ] c Duplicate result
chromium.googlesource.com/git/chromium:sync/syncable/directory.h: [ trunk, ] c++
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, ] c++ Duplicate result
github.com/google/swiftshader:third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] c++ Duplicate result
swiftshader.googlesource.com/SwiftShader:third_party/llvm-7.0/llvm/utils/TableGen/SearchableTableEmitter.cpp: [ master, ] c++ Duplicate result
github.com/apache/any23:api/src/main/java/org/apache/any23/vocab/WO.java: [ master, ] java
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:src/main/web/hicc/js/workspace/prototype.js: [ master, ] javascript
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, ] python
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/firebase/oss-bot:appengine/package-lock.json: [ master, ] json
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",
github.com/yeoman/generator-angular:route/index.js: [ master, ] javascript
63:     needle: '.otherwise',
66:       "  controller: '" + this.classedName + "Ctrl'" + (coffee ? "" : ","),
github.com/fuchsia-mirror/third_party-llvm:utils/TableGen/SearchableTableEmitter.cpp: [ master, ] c++ Duplicate result
github.com/fuchsia-mirror/third_party-clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ] c++ Duplicate result
github.com/angular/gulp-clang-format:package-lock.json: [ master, ] json
1416:             "needle": "^2.2.0",
259:         "class-utils": "^0.3.5",
870:         "posix-character-classes": "^0.1.0",
440:     "class-utils": {
442:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1397:         "needle": {
2899:     "posix-character-classes": {
2901:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/apache/airavata-django-portal:django_airavata/apps/api/package-lock.json: [ master, ] json
1226:             "needle": "^2.2.0",
626:         "babel-plugin-transform-es2015-classes": "^6.23.0",
1207:         "needle": {
353:     "babel-plugin-transform-es2015-classes": {
355:       "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz",
android.googlesource.com/platform/external/qt:Mac-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp: [ master, ] c++
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, ] json
1045:             "needle": "2.2.0",
166:         "class-utils": "0.3.6",
581:         "posix-character-classes": "0.1.1",
337:     "class-utils": {
339:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
1026:         "needle": {
2034:     "posix-character-classes": {
2036:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.6.0.0/src/pagespeed_firefox/js/pagespeed/cssEfficiencyChecker.js: [ master, ] javascript
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, ] javascript Duplicate result
chromium.googlesource.com/chromium/codesearch:src:codesearch-gitlink-overlay/third_party/ffmpeg/libavfilter/vf_find_rect.c: [ master, ] c
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/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx: [ master, ] c++
627:   const cmSourceFileLocation& Needle;
643:   const cmSourceFileLocation& Needle;
156: class cmTargetInternals
629:   LocationMatcher(const cmSourceFileLocation& needle)
630:     : Needle(needle)
636:     return loc.Matches(this->Needle);
646:   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
647:     : Needle(needle)
658:                    CreateLocation(this->Needle.GetMakefile()));
661:                         LocationMatcher(this->Needle)) != locations.end();
github.com/apache/incubator-openwhisk-client-js:lib/client.js: [ master, ] javascript
8: const needle = require('needle')
13:  * This implements a request-promise-like facade over the needle
14:  * library. There are two gaps between needle and rp that need to be
16:  * needle's non-excepting >=400 statusCode responses into exceptions
36:   // this situation than needle
39:   return needle(opts.method.toLowerCase(), // needle takes e.g. 'put' not 'PUT'
58: class Client {
chromium.googlesource.com/chromium/src/codesearch:third_party/ffmpeg/libavfilter/vf_find_rect.c: [ master, ] c Duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.2.0.0/src/js/pagespeed/cssEfficiencyChecker.js: [ master, ] javascript
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, ] javascript Duplicate result
android.googlesource.com/platform/external/qt:Windows-4.7.4/src/scripttools/debugging/qscriptsyntaxhighlighter.cpp: [ master, ] c++
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, ] c Duplicate result
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.1.0.0/src/js/pagespeed/cssEfficiencyChecker.js: [ master, ] javascript
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, ] javascript Duplicate result
github.com/apache/marmotta:libraries/kiwi/kiwi-sparql/src/main/java/org/apache/marmotta/kiwi/sparql/builder/collect/SQLProjectionFinder.java: [ master, ] java
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-helpers:package-lock.json: [ master, ] json
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",
github.com/PolymerLabs/actor-boilerplate:package-lock.json: [ master, ] json
868:             "needle": "^2.2.0",
143:         "class-utils": "^0.3.5",
1824:             "posix-character-classes": "^0.1.0",
280:     "class-utils": {
282:       "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
851:         "needle": {
1704:     "posix-character-classes": {
1706:       "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",