1127:             "needle": "^2.2.1",

1108:         "needle": {

1098:             "needle": "^2.2.1",

1079:         "needle": {

1624:             "needle": "^2.2.1",

1605:         "needle": {

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 },

1560:             "needle": "^2.2.1",

1541:         "needle": {

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 },

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)

1251:                         "needle": "^2.2.1",

1234:                 "needle": {

1468:             "needle": "^2.2.1",

1449:         "needle": {

1376:             "needle": "^2.2.1",

1357:         "needle": {

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)

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)

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)

768:             "needle": "^2.2.0",

751:         "needle": {

172:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],

223:     'needle', 'halo', 'noodles', 'neutron', 'nose'

172:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],

223:     'needle', 'halo', 'noodles', 'neutron', 'nose'

185:   'needle': ['intro-finale/items-needle-thread', 'intro-finale/items-needle'],

236:     'needle', 'halo', 'noodles', 'neutron', 'nose'

1098:             "needle": "^2.2.1",

1079:         "needle": {

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)),

63:     needle: '.otherwise',

53:     "needle": "^2.4.0"

667:             "needle": "^2.2.1",

650:         "needle": {

652:           "resolved": "https://registry.npmjs.org/needle/-/needle-2.4.0.tgz",

65:   const gchar                     *needle;

408:   lookup.needle = query;

1088:             "needle": "^2.2.1",

1069:         "needle": {

1274:             "needle": "^2.2.1",

1255:         "needle": {

168: 	const char *needle;

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);

129:     const QString needle;

128:     inline KeywordHelper(const QString &word) : needle(word) {}

134:     return helper.needle < QLatin1String(kw);

139:     return QLatin1String(kw) < helper.needle;

26:     needle: 'Nietzsche'

31:     needle: 'Jules Verne'

36:     needle: 'Shakespeare'

40:     needle: 'TensorFlow.js Code (Compiled, 0.11.7)'

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);

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))

18: const needle = require('needle');

