This file is indexed.

/usr/share/doc/stilts/sun256/uk.ac.starlink.ttools.func.Strings.html is in stilts-doc 3.1.2-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
<html>
   
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <link rel="stylesheet" type="text/css" href="sun-style.css">
      <title>Strings</title>
   </head>
   
   <body>
      <hr>
      <a href="uk.ac.starlink.ttools.func.Tilings.html">Next</a> <a href="staticMethods.html">Previous</a> <a href="staticMethods.html">Up</a> <a href="index.html">Contents</a> <br> <b>Next: </b><a href="uk.ac.starlink.ttools.func.Tilings.html">Tilings</a><br>
       <b>Up: </b><a href="staticMethods.html">Functions</a><br>
       <b>Previous: </b><a href="staticMethods.html">Functions</a><br>
      
      <hr>
      <h4><a name="uk.ac.starlink.ttools.func.Strings">10.5.1 Strings</a></h4>
      <p>String manipulation and query functions.</p>
      <p>
         <dl>
            <dt><strong><code>concat( strings, ... )</code></strong></dt>
            <dd>Concatenates multiple values into a string.
               In some cases the same effect can be achieved by
               writing <code>s1+s2+...</code>, but this method makes sure that
               values are converted to strings, with the blank value invisible.
               <ul>
                  <li><code>strings</code> <em>(Object, one or more)</em>: one or more strings
                  </li>
                  <li>return value <em>(String)</em>: concatenation of input strings, without separators
                  </li>
               </ul>
            </dd>
            <dt><strong><code>join( separator, words, ... )</code></strong></dt>
            <dd>Joins multiple values into a string, with a given
               separator between each pair.
               <ul>
                  <li><code>separator</code> <em>(String)</em>: string to insert between adjacent words
                  </li>
                  <li><code>words</code> <em>(Object, one or more)</em>: one or more values to join
                  </li>
                  <li>return value <em>(String)</em>: input values joined together with <code>separator</code></li>
               </ul>
            </dd>
            <dt><strong><code>equals( s1, s2 )</code></strong></dt>
            <dd>Determines whether two strings are equal.
               Note you should use this function instead of <code>s1==s2</code>,
               which can (for technical reasons) return false even if the
               strings are the same.
               <ul>
                  <li><code>s1</code> <em>(String)</em>: first string
                  </li>
                  <li><code>s2</code> <em>(String)</em>: second string
                  </li>
                  <li>return value <em>(boolean)</em>: true if s1 and s2 are both blank, or have the same content
                  </li>
               </ul>
            </dd>
            <dt><strong><code>equalsIgnoreCase( s1, s2 )</code></strong></dt>
            <dd>Determines whether two strings are equal apart from possible
               upper/lower case distinctions.
               <ul>
                  <li><code>s1</code> <em>(String)</em>: first string
                  </li>
                  <li><code>s2</code> <em>(String)</em>: second string
                  </li>
                  <li>return value <em>(boolean)</em>: true if s1 and s2 are both blank, or have the same content
                     apart from case folding
                  </li>
               </ul>
            </dd>
            <dt><strong><code>startsWith( whole, start )</code></strong></dt>
            <dd>Determines whether a string starts with a certain substring.
               <ul>
                  <li><code>whole</code> <em>(String)</em>: the string to test
                  </li>
                  <li><code>start</code> <em>(String)</em>: the sequence that may appear at the start of 
                     <code>whole</code></li>
                  <li>return value <em>(boolean)</em>: true if the first few characters of <code>whole</code> are
                     the same as <code>start</code></li>
               </ul>
            </dd>
            <dt><strong><code>endsWith( whole, end )</code></strong></dt>
            <dd>Determines whether a string ends with a certain substring.
               <ul>
                  <li><code>whole</code> <em>(String)</em>: the string to test
                  </li>
                  <li><code>end</code> <em>(String)</em>: the sequence that may appear at the end of 
                     <code>whole</code></li>
                  <li>return value <em>(boolean)</em>: true if the last few characters of <code>whole</code> are
                     the same as <code>end</code></li>
               </ul>
            </dd>
            <dt><strong><code>contains( whole, sub )</code></strong></dt>
            <dd>Determines whether a string contains a given substring.
               <ul>
                  <li><code>whole</code> <em>(String)</em>: the string to test
                  </li>
                  <li><code>sub</code> <em>(String)</em>: the sequence that may appear within <code>whole</code></li>
                  <li>return value <em>(boolean)</em>: true   if the sequence <code>sub</code> appears within 
                     <code>whole</code></li>
               </ul>
            </dd>
            <dt><strong><code>length( str )</code></strong></dt>
            <dd>Returns the length of a string in characters.
               <ul>
                  <li><code>str</code> <em>(String)</em>: string
                  </li>
                  <li>return value <em>(integer)</em>: number of characters in <code>str</code></li>
               </ul>
            </dd>
            <dt><strong><code>split( words )</code></strong></dt>
            <dd>Splits a string into an array of space-separated words.
               One or more spaces separates each word from the next.
               Leading and trailing spaces are ignored.
               <p>The result is an array of strings, and if you want to use the
                  individual elements you need to use square-bracket indexing,
                  with <code>[0]</code> representing the first object
                  <ul>
                     <li><code>words</code> <em>(String)</em>: string with embedded spaces delimiting the words
                     </li>
                     <li>return value <em>(array of String)</em>: array of the separate words;
                        you can extract the individual words from the result using
                        square bracket indexing
                     </li>
                  </ul>
               </p>
            </dd>
            <dt><strong><code>split( words, regex )</code></strong></dt>
            <dd>Splits a string into an array of words separated by a given
               regular expression.
               <p>The result is an array of strings, and if you want to use the
                  individual elements you need to use square-bracket indexing,
                  with <code>[0]</code> representing the first object
                  <ul>
                     <li><code>words</code> <em>(String)</em>: string with multiple parts
                     </li>
                     <li><code>regex</code> <em>(String)</em>: regular expression delimiting the different words in
                        the <code>words</code> parameter
                     </li>
                     <li>return value <em>(array of String)</em>: array of the separate words;
                        you can extract the individual words from the result using
                        square bracket indexing
                     </li>
                  </ul>
               </p>
            </dd>
            <dt><strong><code>matches( str, regex )</code></strong></dt>
            <dd>Tests whether a string matches a given regular expression.
               <ul>
                  <li><code>str</code> <em>(String)</em>: string to test
                  </li>
                  <li><code>regex</code> <em>(String)</em>: regular expression string
                  </li>
                  <li>return value <em>(boolean)</em>: true if <code>regex</code> matches <code>str</code> anywhere
                  </li>
               </ul>
            </dd>
            <dt><strong><code>matchGroup( str, regex )</code></strong></dt>
            <dd>Returns the first grouped expression matched in a string defined
               by a regular expression.  A grouped expression is one enclosed
               in parentheses.
               <ul>
                  <li><code>str</code> <em>(String)</em>: string to match against
                  </li>
                  <li><code>regex</code> <em>(String)</em>: regular expression containing a grouped section
                  </li>
                  <li>return value <em>(String)</em>: contents of the matched group 
                     (or null, if <code>regex</code> didn't match <code>str</code>)
                  </li>
               </ul>
            </dd>
            <dt><strong><code>replaceFirst( str, regex, replacement )</code></strong></dt>
            <dd>Replaces the first occurrence of a regular expression in a string with
               a different substring value.
               <ul>
                  <li><code>str</code> <em>(String)</em>: string to manipulate
                  </li>
                  <li><code>regex</code> <em>(String)</em>: regular expression to match in <code>str</code></li>
                  <li><code>replacement</code> <em>(String)</em>: replacement string
                  </li>
                  <li>return value <em>(String)</em>: same as <code>str</code>, but with the first match (if any) of 
                     <code>regex</code> replaced by <code>replacement</code></li>
               </ul>
            </dd>
            <dt><strong><code>replaceAll( str, regex, replacement )</code></strong></dt>
            <dd>Replaces all occurrences of a regular expression in a string with
               a different substring value.
               <ul>
                  <li><code>str</code> <em>(String)</em>: string to manipulate
                  </li>
                  <li><code>regex</code> <em>(String)</em>: regular expression to match in <code>str</code></li>
                  <li><code>replacement</code> <em>(String)</em>: replacement string
                  </li>
                  <li>return value <em>(String)</em>: same as <code>str</code>, but with all matches of 
                     <code>regex</code> replaced by <code>replacement</code></li>
               </ul>
            </dd>
            <dt><strong><code>substring( str, startIndex )</code></strong></dt>
            <dd>Returns the last part of a given string.
               The substring begins with the character at the specified
               index and extends to the end of this string.
               <ul>
                  <li><code>str</code> <em>(String)</em>: the input string
                  </li>
                  <li><code>startIndex</code> <em>(integer)</em>: the beginning index, inclusive
                  </li>
                  <li>return value <em>(String)</em>: last part of <code>str</code>, omitting the first 
                     <code>startIndex</code> characters
                  </li>
               </ul>
            </dd>
            <dt><strong><code>substring( str, startIndex, endIndex )</code></strong></dt>
            <dd>Returns a substring of a given string.
               The substring begins with the character at <code>startIndex</code>
               and continues to the character at index <code>endIndex-1</code>
               Thus the length of the substring is <code>endIndex-startIndex</code>.
               <ul>
                  <li><code>str</code> <em>(String)</em>: the input string
                  </li>
                  <li><code>startIndex</code> <em>(integer)</em>: the beginning index, inclusive
                  </li>
                  <li><code>endIndex</code> <em>(integer)</em>: the end index, inclusive
                  </li>
                  <li>return value <em>(String)</em>: substring of <code>str</code></li>
               </ul>
            </dd>
            <dt><strong><code>toUpperCase( str )</code></strong></dt>
            <dd>Returns an uppercased version of a string.
               <ul>
                  <li><code>str</code> <em>(String)</em>: input string
                  </li>
                  <li>return value <em>(String)</em>: uppercased version of <code>str</code></li>
               </ul>
            </dd>
            <dt><strong><code>toLowerCase( str )</code></strong></dt>
            <dd>Returns an lowercased version of a string.
               <ul>
                  <li><code>str</code> <em>(String)</em>: input string
                  </li>
                  <li>return value <em>(String)</em>: lowercased version of <code>str</code></li>
               </ul>
            </dd>
            <dt><strong><code>trim( str )</code></strong></dt>
            <dd>Trims whitespace from both ends of a string.
               <ul>
                  <li><code>str</code> <em>(String)</em>: input string
                  </li>
                  <li>return value <em>(String)</em>: str with any spaces trimmed from start and finish
                  </li>
               </ul>
            </dd>
            <dt><strong><code>padWithZeros( value, ndigit )</code></strong></dt>
            <dd>Takes an integer argument and returns a string representing the
               same numeric value but padded with leading zeros to a specified
               length.
               <ul>
                  <li><code>value</code> <em>(long integer)</em>: numeric value to pad
                  </li>
                  <li><code>ndigit</code> <em>(integer)</em>: the number of digits in the resulting string
                  </li>
                  <li>return value <em>(String)</em>: a string evaluating to the same as <code>value</code> with
                     at least <code>ndigit</code> characters
                  </li>
               </ul>
            </dd>
            <dt><strong><code>desigToRa( designation )</code></strong></dt>
            <dd>Attempts to determine the ICRS Right Ascension from
               an IAU-style designation such as "<code>2MASS J04355524+1630331</code>"
               following the specifications in the document
               <a href="http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx">http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx</a>.
               <p><strong>Note:</strong>
                  this function should be used with considerable care.
                  Such designators are intended for object identification
                  and not for communicating sky positions,
                  so that the resulting positions are likely to lack precision,
                  and may be inaccurate.
                  If positional information is available from other sources,
                  it should almost certainly be used instead.
                  But if there's no other choice, this may be used as a fallback.
               </p>
               <p><strong>Note also</strong>
                  that a designator with no coordsystem-specific flag character
                  (a leading "<code>J</code>", "<code>B</code>" or "<code>G</code>")
                  is considered to be B1950, <em>not</em> J2000.
                  <ul>
                     <li><code>designation</code> <em>(String)</em>: designation string in IAU format
                     </li>
                     <li>return value <em>(floating point)</em>: ICRS right ascension in degreees,
                        or blank if no position can be decoded
                     </li>
                  </ul>
               </p>
            </dd>
            <dt><strong><code>desigToDec( designation )</code></strong></dt>
            <dd>Attempts to determine the ICRS Declination from
               an IAU-style designation such as "<code>2MASS J04355524+1630331</code>"
               following the specifications in the document
               <a href="http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx">http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx</a>.
               <p><strong>Note:</strong>
                  this function should be used with considerable care.
                  Such designators are intended for object identification
                  and not for communicating sky positions,
                  so that the resulting positions are likely to lack precision,
                  and may be inaccurate.
                  If positional information is available from other sources,
                  it should almost certainly be used instead.
                  But if there's no other choice, this may be used as a fallback.
               </p>
               <p><strong>Note also</strong>
                  that a designator with no coordsystem-specific flag character
                  (a leading "<code>J</code>", "<code>B</code>" or "<code>G</code>")
                  is considered to be B1950, <em>not</em> J2000.
                  <ul>
                     <li><code>designation</code> <em>(String)</em>: designation string in IAU format
                     </li>
                     <li>return value <em>(floating point)</em>: ICRS declination in degrees,
                        or blank if no position can be decoded
                     </li>
                  </ul>
               </p>
            </dd>
            <dt><strong><code>desigToIcrs( designation )</code></strong></dt>
            <dd>Attempts to decode
               an IAU-style designation such as "<code>2MASS J04355524+1630331</code>"
               to determine its sky position,
               following the specifications in the document
               <a href="http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx">http://cds.u-strasbg.fr/vizier/Dic/iau-spec.htx</a>.
               <p>Obviously, this only works where the <em>sequence</em> part
                  of the designation takes one of the family of coordinate-based forms.
               </p>
               <p><strong>Note:</strong>
                  this function should be used with considerable care.
                  Such designators are intended for object identification
                  and not for communicating sky positions,
                  so that the resulting positions are likely to lack precision,
                  and may be inaccurate.
                  If positional information is available from other sources,
                  it should almost certainly be used instead.
                  But if there's no other choice, this may be used as a fallback.
               </p>
               <p><strong>Note also</strong>
                  that a designator with no coordsystem-specific flag character
                  (a leading "<code>J</code>", "<code>B</code>" or "<code>G</code>")
                  is considered to be B1950, <em>not</em> J2000.
                  <ul>
                     <li><code>designation</code> <em>(String)</em>: designation string in IAU format
                     </li>
                     <li>return value <em>(array of floating point)</em>: 2-element array giving ICRS (RA,Dec) in degrees,
                        or <code>null</code> if no position can be decoded
                     </li>
                  </ul>
               </p>
            </dd>
         </dl>
      </p>
      <hr><a href="uk.ac.starlink.ttools.func.Tilings.html">Next</a> <a href="staticMethods.html">Previous</a> <a href="staticMethods.html">Up</a> <a href="index.html">Contents</a> <br> <b>Next: </b><a href="uk.ac.starlink.ttools.func.Tilings.html">Tilings</a><br>
       <b>Up: </b><a href="staticMethods.html">Functions</a><br>
       <b>Previous: </b><a href="staticMethods.html">Functions</a><br>
      
      <hr><i>STILTS - Starlink Tables Infrastructure Library Tool Set<br>Starlink User Note256<br>STILTS web page:
         <a href="http://www.starlink.ac.uk/stilts/">http://www.starlink.ac.uk/stilts/</a><br>Author email:
         <a href="mailto:m.b.taylor@bristol.ac.uk">m.b.taylor@bristol.ac.uk</a><br>Mailing list:
         <a href="mailto:topcat-user@jiscmail.ac.uk">topcat-user@jiscmail.ac.uk</a><br></i></body>
</html>