Search some code: Max results:

Found 20569 results in 1027 files (18MB index data, 9965756 ngram matches, 838619 docs considered, 1695 docs (51MB) loaded, 75257 docs skipped): for
(and substr:"class" substr:"needle") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 856.399213ms (queued: 2.323µs)

github.com/GoogleChrome/web-audio-samples:stress-test/boxes/third-party/prototype-1.6.0.2.js:[gh-pages, ]

41: var Class = {
2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
2625:   function findDOMClass(tagName) {
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
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);
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();
4163:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
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 ?
eclipse.googlesource.com/jgit/jgit:org.eclipse.jgit/src/org/eclipse/jgit/util/RawSubStringPattern.java:[master, ]
59: 	private final byte[] needle;
57: 	private final String needleString;
56: public class RawSubStringPattern {
75: 		needle = new byte[b.length];
77: 			needle[i] = lc(b[i]);
91: 		final int needleLen = needle.length;
92: 		final byte first = needle[0];
109: 				if (neq(needle[j], text[si]))
72: 		needleString = patternText;
96: 		final int maxPos = rcs.endPtr - needleLen;
108: 			for (int j = 1; j < needleLen; j++, si++) {
131: 		return needleString;
github.com/google/caja:third_party/js/sunspider-benchmark/parse-only/prototype-1.6.0.3.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
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);
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();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
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/lemire/OLAPTagCloud:WebContent/scripts/prototype.js:[master, ]
31: var Class = {
1460:   classNames: function(element) {
1824:   function findDOMClass(tagName) {
1963: Element.ClassNames.prototype = {
1247:   document.getElementsByClassName = function(className, parentElement) {
1435:   getElementsByClassName: function(element, className) {
1464:   hasClassName: function(element, className) {
1474:   addClassName: function(element, className) {
1480:   removeClassName: function(element, className) {
1486:   toggleClassName: function(element, className) {
164: var PeriodicalExecuter = Class.create();
404: var Template = Class.create();
881: ObjectRange = Class.create();
979: Ajax.Request = Class.create();
1143: Ajax.Updater = Class.create();
1184: Ajax.PeriodicalUpdater = Class.create();
1248:     var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
1355:     $H({'id': 'id', 'className': 'class'}).each(function(pair) {
1905: Insertion.Before = Class.create();
1918: Insertion.Top = Class.create();
1932: Insertion.Bottom = Class.create();
1946: Insertion.After = Class.create();
1962: Element.ClassNames = Class.create();
1994: /* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
1998: var Selector = Class.create();
2095:     className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
2350:       var needle = ' ' + className + ' ';
2354:         if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
2811: Form.Element.Observer = Class.create();
2818: Form.Observer = Class.create();
2867: Form.Element.EventObserver = Class.create();
2874: Form.EventObserver = Class.create();
1252: } else document.getElementsByClassName = function(className, parentElement) {
1257:     if (Element.hasClassName(child, className))
1436:     return document.getElementsByClassName(className, element);
1461:     return new Element.ClassNames(element);
1466:     var elementClassName = element.className;
1468:     if (elementClassName == className ||
1469:         elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
1476:     Element.classNames(element).add(className);
1482:     Element.classNames(element).remove(className);
1488:     Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
1856:       var klass = findDOMClass(tag);
1969:     this.element.className.split(/\s+/).select(function(name) {
1974:   set: function(className) {
1975:     this.element.className = className;
1978:   add: function(classNameToAdd) {
1979:     if (this.include(classNameToAdd)) return;
1980:     this.set($A(this).concat(classNameToAdd).join(' '));
1983:   remove: function(classNameToRemove) {
1984:     if (!this.include(classNameToRemove)) return;
1985:     this.set($A(this).without(classNameToRemove).join(' '));
1993: Object.extend(Element.ClassNames.prototype, Enumerable);
2176:     className:    'n = h.className(n, r, "#{1}", c); c = false;',
2201:     className:    /^\.([\w\-\*]+)(\b|$)/,
2343:     className: function(nodes, root, className, combinator) {
2345:       return Selector.handlers.byClassName(nodes, root, className);
2348:     byClassName: function(nodes, root, className) {
2352:         nodeClassName = node.className;
2472:         case 'className': case 'tagName': case 'id': // fallthroughs
1467:     if (elementClassName.length == 0) return false;
2351:       for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
2353:         if (nodeClassName.length == 0) continue;
android.googlesource.com/platform/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
android.googlesource.com/platform/external/webkit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
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);
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();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
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/fuchsia-mirror/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/fuchsia-mirror/third_party-cmake:Source/cmTarget.cxx:[master, ]
565:   const cmSourceFileLocation& Needle;
581:   const cmSourceFileLocation& Needle;
160: class cmTargetInternals
567:   LocationMatcher(const cmSourceFileLocation& needle)
568:     : Needle(needle)
574:     return loc.Matches(this->Needle);
584:   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
585:     : Needle(needle)
595:                    CreateLocation(this->Needle.GetMakefile()));
598:                         LocationMatcher(this->Needle)) != locations.end();
github.com/pagespeed/page-speed:firefox_addon/branches/ff5/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/yeoman/generator-angular:route/index.js:[master, ]
63:     needle: '.otherwise',
66:       "  controller: '" + this.classedName + "Ctrl'" + (coffee ? "" : ","),
github.com/pagespeed/page-speed:firefox_addon/branches/chromium_update4/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/google/rekall:rekall-core/rekall/scan.py:[master, ]
163:     needle = None
164:     needle_offset = None
539:     needles = []
41:     __metaclass__ = registry.MetaclassRegistry
356:     __metaclass__ = registry.MetaclassRegistry
31: class ScannerCheck(object):
32:     """A scanner check is a special class which is invoked on an AS to check
38:     This class is the base class for all checks.
55:         """Is the needle found at 'offset'?
59:             checked for the needle.
89: class MultiStringFinderCheck(ScannerCheck):
160: class StringCheck(ScannerCheck):
166:     def __init__(self, needle=None, needle_offset=0, **kwargs):
168:         self.needle = needle
169:         self.needle_offset = needle_offset
173:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
174:         if buffer_as.data.startswith(self.needle, buffer_offset):
175:             return self.needle
178:         # Search the rest of the buffer for the needle.
179:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
180:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)
188: class RegexCheck(ScannerCheck):
203: class _Padding(object):
209: class _BufferFragments(object):
251: class BufferASGenerator(object):
353: class BaseScanner(object):
354:     """Base class for all scanners."""
388:         for class_name, args in self.checks:
389:             check = ScannerCheck.classes[class_name](
490: class FastStructScanner(BaseScanner):
531:             yield ("StringCheck", dict(needle=expected_bytes,
532:                                        needle_offset=rel_offset + array_offset))
535: class MultiStringScanner(BaseScanner):
552:                 needle=self.needles[0])
568: class PointerScanner(BaseScanner):
602: class ScannerGroup(BaseScanner):
639: class DiscontigScannerGroup(ScannerGroup):
652: class DebugChecker(ScannerCheck):
92:     def __init__(self, needles=None, **kwargs):
96:           needles: A list of strings we search for.
99:           RuntimeError: No needles provided.
105:         if not needles:
106:             raise RuntimeError("No needles provided to search.")
110:         if max([len(x) for x in needles]) > 50:
113:         tree = acora.AcoraBuilder(*needles)
538:     # Override with the needles to check for.
541:     def __init__(self, needles=None, **kwargs):
543:         if needles is not None:
544:             self.needles = needles
549:         if len(needles) == 1:
556:                 needles=self.needles)
586:         self.needles = []
594:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))
596:         # The common string between all the needles.
598:             ("MultiStringFinderCheck", dict(needles=self.needles)),
github.com/GoogleChrome/web-audio-samples:samples/audio/box2d-js/lib/prototype-1.6.0.2.js:[gh-pages, ]
41: var Class = {
2293:         'class': 'className',
56:       var subclass = function() { };
57:       subclass.prototype = parent.prototype;
1816:   classNames: function(element) {
2165:       className: 'class',
2625:   function findDOMClass(tagName) {
4187: Element.ClassNames.prototype = {
1820:   hasClassName: function(element, className) {
1827:   addClassName: function(element, className) {
1834:   removeClassName: function(element, className) {
1841:   toggleClassName: function(element, className) {
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);
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();
4163:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
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 ?
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);
android.googlesource.com/platform/external/chromium_org/third_party/WebKit:PerformanceTests/SunSpider/tests/parse-only/prototype-1.6.0.3.js:[master, ]
44: var Class = {
2312:         'class': 'className',
59:       var subclass = function() { };
60:       subclass.prototype = parent.prototype;
1830:   classNames: function(element) {
2171:       className: 'class',
2644:   function findDOMClass(tagName) {
4286: Element.ClassNames.prototype = {
1834:   hasClassName: function(element, className) {
1841:   addClassName: function(element, className) {
1848:   removeClassName: function(element, className) {
1855:   toggleClassName: function(element, className) {
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);
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();
4262:     var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
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/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);
github.com/fuchsia-mirror/third_party-clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
618:   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.
613: /// ContainsReference - A visitor class to search for references to
614: /// a particular declaration (the needle) within any evaluated component of an
616: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
623:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
624:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
635:     if (E == Needle)
926:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1396: class UninitValsDiagReporter : public UninitVariablesHandler {
1508: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1778: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
754:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
761:     case Stmt::IfStmtClass: {
771:     case Stmt::ConditionalOperatorClass: {
781:     case Stmt::BinaryOperatorClass: {
801:     case Stmt::WhileStmtClass:
808:     case Stmt::ForStmtClass:
818:     case Stmt::CXXForRangeStmtClass:
831:     case Stmt::DoStmtClass:
840:     case Stmt::CaseStmtClass:
845:     case Stmt::DefaultStmtClass:
1218:     switch (S->getStmtClass()) {
1219:     case Stmt::ForStmtClass:
1220:     case Stmt::WhileStmtClass:
1221:     case Stmt::CXXForRangeStmtClass:
1222:     case Stmt::ObjCForCollectionStmtClass:
1224:     case Stmt::DoStmtClass: {
1313:   // Classify the current code body for better warning text.
1316:   // FIXME: Should we use a common classification enum and the same set of
1351:     // Classify the weak object being accessed for better warning text.
1971:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1972:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1973:       .setAlwaysAdd(Stmt::BlockExprClass)
1974:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1975:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1976:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1977:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1978:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp:[master, ]
618:   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.
613: /// ContainsReference - A visitor class to search for references to
614: /// a particular declaration (the needle) within any evaluated component of an
616: class ContainsReference : public ConstEvaluatedExprVisitor<ContainsReference> {
623:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
624:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
635:     if (E == Needle)
926:   class FallthroughMapper : public RecursiveASTVisitor<FallthroughMapper> {
1396: class UninitValsDiagReporter : public UninitVariablesHandler {
1508: class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {
1778: class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
264:   // templated classes.
754:     switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
761:     case Stmt::IfStmtClass: {
771:     case Stmt::ConditionalOperatorClass: {
781:     case Stmt::BinaryOperatorClass: {
801:     case Stmt::WhileStmtClass:
808:     case Stmt::ForStmtClass:
818:     case Stmt::CXXForRangeStmtClass:
831:     case Stmt::DoStmtClass:
840:     case Stmt::CaseStmtClass:
845:     case Stmt::DefaultStmtClass:
1218:     switch (S->getStmtClass()) {
1219:     case Stmt::ForStmtClass:
1220:     case Stmt::WhileStmtClass:
1221:     case Stmt::CXXForRangeStmtClass:
1222:     case Stmt::ObjCForCollectionStmtClass:
1224:     case Stmt::DoStmtClass: {
1313:   // Classify the current code body for better warning text.
1316:   // FIXME: Should we use a common classification enum and the same set of
1351:     // Classify the weak object being accessed for better warning text.
1971:       .setAlwaysAdd(Stmt::BinaryOperatorClass)
1972:       .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
1973:       .setAlwaysAdd(Stmt::BlockExprClass)
1974:       .setAlwaysAdd(Stmt::CStyleCastExprClass)
1975:       .setAlwaysAdd(Stmt::DeclRefExprClass)
1976:       .setAlwaysAdd(Stmt::ImplicitCastExprClass)
1977:       .setAlwaysAdd(Stmt::UnaryOperatorClass)
1978:       .setAlwaysAdd(Stmt::AttributedStmtClass);
github.com/pagespeed/page-speed:firefox_addon/tags/page-speed-1.7.1.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.12.9.1/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.12.9.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, ]
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/hanwen/artisjokke:needle2d/needle-inserter.hh:[master, ]
6: #define NEEDLE_INSERTER
13: class Needle_inserter : public Deformation_hook
29:   Link_array<Node> needle_;
36:   Array<Vector2> needle_params_;
2:   declare Needle_inserter
5: #ifndef NEEDLE_INSERTER
44:   Auto_needle_insert * auto_insert_;
49:   void dump_needle_forces (const char *);
54:   Needle_inserter (Maubach_tree*, Deformation_state*);
55:   void move_needle (Vector2 h, Vector2 t);
58:   void auto_needle_insert ();
61:   void refine_around_needle_tip (Vector2,Vector2);
64:   void print_needle ();  
github.com/hanwen/artisjokke:needle2d/artisjokke-drawer2.hh:[master, ]
12:   Needle_inserter * needle_inserter_;
6: #include "needle-inserter.hh"
8: class Artisjokke_drawer2 : public Artisjokke_drawer
18:   virtual void set_needle ();
20:   virtual void draw_needle ();
github.com/google/mysql-protobuf:unittest/gunit/item_like-t.cc:[mysql-5.7.9, ]
104:   const char *m_needle;
121:   const char *m_needle;
124: static const char *needles[] = {
218: static const char* falseNeedles[] = {
25: #include "sql_class.h"
39: class ItemLikeTest : public ::testing::Test
60:   const char needle[]= "%ACAGGTGCTGGAGAGGATGCGGAGAAATAGGAACA%" ;
62:   Item_string *it_needle=
63:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
65:     new Item_func_like(it_haystack, it_needle, it_escape, false);
78:   const char needle[]= "%CAAAACCACTATGAGATATCATCTCACACCAGTTA%";
79:   Item_string *it_needle=
80:     new Item_string(STRING_WITH_LEN(needle), &my_charset_latin1);
83:     new Item_func_like(it_haystack, it_needle, it_escape, false);
91: class ItemLikeTestP : public ::testing::TestWithParam<const char*>
97:     m_needle= GetParam();
108: class ItemFalseLikeTestP : public ::testing::TestWithParam<const char*>
114:     m_needle= GetParam();
207:   Item_string *it_needle=
208:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
213:     new Item_func_like(it_haystack, it_needle, it_escape, false);
296:   Item_string *it_needle=
297:     new Item_string(m_needle, strlen(m_needle), &my_charset_latin1);
302:     new Item_func_like(it_haystack, it_needle, it_escape, false);
200:                         ::testing::ValuesIn(needles));
199: INSTANTIATE_TEST_CASE_P(MoreNeedles, ItemLikeTestP,
203: TEST_P(ItemLikeTestP, MoreNeedlesTest)
289: INSTANTIATE_TEST_CASE_P(FalseNeedlesTest, ItemFalseLikeTestP,
290:                         ::testing::ValuesIn(falseNeedles));
292: TEST_P(ItemFalseLikeTestP,FalseNeedlesTest)
android.googlesource.com/platform/external/qt:Windows-4.7.4/tools/qdoc3/cppcodeparser.cpp:[master, ]
61: #define COMMAND_CLASS                   Doc::alias("class")
88: #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
1608: bool CppCodeParser::matchClassDecl(InnerNode *parent,
194:         // remove needless (and needful) class prefixes
229:     nodeTypeMap.insert(COMMAND_CLASS, Node::Class);
230:     nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);
257:   the same function in the base class.
348:   I think the most important thing it does is resolve class
532:     return QSet<QString>() << COMMAND_CLASS
689:             // class with the actual service name.
704:         if (command == COMMAND_CLASS) {
742:             Node* n = tre->findNode(names[1].split("::"),Node::Class);
971:                     tr("The function either doesn't exist in any base class "
978:               another function in a base class.
1005:                                                       Node::Class));
1606:   Parse a C++ class, union, or struct declarion.
1611:     bool isClass = (tok == Tok_class);
1624:       So far, so good. We have 'class Foo {' or 'class Foo :'.
1625:       This is enough to recognize a class definition.
1936:         case Tok_class:
416:   \a fuzzy is true, base classes are searched. The function
549:                            << COMMAND_QMLCLASS
692:                 ClassNode *cnode = static_cast<ClassNode *>(node);
707:                     ClassNode*cnode = static_cast<ClassNode*>(node);
738:     else if (command == COMMAND_QMLCLASS) {
739:         const ClassNode* classNode = 0;
744:                 classNode = static_cast<const ClassNode*>(n);
747:             return new QmlClassNode(tre->root(), QLatin1String("QML:")+names[0], classNode);
749:             return new QmlClassNode(tre->root(), names[0], classNode);
760:         QmlClassNode* qmlClass = 0;
765:             if (n && n->subType() == Node::QmlClass) {
766:                 qmlClass = static_cast<QmlClassNode*>(n);
768:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
770:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
772:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
774:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
872:             if (n && n->subType() == Node::QmlClass) {
873:                 QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
874:                 if (qmlClass)
875:                     qmlPropGroup = new QmlPropGroupNode(qmlClass,
881:             const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
885:             if (correspondingClass) {
1037:         if (node->subType() == Node::QmlClass) {
1557: bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)
1575:         access = isClass ? Node::Private : Node::Public;
1581:     CodeChunk baseClass;
1582:     if (!matchDataType(&baseClass))
1585:     tre->addBaseClass(classe,
1587:                       baseClass.toPath(),
1588:                       baseClass.toString(),
1589:                       classe->parent());
1593: bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)
1596:         if (!matchBaseSpecifier(classe, isClass))
1627:     ClassNode *classe = new ClassNode(parent, previousLexeme());
1628:     classe->setAccess(access);
1629:     classe->setLocation(location());
1631:         classe->setStatus(Node::Compat);
1633:         classe->setModuleName(moduleName);
1634:     classe->setTemplateStuff(templateStuff);
1636:     if (match(Tok_Colon) && !matchBaseList(classe, isClass))
1642:     access = isClass ? Node::Private : Node::Public;
1646:     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
356:     QMapIterator<QString, QString> i(sequentialIteratorClasses);
364:     i = mutableSequentialIteratorClasses;
372:     i = associativeIteratorClasses;
380:     i = mutableAssociativeIteratorClasses;
392:     sequentialIteratorClasses.clear();
393:     mutableSequentialIteratorClasses.clear();
394:     associativeIteratorClasses.clear();
395:     mutableAssociativeIteratorClasses.clear();
427:     int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;
1038:             QmlClassNode::addInheritedBy(arg,node);
1939:             matchClassDecl(parent, templateStuff);
1994:                 sequentialIteratorClasses.insert(previousLexeme(),
2001:                 mutableSequentialIteratorClasses.insert(previousLexeme(),
2008:                 associativeIteratorClasses.insert(previousLexeme(),
2015:                 mutableAssociativeIteratorClasses.insert(previousLexeme(),
github.com/google/coursebuilder-android-container-module:android/worker.py:[master, ]
110: _ACCEPT_LICENSE_NEEDLE = 'Do you accept the license'
133: _GRADLEW_INSTALL_SUCCESS_NEEDLE = 'BUILD SUCCESSFUL'
145: _TEST_FAILURE_NEEDLE = 'FAILURES!!!\r'
268: class Config(object):
289: class Error(Exception):
290:     """Base error class."""
293: class LockError(Error):
297: class Lock(object):
340: class Patch(object):
347: class TestRun(object):
635: class _Project(object):
638:             self, name, editor_file, package, path, test_class, test_package):
643:         self.test_class = test_class
724:             _Sdk.get_adb(), 'shell', 'am', 'instrument', '-w', '-e', 'class',
725:             self.test_class,
779:         return _GRADLEW_INSTALL_SUCCESS_NEEDLE not in result
782:         return _TEST_FAILURE_NEEDLE in result
785: class _Runtime(object):
1050: class _Sdk(object):
1111:             if _ACCEPT_LICENSE_NEEDLE in line and not process.poll():
1161: class _TestEnvironment(object):
1283:             src_project.package, test_project_path, src_project.test_class,
280:     @classmethod
306:     @classmethod
310:     @classmethod
322:     @classmethod
331:     @classmethod
646:     @classmethod
651:             value['testClass'], value['testPackage'])
797:     @classmethod
1056:     @classmethod
1067:     @classmethod
1071:     @classmethod
1075:     @classmethod
1079:     @classmethod
1091:     @classmethod
1095:     @classmethod
1101:     @classmethod
1105:     @classmethod
1125:     @classmethod
1131:     @classmethod
1135:     @classmethod
1144:     @classmethod
1153:     @classmethod
1188:     @classmethod
1210:     @classmethod
1214:     @classmethod
github.com/google/contentbox:third_party/django/test/testcases.py:[master, ]
160:     client_class = Client
1141:     def setUpClass(cls):
1206:     def tearDownClass(cls):
1192:     def _tearDownClassInternal(cls):
92: class _AssertNumQueriesContext(CaptureQueriesContext):
110: class _AssertTemplateUsedContext(object):
148: class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext):
156: class SimpleTestCase(ut2.TestCase):
158:     # The class we'll use for the test client self.client.
173:         skipped = (getattr(self.__class__, "__unittest_skip__", False) or
198:         * If the class has a 'urls' attribute, replace ROOT_URLCONF with it.
201:         self.client = self.client_class()
575:             expected_exception: Exception class expected to be raised.
590:             fieldclass: the class of the field to be tested.
666:     def assertInHTML(self, needle, haystack, count=None, msg_prefix=''):
667:         needle = assert_and_parse_html(self, needle, None,
671:         real_count = haystack.count(needle)
675:                 " (expected %d)" % (real_count, needle, count))
678:                 msg_prefix + "Couldn't find '%s' in response" % needle)
725: class TransactionTestCase(SimpleTestCase):
737:         * If the class has an 'available_apps' attribute, restricting the app
740:         * If the class has a 'fixtures' attribute, installing these fixtures.
792:           the class has an 'available_apps' attribute, post_syncdb isn't fired.
851: class TestCase(TransactionTestCase):
932: class QuietWSGIRequestHandler(WSGIRequestHandler):
948:     class _ImprovedEvent(threading._Event):
954:         timeout. This class can be removed when Django supports only Python >= 2.7.
967: class StoppableWSGIServer(WSGIServer):
969:     The code in this class is borrowed from the `SocketServer.BaseServer` class
974:     Note for the future: Once Django stops supporting Python 2.6, this class
976:     demand and will not require the use of the _ImprovedEvent class whose code
1041: class _MediaFilesHandler(StaticFilesHandler):
1043:     Handler for serving the media files. This is a private class that is
1058: class LiveServerThread(threading.Thread):
1123: class LiveServerTestCase(TransactionTestCase):
159:     # Can be overridden in derived classes.
584:     def assertFieldOutput(self, fieldclass, valid, invalid, field_args=None,
604:         required = fieldclass(*field_args, **field_kwargs)
605:         optional = fieldclass(*field_args,
629:         if issubclass(fieldclass, CharField):
631:             self.assertTrue(isinstance(fieldclass(*field_args, **field_kwargs),
632:                                        fieldclass))
902:                 issubclass(test_func, TestCase)):
1140:     @classmethod
1184:             # Clean up behind ourselves, since tearDownClass won't get called in
1189:         super(LiveServerTestCase, cls).setUpClass()
1191:     @classmethod
1193:         # There may not be a 'server_thread' attribute if setUpClass() for some
1205:     @classmethod
1208:         super(LiveServerTestCase, cls).tearDownClass()
727:     # Subclasses can ask for resetting of auto increment sequence before each
731:     # Subclasses can enable only a subset of apps for faster tests
1186:             cls._tearDownClassInternal()
1207:         cls._tearDownClassInternal()
github.com/google/supersonic:supersonic/expression/core/comparison_expressions.cc:[master, ]
79:   const scoped_ptr<const Expression> needle_expression_;
42: class BufferAllocator;
48: class InExpressionSetExpression : public Expression {
50:   InExpressionSetExpression(const Expression* const needle_expression,
52:       : needle_expression_(needle_expression),
60:     FailureOrOwned<BoundExpression> bound_needle =
61:         needle_expression_->DoBind(input_schema, allocator, max_row_count);
62:     PROPAGATE_ON_FAILURE(bound_needle);
66:     return BoundInSet(bound_needle.release(),
73:     return StrCat(needle_expression_->ToString(verbose),
84: const Expression* In(const Expression* const needle_expression,
86:   return new InExpressionSetExpression(needle_expression, haystack_arguments);
android.googlesource.com/platform/external/v8:src/mips64/constants-mips64.h:[master, ]
560:   CLASS_S = ((3U << 3) + 3),
586:   CLASS_D = ((3U << 3) + 3),
163: class Registers {
185: class FPURegisters {
334:   COP1 = ((2U << 3) + 1) << kOpcodeShift,  // Coprocessor 1 class.
851: enum class MaxMinKind : int { kMin = 0, kMax = 1 };
902: class InstructionBase {
1021: template <class T>
1022: class InstructionGetters : public T {
1198: class Instruction : public InstructionGetters<InstructionBase> {
1202:   // to allocate or create instances of class Instruction.
1209:   // We need to prevent the creation of instances of class Instruction.
1321: template <class P>
1351: template <class P>
1372: template <class T>
91: // Defines constants and accessor classes to assemble, disassemble and
1221: // TODO(plind): find all usages and remove the needless instructions for n64.
github.com/google/supersonic:supersonic/expression/core/comparison_bound_expressions.cc:[master, ]
376:   scoped_ptr<BoundExpression> needle_expression_;
733:   BoundExpression* needle_expression_;
381:   bool_ptr skipped_or_matched_or_needle_expression_null_copy() {
391:   bool_ptr skipped_or_matched_or_needle_expression_null() {
53: class BufferAllocator;
64: // A class used only in BoundInSetExpression. This keeps an array of hold_type.
66: class SortedVector {
77:   template<class InputIterator>
135: class BoundInSetExpression : public BasicBoundExpression {
140:   // Needle expression, haystack arguments, and haystack constants are expected
146:                        BoundExpression* needle_expression,
154:                            GetExpressionNullability(needle_expression),
157:         needle_expression_(needle_expression),
163:         data_type, needle_expression_.get()).is_success());
187:     // Step 1: Evaluate the needle expression.
188:     EvaluationResult needle_expression_result =
189:         needle_expression_->DoEvaluate(input, skip_vectors);
190:     PROPAGATE_ON_FAILURE(needle_expression_result);
194:     // a) it's skipped either because needle expression evaluates to null
197:     bit_pointer::FillFrom(skipped_or_matched_or_needle_expression_null(),
201:     DCHECK_EQ(needle_expression_result.get().schema().attribute(0).type(),
204:         needle_expression_result.get().column(0).typed_data<data_type>();
206:     bool_ptr output_data = skipped_or_matched_or_needle_expression_null();
233:           skipped_or_matched_or_needle_expression_null(),
253:       bit_pointer::FillFrom(skipped_or_matched_or_needle_expression_null_copy(),
254:                             skipped_or_matched_or_needle_expression_null(),
258:           0, skipped_or_matched_or_needle_expression_null_copy());
266:       const cpp_type* needle_expression_iterator =
267:           needle_expression_result.get().column(0).typed_data<data_type>();
273:       bool_ptr skip_iterator = skipped_or_matched_or_needle_expression_null();
282:           // We only need to check equality between needle and haystack
283:           // if needle is not null, not skipped, not yet matched
287:               *haystack_expression_iterator, *needle_expression_iterator);
291:           ++needle_expression_iterator;
300:               *needle_expression_iterator);
303:           ++needle_expression_iterator;
309:     // skipped_or_matched_or_needle_expression_null_copy (since it is not
311:     vector_logic::AndNot(skipped_or_matched_or_needle_expression_null(),
320:         skipped_or_matched_or_needle_expression_null(),
327:   // Needle in <haystack_constants, haystack_arguments> can be resolved if
328:   // needle expression is a constant and at least one of the following is true:
330:   // b) needle expression evaluates null.
331:   // c) the value of the needle expression is present in haystack_constants.
333:     if (!needle_expression_->is_constant()) {
342:           needle_expression_.get(), &is_null);
343:       // If actual evaluation of needle expression fails, we can't propagate
366:     needle_expression_->CollectReferredAttributeNames(referred_attribute_names);
643:     BoundExpression* input_needle_expression,
647:   scoped_ptr<BoundExpression> needle_expression(input_needle_expression);
656:   string name = StrCat(GetExpressionName(needle_expression.get()),
688:   // hashing for matching needle with constant-valued haystack expressions.
699:           needle_expression.release(),
708:             needle_expression.release(),
718:   InSetResolver(BoundExpression* needle_expression,
723:         needle_expression_(needle_expression),
730:         needle_expression_, haystack_arguments_, allocator_, max_row_count_);
760:     BoundExpression* input_needle_expression,
764:   scoped_ptr<BoundExpression> needle_expression(input_needle_expression);
766:   PROPAGATE_ON_FAILURE(CheckAttributeCount("Needle Bound Expression",
767:                                            needle_expression->result_schema(),
777:       needle_expression->result_schema().attribute(0).type();
792:       needle_expression.release(),
796:   needle_expression.reset(converted.release());
807:   InSetResolver resolver(needle_expression.release(),
github.com/google/coursebuilder-core:coursebuilder/modules/gitkit/gitkit.py:[master, ]
150: _BAD_CRYPTO_NEEDLE = 'PKCS12 format is not supported by the PyCrypto library'
1016:     def get_email_update_policy_class(cls):
1020:     def get_federated_email_resolver_class(cls):
1024:     def get_mailer_class(cls):
1028:     def get_request_context_class(cls):
1032:     def get_template_resolver_class(cls):
246: class EmailMapping(models.BaseEntity):
301: class EmailUpdatePolicy(users.EmailUpdatePolicy):
320: class FederatedEmailResolver(users.FederatedEmailResolver):
328: class AbstractOobResponse(object):
339:         containing the keys that can be accepted by this particular child class.
341:         response dict, that dict can be cast to the particular child class type.
399: class AbstractOobEmailResponse(AbstractOobResponse):
411: class OobFailureResponse(AbstractOobResponse):
423: class OobChangeEmailResponse(AbstractOobEmailResponse):
449: class OobResetPasswordResponse(AbstractOobEmailResponse):
473: class GitkitService(object):
627:             if _BAD_CRYPTO_NEEDLE in e.message:
651: class Mailer(users.Mailer):
682:         template_resolver = users_service.get_template_resolver_class()
707: class RequestContext(webapp2.RequestContext):
735: class Runtime(object):
835: class RuntimeConfig(object):
897: class TemplateResolver(users.TemplateResolver):
959: class UsersService(users.AbstractUsersService):
1061: class BaseHandler(controllers_utils.BaseHandler):
1087:         return '%s: %s' % (exception.__class__.__name__, exception.message)
1105: class AccountChooserCustomizationBaseHandler(BaseHandler):
1124: class BrandingHandler(AccountChooserCustomizationBaseHandler):
1134:         template = users_service.get_template_resolver_class().get(
1139: class EmailRestHandler(BaseHandler):
1186:             users_service.get_mailer_class().send_async(locale, oob_response)
1211: class FaviconHandler(AccountChooserCustomizationBaseHandler):
1220: class SignInContinueHandler(BaseHandler):
1231: class SignInHandler(BaseHandler):
1270:         users_service.get_email_update_policy_class().apply(user)
1277: class SignOutContinueHandler(BaseHandler):
1294: class SignOutHandler(BaseHandler):
1307:         template = users_service.get_template_resolver_class().get(
1315: class WidgetHandler(BaseHandler):
1328:         template = users_service.get_template_resolver_class().get(
259:     @classmethod
274:     @classmethod
279:     @classmethod
285:     @classmethod
290:     @classmethod
295:     @classmethod
304:     @classmethod
322:     @classmethod
334:     @classmethod
348:     @classmethod
374:     @classmethod
414:     @classmethod
418:     @classmethod
441:     @classmethod
465:     @classmethod
492:     @classmethod
502:     @classmethod
506:     @classmethod
510:     @classmethod
654:     @classmethod
663:     @classmethod
743:     @classmethod
753:     @classmethod
757:     @classmethod
761:     @classmethod
765:     @classmethod
769:     @classmethod
774:     @classmethod
778:     @classmethod
782:     @classmethod
794:     @classmethod
798:     @classmethod
803:     @classmethod
807:     @classmethod
817:     @classmethod
822:     @classmethod
826:     @classmethod
830:     @classmethod
900:     @classmethod
905:     @classmethod
933:     @classmethod
940:     @classmethod
961:     @classmethod
972:     @classmethod
981:     @classmethod
1015:     @classmethod
1019:     @classmethod
1023:     @classmethod
1027:     @classmethod
1031:     @classmethod
1035:     @classmethod
1047:     @classmethod
1055:     @classmethod
1063:     @classmethod
github.com/emacs-mirror/emacs:lisp/gnus/gnus-cache.el:[master, ]
427: (defun gnus-cache-member-of-class (class ticked dormant unread)
169: 			  (gnus-cache-member-of-class
426: ;; Return whether an article is a member of a class.
428:   (or (and ticked (memq 'ticked class))
429:       (and dormant (memq 'dormant class))
430:       (and unread (memq 'unread class))
431:       (and (not unread) (not ticked) (not dormant) (memq 'read class))))
511: 		   (gnus-cache-member-of-class
43:   "Classes of articles to enter into the cache."
48:   "Classes of articles to remove from the cache."
735:       ;; `gnus-cache-unified-group-names' needless.
github.com/emacs-mirror/emacs:lisp/emacs-lisp/cl-preloaded.el:[master, ]
70: (defun cl--struct-get-class (name)
26: ;; cl-structure-class type (and its accessors) which is defined with itself,
28: ;; with cl-defstruct, and to make things more interesting, the class of
29: ;; cl-structure-object is of course an object of type cl-structure-class while
30: ;; cl-structure-class's parent is cl-structure-object.
40: (eval-when-compile (require 'cl-macs))  ;For cl--struct-class.
53: ;; When we load this (compiled) file during pre-loading, the cl--struct-class
58: (unless (cl--find-class 'cl-structure-object)
59:   (setf (cl--find-class 'cl-structure-object) 'dummy))
72:       (cl--find-class name)
74:           ;; FIXME: Add a conversion for `eieio--class' so we can
75:           ;; create a cl-defstruct that inherits from an eieio class?
92:           (cl--find-class name)))))
102:   ;; Can't use (cl-typep parent 'cl-structure-class) at this stage
103:   ;; because `cl-structure-class' is defined later.
105:     (add-to-list (cl--struct-class-children-sym parent) tag)
108:     (setq parent (car (cl--struct-class-parents parent)))))
126:   (let* ((parent-class (when parent (cl--struct-get-class parent)))
142:          (class (cl--struct-new-class
144:                  (unless (symbolp parent-class) (list parent-class))
146:     (unless (symbolp parent-class)
147:       (let ((pslots (cl--struct-class-slots parent-class)))
158:     (cl--struct-register-child parent-class tag)
162:       ;; class object stored in the tag ends up being a *copy* of the
163:       ;; one stored in the `cl--class' property!  We could have fixed
166:       ;; cl-structure-class class object to close the recursion
167:       ;; between cl-structure-object and cl-structure-class (because
173:       (set tag class)
179:     (setf (cl--find-class name) class)))
181: (cl-defstruct (cl-structure-class
182:                (:conc-name cl--struct-class-)
183:                (:predicate cl--struct-class-p)
185:                (:constructor cl--struct-new-class
190:   ;; The first few fields here are actually inherited from cl--class, but we
192:   ;; list the fields here and later "backpatch" cl--class as the parent.
196:   (parents nil :type (list-of cl--class)) ;The included struct.
199:   (tag nil :type symbol) ;Placed in cl-tag-slot.  Holds the struct-class object.
234: (cl-defstruct (cl--class
242:   ;; from cl--class, we'll need this to hold a list.
243:   (parents nil :type (list-of cl--class))
248:  (let ((sc-slots (cl--struct-class-slots (cl--find-class 'cl-structure-class)))
249:        (c-slots (cl--struct-class-slots (cl--find-class 'cl--class)))
259: ;; Close the recursion between cl-structure-object and cl-structure-class.
260: (setf (cl--struct-class-parents (cl--find-class 'cl-structure-class))
261:       (list (cl--find-class 'cl--class)))
263:  (cl--find-class 'cl--class)
264:  (cl--struct-class-tag (cl--find-class 'cl-structure-class)))
266: (cl-assert (cl--find-class 'cl-structure-class))
267: (cl-assert (cl--find-class 'cl-structure-object))
268: (cl-assert (cl-struct-p (cl--find-class 'cl-structure-class)))
269: (cl-assert (cl-struct-p (cl--find-class 'cl-structure-object)))
270: (cl-assert (cl--class-p (cl--find-class 'cl-structure-class)))
271: (cl-assert (cl--class-p (cl--find-class 'cl-structure-object)))
164:       ;; this needless duplication by using the purecopied object, but
238:   ;; Intended to be shared between defstruct and defclass.
241:   ;; For structs there can only be one parent, but when EIEIO classes inherit
github.com/fuchsia-mirror/third_party-ffmpeg:libavformat/avio.h:[master, ]
160:     const AVClass *av_class;
149:      * A class for private options.
151:      * If this AVIOContext is created by avio_open2(), av_class is set and
154:      * If this AVIOContext is manually allocated, then av_class may be set by
306:      * but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly
github.com/google/capsicum-linux:drivers/char/xillybus/xillybus_core.c:[capsicum, ]
64: static struct class *xillybus_class;
1846: 		device = device_create(xillybus_class,
1868: 		device_destroy(xillybus_class, MKDEV(major, i));
1884: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2085: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2086: 	if (IS_ERR(xillybus_class))
2087: 		return PTR_ERR(xillybus_class);
2091: 		class_destroy(xillybus_class);
2103: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux:drivers/char/xillybus/xillybus_core.c:[master, ]
64: static struct class *xillybus_class;
1846: 		device = device_create(xillybus_class,
1868: 		device_destroy(xillybus_class, MKDEV(major, i));
1884: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2085: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2086: 	if (IS_ERR(xillybus_class))
2087: 		return PTR_ERR(xillybus_class);
2091: 		class_destroy(xillybus_class);
2103: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
github.com/googleglass/gdk-compass-sample:app/src/main/java/com/google/android/glass/sample/compass/CompassView.java:[master, ]
53:     private static final float NEEDLE_WIDTH = 6;
54:     private static final float NEEDLE_HEIGHT = 125;
55:     private static final int NEEDLE_COLOR = Color.RED;
341:     private void drawNeedle(Canvas canvas, boolean bottom) {
50: public class CompassView extends View {
216:         mPaint.setColor(NEEDLE_COLOR);
336:      * Draws a needle that is centered at the top or bottom of the compass.
339:      * @param bottom true to draw the bottom needle, or false to draw the top needle
346:         // Flip the vertical coordinates if we're drawing the bottom needle.
355:         float needleHalfWidth = NEEDLE_WIDTH / 2;
359:         mPath.lineTo(centerX - needleHalfWidth, origin + sign * (NEEDLE_HEIGHT - 4));
360:         mPath.lineTo(centerX, origin + sign * NEEDLE_HEIGHT);
361:         mPath.lineTo(centerX + needleHalfWidth, origin + sign * (NEEDLE_HEIGHT - 4));
48:  * marks at the half-winds. The red "needles" in the display mark the current heading.
217:         drawNeedle(canvas, false);
218:         drawNeedle(canvas, true);
358:         mPath.moveTo(centerX - needleHalfWidth, origin);
362:         mPath.lineTo(centerX + needleHalfWidth, origin);
github.com/gwtproject/gwt:samples/dynatable/src/com/google/gwt/sample/dynatable/server/SchoolCalendarServiceImpl.java:[master, ]
52:   private static final int CLASS_LENGTH_MINS = 50;
34: public class SchoolCalendarServiceImpl extends RemoteServiceServlet implements
146:       int absStopMins = absStartMins + CLASS_LENGTH_MINS;
43:       "Crutcher", "Needler", "Wilson", "Chase", "Edelstein"};
168:     generateRandomSchedule(student.getClassSchedule());
github.com/google/ktsan:drivers/char/xillybus/xillybus_core.c:[tsan, ]
64: static struct class *xillybus_class;
1844: 		device = device_create(xillybus_class,
1866: 		device_destroy(xillybus_class, MKDEV(major, i));
1882: 		device_destroy(xillybus_class, MKDEV(endpoint->major, minor));
2083: 	xillybus_class = class_create(THIS_MODULE, xillyname);
2084: 	if (IS_ERR(xillybus_class))
2085: 		return PTR_ERR(xillybus_class);
2089: 		class_destroy(xillybus_class);
2101: 	class_destroy(xillybus_class);
84:  * They are held for short direct memory manipulations. Needless to say,
github.com/llvm-mirror/vmkit:lib/j3/VMCore/Jnjvm.cpp:[master, ]
819: #define MAIN_CLASS "Main-Class: "
820: #define MAIN_LOWER_CLASS "Main-class: "
821: #define PREMAIN_CLASS "Premain-Class: "
825: #define LENGTH_MAIN_CLASS 12
826: #define LENGTH_PREMAIN_CLASS 15
1119: #define LOAD_CLASS(cl) \
70: void UserClass::initialiseClass(Jnjvm* vm) {
468: void Jnjvm::classCastException(JavaObject* obj, UserCommonClass* cl) {
662: void Jnjvm::classNotFoundException(JavaString* name) {
741: void Jnjvm::classFormatError(const char* msg) {
1195: void Jnjvm::executeClass(const char* className, ArrayObject* args) {
822: #define BOOT_CLASS_PATH "Boot-Class-Path: "
823: #define CAN_REDEFINE_CLASS_PATH "Can-Redefine-Classes: "
827: #define LENGTH_BOOT_CLASS_PATH 17
399: JavaObject* Jnjvm::CreateClassCastException(JavaObject* obj,
475: void Jnjvm::noClassDefFoundError(JavaObject* obj) {
654: void Jnjvm::noClassDefFoundError(const UTF8* name) {
670: void Jnjvm::noClassDefFoundError(UserClass* cl, const UTF8* name) {
787: JavaObject* UserCommonClass::getClassDelegatee(Jnjvm* vm, JavaObject* pd) {
811: JavaObject* const* UserCommonClass::getClassDelegateePtr(Jnjvm* vm, JavaObject* pd) {
862: void ClArgumentsInfo::extractClassFromJar(Jnjvm* vm, int argc, char** argv, 
1078: JnjvmClassLoader* Jnjvm::loadAppClassLoader() {
68: /// initialiseClass - Java class initialization. Java specification §2.17.5.
78:   // Assumes that the Class object has already been verified and prepared and
79:   // that the Class object contains state that can indicate one of four
82:   //  * This Class object is verified and prepared but not initialized.
83:   //  * This Class object is being initialized by some particular thread T.
84:   //  * This Class object is fully initialized and ready for use.
85:   //  * This Class object is in an erroneous state, perhaps because the
90:          isErroneous()) && "Class in wrong state");
94:     // 1. Synchronize on the Class object that represents the class or 
103:       //    class or interface, then wait on this Class object (which 
111:         // 3. If initialization is in progress for the class or interface by
113:         //    initialization. Release the lock on the Class object and complete
120:     // 4. If the class or interface has already been initialized, then no 
121:     //    further action is required. Release the lock on the Class object
128:     // 5. If the Class object is in an erroneous state, then initialization is
129:     //    not possible. Release the lock on the Class object and throw a
136:     // 6. Otherwise, record the fact that initialization of the Class object is
138:     //    Class object.
151:     // 7. Next, if the Class object represents a class rather than an interface, 
152:     //    and the direct superclass of this class has not yet been initialized,
155:     //    abruptly because of a thrown exception, then lock this Class object, 
176:     // 8. Next, execute either the class variable initializers and static
177:     //    initializers of the class or the field initializers of the interface,
206:     //    this Class object, label it fully initialized, notify all waiting 
218:     //     throwing some exception E. If the class of E is not Error or one
219:     //     of its subclasses, then create a new instance of the class 
239:     // 11. Lock the Class object, label it erroneous, notify all waiting
786: // Mimic what's happening in Classpath when creating a java.lang.Class object.
836: extern "C" int sys_strnstr(const char *haystack, const char *needle) {
837:   const char* res = strstr(haystack, needle);
853:     char* name = (char*)vm->allocator.Allocate(length + 1, "class name");
886:         char* mainClass = findInformation(vm, res, MAIN_CLASS,
887:                                           LENGTH_MAIN_CLASS);
889:           mainClass = findInformation(vm, res, MAIN_LOWER_CLASS,
890:                                       LENGTH_MAIN_CLASS);
895:           printf("No Main-Class:  in Manifest of archive %s.\n", jarFile);
918:   "Usage: j3 [-options] class [args...] (to execute a class)\n"
921:     "-cp <class search path of directories and zip/jar files>\n"
922:     "-classpath <class search path of directories and zip/jar files>\n"
924:     "              and ZIP archives to search for class files.\n"
927:     "-verbose[:class|gc|jni]\n"
1043:     } else if (!(strcmp(cur, "-verbose:class"))) {
1113:   // Initialize the bootstrap class loader if it's not
1123:   LOAD_CLASS(upcalls->newString);
1129:   LOAD_CLASS(upcalls->newClass);
1130:   LOAD_CLASS(upcalls->newConstructor);
1131:   LOAD_CLASS(upcalls->newField);
1132:   LOAD_CLASS(upcalls->newMethod);
1133:   LOAD_CLASS(upcalls->newStackTraceElement);
1134:   LOAD_CLASS(upcalls->boolClass);
1135:   LOAD_CLASS(upcalls->byteClass);
1136:   LOAD_CLASS(upcalls->charClass);
1137:   LOAD_CLASS(upcalls->shortClass);
1138:   LOAD_CLASS(upcalls->intClass);
1139:   LOAD_CLASS(upcalls->longClass);
1140:   LOAD_CLASS(upcalls->floatClass);
1141:   LOAD_CLASS(upcalls->doubleClass);
1142:   LOAD_CLASS(upcalls->InvocationTargetException);
1143:   LOAD_CLASS(upcalls->ArrayStoreException);
1144:   LOAD_CLASS(upcalls->ClassCastException);
1145:   LOAD_CLASS(upcalls->IllegalMonitorStateException);
1146:   LOAD_CLASS(upcalls->IllegalArgumentException);
1147:   LOAD_CLASS(upcalls->InterruptedException);
1148:   LOAD_CLASS(upcalls->IndexOutOfBoundsException);
1149:   LOAD_CLASS(upcalls->ArrayIndexOutOfBoundsException);
1150:   LOAD_CLASS(upcalls->NegativeArraySizeException);
1151:   LOAD_CLASS(upcalls->NullPointerException);
1152:   LOAD_CLASS(upcalls->SecurityException);
1153:   LOAD_CLASS(upcalls->ClassFormatError);
1154:   LOAD_CLASS(upcalls->ClassCircularityError);
1155:   LOAD_CLASS(upcalls->NoClassDefFoundError);
1156:   LOAD_CLASS(upcalls->UnsupportedClassVersionError);
1157:   LOAD_CLASS(upcalls->NoSuchFieldError);
1158:   LOAD_CLASS(upcalls->NoSuchMethodError);
1159:   LOAD_CLASS(upcalls->InstantiationError);
1160:   LOAD_CLASS(upcalls->IllegalAccessError);
1161:   LOAD_CLASS(upcalls->IllegalAccessException);
1162:   LOAD_CLASS(upcalls->VerifyError);
1163:   LOAD_CLASS(upcalls->ExceptionInInitializerError);
1164:   LOAD_CLASS(upcalls->LinkageError);
1165:   LOAD_CLASS(upcalls->AbstractMethodError);
1166:   LOAD_CLASS(upcalls->UnsatisfiedLinkError);
1167:   LOAD_CLASS(upcalls->InternalError);
1168:   LOAD_CLASS(upcalls->OutOfMemoryError);
1169:   LOAD_CLASS(upcalls->StackOverflowError);
1170:   LOAD_CLASS(upcalls->UnknownError);
1171:   LOAD_CLASS(upcalls->ClassNotFoundException); 
1172:   LOAD_CLASS(upcalls->ArithmeticException); 
1173:   LOAD_CLASS(upcalls->InstantiationException);
1174:   LOAD_CLASS(upcalls->SystemClass);
1175:   LOAD_CLASS(upcalls->cloneableClass);
1176:   LOAD_CLASS(upcalls->CloneNotSupportedException);
1177: #undef LOAD_CLASS
1209:     // If not, load the class.
1487:       assert(cl->isClass() && "Not a class!");
24: #include "ClasspathReflect.h"
26: #include "JavaClass.h"
63: 	UserClass* cl = kk->getJVM()->upcalls->SystemClass;
89:   assert((isResolved() || getOwnerClass() || isReady() ||
106:       if (getOwnerClass() != self) {
107:         while (getOwnerClass()) {
108:           waitClass();
139:     setOwnerClass(self);
141:     UserClass* cl = (UserClass*)this;
154:     //    superclass. If the initialization of the direct superclass completes 
158:     //    the initializing the superclass.
159:     UserClass* super = getSuper();
162:         super->initialiseClass(vm);
166:         setOwnerClass(0);
167:         broadcastClass();
211:       setOwnerClass(0);
212:       broadcastClass();
225:     if (JavaObject::getClass(exc)->isSubclassOf(vm->upcalls->newException)) {
226:       Classpath* upcalls = classLoader->bootstrapLoader->upcalls;
227:       UserClass* clExcp = upcalls->ExceptionInInitializerError;
244:     setOwnerClass(0);
245:     broadcastClass();
252: void Jnjvm::errorWithExcp(UserClass* cl, JavaMethod* init,
263: JavaObject* Jnjvm::CreateError(UserClass* cl, JavaMethod* init,
277: JavaObject* Jnjvm::CreateError(UserClass* cl, JavaMethod* init,
287: void Jnjvm::error(UserClass* cl, JavaMethod* init, JavaString* str) {
305:       this, upcalls->intClass, entry, 10);
314:     upcalls->IntToString->invokeJavaObjectStatic(this, upcalls->intClass,
334:     upcalls->IntToString->invokeJavaObjectStatic(this, upcalls->intClass,
400:                                             UserCommonClass* cl) {
402:   return CreateError(upcalls->ClassCastException,
470:   error(upcalls->ClassCastException,
482: void Jnjvm::instantiationException(UserCommonClass* cl) {
490: void Jnjvm::instantiationError(UserCommonClass* cl) {
498: JavaString* CreateNoSuchMsg(CommonClass* cl, const UTF8* name,
551: void Jnjvm::noSuchFieldError(CommonClass* cl, const UTF8* name) { 
559: void Jnjvm::noSuchMethodError(CommonClass* cl, const UTF8* name) {
567: void Jnjvm::abstractMethodError(CommonClass* cl, const UTF8* name) {
666:   error(upcalls->ClassNotFoundException,
745:   error(upcalls->ClassFormatError, upcalls->InitClassFormatError, str);
768:         this, upcalls->internString->classDef, &key);
788:   JavaObjectClass* delegatee = 0;
789:   JavaObjectClass* base = 0;
795:     UserClass* cl = vm->upcalls->newClass;
796:     delegatee = (JavaObjectClass*)cl->doNew(vm);
797:     JavaObjectClass::setClass(delegatee, this);
799:       base = (JavaObjectClass*)
800:         asArrayClass()->baseClass()->getClassDelegatee(vm, pd);
801:       JavaObjectClass::setProtectionDomain(
802:         delegatee, JavaObjectClass::getProtectionDomain(base));
804:       JavaObjectClass::setProtectionDomain(delegatee, pd);
843: static char* findInformation(Jnjvm* vm, ClassBytes* manifest, const char* entry,
864:   ClassBytes* bytes = NULL;
865:   ClassBytes* res = NULL;
883:       res = new (allocator, file->ucsize) ClassBytes(file->ucsize);
888:         if (mainClass == NULL) {
892:         if (mainClass != NULL) {
893:           className = mainClass;
937:     "-ea[:<packagename>...|:<classname>]\n"
938:     "-enableassertions[:<packagename>...|:<classname>]\n"
940:     "-da[:<packagename>...|:<classname>]\n"
941:     "-disableassertions[:<packagename>...|:<classname>]\n"
957:   className = 0;
963:     if (!(strcmp(cur, "-classpath"))) {
1069:       className = cur;
1083:     UserClass* cl = upcalls->newClassLoader;
1089:                                      argumentsInfo.className);
1090:     } else if (argumentsInfo.className) {
1091:       appClassLoader->loadLibFromFile(this, argumentsInfo.className);
1120:   cl->resolveClass(); \
1121:   cl->initialiseClass(this);
1125:   // The initialization code of the classes initialized below may require
1191:   UserCommonClass* math = loader->loadName(loader->mathName, true, true, NULL);
1192:   math->asClass()->initialiseClass(this);
1207:     UserClass* cl = appClassLoader->loadClassFromSelf(this, className);
1211:       const UTF8* name = appClassLoader->asciizConstructUTF8(className);
1212:       cl = (UserClass*)appClassLoader->loadName(name, true, true, NULL);
1215:     cl->initialiseClass(this);
1222:       method->invokeIntStatic(this, method->classDef, &args);
1238:       upcalls->uncaughtException->invokeIntVirtual(this, upcalls->uncaughtException->classDef, handler, &obj, &exc);
1248: void Jnjvm::executePremain(const char* className, JavaString* args,
1253:     const UTF8* name = appClassLoader->asciizConstructUTF8(className);
1254:     UserClass* cl = (UserClass*)
1256:     cl->initialiseClass(this);
1263:     method->invokeIntStatic(this, method->classDef, &args, &instrumenter);
1281:   if (vm->argumentsInfo.className == NULL) {
1300:         UTF8Buffer(JavaObject::getClass(exc)->name).cString());
1321:     vm->executeClass(info.className, args);
1354:   classpath = getenv("CLASSPATH");
1355:   if (classpath == NULL) classpath = ".";
1477:     CommonClass* cl = JavaObject::getClass(src);
1479:       UserClassArray* array = cl->asArrayClass();
1480:       UserCommonClass* base = array->baseClass();
1482:         base->asPrimitiveClass()->logSize : (sizeof(JavaObject*) == 8 ? 3 : 2); 
1488:       size = cl->asClass()->getVirtualSize();
1504:     CommonClass* cl = JavaObject::getClass(src);
1512: extern "C" int StartJnjvmWithoutJIT(int argc, char** argv, char* mainClass) {
1519:   newArgv[1] = mainClass;
1543:           UTF8Buffer(meth->classDef->name).cString(),
51:  * In GNUClasspath the default behavior when the program call System.exit
130:     //    NoClassDefFoundError.
133:       vm->noClassDefFoundError(name);
403:                      upcalls->InitClassCastException,
471:         upcalls->InitClassCastException,
477:   errorWithExcp(upcalls->NoClassDefFoundError,
478:         upcalls->ErrorWithExcpNoClassDefFoundError, 
658:   error(upcalls->NoClassDefFoundError,
659:         upcalls->InitNoClassDefFoundError, str);
667:         upcalls->InitClassNotFoundException, str);
737:   error(upcalls->NoClassDefFoundError, upcalls->InitNoClassDefFoundError, str);
814:   getClassDelegatee(vm, pd);
868:   vm->setClasspath(jarFile);
966:       else vm->setClasspath(argv[i]);
970:       else vm->setClasspath(argv[i]);
986:     } else if (!(strncmp(cur, "-Xbootclasspath:", 16))) {
992:         vm->bootstrapLoader->analyseClasspathEnv(path);
995:     else if (!(strncmp(cur, "-Xbootclasspath/a:", 18))) {
1001: 		vm->bootstrapLoader->analyseClasspathEnv(path);
1025:         extractClassFromJar(vm, argc, argv, i);
1033:     } else if (!(strcmp(cur, "-noclassgc"))) {
1082:   if (appClassLoader == NULL) {
1084:     loader = upcalls->getSystemClassLoader->invokeJavaObjectStatic(this, cl);
1085:     appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader,
1088:       appClassLoader->loadLibFromJar(this, argumentsInfo.jarFile,
1094:   return appClassLoader;
1116:     bootstrapLoader->upcalls->initialiseClasspath(bootstrapLoader);
1182:   loadAppClassLoader();
1184:   javaLoader = appClassLoader->getJavaClassLoader();
1186:   upcalls->setContextClassLoader->invokeIntSpecial(this, upcalls->newThread,
1218:       appClassLoader->asciizConstructUTF8("([Ljava/lang/String;)V");
1219:     const UTF8* funcName = appClassLoader->asciizConstructUTF8("main");
1255:         appClassLoader->loadName(name, true, true, NULL);
1258:     const UTF8* funcSign = appClassLoader->asciizConstructUTF8(
1260:     const UTF8* funcName = appClassLoader->asciizConstructUTF8("premain");
1314:     UserClassArray* array = vm->bootstrapLoader->upcalls->ArrayOfString;
1357:   appClassLoader = NULL;
1472:   if (VMClassLoader::isVMClassLoader(src)) {
1473:     size = sizeof(VMClassLoader);
1499:   if (VMClassLoader::isVMClassLoader(src)) {
1500:     return "VMClassLoader";
android.googlesource.com/platform/external/qt:Mac-4.7.4/tools/qdoc3/cppcodeparser.cpp:[master, ]
61: #define COMMAND_CLASS                   Doc::alias("class")
88: #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
1608: bool CppCodeParser::matchClassDecl(InnerNode *parent,
194:         // remove needless (and needful) class prefixes
229:     nodeTypeMap.insert(COMMAND_CLASS, Node::Class);
230:     nodeTypeMap.insert(COMMAND_SERVICE, Node::Class);
257:   the same function in the base class.
348:   I think the most important thing it does is resolve class
532:     return QSet<QString>() << COMMAND_CLASS
689:             // class with the actual service name.
704:         if (command == COMMAND_CLASS) {
742:             Node* n = tre->findNode(names[1].split("::"),Node::Class);
971:                     tr("The function either doesn't exist in any base class "
978:               another function in a base class.
1005:                                                       Node::Class));
1606:   Parse a C++ class, union, or struct declarion.
1611:     bool isClass = (tok == Tok_class);
1624:       So far, so good. We have 'class Foo {' or 'class Foo :'.
1625:       This is enough to recognize a class definition.
1936:         case Tok_class:
416:   \a fuzzy is true, base classes are searched. The function
549:                            << COMMAND_QMLCLASS
692:                 ClassNode *cnode = static_cast<ClassNode *>(node);
707:                     ClassNode*cnode = static_cast<ClassNode*>(node);
738:     else if (command == COMMAND_QMLCLASS) {
739:         const ClassNode* classNode = 0;
744:                 classNode = static_cast<const ClassNode*>(n);
747:             return new QmlClassNode(tre->root(), QLatin1String("QML:")+names[0], classNode);
749:             return new QmlClassNode(tre->root(), names[0], classNode);
760:         QmlClassNode* qmlClass = 0;
765:             if (n && n->subType() == Node::QmlClass) {
766:                 qmlClass = static_cast<QmlClassNode*>(n);
768:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,false,COMMAND_QMLSIGNAL);
770:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlSignal,true,COMMAND_QMLATTACHEDSIGNAL);
772:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,false,COMMAND_QMLMETHOD);
774:                     return makeFunctionNode(doc,arg,qmlClass,Node::QmlMethod,true,COMMAND_QMLATTACHEDMETHOD);
872:             if (n && n->subType() == Node::QmlClass) {
873:                 QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
874:                 if (qmlClass)
875:                     qmlPropGroup = new QmlPropGroupNode(qmlClass,
881:             const ClassNode *correspondingClass = static_cast<const QmlClassNode*>(qmlPropGroup->parent())->classNode();
885:             if (correspondingClass) {
1037:         if (node->subType() == Node::QmlClass) {
1557: bool CppCodeParser::matchBaseSpecifier(ClassNode *classe, bool isClass)
1575:         access = isClass ? Node::Private : Node::Public;
1581:     CodeChunk baseClass;
1582:     if (!matchDataType(&baseClass))
1585:     tre->addBaseClass(classe,
1587:                       baseClass.toPath(),
1588:                       baseClass.toString(),
1589:                       classe->parent());
1593: bool CppCodeParser::matchBaseList(ClassNode *classe, bool isClass)
1596:         if (!matchBaseSpecifier(classe, isClass))
1627:     ClassNode *classe = new ClassNode(parent, previousLexeme());
1628:     classe->setAccess(access);
1629:     classe->setLocation(location());
1631:         classe->setStatus(Node::Compat);
1633:         classe->setModuleName(moduleName);
1634:     classe->setTemplateStuff(templateStuff);
1636:     if (match(Tok_Colon) && !matchBaseList(classe, isClass))
1642:     access = isClass ? Node::Private : Node::Public;
1646:     bool matches = (matchDeclList(classe) && match(Tok_RightBrace) &&
356:     QMapIterator<QString, QString> i(sequentialIteratorClasses);
364:     i = mutableSequentialIteratorClasses;
372:     i = associativeIteratorClasses;
380:     i = mutableAssociativeIteratorClasses;
392:     sequentialIteratorClasses.clear();
393:     mutableSequentialIteratorClasses.clear();
394:     associativeIteratorClasses.clear();
395:     mutableAssociativeIteratorClasses.clear();
427:     int flags = fuzzy ? int(Tree::SearchBaseClasses) : 0;
1038:             QmlClassNode::addInheritedBy(arg,node);
1939:             matchClassDecl(parent, templateStuff);
1994:                 sequentialIteratorClasses.insert(previousLexeme(),
2001:                 mutableSequentialIteratorClasses.insert(previousLexeme(),
2008:                 associativeIteratorClasses.insert(previousLexeme(),
2015:                 mutableAssociativeIteratorClasses.insert(previousLexeme(),
chromium.googlesource.com/v8/v8:src/mips64/constants-mips64.h:[master, ]
605:   CLASS_S = ((3U << 3) + 3),
631:   CLASS_D = ((3U << 3) + 3),
798:   FCLASS = (0U << 17),
171: class Registers {
193: class FPURegisters {
212: class MSARegisters {
378:   COP1 = ((2U << 3) + 1) << kOpcodeShift,  // Coprocessor 1 class.
1154: enum class MaxMinKind : int { kMin = 0, kMax = 1 };
1205: class InstructionBase {
1380: template <class T>
1381: class InstructionGetters : public T {
1658: class Instruction : public InstructionGetters<InstructionBase> {
1662:   // to allocate or create instances of class Instruction.
1669:   // We need to prevent the creation of instances of class Instruction.
1807: template <class P>
1837: template <class P>
1858: template <class T>
91: // Defines constants and accessor classes to assemble, disassemble and
1681: // TODO(plind): find all usages and remove the needless instructions for n64.
github.com/v8/v8:src/mips64/constants-mips64.h:[master, ]
605:   CLASS_S = ((3U << 3) + 3),
631:   CLASS_D = ((3U << 3) + 3),
798:   FCLASS = (0U << 17),
171: class Registers {
193: class FPURegisters {
212: class MSARegisters {
378:   COP1 = ((2U << 3) + 1) << kOpcodeShift,  // Coprocessor 1 class.
1154: enum class MaxMinKind : int { kMin = 0, kMax = 1 };
1205: class InstructionBase {
1380: template <class T>
1381: class InstructionGetters : public T {
1658: class Instruction : public InstructionGetters<InstructionBase> {
1662:   // to allocate or create instances of class Instruction.
1669:   // We need to prevent the creation of instances of class Instruction.
1807: template <class P>
1837: template <class P>
1858: template <class T>
91: // Defines constants and accessor classes to assemble, disassemble and
1681: // TODO(plind): find all usages and remove the needless instructions for n64.
android.googlesource.com/platform/external/c-ares:adig.c:[master, ]
800: static const char *class_name(int dnsclass)
118: static const struct nv classes[] = {
124: static const int nclasses = sizeof(classes) / sizeof(classes[0]);
191: static const char *class_name(int dnsclass);
302:           /* Set the query class. */
526:   /* Parse the question type and class. */
528:   dnsclass = DNS_QUESTION_CLASS(aptr);
536:     printf("\t%s", class_name(dnsclass));
572:   dnsclass = DNS_RR_CLASS(aptr);
582:   /* Display the RR name, class, and type. */
585:     printf("\t%s", class_name(dnsclass));
814:   fprintf(stderr, "usage: adig [-f flag] [-s server] [-c class] "
200:   int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A;
297:            * ares_init_options() will do needless work. */
305:               if (strcasecmp(classes[i].name, optarg) == 0)
309:             dnsclass = classes[i].value;
376:     ares_query(channel, *argv, dnsclass, type, callback, (char *) NULL);
380:         ares_query(channel, *argv, dnsclass, type, callback, *argv);
508:   int type, dnsclass, status;
535:   if (dnsclass != C_IN)
546:   int type, dnsclass, ttl, dlen, status;
584:   if (dnsclass != C_IN)
806:       if (classes[i].value == dnsclass)
807:         return classes[i].name;
303:           for (i = 0; i < nclasses; i++)
308:           if (i < nclasses)
804:   for (i = 0; i < nclasses; i++)
github.com/vanadium/travel:browser/mocks/google-maps.js:[master, ]
32:   SPACE_NEEDLE: {
6: var defineClass = require('../src/util/define-class');
62: var ControlPanel = defineClass({
75: var DirectionsRenderer = defineClass({
82: var DirectionsService = defineClass({
101: var Geocoder = defineClass({
125: var InfoWindow = defineClass({
140: var LatLng = defineClass({
160: var LatLngBounds = defineClass({
170: var Map = defineClass({
222: var Marker = defineClass({
278: var PlacesService = defineClass({
295: var SearchBox = defineClass({
github.com/fuchsia-mirror/third_party-binutils-gdb:sim/common/sim-fpu.h:[master, ]
89: } sim_fpu_class;
83:   sim_fpu_class_zero,
84:   sim_fpu_class_snan,
85:   sim_fpu_class_qnan,
86:   sim_fpu_class_number,
87:   sim_fpu_class_denorm,
88:   sim_fpu_class_infinity,
92:   sim_fpu_class class;
346: /* General number class and comparison operators.
46:    Needless to say the results, while better than for a packed 64 bit
297: /* Specific number classes.
github.com/fuchsia-mirror/third_party-gdb:sim/common/sim-fpu.h:[master, ]
89: } sim_fpu_class;
83:   sim_fpu_class_zero,
84:   sim_fpu_class_snan,
85:   sim_fpu_class_qnan,
86:   sim_fpu_class_number,
87:   sim_fpu_class_denorm,
88:   sim_fpu_class_infinity,
92:   sim_fpu_class class;
346: /* General number class and comparison operators.
46:    Needless to say the results, while better than for a packed 64 bit
297: /* Specific number classes.
github.com/google/gdata-objectivec-client:Source/BaseClasses/GDataServiceBase.m:[master, ]
78: @interface GDataUploadFetcherClass : GTMBridgeFetcher
160: + (Class)ticketClass {
161:   return [GDataServiceTicketBase class];
191:     NSUInteger chunkSize = [[self class] defaultServiceUploadChunkSize];
231:     userAgent = [[self class] defaultApplicationIdentifier];
246:     NSString *systemString = [[self class] systemVersionString];
380:                                    objectClass:(Class)objectClass
414:     ticket = [[[self class] ticketClass] ticketForService:self];
521:         // us, so this service class wouldn't ever need to have the plain XML.
572:     // prepend the class name prefix
573:     Class uploadClass = NSClassFromString(@GDATA_TARGET_NAMESPACE_STRING
576:     Class uploadClass = NSClassFromString(GDataUploadFetcherClassStr);
873:   Class objectClass = (Class)[fetcher propertyForKey:kFetcherObjectClassKey];
889:     // see if the top-level class for the XML is listed in the surrogates;
890:     // if so, instantiate the surrogate class instead
892:     Class baseSurrogate = (Class)[surrogates objectForKey:objectClass];
905:                                  && [objectClass isSubclassOfClass:[GDataFeedBase class]]);
997:         && [object isKindOfClass:[GDataFeedBase class]]) {
1047:                 NSStringFromClass([accumulatedFeed class]),
1057:       [[self class] invokeCallback:finishedSelector
1079:       [[self class] invokeCallback:finishedSelector
1132:     [[self class] invokeCallback:finishedSelector
1321:                                objectClass:[[ticket accumulatedFeed] class]
1375:                                          feedClass:(Class)feedClass
1392:                                          entryClass:(Class)entryClass
1409:                                            feedClass:(Class)feedClass
1440:                         objectClass:[batchFeed class]
1472:                                          feedClass:(Class)feedClass
1488:                                            feedClass:(Class)feedClass
1496:                                          entryClass:(Class)entryClass
1526: // if they are using an instance of the base class directly.
1536:   NSString *str = [[self class] defaultServiceVersion];
1903:   NSBundle *bundle = [[self class] owningBundle];
1965:     [self class], self, service_, currentFetcher_, userData_];
37: static NSString* const kFetcherObjectClassKey          = @"_objectClass";
563:     GDataUploadFetcherClass *uploadFetcher;
578:     GDATA_ASSERT(uploadClass != nil, GDataUploadFetcherClassStr @" needed");
586:       uploadFetcher = [uploadClass uploadFetcherWithLocation:uploadLocationURL
592:       uploadFetcher = [uploadClass uploadFetcherWithRequest:request
604:       uploadFetcher = [uploadClass uploadFetcherWithRequest:request
610:       uploadFetcher = [uploadClass uploadFetcherWithLocation:uploadLocationURL
616:       uploadFetcher = [uploadClass uploadFetcherWithRequest:request
659:   [fetcher setProperty:objectClass forKey:kFetcherObjectClassKey];
885:     if (!objectClass) {
886:       objectClass = [GDataObject objectClassForXMLElement:root];
894:       objectClass = baseSurrogate;
907:     object = [[objectClass alloc] initWithXMLElement:root
927:     NSLog(@"allocation of %@ took %f seconds", objectClass, secs2 - secs1);
1380:                       objectClass:feedClass
1397:                       objectClass:entryClass
1414:                             feedClass:feedClass
1476:                       objectClass:feedClass
1491:                             feedClass:feedClass
1499:                       objectClass:entryClass
1890:   NSBundle *bundle = [NSBundle bundleForClass:self];
1973:     [(GDataUploadFetcherClass *)objectFetcher_ pauseFetching];
1982:     [(GDataUploadFetcherClass *)objectFetcher_ resumeFetching];
1991:     return [(GDataUploadFetcherClass *)objectFetcher_ isPaused];
2250:     // a new, parentless copy of the entry for us, but that would be a needless
261:   // subclasses may add headers to this
574:                                           @"_" GDataUploadFetcherClassStr);
1524: // Subclasses typically implement defaultServiceVersion to specify the expected
1805:   // subclasses may override
github.com/google/error-prone:check_api/src/test/java/com/google/errorprone/names/NeedlemanWunschEditDistanceTest.java:[master, ]
27: public class NeedlemanWunschEditDistanceTest {
30:   public void needlemanWunschEditDistance_returnsZero_withIdenticalNames() {
41:   public void needlemanWunschEditDistance_matchesLevenschtein_withHugeGapCost() {
54:   public void needlemanWunschEditDistanceWorstCase_matchesLevenschtein_withHugeGapCost() {
26: @RunWith(JUnit4.class)
25: /** Tests for NeedlemanWunschEditDistance */
34:         NeedlemanWunschEditDistance.getEditDistance(
46:     double needlemanWunsch =
47:         NeedlemanWunschEditDistance.getEditDistance(
50:     assertThat(needlemanWunsch).isEqualTo(levenschtein);
61:     double needlemanWunsch =
62:         NeedlemanWunschEditDistance.getWorstCaseEditDistance(
65:     assertThat(needlemanWunsch).isEqualTo(levenschtein);