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

1127:             "needle": "^2.2.1",

1108:         "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 },

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

1098:             "needle": "^2.2.1",

1079:         "needle": {

1098:             "needle": "^2.2.1",

1079:         "needle": {

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)

938: 				"needle": "bin/needle"

1147: 				"needle": "^2.5.2",

2371: 				"needle": "^2.5.2",

928: 		"node_modules/needle": {

930: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz",

944: 		"node_modules/needle/node_modules/debug": {

2220: 		"needle": {

2222: 			"resolved": "https://registry.npmjs.org/needle/-/needle-2.9.1.tgz",

1616:                 "needle": "bin/needle"

1871:                 "needle": "2.4.0",

4391:                 "needle": "2.4.0",

1606:         "node_modules/needle": {

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

1622:         "node_modules/needle/node_modules/debug": {

1630:         "node_modules/needle/node_modules/ms": {

4193:         "needle": {

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

1065:         "needle": "bin/needle"

1230:         "needle": "2.4.0",

2783:         "needle": "2.4.0",

1055:     "node_modules/needle": {

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

1071:     "node_modules/needle/node_modules/debug": {

2640:     "needle": {

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

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)

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)

131:     "needle": "^2.5.0",

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": {

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

76:   needle: string;

123:   const { mode, needle } = modeAndNeedle;

145:   const { mode, needle } = modeAndNeedle;

74: interface FilterModeAndNeedle {

88: export function parseFilterModeAndNeedle(

102: export function combineModeAndNeedle(mode: FilterMode, needle: string): string {

121:   const modeAndNeedle = parseFilterModeAndNeedle(filter);

143:   const modeAndNeedle = parseFilterModeAndNeedle(filter);

83:   needle: string,

85:   return addOrUpdateFilter(filters, { id, value: combineModeAndNeedle(mode, needle) });

98:     needle: m[2] || '',

103:   return `${mode}${needle}`;

126:       return String(value) === needle;

129:       return String(value) !== needle;

132:       return String(value) <= needle;

135:       return String(value) >= needle;

138:       return caseInsensitiveContains(String(value), needle);

149:       return column.equal(needle);

152:       return column.unequal(needle);

155:       return column.lessThanOrEqual(needle);

158:       return column.greaterThanOrEqual(needle);

161:       return F('LOWER', column).like(`%${needle.toLowerCase()}%`);

91: ): FilterModeAndNeedle | undefined {

122:   if (!modeAndNeedle) return true;

144:   if (!modeAndNeedle) return;

1694:             "needle": "^2.2.1",

1675:         "needle": {

63:     needle: '.otherwise',

55:     "needle": "^2.4.0"

65:   const gchar                     *needle;

408:   lookup.needle = query;

26:     needle: 'Nietzsche'

31:     needle: 'Jules Verne'

36:     needle: 'Shakespeare'

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

1274:             "needle": "^2.2.1",

1255:         "needle": {

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

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

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

129:     const QString needle;

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

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

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

42:     std::string needle;

37:     const std::string &getNeedle() const { return needle; }

17:     StringObserver(const std::string &needle) : needle(needle) { ASSERT(!needle.empty()); }

21:         if (needle[currPos] == c)

24:             if (currPos == needle.size())

81:     void watch(std::string const &needle)

83:         if (!needle.empty())

85:             mObservers.emplace_back(needle);

138:                     const std::string &needle = observer.getNeedle();

139:                     (void)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;

38:     "needle": "^2.2.1",

22: const needle = require('needle')

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

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

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

43:   // this situation than needle

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

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

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

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

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

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

641:             "needle": "^2.2.1",

626:         "needle": {

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

129:     const QString needle;

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

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

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