72:       needle.post(registrationEndpoint, body, { 'json': true, username: username, password: accessToken, user_ag...(50 bytes skipped)...

99:       needle.get(registrationEndpoint, { 'json': true, username: username, password: accessToken, user_agent: 'w...(43 bytes skipped)...

116:               needle.delete(body[i].url, null, { username: username, password: accessToken, user_agent: 'whisk' }, funct...(29 bytes skipped)...

30:   const char* needle;

76:       const char* needle_string = nullptr;

79:         auto needlepos = after_replacing_many->find(r.needle, pos);

82:           needle_string = r.needle;

87:       after_replacing_many->replace(next_pos, strlen(needle_string),

80:         if (needlepos != std::string::npos && needlepos < next_pos) {

81:           next_pos = needlepos;

79:    const gchar  *needle;

432:  * @needle: (in): The needle to fuzzy search for.

435:  * DzlFuzzyMutableIndex searches within @fuzzy for strings that fuzzy match @needle.

448:                                const gchar          *needle,

465:   g_return_val_if_fail (needle, NULL);

469:   if (!*needle)

474:       downcase = g_utf8_casefold (needle, -1);

475:       needle = downcase;

479:   lookup.n_tables = g_utf8_strlen (needle, -1);

482:   lookup.needle = needle;

486:   for (i = 0, tmp = needle; *tmp; tmp = g_utf8_next_char (tmp))

18: const needle = require('needle');

30:         // needle takes e.g. 'put' not 'PUT'

31:         needle.request(method.toLowerCase(), url, input, options, function(error, response, body) {

129:     const QString needle;

128:     inline KeywordHelper(const QString &word) : needle(word) {}

134:     return helper.needle < QLatin1String(kw);

139:     return QLatin1String(kw) < helper.needle;

1590:             "needle": "^2.2.1",

1573:         "needle": {

22: const needle = require('needle')

27:  * This implements a request-promise-like facade over the needle

28:  * library. There are two gaps between needle and rp that need to be

30:  * needle's non-excepting >=400 statusCode responses into exceptions

50:   // this situation than needle

53:   return needle(opts.method.toLowerCase(), // needle takes e.g. 'put' not 'PUT'

18: const needle = require('needle');

79:         needle.post(params.url, body, function (err, res, body) {

583:             "needle": "^2.2.1",

568:         "needle": {

30:   const char* needle;

76:       const char* needle_string = nullptr;

79:         auto needlepos = after_replacing_many->find(r.needle, pos);

82:           needle_string = r.needle;

87:       after_replacing_many->replace(next_pos, strlen(needle_string),

80:         if (needlepos != std::string::npos && needlepos < next_pos) {

81:           next_pos = needlepos;

53:   gchar             *needle;

124:   bjb_controller_set_needle (BJB_CONTROLLER (self->controller),

161:   /* Get the needle from controller */

162:   self->needle = bjb_controller_get_needle (self->controller);

164:   if (self->needle && g_strcmp0 (self->needle, "") != 0)

166:     gtk_entry_set_text (GTK_ENTRY (self->entry), self->needle);

39:     private String needle;

43:     public SQLProjectionFinder(TupleExpr expr, String needle) {

44:         this.needle = needle;

50:         if(node.getName().equals(needle)) {

59:             if(g.equals(needle)) {

68:         if(node.getName().equals(needle)) {

77:             if(elem.getSourceName().equals(needle)) {

551:             "needle": "^2.2.1",

536:         "needle": {

18: const needle = require('needle');

64:         needle.request('get', url, qs, { 'username': username, 'password': password, timeout: 30000 }, function (e...(23 bytes skipped)...

30:   const char* needle;

76:       const char* needle_string = nullptr;

79:         auto needlepos = after_replacing_many->find(r.needle, pos);

82:           needle_string = r.needle;

87:       after_replacing_many->replace(next_pos, strlen(needle_string),

80:         if (needlepos != std::string::npos && needlepos < next_pos) {

81:           next_pos = needlepos;

868:             "needle": "^2.2.0",

851:         "needle": {

1359:             "needle": "^2.2.0",

1340:         "needle": {

1199:             "needle": "^2.2.1",

1167:         "needle": {

67:   int* needle() const { return container_->value.get(); }

79:   // No check that the needle is initially not found as on some platforms it

82:     int* volatile tmp = scanner->needle();

92:   // No check that the needle is initially not found as on some platforms it

97:     int* volatile tmp = scanner->needle();

199:   void* needle = RecursivelyPassOnParameter(0, scanner->needle(), GetStack(),

201:   EXPECT_EQ(scanner->needle(), needle);

207:   void* needle = RecursivelyPassOnParameter(1, scanner->needle(), GetStack(),

209:   EXPECT_EQ(scanner->needle(), needle);

215:   void* needle = RecursivelyPassOnParameter(2, scanner->needle(), GetStack(),

217:   EXPECT_EQ(scanner->needle(), needle);

223:   void* needle = RecursivelyPassOnParameter(3, scanner->needle(), GetStack(),

225:   EXPECT_EQ(scanner->needle(), needle);

231:   void* needle = RecursivelyPassOnParameter(4, scanner->needle(), GetStack(),

233:   EXPECT_EQ(scanner->needle(), needle);

239:   void* needle = RecursivelyPassOnParameter(5, scanner->needle(), GetStack(),

241:   EXPECT_EQ(scanner->needle(), needle);

247:   void* needle = RecursivelyPassOnParameter(6, scanner->needle(), GetStack(),

249:   EXPECT_EQ(scanner->needle(), needle);

255:   void* needle = RecursivelyPassOnParameter(7, scanner->needle(), GetStack(),

257:   EXPECT_EQ(scanner->needle(), needle);

263:   void* needle = RecursivelyPassOnParameter(8, scanner->needle(), GetStack(),

265:   EXPECT_EQ(scanner->needle(), needle);

306:   // No check that the needle is initially not found as on some platforms it

319: // Moves |local_scanner->needle()| into a callee-saved register, leaving the

320: // callee-saved register as the only register referencing the needle.

325:   asm("mov %0, %%" reg : : "r"(local_scanner->needle()) : reg);          \

26: 	private final byte[] needle;

24: 	private final String needleString;

42: 		needle = new byte[b.length];

44: 			needle[i] = lc(b[i]);

58: 		final int needleLen = needle.length;

59: 		final byte first = needle[0];

76: 				if (neq(needle[j], text[si]))

39: 		needleString = patternText;

63: 		final int maxPos = rcs.endPtr - needleLen;

75: 			for (int j = 1; j < needleLen; j++, si++) {

98: 		return needleString;

161:     static String needle = "<miss>";

184:     static int indexOf_no_match_unknown_needle(String s, String needle) {

190:     static int indexOf_no_match_imm_needle(String s) {

196:     static int indexOf_no_match_imm2_needle(String s) {

202:     static int indexOf_no_match_imm1_needle(String s) {

221:     static String indexOf_reads_past_string_unknown_needle(String s, String needle) {

231:     static String indexOf_reads_past_string_imm_needle(String s) {

240:     static String indexOf_reads_past_string_imm2_needle(String s) {

249:     static String indexOf_reads_past_string_imm1_needle(String s) {

313:     static int indexOf_match_at_end_of_string_unknown_needle(String s, String needle) {

319:     static int indexOf_match_at_end_of_string_imm_needle(String s) {

325:     static int indexOf_match_at_end_of_string_imm2_needle(String s) {

331:     static int indexOf_match_at_end_of_string_imm1_needle(String s) {

438:     static String indexOf_match_spans_end_of_string_unknown_needle(String s, String needle) {

447:     static String indexOf_match_spans_end_of_string_imm_needle(String s) {

456:     static String indexOf_match_spans_end_of_string_imm2_needle(String s) {

481:     public static void test_indexOf_imm1_needle() {

498:     static int indexOf_imm1_needle(String s) {

512:     static int indexOf_imm1Latin1_needle(String s) {

517:     static int indexOf_imm1UTF16_needle(String s) {

522:     static int indexOf_immUTF16_needle(String s) {

71:     // - The needle is exactly at the end of the string.

72:     // - The needle spans the end of the string

75:     // - needle is first char

76:     // - needle is last char

80:     // We test all these for an unknown needle, and needles known to the compiler

165:         int res = indexOf_no_match_unknown_needle(ss[0], "<miss>");

166:         assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);

167:         res = indexOf_no_match_imm_needle(ss[0]);

168:         assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);

169:         res = indexOf_no_match_imm2_needle(ss[0]);

170:         assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);

173:         res = indexOf_no_match_unknown_needle(ss2[0], "<miss>");

174:         assertEquals(res, -1, "test_indexOf_no_match_unknown_needle matched at: " + res);

175:         res = indexOf_no_match_imm_needle(ss2[0]);

176:         assertEquals(res, -1, "test_indexOf_no_match_imm_needle matched at: " + res);

177:         res = indexOf_no_match_imm2_needle(ss2[0]);

178:         assertEquals(res, -1, "test_indexOf_no_match_imm2_needle matched at: " + res);

179:         res = indexOf_no_match_imm1_needle(ss2[0]);

180:         assertEquals(res, -1, "test_indexOf_no_match_imm1_needle matched at: " + res);

185:         int index = s.indexOf(needle);

210:         String res = indexOf_reads_past_string_unknown_needle(ss[0], "<hit>");

211:         assertEquals(res, null, "test_indexOf_reads_past_string_unknown_needle " + res);

212:         res = indexOf_reads_past_string_imm_needle(ss[0]);

213:         assertEquals(res, null, "test_indexOf_reads_past_string_imm_needle " + res);

214:         res = indexOf_reads_past_string_imm2_needle(ss[0]);

215:         assertEquals(res, null, "test_indexOf_reads_past_string_imm2_needle " + res);

216:         res = indexOf_reads_past_string_imm1_needle(ss[0]);

217:         assertEquals(res, null, "test_indexOf_reads_past_string_imm1_needle " + res);

222:         int index = s.indexOf(needle);

224:             return "Found needle \"" + needle + "\" behind string of length " + s.length()

234:             return "Found needle \"<hit>\" behind string of length " + s.length() + " at position " + index + ".";

243:             return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";

252:             return "Found needle \"<h\" behind string of length " + s.length() + " at position " + index + ".";

275:         res = indexOf_match_at_end_of_string_unknown_needle(text3, "<hit>");

277:         res = indexOf_match_at_end_of_string_unknown_needle(text4, "<hit>");

279:         res = indexOf_match_at_end_of_string_unknown_needle(text5, "<hit>");

281:         res = indexOf_match_at_end_of_string_unknown_needle(text6, "<hit>");

284:         res = indexOf_match_at_end_of_string_imm_needle(text3);

286:         res = indexOf_match_at_end_of_string_imm_needle(text4);

288:         res = indexOf_match_at_end_of_string_imm_needle(text5);

290:         res = indexOf_match_at_end_of_string_imm_needle(text6);

293:         res = indexOf_match_at_end_of_string_imm2_needle(text7);

295:         res = indexOf_match_at_end_of_string_imm2_needle(text8);

297:         res = indexOf_match_at_end_of_string_imm2_needle(text9);

299:         res = indexOf_match_at_end_of_string_imm2_needle(text10);

302:         res = indexOf_match_at_end_of_string_imm1_needle(text7);

304:         res = indexOf_match_at_end_of_string_imm1_needle(text8);

306:         res = indexOf_match_at_end_of_string_imm1_needle(text9);

308:         res = indexOf_match_at_end_of_string_imm1_needle(text10);

314:         int index = s.indexOf(needle);

361:         res = indexOf_match_spans_end_of_string_unknown_needle(s0_1, "<hit>");

362:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_1 " + res);

363:         res = indexOf_match_spans_end_of_string_unknown_needle(s0_2, "<hit>");

364:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_2 " + res);

365:         res = indexOf_match_spans_end_of_string_unknown_needle(s0_3, "<hit>");

366:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_3 " + res);

367:         res = indexOf_match_spans_end_of_string_unknown_needle(s0_4, "<hit>");

368:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s0_4 " + res);

369:         res = indexOf_match_spans_end_of_string_unknown_needle(s1_1, "<hit>");

370:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_1 " + res);

371:         res = indexOf_match_spans_end_of_string_unknown_needle(s1_2, "<hit>");

372:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_2 " + res);

373:         res = indexOf_match_spans_end_of_string_unknown_needle(s1_3, "<hit>");

374:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_3 " + res);

375:         res = indexOf_match_spans_end_of_string_unknown_needle(s1_4, "<hit>");

376:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s1_4 " + res);

377:         res = indexOf_match_spans_end_of_string_unknown_needle(s2_1, "<hit>");

378:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_1 " + res);

379:         res = indexOf_match_spans_end_of_string_unknown_needle(s2_2, "<hit>");

380:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_2 " + res);

381:         res = indexOf_match_spans_end_of_string_unknown_needle(s2_3, "<hit>");

382:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_3 " + res);

383:         res = indexOf_match_spans_end_of_string_unknown_needle(s2_4, "<hit>");

384:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s2_4 " + res);

385:         res = indexOf_match_spans_end_of_string_unknown_needle(s3_1, "<hit>");

386:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_1 " + res);

387:         res = indexOf_match_spans_end_of_string_unknown_needle(s3_2, "<hit>");

388:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_2 " + res);

389:         res = indexOf_match_spans_end_of_string_unknown_needle(s3_3, "<hit>");

390:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_3 " + res);

391:         res = indexOf_match_spans_end_of_string_unknown_needle(s3_4, "<hit>");

392:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_unknown_needle s3_4 " + res);

394:         res = indexOf_match_spans_end_of_string_imm_needle(s0_1);

395:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_1 " + res);

396:         res = indexOf_match_spans_end_of_string_imm_needle(s0_2);

397:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_2 " + res);

398:         res = indexOf_match_spans_end_of_string_imm_needle(s0_3);

399:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_3 " + res);

400:         res = indexOf_match_spans_end_of_string_imm_needle(s0_4);

401:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s0_4 " + res);

402:         res = indexOf_match_spans_end_of_string_imm_needle(s1_1);

403:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_1 " + res);

404:         res = indexOf_match_spans_end_of_string_imm_needle(s1_2);

405:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_2 " + res);

406:         res = indexOf_match_spans_end_of_string_imm_needle(s1_3);

407:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_3 " + res);

408:         res = indexOf_match_spans_end_of_string_imm_needle(s1_4);

409:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s1_4 " + res);

410:         res = indexOf_match_spans_end_of_string_imm_needle(s2_1);

411:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_1 " + res);

412:         res = indexOf_match_spans_end_of_string_imm_needle(s2_2);

413:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_2 " + res);

414:         res = indexOf_match_spans_end_of_string_imm_needle(s2_3);

415:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_3 " + res);

416:         res = indexOf_match_spans_end_of_string_imm_needle(s2_4);

417:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s2_4 " + res);

418:         res = indexOf_match_spans_end_of_string_imm_needle(s3_1);

419:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_1 " + res);

420:         res = indexOf_match_spans_end_of_string_imm_needle(s3_2);

421:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_2 " + res);

422:         res = indexOf_match_spans_end_of_string_imm_needle(s3_3);

423:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_3 " + res);

424:         res = indexOf_match_spans_end_of_string_imm_needle(s3_4);

425:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm_needle s3_4 " + res);

427:         res = indexOf_match_spans_end_of_string_imm2_needle(s0_1x);

428:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s0_1x " + res);

429:         res = indexOf_match_spans_end_of_string_imm2_needle(s1_1x);

430:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s1_1x " + res);

431:         res = indexOf_match_spans_end_of_string_imm2_needle(s2_1x);

432:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s2_1x " + res);

433:         res = indexOf_match_spans_end_of_string_imm2_needle(s3_1x);

434:         assertEquals(res, null, "test_indexOf_match_spans_end_of_string_imm2_needle s3_1x " + res);

439:         int index = s.indexOf(needle);

441:             return "Found needle \"" + needle + "\" that is spanning the end of the string: " + s + ".";

450:             return "Found needle \"<hit>\" that is spanning the end of the string: " + s + ".";

459:             return "Found needle \"<h\" that is spanning the end of the string: " + s + ".";

482:         assertEquals(     -1, indexOf_imm1_needle(text16), "test_indexOf_imm1_needle no_match");

484:         assertEquals(      0, indexOf_imm1_needle(text11), "test_indexOf_imm1_needle first_matches");

486:         assertEquals(len12-1, indexOf_imm1_needle(text12), "test_indexOf_imm1_needle last_matches");

487:         assertEquals(len13-1, indexOf_imm1_needle(text13), "test_indexOf_imm1_needle last_matches");

488:         assertEquals(len14-1, indexOf_imm1_needle(text14), "test_indexOf_imm1_needle last_matches");

489:         assertEquals(len15-1, indexOf_imm1_needle(text15), "test_indexOf_imm1_needle last_matches");

491:         assertEquals(     -1, indexOf_imm1_needle(text12_1), "test_indexOf_imm1_needle walked_past");

492:         assertEquals(     -1, indexOf_imm1_needle(text13_1), "test_indexOf_imm1_needle walked_past");

493:         assertEquals(     -1, indexOf_imm1_needle(text14_1), "test_indexOf_imm1_needle walked_past");

494:         assertEquals(     -1, indexOf_imm1_needle(text15_1), "test_indexOf_imm1_needle walked_past");

506:         assertEquals(      3, indexOf_imm1Latin1_needle(text1UTF16), "test_indexOf_immUTF16");

507:         assertEquals(      1, indexOf_imm1UTF16_needle(text1UTF16), "test_indexOf_immUTF16");

508:         assertEquals(      1, indexOf_immUTF16_needle(text1UTF16), "test_indexOf_immUTF16");

74:     // A special case are needles of length 1. For these we test:

7:     "needle": "2.3.2",

9: 	Needle string

13: func NewContains(needle string, not bool) Contains {

14: 	return Contains{needle, not}

18: 	return strings.Contains(s, self.Needle) != self.Not

24: 	idx := strings.Index(s, self.Needle)

31: 		offset = idx + len(self.Needle)

57: 	return fmt.Sprintf("<contains:%s[%s]>", not, self.Needle)

7:     "needle": "2.3.2"

29:         const needle = j * 2;

45:         const needle = j * 2 - 1;

64:     const needle = -1;

79:     const needle = 18;

94:     const needle = 1;

103:     const needle = 1;

20:   function comparator(item: number, needle: number): number {

21:     return item - needle;

30:         const index = binarySearch(array, needle, comparator);

34:         expect(array[index]).toEqual(needle);

46:         const index = binarySearch(array, needle, comparator);

53:           expect(array[negated - 1]).toBeLessThan(needle);

56:           expect(array[negated]).toBeGreaterThan(needle);

62:   test('needle is lower than all elements', () => {

68:       const index = binarySearch(array, needle, comparator);

73:       expect(array[negated]).toBeGreaterThan(needle);

77:   test('needle is higher than all elements', () => {

83:       const index = binarySearch(array, needle, comparator);

88:       expect(array[negated - 1]).toBeLessThan(needle);

95:     const index = binarySearch(array, needle, comparator);

108:       array.push(needle);

110:       const index = binarySearch(array, needle, comparator);

7: const needle = Array(1802).join(" +") + Array(16884).join("A");

10: assertEquals(string.search(needle), -1);

11: assertEquals(string.search(needle), -1);

578:                 "needle": "^2.2.1",

559:             "needle": {

1505:             "needle": "^2.2.0",

1486:         "needle": {

1437:             "needle": "^2.2.0",

1418:         "needle": {

96:     needle <- "--file="

97:     match <- grep(needle, cmdArgs)

99:       return(normalizePath(sub(needle, "", cmdArgs[match])))

139:             needle: "Mauris"

194:             needle: "consectetur"

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 ();  

2: #define NEEDLE_INSERTER3_HH

10: class Needle_inserter3 : public Deformation_hook,  public Element_watcher

12:   enum Needle_state {

19:   set<Element*> needle_elements_;

20:   map<Node*,Real> needle_node_radii_;

26:   Real needle_radius_;

23:   bool filter_needle_rotations_ ;

1: #ifndef NEEDLE_INSERTER3_HH

16:   Needle_state state_;

40:   void select_elements_around_needle (Element*, Vector3,Vector3);

42:   void update_needle_elements ();

45:   void accrue_needle_elements (Vector3, Vector3);    

47:   bool is_needle_element (Element*, Vector3 , Vector3, Real ) const;

50:   Auto_needle_inserter3 * auto_insert_;

51:   void auto_needle_insert ();

53:   void refine_around_needle_tip (Vector3, Vector3);

55:   Needle_inserter3 (Maubach_tree3*, Deformation_state*);

59:   void move_needle (Vector3,Vector3);

60:   set<Face*> get_needle_surface ();

64: extern float needle_color [];

30: Needle_inserter3::Needle_inserter3 (Maubach_tree3* tree,

63: Needle_inserter3::move_needle (Vector3 h, Vector3 t)

96: Needle_inserter3::get_needle_surface ()

481: Needle_inserter3::refine_around_needle_tip (Vector3 h, Vector3 t)

527: Needle_inserter3::is_needle_element (Element *e, Vector3 h, Vector3 t,  Real entry_param) const

551: Needle_inserter3::accrue_needle_elements (Vector3 h, Vector3 t)

677: Needle_inserter3::update_needle_elements ()

9: #include "needle-inserter3.hh"

16:   The needle is characterized by the set NEEDLE_ELEMENTS_.

18:   All nodes that are constrained (boundary of the NEEDLE_ELEMENTS_

19:   subcomplex) also have a needle radius (necessary for moving the needle.)

21:   The needle is described by vectors (H, T), where H is the handle

26:   Handling NEEDLE_ELEMENTS_ is not done particularly

38:   needle_radius_ = get_number_setting ("needle-radius");

45:   filter_needle_rotations_ = strcmp (get_string_setting ("elasticity"), "linear");

51: Needle_inserter3::handle () const

57: Needle_inserter3::tip () const

89:   All faces of NEEDLE_ELEMENTS_ whose mates are not in

90:   NEEDLE_ELEMENTS_.

98:   set<Face*> needle_surf;

100:   for (iterof (i, needle_elements_); i != needle_elements_.end(); i++)

107: 	      !has_elt(needle_elements_, f->mate ()->element()))

109: 	      needle_surf .insert (f);

113:   return needle_surf;

121: Needle_inserter3::force_distribution (Real tip_distance, Real entry_param)

143:   Compute the friction force for triangle PLEX, given needle

148:   This should approximate the area of the needle relatively accurate.

158: Needle_inserter3::friction_force (Real * area, Simplex const &plex, Vector3 h, Vector3 t,

178:     beyond the tip of the needle:

190:     We could discard tris if the triangle intersects the needle line, but

194:   if (dir1.length () < needle_radius_ / 100)

196:       printf ("Short distance to needle, %lf\n", dir1.length());

207:       if  (xy.length () < needle_radius_/ 100)

209: 	  printf ("Short distance to needle : %lf\n", xy.length ());

220: 			  phi_z_coordinates[1] - phi_z_coordinates[2]).length () * 0.5 * needle_radius_ *sign;

227:   Change the needle position: express the locations of all needle

228:   nodes (including internal nodes of NEEDLE_ELEMENTS_) in coordinates

229:   relative to the needle, and set their positions to by changing the

230:   coordinate system to the new needle position.

233: Needle_inserter3::drag_nodes (Vector3 h, Vector3 t)

249:   for (iterof (i, needle_elements_); i != needle_elements_.end (); i++)

293:   ENTRY_PARAM is where the needle enters the tissue.

296: Needle_inserter3::get_entry_parameter (Vector3 h, Vector3 t) const

303:   for (iterof (i, needle_elements_); i != needle_elements_.end () ; i++)

318: Needle_inserter3::rearrange_boundary_conditions ()

323:   set<Face*> needle_surf = get_needle_surface ();

324:   for (iterof (i, needle_surf); i != needle_surf.end(); i++)

347:   for (iterof (i, needle_surf); i != needle_surf.end(); i++)

363:   Real theoretical_area = (maxp - minp) * needle_radius_ * 2 * M_PI;

370: 	  needle_surf.size(),

372: 	  (100.0 * inverted )/  needle_surf.size());

389:       assert (has_key (needle_node_radii_, n));

390:       Real node_radius = needle_node_radii_[n]; 

407:       if (filter_needle_rotations_)

436:     Pop off elements slid off the needle.

439:   for (iterof (i, needle_elements_); i != needle_elements_.end (); i++)

455:     needle_elements_.erase (erase[i]);

457:   if (!needle_elements_.size ())

464: Needle_inserter3::handle_tip_changes (Vector3 h, Vector3 t)

466:   refine_around_needle_tip (h, t);

468:   update_needle_elements ();

469:   accrue_needle_elements (h, t); 

473:   Refine the mesh around the needle tip.

475:   This happens in a circle perpendicular to the needle.

477:   This assumes that the needle doesn't move a big deal between

499:   int steps =  int (needle_radius_ * 2 * M_PI / refinement_h);

506:       Vector3 x = t + rad * needle_radius_;

511:       Vector3 farx = t + rad * (refinement_h +  needle_radius_);

542:   return (p >= 0.0 && p <= entry_param)  && (r < needle_radius_ || simp_dist < r /2 ) ;

547:   Add elements to NEEDLE_ELEMENTS_. We start from the tip, and

583:       if (has_elt (needle_elements_, e))

586:       if (is_needle_element (e, last_handle_, last_tip_, entry_param))

588: 	  needle_elements_.insert (e);

605:   Find new needle surface nodes by comparing NEEDLE_ELEMENTS_ and

606:   NEEDLE_NODE_RADII_, and set appropriate radii.

608:   Remove node that are no longer part of the needle, junking the

612: Needle_inserter3::update_boundary_nodes ()

614:   set<Face*> surf = get_needle_surface ();

625:       if (!has_key (needle_node_radii_, *i))

628: 	  needle_node_radii_[*i] = point_to_line_distance3 (y, last_handle_, last_tip_);

635:   for (iterof (i, needle_node_radii_); i != needle_node_radii_.end ();  i++)

645:       needle_node_radii_.erase (rm[i]);

656: Needle_inserter3::signal_converged ()

667:       auto_needle_insert ();

673:   Put topological changes in the NEEDLE_ELEMENTS_ set: subdivision may

674:   render existing elements of NEEDLE_ELEMENTS_ invalid. a

690: 	  bool h = has_elt (needle_elements_, e);

694: 	      needle_elements_.erase (*i);

701: 		  if (is_needle_element (*j, last_handle_, last_tip_, entry_param))

702: 		    needle_elements_.insert (*j);

707: 	      if (is_needle_element (e, last_handle_, last_tip_, entry_param))

708: 		needle_elements_.insert (e);

17: #define needle_assert(a) do { if (!a) { fprintf(stderr, "NEEDLE ASSERT FAILED: %s\n", #a); suicide(); return ; }}  while (0)

47: Needle_inserter::Needle_inserter(Maubach_tree * tr, Deformation_state * st)

389: Needle_inserter::print_needle ()

416: Needle_inserter::move_needle (Vector2 h, Vector2 t)

80: Needle_inserter::refine_around_needle_tip (Vector2 handle , Vector2 tip)

447: Needle_inserter::dump_needle_forces (const char *fn)

8: #include "needle-inserter.hh"

42: Needle_inserter::live()const

61:     sqrt(2), is to control the inter needle-node spacing.

73: Needle_inserter::suicide ()

88:   if (needle_.size())

90:       tip_param  = ((deformed_location2 (needle_.top(), deformation ()) - tip)*dir);

94:     init  to length_threshold_  to refine in advance of the needle.

112: 	    This refines in a region around the needle.  Have not

125:       if (!e && ! needle_.size())

147:     Walk from tip to the first node that's already on the needle.

153: 	  && needle_.size()

154: 	  && e->opposite_node (entry) == needle_.top ())

169:       if (needle_.find_l (newnod))

209:       assert (!needle_.find_l (n));

254:       needle_.push (n);

255:       needle_params_.push (param);

259:     TODO: add nodes to needle_

264: Needle_inserter::drag_fixed_nodes (Vector2 h, Vector2 t)

267:   for (int i = 0; i < needle_.size (); i++)

269:       Node * n = needle_[i];

270:       Vector2 param = needle_params_[i];

287: Needle_inserter::rearrange_boundary_conditions ()

289:   if (!needle_.size())

302:   for (int i =  needle_.size(); i--;)

304:       Vector2 x =  deformed_location2 (needle_[i], deformation ());

318:   for (int i = 0; i < needle_.size(); i++)

320:       Node * n = needle_[i];

341: 	  Vector2 p = needle_params_[i];

343: 	  needle_params_[i]

353:   for (int i = needle_.size(); i--;)

355:       Node * n = needle_[i];

372: 	  needle_.del (i);

373: 	  needle_params_.del(i);

381:   if (!needle_.size())

391:   log_message ("Needle: "); 

392:   for (int i = needle_.size(); i--;)

394:       bool f = deformation ()->constraints_.is_fixed (needle_[i]);

395:       bool l = deformation ()->constraints_.has_linear_movement_constraint (needle_[i]);

401: Needle_inserter::signal_converged ()

407:   refine_around_needle_tip (last_handle_, last_tip_ );

411:       auto_needle_insert ();

442:       refine_around_needle_tip (h, t); 

458:   fprintf (f, "%d\n", needle_.size ());

467:   for (int i =0; i < needle_.size (); i++)

469:       Node* n = needle_[i];

526:     Walk from tip to the first node that's already on the needle.

588: Needle_inserter::tip_reference_location () const

127: print_needle (FILE * f,

15: #include "needle-inserter.hh"

150:       fprintf (f, " %lf %lf moveto %lf %lf lineto stroke %% needle \n ",

161: 	    Needle_inserter * ni,

203: 	  print_needle (f, top, def, tip, handle);

216: 	    Needle_inserter * ni,

252: 	  print_needle (f, top, def, tip, handle);

51:         #define NEEDLE_MAP_SCALE 16

54:         __global__ void NeedleMapAverageKernel(const PtrStepSzf u, const PtrStepf v, PtrStepf u_avg, PtrStepf v_avg)

116:         void NeedleMapAverage_gpu(PtrStepSzf u, PtrStepSzf v, PtrStepSzf u_avg, PtrStepSzf v_avg)

127:         __global__ void NeedleMapVertexKernel(const PtrStepSzf u_avg, const PtrStepf v_avg, float* vertex_data, float* color_data,...(44 bytes skipped)...

207:         void CreateOpticalFlowNeedleMap_gpu(PtrStepSzf u_avg, PtrStepSzf v_avg, float* vertex_buffer, float* color_data, float max_flow,...(28 bytes skipped)...

56:             __shared__ float smem[2 * NEEDLE_MAP_SCALE];

59:             volatile float* v_col_sum = u_col_sum + NEEDLE_MAP_SCALE;

61:             const int x = blockIdx.x * NEEDLE_MAP_SCALE + threadIdx.x;

62:             const int y = blockIdx.y * NEEDLE_MAP_SCALE;

68:             for(int i = 0; i < NEEDLE_MAP_SCALE; ++i)

106:                 const float coeff = 1.0f / (NEEDLE_MAP_SCALE * NEEDLE_MAP_SCALE);

118:             const dim3 block(NEEDLE_MAP_SCALE);

133:             const float arrow_x = x * NEEDLE_MAP_SCALE + NEEDLE_MAP_SCALE / 2.0f;

134:             const float arrow_y = y * NEEDLE_MAP_SCALE + NEEDLE_MAP_SCALE / 2.0f;

121:             NeedleMapAverageKernel<<<grid, block>>>(u, v, u_avg, v_avg);

212:             NeedleMapVertexKernel<<<grid, block>>>(u_avg, v_avg, vertex_buffer, color_data, max_flow, xscale, yscale);...(0 bytes skipped)...

1: ...(1125 bytes skipped)....inner{stroke-width:1px;stroke:#555}.epoch .gauge .tick{stroke-width:1px;stroke:#555}.epoch .gauge .needle{fill:orange}.epoch .gauge .needle-base{fill:#666}.epoch div.ref.category1,.epoch.category10 div.ref.category1{background-color:#1f77b...(24132 bytes skipped)...

2852:     def search_vmas_for_needle(self, search_string=None, pointers=None,

3053:     def search_chunks_for_needle(self, search_string=None, pointers=None,

2307:             for hit in self.search_vmas_for_needle(pointers=[top_chunk.v()]):

2787:             for hit in self.search_vmas_for_needle(pointers=mmap_pointers):

2789:                 found_pointers.add(hit['needle'])

2854:         """Searches all vmas or only the given ones for the given needle(s).

2868:                                                 dict(needle=search_string))])

2901:                     temp['needle'] = pointer

2904:                     temp['needle'] = search_string

3055:         """Searches all chunks for the given needle(s) and returns the ones

3070:             hits = self.search_vmas_for_needle(pointers=pointers,

3074:             hits = self.search_vmas_for_needle(search_string=search_string,

3085:         #   { needle (string or pointer): { offsets: {offsets} }, needle2: ...}

3099:                         result[chunk] = {hit['needle']: {hit['hit']}}

3102:                         if hit['needle'] not in list(result[chunk].keys()):

3103:                             result[chunk][hit['needle']] = {hit['hit']}

3106:                             result[chunk][hit['needle']].add(hit['hit'])

3657:                 hits = self.search_vmas_for_needle(

3661:                 hits = self.search_vmas_for_needle(

4228:                         hits = self.search_chunks_for_needle(

4233:                         temp_hits = self.search_chunks_for_needle(

4264:                                 temp_hit['needle'] = ','.join(rule_strings)

4267:                         temp_hits = self.search_chunks_for_needle(

4308:                             temp_hits = self.search_chunks_for_needle(

4342:                             "We didn't find anything for the given needle(s).")

4350:                         for needle, data in needles.items():

4351:                             if isinstance(needle, malloc_chunk):

4355:                                     "0x{:X}:\n".format(needle.v()))

4371:                                     "The following needle at the given "

4373:                                 renderer.write("Needle     Offset(s)\n")

4378:                                         (hex(needle) if isinstance(needle, int)

4379:                                          else repr(needle)) + ": "

4386:                                         (hex(needle) if isinstance(needle, int)

4387:                                          else repr(needle)) + ": The needle "

4237:                         for chunk, needles in temp_hits.items():

4239:                                 hits[chunk].update(needles)

4242:                                 hits[chunk] = needles

4271:                         for chunk, needles in temp_hits.items():

4273:                                 hits[chunk].update(needles)

4276:                                 hits[chunk] = needles

4345:                     for chunk, needles in hits.items():

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) {

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);

150: _BAD_CRYPTO_NEEDLE = 'PKCS12 format is not supported by the PyCrypto library'

627:             if _BAD_CRYPTO_NEEDLE in e.message:

110: _ACCEPT_LICENSE_NEEDLE = 'Do you accept the license'

133: _GRADLEW_INSTALL_SUCCESS_NEEDLE = 'BUILD SUCCESSFUL'

145: _TEST_FAILURE_NEEDLE = 'FAILURES!!!\r'

779:         return _GRADLEW_INSTALL_SUCCESS_NEEDLE not in result

782:         return _TEST_FAILURE_NEEDLE in result

1111:             if _ACCEPT_LICENSE_NEEDLE in line and not process.poll():

1: ...(1365 bytes skipped)....inner{stroke-width:1px;stroke:#555}.epoch .gauge .tick{stroke-width:1px;stroke:#555}.epoch .gauge .needle{fill:orange}.epoch .gauge .needle...(24288 bytes skipped)...nner{stroke:#AAA}.epoch-theme-dark .epoch .gauge .tick{stroke:#AAA}.epoch-theme-dark .epoch .gauge .needle{fill:#F3DE88}.epoch-theme-dark .epoch .gauge .needle-base{fill:#999}.epoch-theme-dark .epoch div.ref.category1,.epoch-theme-dark .epoch.category10 div.r...(32086 bytes skipped)...

38: #define RSS_NEEDLE "<rss "

40: #define ATOM_NEEDLE "<feed "

41: #define OPML_NEEDLE "<opml "

39: #define RSS_NEEDLE2 "<rss\n"

51: 	if (g_strstr_len (data, len, RSS_NEEDLE) != NULL)

53: 	if (g_strstr_len (data, len, RSS_NEEDLE2) != NULL)

67: 	if (g_strstr_len (data, len, ATOM_NEEDLE) != NULL)

81: 	if (g_strstr_len (data, len, OPML_NEEDLE) != NULL)

40: #define ASX_NEEDLE "<ASX"

41: #define ASX_NEEDLE2 "<asx"

42: #define ASX_NEEDLE3 "<Asx"

53: 	if (g_strstr_len (data, len, ASX_NEEDLE) != NULL)

55: 	if (g_strstr_len (data, len, ASX_NEEDLE2) != NULL)

57: 	if (g_strstr_len (data, len, ASX_NEEDLE3) != NULL)

38:   Drag_state needle_drag_;

76:   virtual void set_needle ();

79:   virtual void draw_needle ();

291: Artisjokke_drawer::set_needle ()

296: Artisjokke_drawer::draw_needle ()

64:   else if (current == & needle_drag_.quat_)

66:       set_needle ();

108:   //  set_needle();

192:   this->draw_needle ();

256:   else if (current == &needle_drag_.scale_)

258:       set_needle ();

280:    else if (current == &needle_drag_.translate_)

282:       set_needle ();

39: #define QT_NEEDLE "<?quicktime"

59: 	if (g_strstr_len (data, len, QT_NEEDLE) != NULL)

259: .gauge > .window > .needle {

47:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";

104:                 Assert.assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));

35:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";

88:             assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));

34:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";

84:         assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));

47:     private static final String EXPECTED_HTML_NEEDLE = "http://www.example.com/";

97:             Assert.assertTrue(htmlText.contains(EXPECTED_HTML_NEEDLE));

316:     "test: replace() should return the replacement if the input matches the needle" : function() {

54:             needle: "juhu",

62:             needle: "kinners"

73:             needle: "kinners"

85:             needle: "kinners"

98:             needle: "kinners"

109:             needle: "kinners",

123:             needle: "xyz",

134:             needle: "JUHU"

144:             needle: "KINNERS",

156:             needle: "kinners",

169:             needle: "juhu",

184:             needle: "juhu",

205:             needle: "juhu",

228:             needle: "juhu",

243:             needle: "juhu",

259:             needle: "\\d+",

272:             needle: "\\d+\\b",

286:             needle: "(\\d+)",

299:             needle: "uh",

318:             needle: "juhu"

330:             needle: "\\d+",

343:             needle: "ab(\\d\\d)",

356:             needle: "[ ]+$",

374:             needle: "foo",

396:             needle: "foo",

33: public final class NeedlemanWunschEditDistance {

35:   private NeedlemanWunschEditDistance() {

23:  * The Needleman-Wunsch algorithm for finding least-cost string edit distances between pairs of

29:  * <p>See http://en.wikipedia.org/wiki/Needleman-Wunsch_algorithm

27: public class NeedlemanWunschEditDistanceTest {

30:   public void needlemanWunschEditDistance_returnsZero_withIdenticalNames() {

41:   public void needlemanWunschEditDistance_matchesLevenschtein_withHugeGapCost() {

54:   public void needlemanWunschEditDistanceWorstCase_matchesLevenschtein_withHugeGapCost() {

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);

25: public class NeedlesslyAnnotatedLabel extends Label {

26:   @UiConstructor public NeedlesslyAnnotatedLabel() {

219: 	unsigned needlen;

3921: 		if (extend_contents(dh, dh->needlen) == -1)

3927: 					  dh->needlen - dh->len, name,

3929: 		if (newlen > dh->needlen)

3960: 		dh->needlen = size;

78: return this.drawNeedle()}};d.prototype.drawNeedle...(22 bytes skipped)...d=[this.centerX(),this.centerY(),this.radius()];c=d[0];a=d[1];d=d[2];this.setStyles(".epoch .gauge .needle...(194 bytes skipped)...eTo(-1*this.pixelRatio,19-d);this.ctx.lineTo(1,19-d);this.ctx.fill();this.setStyles(".epoch .gauge .needle-base");this.ctx.beginPath();

432:   static bool NeedLegacyFlags(char phase, uint32_t flags) {

338:     if (NeedLegacyFlags(phase, flags)) {

380:     if (NeedLegacyFlags(phase, flags) || pid_override || tid_override) {

186: 	unsigned needlen;

3527: 		if (extend_contents(dh, dh->needlen) == -1)

3532: 					  dh->needlen - dh->len, name,

3534: 		if (newlen > dh->needlen)

3599: 		if (extend_contents(dh, dh->needlen) == -1)

3604: 					       dh->needlen - dh->len, name,

3606: 		if (newlen > dh->needlen)

3653: 		dh->needlen = size;

3677: 	if (extend_contents(dh, dh->needlen) == -1)

3688: 		unsigned rem = dh->needlen - dh->len;

3705: 		if (newlen > dh->needlen)

3736: 		dh->needlen = size;

406: goog.ui.Gauge.prototype.needleRadius_ = 0;

415: goog.ui.Gauge.prototype.needleGroup_ = null;

424: goog.ui.Gauge.prototype.needleValuePosition_ = null;

82:  * ticks and labels inside the internal border, and a needle that points to

191:  * The length of the needle front (value facing) from the internal radius.

192:  * The needle front is the part of the needle that points to the value.

195: goog.ui.Gauge.FACTOR_NEEDLE_FRONT = 0.95;

199:  * The length of the needle back relative to the internal radius.

200:  * The needle back is the part of the needle that points away from the value.

203: goog.ui.Gauge.FACTOR_NEEDLE_BACK = 0.3;

207:  * The width of the needle front at the hinge.

212: goog.ui.Gauge.FACTOR_NEEDLE_WIDTH = 0.07;

216:  * The width (radius) of the needle hinge from the gauge radius.

219: goog.ui.Gauge.FACTOR_NEEDLE_HINGE = 0.15;

266:  * The maximal size of a step the needle can move (percent from size of range).

267:  * If the needle needs to move more, it will be moved in animated steps, to

271: goog.ui.Gauge.NEEDLE_MOVE_MAX_STEP = 0.02;

278: goog.ui.Gauge.NEEDLE_MOVE_TIME = 400;

400:  * The radius for drawing the needle.

402:  * the needle.

410:  * The group elemnt of the needle. Contains all elements that change when the

419:  * The current position (0-1) of the visible needle.

436:  * Animation object while needle is being moved (animated).

489:  *     determines the position of the needle of the gauge.

509:         goog.ui.Gauge.NEEDLE_MOVE_TIME, goog.fx.easing.inAndOut);

795:   // Draw the needle and the value label. Stop animation when doing

889:  * Draw the elements that depend on the current value (the needle and

907:   // Compute the needle path

908:   var frontRadius = Math.round(r * goog.ui.Gauge.FACTOR_NEEDLE_FRONT);

909:   var backRadius = Math.round(r * goog.ui.Gauge.FACTOR_NEEDLE_BACK);

915:   var distanceControlPointBase = r * goog.ui.Gauge.FACTOR_NEEDLE_WIDTH;

932:   // Draw the needle hinge

933:   var rh = Math.round(r * goog.ui.Gauge.FACTOR_NEEDLE_HINGE);

935:   // Clean previous needle

959:   // Draw the needle

501:   if (this.needleValuePosition_ == null) {

503:     this.needleValuePosition_ = valuePosition;

508:         [this.needleValuePosition_], [valuePosition],

639:   this.needleGroup_ = null;

798:   this.needleRadius_ = r;