Found 41743 results in 8732 files, showing top 50 files (show more).
github.com/PolymerLabs/arcs-live:concrete-storage/node_modules/grpc/node_modules/needle/lib/needle.js: [ master, ]
150: function Needle(method, uri, data, options, callback) {
2: // Needle -- HTTP Client for Node.js
13:     debug       = require('debug')('needle'),
26: var user_agent  = 'Needle/' + version;
39: // these are the status codes that Needle interprets as redirects.
151:   // if (!(this instanceof Needle)) {
152:   //   return new Needle(method, uri, data, options, callback);
172: Needle.prototype.setup = function(uri, options) {
283: Needle.prototype.start = function() {
378: Needle.prototype.get_request_opts = function(method, uri, config) {
404: Needle.prototype.should_follow = function(location, config, original) {
426: Needle.prototype.send_request = function(count, method, uri, config, post_data, out, callback) {
785:     return new Needle(method, uri, null, options, callback).start();
791:     return new Needle(method, uri, data, options, callback).start();
796:   return new Needle(method, uri, data, opts, callback).start();
68:   boundary                : '--------------------NODENEEDLEHTTPCLIENT',
github.com/kubernetes/minikube:site/package-lock.json: [ master, ]
1127:             "needle": "^2.2.1",
1108:         "needle": {
github.com/kubernetes/minikube:site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
1079:         "needle": {
github.com/apache/beam:website/www/site/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
1079:         "needle": {
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-planes/combined.js: [ master, ]
5051:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
5102:     'needle', 'halo', 'noodles', 'neutron', 'nose'
13797:     'intro-finale/items-needle-thread',
13798:     'intro-finale/items-needle',
15100:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
15101:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
github.com/html5rocks/www.html5rocks.com:static/demos/lemdoodle/examples/lem-embedded/combined.js: [ master, ]
5024:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
5075:     'needle', 'halo', 'noodles', 'neutron', 'nose'
13843:             nItems = ['needle', 'noodles'];
15362:     'intro-finale/items-needle-thread',
15363:     'intro-finale/items-needle',
16665:   'intro-finale/items-needle-thread': { width: 68, height: 65, x: 834, y: 0 },
16666:   'intro-finale/items-needle': { top: 8, width: 59, height: 51, x: 904, y: 0 },
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/paymentservice/package-lock.json: [ master, ]
1058:             "needle": "^2.2.0",
1043:         "needle": {
github.com/GoogleCloudPlatform/training-data-analyst:blogs/microservices-demo-1/src/currencyservice/package-lock.json: [ master, ]
1036:             "needle": "^2.2.0",
1021:         "needle": {
github.com/kubernetes/website:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/llvm-mirror/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
727:   const DeclRefExpr *Needle;
723: /// a particular declaration (the needle) within any evaluated component of an
732:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
733:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
744:     if (E == Needle)
android.googlesource.com/platform/external/rust/crates/memchr:src/iter.rs: [ master, ]
35:     needle: u8,
73:     needle1: u8,
74:     needle2: u8,
120:     needle1: u8,
121:     needle2: u8,
122:     needle3: u8,
43:     /// Creates a new iterator that yields all positions of needle in haystack.
45:     pub fn new(needle: u8, haystack: &[u8]) -> Memchr {
46:         Memchr { needle: needle, haystack: haystack, position: 0 }
55:         iter_next!(self, memchr(self.needle, self.haystack))
67:         iter_next_back!(self, memrchr(self.needle, self.haystack))
82:     /// Creates a new iterator that yields all positions of needle in haystack.
84:     pub fn new(needle1: u8, needle2: u8, haystack: &[u8]) -> Memchr2 {
86:             needle1: needle1,
87:             needle2: needle2,
99:         iter_next!(self, memchr2(self.needle1, self.needle2, self.haystack))
113:             memrchr2(self.needle1, self.needle2, self.haystack)
133:         needle1: u8,
134:         needle2: u8,
135:         needle3: u8,
139:             needle1: needle1,
140:             needle2: needle2,
141:             needle3: needle3,
155:             memchr3(self.needle1, self.needle2, self.needle3, self.haystack)
170:             memrchr3(self.needle1, self.needle2, self.needle3, self.haystack)
gerrit.googlesource.com/plugins/image-diff:package-lock.json: [ master, ]
1435:                 "needle": "^2.2.1",
1410:         "needle": {
1412:             "resolved": "https://registry.npmjs.org/needle/-/needle-2.5.0.tgz",
android.googlesource.com/platform/external/rust/crates/bstr:src/ext_slice.rs: [ master, ]
3020:     pub fn needle(&self) -> &[u8] {
3105:     pub fn needle(&self) -> &[u8] {
3214:     fn needle(&self) -> &[u8] {
599:     /// Returns true if and only if this byte string contains the given needle.
613:     fn contains_str<B: AsRef<[u8]>>(&self, needle: B) -> bool {
614:         self.find(needle).is_some()
653:     /// Returns the index of the first occurrence of the given needle.
655:     /// The needle may be any type that can be cheaply converted into a
658:     /// Note that if you're are searching for the same needle in many
665:     /// with respect to both the needle and the haystack. That is, this runs
666:     /// in `O(needle.len() + haystack.len())` time.
684:     fn find<B: AsRef<[u8]>>(&self, needle: B) -> Option<usize> {
685:         Finder::new(needle.as_ref()).find(self.as_bytes())
688:     /// Returns the index of the last occurrence of the given needle.
690:     /// The needle may be any type that can be cheaply converted into a
693:     /// Note that if you're are searching for the same needle in many
701:     /// with respect to both the needle and the haystack. That is, this runs
702:     /// in `O(needle.len() + haystack.len())` time.
721:     fn rfind<B: AsRef<[u8]>>(&self, needle: B) -> Option<usize> {
722:         FinderReverse::new(needle.as_ref()).rfind(self.as_bytes())
726:     /// needle. The iterator yields byte offset positions indicating the start
732:     /// with respect to both the needle and the haystack. That is, this runs
733:     /// in `O(needle.len() + haystack.len())` time.
765:         needle: &'a B,
767:         Find::new(self.as_bytes(), needle.as_ref())
771:     /// needle in reverse. The iterator yields byte offset positions indicating
777:     /// with respect to both the needle and the haystack. That is, this runs
778:     /// in `O(needle.len() + haystack.len())` time.
810:         needle: &'a B,
812:         FindReverse::new(self.as_bytes(), needle.as_ref())
1300:     /// The needle may be any type that can be cheaply converted into a
1345:     /// The needle may be any type that can be cheaply converted into a
1386:     /// Replace all matches of the given needle with the given replacement, and
1412:     /// When the needle is an empty string:
1424:         needle: N,
1428:         self.replace_into(needle, replacement, &mut dest);
1432:     /// Replace up to `limit` matches of the given needle with the given
1458:     /// When the needle is an empty string:
1470:         needle: N,
1475:         self.replacen_into(needle, replacement, limit, &mut dest);
1479:     /// Replace all matches of the given needle with the given replacement,
1513:     /// When the needle is an empty string:
1528:         needle: N,
1532:         let (needle, replacement) = (needle.as_ref(), replacement.as_ref());
1535:         for start in self.find_iter(needle) {
1538:             last = start + needle.len();
1543:     /// Replace up to `limit` matches of the given needle with the given
1577:     /// When the needle is an empty string:
1592:         needle: N,
1597:         let (needle, replacement) = (needle.as_ref(), replacement.as_ref());
1600:         for start in self.find_iter(needle).take(limit) {
1603:             last = start + needle.len();
2972: /// A single substring searcher fixed to a particular needle.
2977: /// concern when it's necessary to re-use the same needle to search multiple
2987: /// lifetime of its needle.
2994:     /// Create a new finder for the given needle.
2996:     pub fn new<B: ?Sized + AsRef<[u8]>>(needle: &'a B) -> Finder<'a> {
2997:         Finder { searcher: TwoWay::forward(needle.as_ref()) }
3001:     /// borrows the needle.
3004:     /// this copies the needle.
3013:     /// Returns the needle that this finder searches for.
3015:     /// Note that the lifetime of the needle returned is tied to the lifetime
3017:     /// finder's needle can be either borrowed or owned, so the lifetime of the
3018:     /// needle returned must necessarily be the shorter of the two.
3021:         self.searcher.needle()
3024:     /// Returns the index of the first occurrence of this needle in the given
3033:     /// with respect to both the needle and the haystack. That is, this runs
3034:     /// in `O(needle.len() + haystack.len())` time.
3057: /// A single substring reverse searcher fixed to a particular needle.
3062: /// concern when it's necessary to re-use the same needle to search multiple
3072: /// the lifetime of its needle.
3079:     /// Create a new reverse finder for the given needle.
3081:     pub fn new<B: ?Sized + AsRef<[u8]>>(needle: &'a B) -> FinderReverse<'a> {
3082:         FinderReverse { searcher: TwoWay::reverse(needle.as_ref()) }
3086:     /// borrows the needle.
3089:     /// this copies the needle.
3098:     /// Returns the needle that this finder searches for.
3100:     /// Note that the lifetime of the needle returned is tied to the lifetime
3102:     /// a finder's needle can be either borrowed or owned, so the lifetime of
3103:     /// the needle returned must necessarily be the shorter of the two.
3106:         self.searcher.needle()
3109:     /// Returns the index of the last occurrence of this needle in the given
3118:     /// with respect to both the needle and the haystack. That is, this runs
3119:     /// in `O(needle.len() + haystack.len())` time.
3157:     fn new(haystack: &'a [u8], needle: &'a [u8]) -> Find<'a> {
3158:         let searcher = TwoWay::forward(needle);
3179:                 self.pos = pos + cmp::max(1, self.searcher.needle().len());
3197:     /// When searching with an empty needle, this gets set to `None` after
3203:     fn new(haystack: &'a [u8], needle: &'a [u8]) -> FindReverse<'a> {
3204:         let searcher = TwoWay::reverse(needle);
3215:         self.searcher.needle()
3401:                 self.last = start + self.finder.searcher.needle().len();
3456:                 let nlen = self.finder.needle().len();
github.com/ampproject/amp.dev:pixi/cloud-function/package-lock.json: [ future, ]
1051: 				"needle": "bin/needle"
1249: 				"needle": "^2.5.2",
2538: 				"needle": "^2.5.2",
1041: 		"node_modules/needle": {
1043: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.6.0.tgz",
1057: 		"node_modules/needle/node_modules/debug": {
2390: 		"needle": {
2392: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.6.0.tgz",
github.com/apache/trafficcontrol:traffic_portal/app/src/package-lock.json: [ master, ]
1251:                         "needle": "^2.2.1",
1234:                 "needle": {
chromium.googlesource.com/native_client/nacl-llvm-project-v10:clang/lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
727:   const DeclRefExpr *Needle;
723: /// a particular declaration (the needle) within any evaluated component of an
732:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
733:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
744:     if (E == Needle)
android.googlesource.com/platform/external/clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
591:   const DeclRefExpr *Needle;
587: /// a particular declaration (the needle) within any evaluated component of an
596:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
597:     : Inherited(Context), FoundReference(false), Needle(Needle) {}
608:     if (E == Needle)
chromium.googlesource.com/native_client/pnacl-clang:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
579:   const DeclRefExpr *Needle;
575: /// a particular declaration (the needle) within any evaluated component of an
582:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
584:       FoundReference(false), Needle(Needle) {}
595:     if (E == Needle)
github.com/google/myanmar-tools:clients/js/package-lock.json: [ master, ]
1881:             "needle": "^2.2.1",
1860:         "needle": {
1862:           "resolved": "https://registry.npmjs.org/needle/-/needle-2.3.0.tgz",
android.googlesource.com/platform/external/clang_35a:lib/Sema/AnalysisBasedWarnings.cpp: [ master, ]
577:   const DeclRefExpr *Needle;
573: /// a particular declaration (the needle) within any evaluated component of an
580:   ContainsReference(ASTContext &Context, const DeclRefExpr *Needle)
582:       FoundReference(false), Needle(Needle) {}
593:     if (E == Needle)
github.com/bazelbuild/rules_nodejs:tools/fine_grained_deps_npm/package-lock.json: [ master, ]
768:             "needle": "^2.2.0",
751:         "needle": {
github.com/googlei18n/myanmar-tools:clients/js/package-lock.json: [ master, ] Duplicate result
github.com/google/kf:docs/kf.dev/themes/docsy/userguide/package-lock.json: [ master, ]
1098:             "needle": "^2.2.1",
1079:         "needle": {
chromium.googlesource.com/chromium:sync/syncable/directory.h: [ trunk, ]
536:     EntryKernel needle;
535:     // look something up in an index.  Needle in haystack metaphor.
chromium.googlesource.com/git/chromium:sync/syncable/directory.h: [ trunk, ] Duplicate result
github.com/apache/hawq:src/backend/optimizer/util/clauses.c: [ master, ]
4526: 	Expr *needle;	/* This is the expression being searched */
4530:  * expression_matching_walker checks if the expression 'needle' in context is a sub-expression of hayStack.
4536: 	Assert(ctx->needle);
4543: 	if (equal(ctx->needle, hayStack))
4558: 	ctx.needle = expr1;
github.com/GoogleCloudPlatform/cloud-ops-sandbox:website/themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/html5rocks/www.html5rocks.com:content/tutorials/doodles/lem/static/code/lem-const.js: [ master, ]
185:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],
236:     'needle', 'halo', 'noodles', 'neutron', 'nose'
chromium.googlesource.com/devtools/devtools-frontend:node_modules/mocha/package.json: [ master, ]
131:     "needle": "^2.5.0",
github.com/google/llvm-propeller:clang/lib/Sema/AnalysisBasedWarnings.cpp: [ plo-dev, ] Duplicate result
github.com/google/rekall:rekall-core/rekall/scan.py: [ master, ]
170:     needle = None
171:     needle_offset = None
540:     needles = []
59:         """Is the needle found at 'offset'?
63:             checked for the needle.
173:     def __init__(self, needle=None, needle_offset=0, **kwargs):
175:         self.needle = needle
176:         self.needle_offset = needle_offset
180:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
181:         if buffer_as.data.startswith(self.needle, buffer_offset):
182:             return self.needle
185:         # Search the rest of the buffer for the needle.
186:         buffer_offset = buffer_as.get_buffer_offset(offset) + self.needle_offset
187:         dindex = buffer_as.data.find(self.needle, buffer_offset + 1)
532:             yield ("StringCheck", dict(needle=expected_bytes,
533:                                        needle_offset=rel_offset + array_offset))
553:                 needle=self.needles[0])
96:     def __init__(self, needles=None, **kwargs):
100:           needles: A list of strings we search for.
103:           RuntimeError: No needles provided.
109:         if not needles:
110:             raise RuntimeError("No needles provided to search.")
114:         if max([len(x) for x in needles]) > 50:
118:         # sure all the needles are bytes too.
119:         byte_needles = [utils.SmartStr(x) for x in needles]
120:         tree = acora.AcoraBuilder(*byte_needles)
539:     # Override with the needles to check for.
542:     def __init__(self, needles=None, **kwargs):
544:         if needles is not None:
545:             self.needles = needles
550:         if len(needles) == 1:
557:                 needles=self.needles)
587:         self.needles = []
595:             self.needles.append(tmp.obj_vm.read(0, tmp.obj_size))
597:         # The common string between all the needles.
599:             ("MultiStringFinderCheck", dict(needles=self.needles)),
github.com/kubernetes/contributor-site:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/apache/sling-whiteboard:serverless-microsling/package-lock.json: [ master, ]
992:         "needle": "^2.1.0"
901:     "needle": {
903:       "resolved": "https://registry.npmjs.org/needle/-/needle-2.4.0.tgz",
github.com/google/virtual-authenticators-tab:package-lock.json: [ master, ]
1694:             "needle": "^2.2.1",
1675:         "needle": {
github.com/google/cyanobyte:docs/themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/google/streetview-publish-client-libraries:client_libraries/nodejs_library/package-lock.json: [ master, ]
1140:             "needle": "^2.2.1",
1125:         "needle": {
github.com/yeoman/generator-angular:route/index.js: [ master, ]
63:     needle: '.otherwise',
github.com/google/gvisor-website:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/apache/openwhisk-client-js:package.json: [ master, ]
53:     "needle": "^2.4.0"
android.googlesource.com/platform/external/rust/crates/bstr:src/search/twoway.rs: [ master, ]
33:     needle: CowBytes<'b>,
118:     pub fn needle(&self) -> &[u8] {
12: /// `n ~ len(needle)` and `m ~ len(haystack)`.
18: /// bytes that are believed to be rare in the needle and use fast vectorized
32:     /// The needle that we're looking for.
37:     /// A critical position in needle. Specifically, this position corresponds
38:     /// to beginning of either the minimal or maximal suffix in needle. (N.B.
54:     pub fn forward(needle: &'b [u8]) -> TwoWay<'b> {
55:         let freqy = Freqy::forward(needle);
56:         if needle.is_empty() {
58:                 needle: CowBytes::new(needle),
65:         let min_suffix = Suffix::forward(needle, SuffixKind::Minimal);
66:         let max_suffix = Suffix::forward(needle, SuffixKind::Maximal);
73:         let shift = Shift::forward(needle, period_lower_bound, critical_pos);
74:         let needle = CowBytes::new(needle);
75:         TwoWay { needle, freqy, critical_pos, shift }
80:     pub fn reverse(needle: &'b [u8]) -> TwoWay<'b> {
81:         let freqy = Freqy::reverse(needle);
82:         if needle.is_empty() {
84:                 needle: CowBytes::new(needle),
91:         let min_suffix = Suffix::reverse(needle, SuffixKind::Minimal);
92:         let max_suffix = Suffix::reverse(needle, SuffixKind::Maximal);
99:         let shift = Shift::reverse(needle, period_lower_bound, critical_pos);
100:         let needle = CowBytes::new(needle);
101:         TwoWay { needle, freqy, critical_pos, shift }
117:     /// Return the needle used by this searcher.
119:         self.needle.as_slice()
122:     /// Convert this searched into an owned version, where the needle is
127:             needle: self.needle.into_owned(),
134:     /// Find the position of the first occurrence of this searcher's needle in
143:     /// Find the position of the last occurrence of this searcher's needle
152:     /// Find the position of the first occurrence of this searcher's needle in
162:         if self.needle.is_empty() {
164:         } else if haystack.len() < self.needle.len() {
166:         } else if self.needle.len() == 1 {
167:             return haystack.find_byte(self.needle[0]);
179:     /// Find the position of the last occurrence of this searcher's needle
189:         if self.needle.is_empty() {
191:         } else if haystack.len() < self.needle.len() {
193:         } else if self.needle.len() == 1 {
194:             return haystack.rfind_byte(self.needle[0]);
239:         let needle = self.needle.as_slice();
242:         while pos + needle.len() <= haystack.len() {
251:                         if pos + needle.len() > haystack.len() {
257:             while i < needle.len() && needle[i] == haystack[pos + i] {
260:             if i < needle.len() {
265:                 while j > shift && needle[j] == haystack[pos + j] {
268:                 if j <= shift && needle[shift] == haystack[pos + shift] {
272:                 shift = needle.len() - period;
300:         let needle = self.needle.as_slice();
302:         while pos + needle.len() <= haystack.len() {
309:                         if pos + needle.len() > haystack.len() {
315:             while i < needle.len() && needle[i] == haystack[pos + i] {
318:             if i < needle.len() {
322:                 while j > 0 && needle[j] == haystack[pos + j] {
325:                 if j == 0 && needle[0] == haystack[pos] {
356:         let needle = &*self.needle;
357:         let nlen = needle.len();
375:             while i > 0 && needle[i - 1] == haystack[pos - nlen + i - 1] {
378:             if i > 0 || needle[0] != haystack[pos - nlen] {
383:                 while j < shift && needle[j] == haystack[pos - nlen + j] {
418:         let needle = &*self.needle;
419:         let nlen = needle.len();
435:             while i > 0 && needle[i - 1] == haystack[pos - nlen + i - 1] {
438:             if i > 0 || needle[0] != haystack[pos - nlen] {
442:                 while j < nlen && needle[j] == haystack[pos - nlen + j] {
458: /// When computing a critical factorization of the needle, we find the position
459: /// of the critical factorization by finding the needle's maximal (or minimal)
461: /// of that suffix is a lower bound on the period of the needle itself.
463: /// This lower bound is equivalent to the actual period of the needle in
464: /// some cases. To describe that case, we denote the needle as `x` where
473: /// equivalent, we know that the period of the needle is no less than half its
475: /// period of the needle (determined by the maximum length of the components
492:     /// Compute the shift for a given needle in the forward direction.
499:         needle: &[u8],
503:         let large = cmp::max(critical_pos, needle.len() - critical_pos);
504:         if critical_pos * 2 >= needle.len() {
508:         let (u, v) = needle.split_at(critical_pos);
515:     /// Compute the shift for a given needle in the reverse direction.
522:         needle: &[u8],
526:         let large = cmp::max(critical_pos, needle.len() - critical_pos);
527:         if (needle.len() - critical_pos) * 2 >= needle.len() {
531:         let (v, u) = needle.split_at(critical_pos);
539: /// A suffix extracted from a needle along with its period.
558:     fn forward(needle: &[u8], kind: SuffixKind) -> Suffix {
559:         debug_assert!(!needle.is_empty());
564:         // The start of a suffix in `needle` that we are considering as a
581:         while candidate_start + offset < needle.len() {
582:             let current = needle[suffix.pos + offset];
583:             let candidate = needle[candidate_start + offset];
608:     fn reverse(needle: &[u8], kind: SuffixKind) -> Suffix {
609:         debug_assert!(!needle.is_empty());
612:         let mut suffix = Suffix { pos: needle.len(), period: 1 };
613:         if needle.len() == 1 {
616:         let mut candidate_start = needle.len() - 1;
620:             let current = needle[suffix.pos - offset - 1];
621:             let candidate = needle[candidate_start - offset - 1];
710:     fn get_suffix_forward(needle: &[u8], kind: SuffixKind) -> (&[u8], usize) {
711:         let s = Suffix::forward(needle, kind);
712:         (&needle[s.pos..], s.period)
716:     fn get_suffix_reverse(needle: &[u8], kind: SuffixKind) -> (&[u8], usize) {
717:         let s = Suffix::reverse(needle, kind);
718:         (&needle[..s.pos], s.period)
727:     fn naive_maximal_suffix_forward(needle: &[u8]) -> &[u8] {
728:         let mut sufs = suffixes(needle);
735:     fn naive_maximal_suffix_reverse(needle: &[u8]) -> Vec<u8> {
736:         let mut reversed = needle.to_vec();
github.com/grpc/grpc.io:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/GNOME/libdazzle:src/search/dzl-fuzzy-index-cursor.c: [ mainline, ]
65:   const gchar                     *needle;
408:   lookup.needle = query;
github.com/google/docsy-example:themes/docsy/userguide/package-lock.json: [ master, ] Duplicate result
github.com/googlesamples/functions-as-a-service:package-lock.json: [ master, ]
1274:             "needle": "^2.2.1",
1255:         "needle": {
github.com/GoogleChrome/chrome-extensions-samples:apps/samples/text-editor/lib/ace/search.js: [ master, ]
49:         needle: "",
74:         if (!this.$options.needle)
94:         if (!options.needle)
204:             var needle = this.$options.needle;
206:             needle = lang.escapeRegExp(this.$options.needle);
210:             needle = "\\b" + needle + "\\b";
218:         var re = new RegExp(needle, modifier);
github.com/GoogleChrome/chrome-app-samples:apps/samples/text-editor/lib/ace/search.js: [ master, ] Duplicate result
android.googlesource.com/platform/external/libwebsockets:include/libwebsockets/lws-fts.h: [ master, ]
168: 	const char *needle;
github.com/GNOME/gnome-notes:src/bjb-controller.c: [ mainline, ]
47:   gchar          *needle;
68:   PROP_NEEDLE,
526: bjb_controller_apply_needle (BjbController *self)
777: bjb_controller_set_needle (BjbController *self, const gchar *needle )
787: bjb_controller_get_needle (BjbController *self)
556: on_needle_changed (BjbController *self)
45:   /* needle, notebook and group define what the controller shows */
122:   g_free (self->needle);
147:   case PROP_NEEDLE:
148:     g_value_set_string (value, self->needle);
175:   case PROP_NEEDLE:
176:     self->needle = g_strdup (g_value_get_string (value));
193:   const gchar *needle = NULL;
196:       needle = biji_item_get_uuid (item);
209:     if (needle && g_strcmp0 (item_path, needle) == 0)
213:     else if (!needle && BIJI_IS_NOTE_OBJ (
308:   if (!self->needle || g_strcmp0 (self->needle, "") == 0)
323:     if (g_strrstr (title, self->needle) != NULL)
330:       if (g_strrstr (content, self->needle) != NULL)
529:   gchar *needle;
531:   needle = self->needle;
536:   if (needle == NULL || g_strcmp0 (needle,"") == 0)
552:   biji_get_items_matching_async (self->manager, self->group, needle, update_controller_callback, self);
558:   bjb_controller_apply_needle (self);
598:       bjb_controller_apply_needle (self);
648:     /* Apply the needle to display the relevant items.
656:       bjb_controller_apply_needle (self);
738:   properties[PROP_NEEDLE] = g_param_spec_string ("needle",
739:                                                  "Needle",
761:                     gchar         *needle)
766:               "needle", needle,
779:   if (self->needle)
780:     g_free (self->needle);
782:   self->needle = g_strdup (needle);
783:   on_needle_changed (self);
789:   if (!self->needle)
792:   return self->needle;
827:     bjb_controller_apply_needle (self);
834:   g_clear_pointer (&self->needle, g_free);
836:   self->needle = g_strdup ("");
871:       bjb_controller_apply_needle (self);
877:     bjb_controller_apply_needle (self);
894:     on_needle_changed (self);
github.com/GoogleChrome/chrome-extensions-samples:apps/samples/text-editor/lib/ace/mode/text.js: [ master, ]
135:             needle: needle
117:         var needle = line.substring(Math.max(startOuter, 0),
121:         if ((startOuter >= 0 && /^[\w\d]/.test(needle)) ||
122:             (endOuter <= lineCols && /[\w\d]$/.test(needle)))
125:         needle = line.substring(selection.start.column, selection.end.column);
126:         if (!/^[\w\d]+$/.test(needle))
github.com/GoogleChrome/chrome-app-samples:apps/samples/text-editor/lib/ace/mode/text.js: [ master, ] Duplicate result