A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1
2//------------------------------------------------------------------------------
3// <auto-generated>
4// This code was generated by a tool.
5//
6// TextTransform Samples/Packages/com.unity.collections/Unity.Collections/FixedStringFormat.tt
7//
8// Changes to this file may cause incorrect behavior and will be lost if
9// the code is regenerated.
10// </auto-generated>
11//------------------------------------------------------------------------------
12
13using System;
14using System.Runtime.InteropServices;
15using Unity.Collections.LowLevel.Unsafe;
16using UnityEngine.Internal;
17
18
19namespace Unity.Collections
20{
21 /// <summary>
22 /// Provides formatting methods for FixedString*N*.
23 /// </summary>
24 [GenerateTestsForBurstCompatibility]
25 public static class FixedString
26 {
27
28 /// <summary>
29 /// Returns a new string produced by interpolating a format string.
30 /// </summary>
31 /// <remarks>
32 /// Similar to StringBuilder.AppendFormat but with significant limitations:
33 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
34 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
35 ///
36 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
37 /// - FixedString*N*Bytes
38 /// - string
39 /// - int
40 /// - float
41 /// - structs implementing INativeList<byte> and IUTF8Bytes
42 ///
43 /// <seealso cref="FixedStringMethods.AppendFormat"/>
44 /// </remarks>
45 /// <param name="formatString">The format string.</param>
46
47 /// <param name="arg0">Value to interpolate into the format string.</param>
48 /// <param name="arg1">Value to interpolate into the format string.</param>
49 /// <param name="arg2">Value to interpolate into the format string.</param>
50 /// <param name="arg3">Value to interpolate into the format string.</param>
51 /// <returns>A new string produced by interpolating the format string.</returns>
52
53 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, int arg3)
54
55 {
56 FixedString512Bytes result = default;
57 FixedString32Bytes carg0 = default; carg0.Append(arg0);
58 FixedString32Bytes carg1 = default; carg1.Append(arg1);
59 FixedString32Bytes carg2 = default; carg2.Append(arg2);
60 FixedString32Bytes carg3 = default; carg3.Append(arg3);
61
62
63 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
64 return result;
65 }
66
67 /// <summary>
68 /// Returns a new string produced by interpolating a format string.
69 /// </summary>
70 /// <remarks>
71 /// Similar to StringBuilder.AppendFormat but with significant limitations:
72 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
73 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
74 ///
75 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
76 /// - FixedString*N*Bytes
77 /// - string
78 /// - int
79 /// - float
80 /// - structs implementing INativeList<byte> and IUTF8Bytes
81 ///
82 /// <seealso cref="FixedStringMethods.AppendFormat"/>
83 /// </remarks>
84 /// <param name="formatString">The format string.</param>
85
86 /// <param name="arg0">Value to interpolate into the format string.</param>
87 /// <param name="arg1">Value to interpolate into the format string.</param>
88 /// <param name="arg2">Value to interpolate into the format string.</param>
89 /// <param name="arg3">Value to interpolate into the format string.</param>
90 /// <returns>A new string produced by interpolating the format string.</returns>
91
92 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, int arg3)
93
94 {
95 FixedString512Bytes result = default;
96 FixedString32Bytes carg0 = default; carg0.Append(arg0);
97 FixedString32Bytes carg1 = default; carg1.Append(arg1);
98 FixedString32Bytes carg2 = default; carg2.Append(arg2);
99 FixedString32Bytes carg3 = default; carg3.Append(arg3);
100
101
102 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
103 return result;
104 }
105
106 /// <summary>
107 /// Returns a new string produced by interpolating a format string.
108 /// </summary>
109 /// <remarks>
110 /// Similar to StringBuilder.AppendFormat but with significant limitations:
111 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
112 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
113 ///
114 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
115 /// - FixedString*N*Bytes
116 /// - string
117 /// - int
118 /// - float
119 /// - structs implementing INativeList<byte> and IUTF8Bytes
120 ///
121 /// <seealso cref="FixedStringMethods.AppendFormat"/>
122 /// </remarks>
123 /// <param name="formatString">The format string.</param>
124
125 /// <param name="arg0">Value to interpolate into the format string.</param>
126 /// <param name="arg1">Value to interpolate into the format string.</param>
127 /// <param name="arg2">Value to interpolate into the format string.</param>
128 /// <param name="arg3">Value to interpolate into the format string.</param>
129 /// <returns>A new string produced by interpolating the format string.</returns>
130 [ExcludeFromBurstCompatTesting("Takes managed string")]
131 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, int arg3)
132
133 {
134 FixedString512Bytes result = default;
135 FixedString32Bytes carg0 = default; carg0.Append(arg0);
136 FixedString32Bytes carg1 = default; carg1.Append(arg1);
137 FixedString32Bytes carg2 = default; carg2.Append(arg2);
138 FixedString32Bytes carg3 = default; carg3.Append(arg3);
139
140
141 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
142 return result;
143 }
144
145 /// <summary>
146 /// Returns a new string produced by interpolating a format string.
147 /// </summary>
148 /// <remarks>
149 /// Similar to StringBuilder.AppendFormat but with significant limitations:
150 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
151 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
152 ///
153 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
154 /// - FixedString*N*Bytes
155 /// - string
156 /// - int
157 /// - float
158 /// - structs implementing INativeList<byte> and IUTF8Bytes
159 ///
160 /// <seealso cref="FixedStringMethods.AppendFormat"/>
161 /// </remarks>
162 /// <param name="formatString">The format string.</param>
163 /// <typeparam name="T1"><undoc /></typeparam>
164
165 /// <param name="arg0">Value to interpolate into the format string.</param>
166 /// <param name="arg1">Value to interpolate into the format string.</param>
167 /// <param name="arg2">Value to interpolate into the format string.</param>
168 /// <param name="arg3">Value to interpolate into the format string.</param>
169 /// <returns>A new string produced by interpolating the format string.</returns>
170 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
171 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, int arg3)
172 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
173
174 {
175 FixedString512Bytes result = default;
176 FixedString32Bytes carg1 = default; carg1.Append(arg1);
177 FixedString32Bytes carg2 = default; carg2.Append(arg2);
178 FixedString32Bytes carg3 = default; carg3.Append(arg3);
179
180
181 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
182 return result;
183 }
184
185 /// <summary>
186 /// Returns a new string produced by interpolating a format string.
187 /// </summary>
188 /// <remarks>
189 /// Similar to StringBuilder.AppendFormat but with significant limitations:
190 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
191 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
192 ///
193 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
194 /// - FixedString*N*Bytes
195 /// - string
196 /// - int
197 /// - float
198 /// - structs implementing INativeList<byte> and IUTF8Bytes
199 ///
200 /// <seealso cref="FixedStringMethods.AppendFormat"/>
201 /// </remarks>
202 /// <param name="formatString">The format string.</param>
203
204 /// <param name="arg0">Value to interpolate into the format string.</param>
205 /// <param name="arg1">Value to interpolate into the format string.</param>
206 /// <param name="arg2">Value to interpolate into the format string.</param>
207 /// <param name="arg3">Value to interpolate into the format string.</param>
208 /// <returns>A new string produced by interpolating the format string.</returns>
209
210 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, int arg3)
211
212 {
213 FixedString512Bytes result = default;
214 FixedString32Bytes carg0 = default; carg0.Append(arg0);
215 FixedString32Bytes carg1 = default; carg1.Append(arg1);
216 FixedString32Bytes carg2 = default; carg2.Append(arg2);
217 FixedString32Bytes carg3 = default; carg3.Append(arg3);
218
219
220 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
221 return result;
222 }
223
224 /// <summary>
225 /// Returns a new string produced by interpolating a format string.
226 /// </summary>
227 /// <remarks>
228 /// Similar to StringBuilder.AppendFormat but with significant limitations:
229 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
230 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
231 ///
232 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
233 /// - FixedString*N*Bytes
234 /// - string
235 /// - int
236 /// - float
237 /// - structs implementing INativeList<byte> and IUTF8Bytes
238 ///
239 /// <seealso cref="FixedStringMethods.AppendFormat"/>
240 /// </remarks>
241 /// <param name="formatString">The format string.</param>
242
243 /// <param name="arg0">Value to interpolate into the format string.</param>
244 /// <param name="arg1">Value to interpolate into the format string.</param>
245 /// <param name="arg2">Value to interpolate into the format string.</param>
246 /// <param name="arg3">Value to interpolate into the format string.</param>
247 /// <returns>A new string produced by interpolating the format string.</returns>
248
249 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, int arg3)
250
251 {
252 FixedString512Bytes result = default;
253 FixedString32Bytes carg0 = default; carg0.Append(arg0);
254 FixedString32Bytes carg1 = default; carg1.Append(arg1);
255 FixedString32Bytes carg2 = default; carg2.Append(arg2);
256 FixedString32Bytes carg3 = default; carg3.Append(arg3);
257
258
259 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
260 return result;
261 }
262
263 /// <summary>
264 /// Returns a new string produced by interpolating a format string.
265 /// </summary>
266 /// <remarks>
267 /// Similar to StringBuilder.AppendFormat but with significant limitations:
268 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
269 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
270 ///
271 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
272 /// - FixedString*N*Bytes
273 /// - string
274 /// - int
275 /// - float
276 /// - structs implementing INativeList<byte> and IUTF8Bytes
277 ///
278 /// <seealso cref="FixedStringMethods.AppendFormat"/>
279 /// </remarks>
280 /// <param name="formatString">The format string.</param>
281
282 /// <param name="arg0">Value to interpolate into the format string.</param>
283 /// <param name="arg1">Value to interpolate into the format string.</param>
284 /// <param name="arg2">Value to interpolate into the format string.</param>
285 /// <param name="arg3">Value to interpolate into the format string.</param>
286 /// <returns>A new string produced by interpolating the format string.</returns>
287 [ExcludeFromBurstCompatTesting("Takes managed string")]
288 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, int arg3)
289
290 {
291 FixedString512Bytes result = default;
292 FixedString32Bytes carg0 = default; carg0.Append(arg0);
293 FixedString32Bytes carg1 = default; carg1.Append(arg1);
294 FixedString32Bytes carg2 = default; carg2.Append(arg2);
295 FixedString32Bytes carg3 = default; carg3.Append(arg3);
296
297
298 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
299 return result;
300 }
301
302 /// <summary>
303 /// Returns a new string produced by interpolating a format string.
304 /// </summary>
305 /// <remarks>
306 /// Similar to StringBuilder.AppendFormat but with significant limitations:
307 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
308 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
309 ///
310 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
311 /// - FixedString*N*Bytes
312 /// - string
313 /// - int
314 /// - float
315 /// - structs implementing INativeList<byte> and IUTF8Bytes
316 ///
317 /// <seealso cref="FixedStringMethods.AppendFormat"/>
318 /// </remarks>
319 /// <param name="formatString">The format string.</param>
320 /// <typeparam name="T1"><undoc /></typeparam>
321
322 /// <param name="arg0">Value to interpolate into the format string.</param>
323 /// <param name="arg1">Value to interpolate into the format string.</param>
324 /// <param name="arg2">Value to interpolate into the format string.</param>
325 /// <param name="arg3">Value to interpolate into the format string.</param>
326 /// <returns>A new string produced by interpolating the format string.</returns>
327 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
328 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, int arg3)
329 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
330
331 {
332 FixedString512Bytes result = default;
333 FixedString32Bytes carg1 = default; carg1.Append(arg1);
334 FixedString32Bytes carg2 = default; carg2.Append(arg2);
335 FixedString32Bytes carg3 = default; carg3.Append(arg3);
336
337
338 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
339 return result;
340 }
341
342 /// <summary>
343 /// Returns a new string produced by interpolating a format string.
344 /// </summary>
345 /// <remarks>
346 /// Similar to StringBuilder.AppendFormat but with significant limitations:
347 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
348 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
349 ///
350 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
351 /// - FixedString*N*Bytes
352 /// - string
353 /// - int
354 /// - float
355 /// - structs implementing INativeList<byte> and IUTF8Bytes
356 ///
357 /// <seealso cref="FixedStringMethods.AppendFormat"/>
358 /// </remarks>
359 /// <param name="formatString">The format string.</param>
360
361 /// <param name="arg0">Value to interpolate into the format string.</param>
362 /// <param name="arg1">Value to interpolate into the format string.</param>
363 /// <param name="arg2">Value to interpolate into the format string.</param>
364 /// <param name="arg3">Value to interpolate into the format string.</param>
365 /// <returns>A new string produced by interpolating the format string.</returns>
366 [ExcludeFromBurstCompatTesting("Takes managed string")]
367 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, int arg3)
368
369 {
370 FixedString512Bytes result = default;
371 FixedString32Bytes carg0 = default; carg0.Append(arg0);
372 FixedString32Bytes carg1 = default; carg1.Append(arg1);
373 FixedString32Bytes carg2 = default; carg2.Append(arg2);
374 FixedString32Bytes carg3 = default; carg3.Append(arg3);
375
376
377 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
378 return result;
379 }
380
381 /// <summary>
382 /// Returns a new string produced by interpolating a format string.
383 /// </summary>
384 /// <remarks>
385 /// Similar to StringBuilder.AppendFormat but with significant limitations:
386 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
387 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
388 ///
389 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
390 /// - FixedString*N*Bytes
391 /// - string
392 /// - int
393 /// - float
394 /// - structs implementing INativeList<byte> and IUTF8Bytes
395 ///
396 /// <seealso cref="FixedStringMethods.AppendFormat"/>
397 /// </remarks>
398 /// <param name="formatString">The format string.</param>
399
400 /// <param name="arg0">Value to interpolate into the format string.</param>
401 /// <param name="arg1">Value to interpolate into the format string.</param>
402 /// <param name="arg2">Value to interpolate into the format string.</param>
403 /// <param name="arg3">Value to interpolate into the format string.</param>
404 /// <returns>A new string produced by interpolating the format string.</returns>
405 [ExcludeFromBurstCompatTesting("Takes managed string")]
406 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, int arg3)
407
408 {
409 FixedString512Bytes result = default;
410 FixedString32Bytes carg0 = default; carg0.Append(arg0);
411 FixedString32Bytes carg1 = default; carg1.Append(arg1);
412 FixedString32Bytes carg2 = default; carg2.Append(arg2);
413 FixedString32Bytes carg3 = default; carg3.Append(arg3);
414
415
416 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
417 return result;
418 }
419
420 /// <summary>
421 /// Returns a new string produced by interpolating a format string.
422 /// </summary>
423 /// <remarks>
424 /// Similar to StringBuilder.AppendFormat but with significant limitations:
425 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
426 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
427 ///
428 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
429 /// - FixedString*N*Bytes
430 /// - string
431 /// - int
432 /// - float
433 /// - structs implementing INativeList<byte> and IUTF8Bytes
434 ///
435 /// <seealso cref="FixedStringMethods.AppendFormat"/>
436 /// </remarks>
437 /// <param name="formatString">The format string.</param>
438
439 /// <param name="arg0">Value to interpolate into the format string.</param>
440 /// <param name="arg1">Value to interpolate into the format string.</param>
441 /// <param name="arg2">Value to interpolate into the format string.</param>
442 /// <param name="arg3">Value to interpolate into the format string.</param>
443 /// <returns>A new string produced by interpolating the format string.</returns>
444 [ExcludeFromBurstCompatTesting("Takes managed string")]
445 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, int arg3)
446
447 {
448 FixedString512Bytes result = default;
449 FixedString32Bytes carg0 = default; carg0.Append(arg0);
450 FixedString32Bytes carg1 = default; carg1.Append(arg1);
451 FixedString32Bytes carg2 = default; carg2.Append(arg2);
452 FixedString32Bytes carg3 = default; carg3.Append(arg3);
453
454
455 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
456 return result;
457 }
458
459 /// <summary>
460 /// Returns a new string produced by interpolating a format string.
461 /// </summary>
462 /// <remarks>
463 /// Similar to StringBuilder.AppendFormat but with significant limitations:
464 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
465 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
466 ///
467 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
468 /// - FixedString*N*Bytes
469 /// - string
470 /// - int
471 /// - float
472 /// - structs implementing INativeList<byte> and IUTF8Bytes
473 ///
474 /// <seealso cref="FixedStringMethods.AppendFormat"/>
475 /// </remarks>
476 /// <param name="formatString">The format string.</param>
477 /// <typeparam name="T1"><undoc /></typeparam>
478
479 /// <param name="arg0">Value to interpolate into the format string.</param>
480 /// <param name="arg1">Value to interpolate into the format string.</param>
481 /// <param name="arg2">Value to interpolate into the format string.</param>
482 /// <param name="arg3">Value to interpolate into the format string.</param>
483 /// <returns>A new string produced by interpolating the format string.</returns>
484 [ExcludeFromBurstCompatTesting("Takes managed string")]
485 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, int arg3)
486 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
487
488 {
489 FixedString512Bytes result = default;
490 FixedString32Bytes carg1 = default; carg1.Append(arg1);
491 FixedString32Bytes carg2 = default; carg2.Append(arg2);
492 FixedString32Bytes carg3 = default; carg3.Append(arg3);
493
494
495 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
496 return result;
497 }
498
499 /// <summary>
500 /// Returns a new string produced by interpolating a format string.
501 /// </summary>
502 /// <remarks>
503 /// Similar to StringBuilder.AppendFormat but with significant limitations:
504 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
505 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
506 ///
507 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
508 /// - FixedString*N*Bytes
509 /// - string
510 /// - int
511 /// - float
512 /// - structs implementing INativeList<byte> and IUTF8Bytes
513 ///
514 /// <seealso cref="FixedStringMethods.AppendFormat"/>
515 /// </remarks>
516 /// <param name="formatString">The format string.</param>
517 /// <typeparam name="T1"><undoc /></typeparam>
518
519 /// <param name="arg0">Value to interpolate into the format string.</param>
520 /// <param name="arg1">Value to interpolate into the format string.</param>
521 /// <param name="arg2">Value to interpolate into the format string.</param>
522 /// <param name="arg3">Value to interpolate into the format string.</param>
523 /// <returns>A new string produced by interpolating the format string.</returns>
524 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
525 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, int arg3)
526 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
527
528 {
529 FixedString512Bytes result = default;
530 FixedString32Bytes carg0 = default; carg0.Append(arg0);
531 FixedString32Bytes carg2 = default; carg2.Append(arg2);
532 FixedString32Bytes carg3 = default; carg3.Append(arg3);
533
534
535 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
536 return result;
537 }
538
539 /// <summary>
540 /// Returns a new string produced by interpolating a format string.
541 /// </summary>
542 /// <remarks>
543 /// Similar to StringBuilder.AppendFormat but with significant limitations:
544 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
545 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
546 ///
547 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
548 /// - FixedString*N*Bytes
549 /// - string
550 /// - int
551 /// - float
552 /// - structs implementing INativeList<byte> and IUTF8Bytes
553 ///
554 /// <seealso cref="FixedStringMethods.AppendFormat"/>
555 /// </remarks>
556 /// <param name="formatString">The format string.</param>
557 /// <typeparam name="T1"><undoc /></typeparam>
558
559 /// <param name="arg0">Value to interpolate into the format string.</param>
560 /// <param name="arg1">Value to interpolate into the format string.</param>
561 /// <param name="arg2">Value to interpolate into the format string.</param>
562 /// <param name="arg3">Value to interpolate into the format string.</param>
563 /// <returns>A new string produced by interpolating the format string.</returns>
564 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
565 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, int arg3)
566 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
567
568 {
569 FixedString512Bytes result = default;
570 FixedString32Bytes carg0 = default; carg0.Append(arg0);
571 FixedString32Bytes carg2 = default; carg2.Append(arg2);
572 FixedString32Bytes carg3 = default; carg3.Append(arg3);
573
574
575 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
576 return result;
577 }
578
579 /// <summary>
580 /// Returns a new string produced by interpolating a format string.
581 /// </summary>
582 /// <remarks>
583 /// Similar to StringBuilder.AppendFormat but with significant limitations:
584 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
585 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
586 ///
587 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
588 /// - FixedString*N*Bytes
589 /// - string
590 /// - int
591 /// - float
592 /// - structs implementing INativeList<byte> and IUTF8Bytes
593 ///
594 /// <seealso cref="FixedStringMethods.AppendFormat"/>
595 /// </remarks>
596 /// <param name="formatString">The format string.</param>
597 /// <typeparam name="T1"><undoc /></typeparam>
598
599 /// <param name="arg0">Value to interpolate into the format string.</param>
600 /// <param name="arg1">Value to interpolate into the format string.</param>
601 /// <param name="arg2">Value to interpolate into the format string.</param>
602 /// <param name="arg3">Value to interpolate into the format string.</param>
603 /// <returns>A new string produced by interpolating the format string.</returns>
604 [ExcludeFromBurstCompatTesting("Takes managed string")]
605 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, int arg3)
606 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
607
608 {
609 FixedString512Bytes result = default;
610 FixedString32Bytes carg0 = default; carg0.Append(arg0);
611 FixedString32Bytes carg2 = default; carg2.Append(arg2);
612 FixedString32Bytes carg3 = default; carg3.Append(arg3);
613
614
615 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
616 return result;
617 }
618
619 /// <summary>
620 /// Returns a new string produced by interpolating a format string.
621 /// </summary>
622 /// <remarks>
623 /// Similar to StringBuilder.AppendFormat but with significant limitations:
624 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
625 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
626 ///
627 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
628 /// - FixedString*N*Bytes
629 /// - string
630 /// - int
631 /// - float
632 /// - structs implementing INativeList<byte> and IUTF8Bytes
633 ///
634 /// <seealso cref="FixedStringMethods.AppendFormat"/>
635 /// </remarks>
636 /// <param name="formatString">The format string.</param>
637 /// <typeparam name="T1"><undoc /></typeparam>
638 /// <typeparam name="T2"><undoc /></typeparam>
639
640 /// <param name="arg0">Value to interpolate into the format string.</param>
641 /// <param name="arg1">Value to interpolate into the format string.</param>
642 /// <param name="arg2">Value to interpolate into the format string.</param>
643 /// <param name="arg3">Value to interpolate into the format string.</param>
644 /// <returns>A new string produced by interpolating the format string.</returns>
645 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
646 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, int arg3)
647 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
648 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
649
650 {
651 FixedString512Bytes result = default;
652 FixedString32Bytes carg2 = default; carg2.Append(arg2);
653 FixedString32Bytes carg3 = default; carg3.Append(arg3);
654
655
656 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
657 return result;
658 }
659
660 /// <summary>
661 /// Returns a new string produced by interpolating a format string.
662 /// </summary>
663 /// <remarks>
664 /// Similar to StringBuilder.AppendFormat but with significant limitations:
665 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
666 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
667 ///
668 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
669 /// - FixedString*N*Bytes
670 /// - string
671 /// - int
672 /// - float
673 /// - structs implementing INativeList<byte> and IUTF8Bytes
674 ///
675 /// <seealso cref="FixedStringMethods.AppendFormat"/>
676 /// </remarks>
677 /// <param name="formatString">The format string.</param>
678
679 /// <param name="arg0">Value to interpolate into the format string.</param>
680 /// <param name="arg1">Value to interpolate into the format string.</param>
681 /// <param name="arg2">Value to interpolate into the format string.</param>
682 /// <param name="arg3">Value to interpolate into the format string.</param>
683 /// <returns>A new string produced by interpolating the format string.</returns>
684
685 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, int arg3)
686
687 {
688 FixedString512Bytes result = default;
689 FixedString32Bytes carg0 = default; carg0.Append(arg0);
690 FixedString32Bytes carg1 = default; carg1.Append(arg1);
691 FixedString32Bytes carg2 = default; carg2.Append(arg2);
692 FixedString32Bytes carg3 = default; carg3.Append(arg3);
693
694
695 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
696 return result;
697 }
698
699 /// <summary>
700 /// Returns a new string produced by interpolating a format string.
701 /// </summary>
702 /// <remarks>
703 /// Similar to StringBuilder.AppendFormat but with significant limitations:
704 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
705 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
706 ///
707 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
708 /// - FixedString*N*Bytes
709 /// - string
710 /// - int
711 /// - float
712 /// - structs implementing INativeList<byte> and IUTF8Bytes
713 ///
714 /// <seealso cref="FixedStringMethods.AppendFormat"/>
715 /// </remarks>
716 /// <param name="formatString">The format string.</param>
717
718 /// <param name="arg0">Value to interpolate into the format string.</param>
719 /// <param name="arg1">Value to interpolate into the format string.</param>
720 /// <param name="arg2">Value to interpolate into the format string.</param>
721 /// <param name="arg3">Value to interpolate into the format string.</param>
722 /// <returns>A new string produced by interpolating the format string.</returns>
723
724 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, int arg3)
725
726 {
727 FixedString512Bytes result = default;
728 FixedString32Bytes carg0 = default; carg0.Append(arg0);
729 FixedString32Bytes carg1 = default; carg1.Append(arg1);
730 FixedString32Bytes carg2 = default; carg2.Append(arg2);
731 FixedString32Bytes carg3 = default; carg3.Append(arg3);
732
733
734 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
735 return result;
736 }
737
738 /// <summary>
739 /// Returns a new string produced by interpolating a format string.
740 /// </summary>
741 /// <remarks>
742 /// Similar to StringBuilder.AppendFormat but with significant limitations:
743 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
744 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
745 ///
746 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
747 /// - FixedString*N*Bytes
748 /// - string
749 /// - int
750 /// - float
751 /// - structs implementing INativeList<byte> and IUTF8Bytes
752 ///
753 /// <seealso cref="FixedStringMethods.AppendFormat"/>
754 /// </remarks>
755 /// <param name="formatString">The format string.</param>
756
757 /// <param name="arg0">Value to interpolate into the format string.</param>
758 /// <param name="arg1">Value to interpolate into the format string.</param>
759 /// <param name="arg2">Value to interpolate into the format string.</param>
760 /// <param name="arg3">Value to interpolate into the format string.</param>
761 /// <returns>A new string produced by interpolating the format string.</returns>
762 [ExcludeFromBurstCompatTesting("Takes managed string")]
763 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, int arg3)
764
765 {
766 FixedString512Bytes result = default;
767 FixedString32Bytes carg0 = default; carg0.Append(arg0);
768 FixedString32Bytes carg1 = default; carg1.Append(arg1);
769 FixedString32Bytes carg2 = default; carg2.Append(arg2);
770 FixedString32Bytes carg3 = default; carg3.Append(arg3);
771
772
773 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
774 return result;
775 }
776
777 /// <summary>
778 /// Returns a new string produced by interpolating a format string.
779 /// </summary>
780 /// <remarks>
781 /// Similar to StringBuilder.AppendFormat but with significant limitations:
782 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
783 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
784 ///
785 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
786 /// - FixedString*N*Bytes
787 /// - string
788 /// - int
789 /// - float
790 /// - structs implementing INativeList<byte> and IUTF8Bytes
791 ///
792 /// <seealso cref="FixedStringMethods.AppendFormat"/>
793 /// </remarks>
794 /// <param name="formatString">The format string.</param>
795 /// <typeparam name="T1"><undoc /></typeparam>
796
797 /// <param name="arg0">Value to interpolate into the format string.</param>
798 /// <param name="arg1">Value to interpolate into the format string.</param>
799 /// <param name="arg2">Value to interpolate into the format string.</param>
800 /// <param name="arg3">Value to interpolate into the format string.</param>
801 /// <returns>A new string produced by interpolating the format string.</returns>
802 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
803 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, int arg3)
804 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
805
806 {
807 FixedString512Bytes result = default;
808 FixedString32Bytes carg1 = default; carg1.Append(arg1);
809 FixedString32Bytes carg2 = default; carg2.Append(arg2);
810 FixedString32Bytes carg3 = default; carg3.Append(arg3);
811
812
813 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
814 return result;
815 }
816
817 /// <summary>
818 /// Returns a new string produced by interpolating a format string.
819 /// </summary>
820 /// <remarks>
821 /// Similar to StringBuilder.AppendFormat but with significant limitations:
822 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
823 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
824 ///
825 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
826 /// - FixedString*N*Bytes
827 /// - string
828 /// - int
829 /// - float
830 /// - structs implementing INativeList<byte> and IUTF8Bytes
831 ///
832 /// <seealso cref="FixedStringMethods.AppendFormat"/>
833 /// </remarks>
834 /// <param name="formatString">The format string.</param>
835
836 /// <param name="arg0">Value to interpolate into the format string.</param>
837 /// <param name="arg1">Value to interpolate into the format string.</param>
838 /// <param name="arg2">Value to interpolate into the format string.</param>
839 /// <param name="arg3">Value to interpolate into the format string.</param>
840 /// <returns>A new string produced by interpolating the format string.</returns>
841
842 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, int arg3)
843
844 {
845 FixedString512Bytes result = default;
846 FixedString32Bytes carg0 = default; carg0.Append(arg0);
847 FixedString32Bytes carg1 = default; carg1.Append(arg1);
848 FixedString32Bytes carg2 = default; carg2.Append(arg2);
849 FixedString32Bytes carg3 = default; carg3.Append(arg3);
850
851
852 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
853 return result;
854 }
855
856 /// <summary>
857 /// Returns a new string produced by interpolating a format string.
858 /// </summary>
859 /// <remarks>
860 /// Similar to StringBuilder.AppendFormat but with significant limitations:
861 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
862 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
863 ///
864 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
865 /// - FixedString*N*Bytes
866 /// - string
867 /// - int
868 /// - float
869 /// - structs implementing INativeList<byte> and IUTF8Bytes
870 ///
871 /// <seealso cref="FixedStringMethods.AppendFormat"/>
872 /// </remarks>
873 /// <param name="formatString">The format string.</param>
874
875 /// <param name="arg0">Value to interpolate into the format string.</param>
876 /// <param name="arg1">Value to interpolate into the format string.</param>
877 /// <param name="arg2">Value to interpolate into the format string.</param>
878 /// <param name="arg3">Value to interpolate into the format string.</param>
879 /// <returns>A new string produced by interpolating the format string.</returns>
880
881 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, int arg3)
882
883 {
884 FixedString512Bytes result = default;
885 FixedString32Bytes carg0 = default; carg0.Append(arg0);
886 FixedString32Bytes carg1 = default; carg1.Append(arg1);
887 FixedString32Bytes carg2 = default; carg2.Append(arg2);
888 FixedString32Bytes carg3 = default; carg3.Append(arg3);
889
890
891 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
892 return result;
893 }
894
895 /// <summary>
896 /// Returns a new string produced by interpolating a format string.
897 /// </summary>
898 /// <remarks>
899 /// Similar to StringBuilder.AppendFormat but with significant limitations:
900 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
901 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
902 ///
903 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
904 /// - FixedString*N*Bytes
905 /// - string
906 /// - int
907 /// - float
908 /// - structs implementing INativeList<byte> and IUTF8Bytes
909 ///
910 /// <seealso cref="FixedStringMethods.AppendFormat"/>
911 /// </remarks>
912 /// <param name="formatString">The format string.</param>
913
914 /// <param name="arg0">Value to interpolate into the format string.</param>
915 /// <param name="arg1">Value to interpolate into the format string.</param>
916 /// <param name="arg2">Value to interpolate into the format string.</param>
917 /// <param name="arg3">Value to interpolate into the format string.</param>
918 /// <returns>A new string produced by interpolating the format string.</returns>
919 [ExcludeFromBurstCompatTesting("Takes managed string")]
920 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, int arg3)
921
922 {
923 FixedString512Bytes result = default;
924 FixedString32Bytes carg0 = default; carg0.Append(arg0);
925 FixedString32Bytes carg1 = default; carg1.Append(arg1);
926 FixedString32Bytes carg2 = default; carg2.Append(arg2);
927 FixedString32Bytes carg3 = default; carg3.Append(arg3);
928
929
930 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
931 return result;
932 }
933
934 /// <summary>
935 /// Returns a new string produced by interpolating a format string.
936 /// </summary>
937 /// <remarks>
938 /// Similar to StringBuilder.AppendFormat but with significant limitations:
939 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
940 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
941 ///
942 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
943 /// - FixedString*N*Bytes
944 /// - string
945 /// - int
946 /// - float
947 /// - structs implementing INativeList<byte> and IUTF8Bytes
948 ///
949 /// <seealso cref="FixedStringMethods.AppendFormat"/>
950 /// </remarks>
951 /// <param name="formatString">The format string.</param>
952 /// <typeparam name="T1"><undoc /></typeparam>
953
954 /// <param name="arg0">Value to interpolate into the format string.</param>
955 /// <param name="arg1">Value to interpolate into the format string.</param>
956 /// <param name="arg2">Value to interpolate into the format string.</param>
957 /// <param name="arg3">Value to interpolate into the format string.</param>
958 /// <returns>A new string produced by interpolating the format string.</returns>
959 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
960 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, int arg3)
961 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
962
963 {
964 FixedString512Bytes result = default;
965 FixedString32Bytes carg1 = default; carg1.Append(arg1);
966 FixedString32Bytes carg2 = default; carg2.Append(arg2);
967 FixedString32Bytes carg3 = default; carg3.Append(arg3);
968
969
970 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
971 return result;
972 }
973
974 /// <summary>
975 /// Returns a new string produced by interpolating a format string.
976 /// </summary>
977 /// <remarks>
978 /// Similar to StringBuilder.AppendFormat but with significant limitations:
979 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
980 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
981 ///
982 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
983 /// - FixedString*N*Bytes
984 /// - string
985 /// - int
986 /// - float
987 /// - structs implementing INativeList<byte> and IUTF8Bytes
988 ///
989 /// <seealso cref="FixedStringMethods.AppendFormat"/>
990 /// </remarks>
991 /// <param name="formatString">The format string.</param>
992
993 /// <param name="arg0">Value to interpolate into the format string.</param>
994 /// <param name="arg1">Value to interpolate into the format string.</param>
995 /// <param name="arg2">Value to interpolate into the format string.</param>
996 /// <param name="arg3">Value to interpolate into the format string.</param>
997 /// <returns>A new string produced by interpolating the format string.</returns>
998 [ExcludeFromBurstCompatTesting("Takes managed string")]
999 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, int arg3)
1000
1001 {
1002 FixedString512Bytes result = default;
1003 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1004 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1005 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1006 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1007
1008
1009 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1010 return result;
1011 }
1012
1013 /// <summary>
1014 /// Returns a new string produced by interpolating a format string.
1015 /// </summary>
1016 /// <remarks>
1017 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1018 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1019 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1020 ///
1021 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1022 /// - FixedString*N*Bytes
1023 /// - string
1024 /// - int
1025 /// - float
1026 /// - structs implementing INativeList<byte> and IUTF8Bytes
1027 ///
1028 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1029 /// </remarks>
1030 /// <param name="formatString">The format string.</param>
1031
1032 /// <param name="arg0">Value to interpolate into the format string.</param>
1033 /// <param name="arg1">Value to interpolate into the format string.</param>
1034 /// <param name="arg2">Value to interpolate into the format string.</param>
1035 /// <param name="arg3">Value to interpolate into the format string.</param>
1036 /// <returns>A new string produced by interpolating the format string.</returns>
1037 [ExcludeFromBurstCompatTesting("Takes managed string")]
1038 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, int arg3)
1039
1040 {
1041 FixedString512Bytes result = default;
1042 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1043 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1044 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1045 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1046
1047
1048 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1049 return result;
1050 }
1051
1052 /// <summary>
1053 /// Returns a new string produced by interpolating a format string.
1054 /// </summary>
1055 /// <remarks>
1056 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1057 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1058 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1059 ///
1060 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1061 /// - FixedString*N*Bytes
1062 /// - string
1063 /// - int
1064 /// - float
1065 /// - structs implementing INativeList<byte> and IUTF8Bytes
1066 ///
1067 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1068 /// </remarks>
1069 /// <param name="formatString">The format string.</param>
1070
1071 /// <param name="arg0">Value to interpolate into the format string.</param>
1072 /// <param name="arg1">Value to interpolate into the format string.</param>
1073 /// <param name="arg2">Value to interpolate into the format string.</param>
1074 /// <param name="arg3">Value to interpolate into the format string.</param>
1075 /// <returns>A new string produced by interpolating the format string.</returns>
1076 [ExcludeFromBurstCompatTesting("Takes managed string")]
1077 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, int arg3)
1078
1079 {
1080 FixedString512Bytes result = default;
1081 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1082 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1083 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1084 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1085
1086
1087 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1088 return result;
1089 }
1090
1091 /// <summary>
1092 /// Returns a new string produced by interpolating a format string.
1093 /// </summary>
1094 /// <remarks>
1095 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1096 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1097 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1098 ///
1099 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1100 /// - FixedString*N*Bytes
1101 /// - string
1102 /// - int
1103 /// - float
1104 /// - structs implementing INativeList<byte> and IUTF8Bytes
1105 ///
1106 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1107 /// </remarks>
1108 /// <param name="formatString">The format string.</param>
1109 /// <typeparam name="T1"><undoc /></typeparam>
1110
1111 /// <param name="arg0">Value to interpolate into the format string.</param>
1112 /// <param name="arg1">Value to interpolate into the format string.</param>
1113 /// <param name="arg2">Value to interpolate into the format string.</param>
1114 /// <param name="arg3">Value to interpolate into the format string.</param>
1115 /// <returns>A new string produced by interpolating the format string.</returns>
1116 [ExcludeFromBurstCompatTesting("Takes managed string")]
1117 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, int arg3)
1118 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1119
1120 {
1121 FixedString512Bytes result = default;
1122 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1123 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1124 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1125
1126
1127 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
1128 return result;
1129 }
1130
1131 /// <summary>
1132 /// Returns a new string produced by interpolating a format string.
1133 /// </summary>
1134 /// <remarks>
1135 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1136 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1137 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1138 ///
1139 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1140 /// - FixedString*N*Bytes
1141 /// - string
1142 /// - int
1143 /// - float
1144 /// - structs implementing INativeList<byte> and IUTF8Bytes
1145 ///
1146 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1147 /// </remarks>
1148 /// <param name="formatString">The format string.</param>
1149 /// <typeparam name="T1"><undoc /></typeparam>
1150
1151 /// <param name="arg0">Value to interpolate into the format string.</param>
1152 /// <param name="arg1">Value to interpolate into the format string.</param>
1153 /// <param name="arg2">Value to interpolate into the format string.</param>
1154 /// <param name="arg3">Value to interpolate into the format string.</param>
1155 /// <returns>A new string produced by interpolating the format string.</returns>
1156 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
1157 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, int arg3)
1158 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1159
1160 {
1161 FixedString512Bytes result = default;
1162 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1163 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1164 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1165
1166
1167 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1168 return result;
1169 }
1170
1171 /// <summary>
1172 /// Returns a new string produced by interpolating a format string.
1173 /// </summary>
1174 /// <remarks>
1175 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1176 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1177 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1178 ///
1179 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1180 /// - FixedString*N*Bytes
1181 /// - string
1182 /// - int
1183 /// - float
1184 /// - structs implementing INativeList<byte> and IUTF8Bytes
1185 ///
1186 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1187 /// </remarks>
1188 /// <param name="formatString">The format string.</param>
1189 /// <typeparam name="T1"><undoc /></typeparam>
1190
1191 /// <param name="arg0">Value to interpolate into the format string.</param>
1192 /// <param name="arg1">Value to interpolate into the format string.</param>
1193 /// <param name="arg2">Value to interpolate into the format string.</param>
1194 /// <param name="arg3">Value to interpolate into the format string.</param>
1195 /// <returns>A new string produced by interpolating the format string.</returns>
1196 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
1197 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, int arg3)
1198 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1199
1200 {
1201 FixedString512Bytes result = default;
1202 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1203 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1204 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1205
1206
1207 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1208 return result;
1209 }
1210
1211 /// <summary>
1212 /// Returns a new string produced by interpolating a format string.
1213 /// </summary>
1214 /// <remarks>
1215 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1216 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1217 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1218 ///
1219 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1220 /// - FixedString*N*Bytes
1221 /// - string
1222 /// - int
1223 /// - float
1224 /// - structs implementing INativeList<byte> and IUTF8Bytes
1225 ///
1226 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1227 /// </remarks>
1228 /// <param name="formatString">The format string.</param>
1229 /// <typeparam name="T1"><undoc /></typeparam>
1230
1231 /// <param name="arg0">Value to interpolate into the format string.</param>
1232 /// <param name="arg1">Value to interpolate into the format string.</param>
1233 /// <param name="arg2">Value to interpolate into the format string.</param>
1234 /// <param name="arg3">Value to interpolate into the format string.</param>
1235 /// <returns>A new string produced by interpolating the format string.</returns>
1236 [ExcludeFromBurstCompatTesting("Takes managed string")]
1237 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, int arg3)
1238 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1239
1240 {
1241 FixedString512Bytes result = default;
1242 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1243 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1244 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1245
1246
1247 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1248 return result;
1249 }
1250
1251 /// <summary>
1252 /// Returns a new string produced by interpolating a format string.
1253 /// </summary>
1254 /// <remarks>
1255 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1256 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1257 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1258 ///
1259 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1260 /// - FixedString*N*Bytes
1261 /// - string
1262 /// - int
1263 /// - float
1264 /// - structs implementing INativeList<byte> and IUTF8Bytes
1265 ///
1266 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1267 /// </remarks>
1268 /// <param name="formatString">The format string.</param>
1269 /// <typeparam name="T1"><undoc /></typeparam>
1270 /// <typeparam name="T2"><undoc /></typeparam>
1271
1272 /// <param name="arg0">Value to interpolate into the format string.</param>
1273 /// <param name="arg1">Value to interpolate into the format string.</param>
1274 /// <param name="arg2">Value to interpolate into the format string.</param>
1275 /// <param name="arg3">Value to interpolate into the format string.</param>
1276 /// <returns>A new string produced by interpolating the format string.</returns>
1277 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
1278 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, int arg3)
1279 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1280 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
1281
1282 {
1283 FixedString512Bytes result = default;
1284 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1285 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1286
1287
1288 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
1289 return result;
1290 }
1291
1292 /// <summary>
1293 /// Returns a new string produced by interpolating a format string.
1294 /// </summary>
1295 /// <remarks>
1296 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1297 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1298 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1299 ///
1300 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1301 /// - FixedString*N*Bytes
1302 /// - string
1303 /// - int
1304 /// - float
1305 /// - structs implementing INativeList<byte> and IUTF8Bytes
1306 ///
1307 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1308 /// </remarks>
1309 /// <param name="formatString">The format string.</param>
1310
1311 /// <param name="arg0">Value to interpolate into the format string.</param>
1312 /// <param name="arg1">Value to interpolate into the format string.</param>
1313 /// <param name="arg2">Value to interpolate into the format string.</param>
1314 /// <param name="arg3">Value to interpolate into the format string.</param>
1315 /// <returns>A new string produced by interpolating the format string.</returns>
1316 [ExcludeFromBurstCompatTesting("Takes managed string")]
1317 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, int arg3)
1318
1319 {
1320 FixedString512Bytes result = default;
1321 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1322 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1323 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1324 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1325
1326
1327 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1328 return result;
1329 }
1330
1331 /// <summary>
1332 /// Returns a new string produced by interpolating a format string.
1333 /// </summary>
1334 /// <remarks>
1335 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1336 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1337 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1338 ///
1339 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1340 /// - FixedString*N*Bytes
1341 /// - string
1342 /// - int
1343 /// - float
1344 /// - structs implementing INativeList<byte> and IUTF8Bytes
1345 ///
1346 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1347 /// </remarks>
1348 /// <param name="formatString">The format string.</param>
1349
1350 /// <param name="arg0">Value to interpolate into the format string.</param>
1351 /// <param name="arg1">Value to interpolate into the format string.</param>
1352 /// <param name="arg2">Value to interpolate into the format string.</param>
1353 /// <param name="arg3">Value to interpolate into the format string.</param>
1354 /// <returns>A new string produced by interpolating the format string.</returns>
1355 [ExcludeFromBurstCompatTesting("Takes managed string")]
1356 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, int arg3)
1357
1358 {
1359 FixedString512Bytes result = default;
1360 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1361 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1362 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1363 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1364
1365
1366 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1367 return result;
1368 }
1369
1370 /// <summary>
1371 /// Returns a new string produced by interpolating a format string.
1372 /// </summary>
1373 /// <remarks>
1374 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1375 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1376 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1377 ///
1378 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1379 /// - FixedString*N*Bytes
1380 /// - string
1381 /// - int
1382 /// - float
1383 /// - structs implementing INativeList<byte> and IUTF8Bytes
1384 ///
1385 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1386 /// </remarks>
1387 /// <param name="formatString">The format string.</param>
1388
1389 /// <param name="arg0">Value to interpolate into the format string.</param>
1390 /// <param name="arg1">Value to interpolate into the format string.</param>
1391 /// <param name="arg2">Value to interpolate into the format string.</param>
1392 /// <param name="arg3">Value to interpolate into the format string.</param>
1393 /// <returns>A new string produced by interpolating the format string.</returns>
1394 [ExcludeFromBurstCompatTesting("Takes managed string")]
1395 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, int arg3)
1396
1397 {
1398 FixedString512Bytes result = default;
1399 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1400 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1401 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1402 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1403
1404
1405 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1406 return result;
1407 }
1408
1409 /// <summary>
1410 /// Returns a new string produced by interpolating a format string.
1411 /// </summary>
1412 /// <remarks>
1413 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1414 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1415 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1416 ///
1417 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1418 /// - FixedString*N*Bytes
1419 /// - string
1420 /// - int
1421 /// - float
1422 /// - structs implementing INativeList<byte> and IUTF8Bytes
1423 ///
1424 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1425 /// </remarks>
1426 /// <param name="formatString">The format string.</param>
1427 /// <typeparam name="T1"><undoc /></typeparam>
1428
1429 /// <param name="arg0">Value to interpolate into the format string.</param>
1430 /// <param name="arg1">Value to interpolate into the format string.</param>
1431 /// <param name="arg2">Value to interpolate into the format string.</param>
1432 /// <param name="arg3">Value to interpolate into the format string.</param>
1433 /// <returns>A new string produced by interpolating the format string.</returns>
1434 [ExcludeFromBurstCompatTesting("Takes managed string")]
1435 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, int arg3)
1436 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1437
1438 {
1439 FixedString512Bytes result = default;
1440 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1441 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1442 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1443
1444
1445 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
1446 return result;
1447 }
1448
1449 /// <summary>
1450 /// Returns a new string produced by interpolating a format string.
1451 /// </summary>
1452 /// <remarks>
1453 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1454 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1455 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1456 ///
1457 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1458 /// - FixedString*N*Bytes
1459 /// - string
1460 /// - int
1461 /// - float
1462 /// - structs implementing INativeList<byte> and IUTF8Bytes
1463 ///
1464 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1465 /// </remarks>
1466 /// <param name="formatString">The format string.</param>
1467
1468 /// <param name="arg0">Value to interpolate into the format string.</param>
1469 /// <param name="arg1">Value to interpolate into the format string.</param>
1470 /// <param name="arg2">Value to interpolate into the format string.</param>
1471 /// <param name="arg3">Value to interpolate into the format string.</param>
1472 /// <returns>A new string produced by interpolating the format string.</returns>
1473 [ExcludeFromBurstCompatTesting("Takes managed string")]
1474 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, int arg3)
1475
1476 {
1477 FixedString512Bytes result = default;
1478 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1479 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1480 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1481 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1482
1483
1484 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1485 return result;
1486 }
1487
1488 /// <summary>
1489 /// Returns a new string produced by interpolating a format string.
1490 /// </summary>
1491 /// <remarks>
1492 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1493 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1494 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1495 ///
1496 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1497 /// - FixedString*N*Bytes
1498 /// - string
1499 /// - int
1500 /// - float
1501 /// - structs implementing INativeList<byte> and IUTF8Bytes
1502 ///
1503 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1504 /// </remarks>
1505 /// <param name="formatString">The format string.</param>
1506
1507 /// <param name="arg0">Value to interpolate into the format string.</param>
1508 /// <param name="arg1">Value to interpolate into the format string.</param>
1509 /// <param name="arg2">Value to interpolate into the format string.</param>
1510 /// <param name="arg3">Value to interpolate into the format string.</param>
1511 /// <returns>A new string produced by interpolating the format string.</returns>
1512 [ExcludeFromBurstCompatTesting("Takes managed string")]
1513 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, int arg3)
1514
1515 {
1516 FixedString512Bytes result = default;
1517 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1518 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1519 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1520 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1521
1522
1523 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1524 return result;
1525 }
1526
1527 /// <summary>
1528 /// Returns a new string produced by interpolating a format string.
1529 /// </summary>
1530 /// <remarks>
1531 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1532 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1533 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1534 ///
1535 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1536 /// - FixedString*N*Bytes
1537 /// - string
1538 /// - int
1539 /// - float
1540 /// - structs implementing INativeList<byte> and IUTF8Bytes
1541 ///
1542 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1543 /// </remarks>
1544 /// <param name="formatString">The format string.</param>
1545
1546 /// <param name="arg0">Value to interpolate into the format string.</param>
1547 /// <param name="arg1">Value to interpolate into the format string.</param>
1548 /// <param name="arg2">Value to interpolate into the format string.</param>
1549 /// <param name="arg3">Value to interpolate into the format string.</param>
1550 /// <returns>A new string produced by interpolating the format string.</returns>
1551 [ExcludeFromBurstCompatTesting("Takes managed string")]
1552 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, int arg3)
1553
1554 {
1555 FixedString512Bytes result = default;
1556 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1557 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1558 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1559 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1560
1561
1562 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1563 return result;
1564 }
1565
1566 /// <summary>
1567 /// Returns a new string produced by interpolating a format string.
1568 /// </summary>
1569 /// <remarks>
1570 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1571 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1572 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1573 ///
1574 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1575 /// - FixedString*N*Bytes
1576 /// - string
1577 /// - int
1578 /// - float
1579 /// - structs implementing INativeList<byte> and IUTF8Bytes
1580 ///
1581 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1582 /// </remarks>
1583 /// <param name="formatString">The format string.</param>
1584 /// <typeparam name="T1"><undoc /></typeparam>
1585
1586 /// <param name="arg0">Value to interpolate into the format string.</param>
1587 /// <param name="arg1">Value to interpolate into the format string.</param>
1588 /// <param name="arg2">Value to interpolate into the format string.</param>
1589 /// <param name="arg3">Value to interpolate into the format string.</param>
1590 /// <returns>A new string produced by interpolating the format string.</returns>
1591 [ExcludeFromBurstCompatTesting("Takes managed string")]
1592 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, int arg3)
1593 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1594
1595 {
1596 FixedString512Bytes result = default;
1597 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1598 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1599 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1600
1601
1602 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
1603 return result;
1604 }
1605
1606 /// <summary>
1607 /// Returns a new string produced by interpolating a format string.
1608 /// </summary>
1609 /// <remarks>
1610 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1611 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1612 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1613 ///
1614 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1615 /// - FixedString*N*Bytes
1616 /// - string
1617 /// - int
1618 /// - float
1619 /// - structs implementing INativeList<byte> and IUTF8Bytes
1620 ///
1621 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1622 /// </remarks>
1623 /// <param name="formatString">The format string.</param>
1624
1625 /// <param name="arg0">Value to interpolate into the format string.</param>
1626 /// <param name="arg1">Value to interpolate into the format string.</param>
1627 /// <param name="arg2">Value to interpolate into the format string.</param>
1628 /// <param name="arg3">Value to interpolate into the format string.</param>
1629 /// <returns>A new string produced by interpolating the format string.</returns>
1630 [ExcludeFromBurstCompatTesting("Takes managed string")]
1631 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, int arg3)
1632
1633 {
1634 FixedString512Bytes result = default;
1635 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1636 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1637 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1638 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1639
1640
1641 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1642 return result;
1643 }
1644
1645 /// <summary>
1646 /// Returns a new string produced by interpolating a format string.
1647 /// </summary>
1648 /// <remarks>
1649 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1650 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1651 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1652 ///
1653 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1654 /// - FixedString*N*Bytes
1655 /// - string
1656 /// - int
1657 /// - float
1658 /// - structs implementing INativeList<byte> and IUTF8Bytes
1659 ///
1660 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1661 /// </remarks>
1662 /// <param name="formatString">The format string.</param>
1663
1664 /// <param name="arg0">Value to interpolate into the format string.</param>
1665 /// <param name="arg1">Value to interpolate into the format string.</param>
1666 /// <param name="arg2">Value to interpolate into the format string.</param>
1667 /// <param name="arg3">Value to interpolate into the format string.</param>
1668 /// <returns>A new string produced by interpolating the format string.</returns>
1669 [ExcludeFromBurstCompatTesting("Takes managed string")]
1670 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, int arg3)
1671
1672 {
1673 FixedString512Bytes result = default;
1674 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1675 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1676 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1677 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1678
1679
1680 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1681 return result;
1682 }
1683
1684 /// <summary>
1685 /// Returns a new string produced by interpolating a format string.
1686 /// </summary>
1687 /// <remarks>
1688 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1689 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1690 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1691 ///
1692 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1693 /// - FixedString*N*Bytes
1694 /// - string
1695 /// - int
1696 /// - float
1697 /// - structs implementing INativeList<byte> and IUTF8Bytes
1698 ///
1699 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1700 /// </remarks>
1701 /// <param name="formatString">The format string.</param>
1702
1703 /// <param name="arg0">Value to interpolate into the format string.</param>
1704 /// <param name="arg1">Value to interpolate into the format string.</param>
1705 /// <param name="arg2">Value to interpolate into the format string.</param>
1706 /// <param name="arg3">Value to interpolate into the format string.</param>
1707 /// <returns>A new string produced by interpolating the format string.</returns>
1708 [ExcludeFromBurstCompatTesting("Takes managed string")]
1709 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, int arg3)
1710
1711 {
1712 FixedString512Bytes result = default;
1713 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1714 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1715 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1716 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1717
1718
1719 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
1720 return result;
1721 }
1722
1723 /// <summary>
1724 /// Returns a new string produced by interpolating a format string.
1725 /// </summary>
1726 /// <remarks>
1727 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1728 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1729 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1730 ///
1731 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1732 /// - FixedString*N*Bytes
1733 /// - string
1734 /// - int
1735 /// - float
1736 /// - structs implementing INativeList<byte> and IUTF8Bytes
1737 ///
1738 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1739 /// </remarks>
1740 /// <param name="formatString">The format string.</param>
1741 /// <typeparam name="T1"><undoc /></typeparam>
1742
1743 /// <param name="arg0">Value to interpolate into the format string.</param>
1744 /// <param name="arg1">Value to interpolate into the format string.</param>
1745 /// <param name="arg2">Value to interpolate into the format string.</param>
1746 /// <param name="arg3">Value to interpolate into the format string.</param>
1747 /// <returns>A new string produced by interpolating the format string.</returns>
1748 [ExcludeFromBurstCompatTesting("Takes managed string")]
1749 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, int arg3)
1750 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1751
1752 {
1753 FixedString512Bytes result = default;
1754 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1755 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1756 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1757
1758
1759 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
1760 return result;
1761 }
1762
1763 /// <summary>
1764 /// Returns a new string produced by interpolating a format string.
1765 /// </summary>
1766 /// <remarks>
1767 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1768 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1769 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1770 ///
1771 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1772 /// - FixedString*N*Bytes
1773 /// - string
1774 /// - int
1775 /// - float
1776 /// - structs implementing INativeList<byte> and IUTF8Bytes
1777 ///
1778 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1779 /// </remarks>
1780 /// <param name="formatString">The format string.</param>
1781 /// <typeparam name="T1"><undoc /></typeparam>
1782
1783 /// <param name="arg0">Value to interpolate into the format string.</param>
1784 /// <param name="arg1">Value to interpolate into the format string.</param>
1785 /// <param name="arg2">Value to interpolate into the format string.</param>
1786 /// <param name="arg3">Value to interpolate into the format string.</param>
1787 /// <returns>A new string produced by interpolating the format string.</returns>
1788 [ExcludeFromBurstCompatTesting("Takes managed string")]
1789 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, int arg3)
1790 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1791
1792 {
1793 FixedString512Bytes result = default;
1794 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1795 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1796 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1797
1798
1799 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1800 return result;
1801 }
1802
1803 /// <summary>
1804 /// Returns a new string produced by interpolating a format string.
1805 /// </summary>
1806 /// <remarks>
1807 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1808 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1809 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1810 ///
1811 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1812 /// - FixedString*N*Bytes
1813 /// - string
1814 /// - int
1815 /// - float
1816 /// - structs implementing INativeList<byte> and IUTF8Bytes
1817 ///
1818 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1819 /// </remarks>
1820 /// <param name="formatString">The format string.</param>
1821 /// <typeparam name="T1"><undoc /></typeparam>
1822
1823 /// <param name="arg0">Value to interpolate into the format string.</param>
1824 /// <param name="arg1">Value to interpolate into the format string.</param>
1825 /// <param name="arg2">Value to interpolate into the format string.</param>
1826 /// <param name="arg3">Value to interpolate into the format string.</param>
1827 /// <returns>A new string produced by interpolating the format string.</returns>
1828 [ExcludeFromBurstCompatTesting("Takes managed string")]
1829 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, int arg3)
1830 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1831
1832 {
1833 FixedString512Bytes result = default;
1834 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1835 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1836 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1837
1838
1839 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1840 return result;
1841 }
1842
1843 /// <summary>
1844 /// Returns a new string produced by interpolating a format string.
1845 /// </summary>
1846 /// <remarks>
1847 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1848 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1849 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1850 ///
1851 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1852 /// - FixedString*N*Bytes
1853 /// - string
1854 /// - int
1855 /// - float
1856 /// - structs implementing INativeList<byte> and IUTF8Bytes
1857 ///
1858 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1859 /// </remarks>
1860 /// <param name="formatString">The format string.</param>
1861 /// <typeparam name="T1"><undoc /></typeparam>
1862
1863 /// <param name="arg0">Value to interpolate into the format string.</param>
1864 /// <param name="arg1">Value to interpolate into the format string.</param>
1865 /// <param name="arg2">Value to interpolate into the format string.</param>
1866 /// <param name="arg3">Value to interpolate into the format string.</param>
1867 /// <returns>A new string produced by interpolating the format string.</returns>
1868 [ExcludeFromBurstCompatTesting("Takes managed string")]
1869 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, int arg3)
1870 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1871
1872 {
1873 FixedString512Bytes result = default;
1874 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1875 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1876 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1877
1878
1879 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
1880 return result;
1881 }
1882
1883 /// <summary>
1884 /// Returns a new string produced by interpolating a format string.
1885 /// </summary>
1886 /// <remarks>
1887 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1888 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1889 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1890 ///
1891 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1892 /// - FixedString*N*Bytes
1893 /// - string
1894 /// - int
1895 /// - float
1896 /// - structs implementing INativeList<byte> and IUTF8Bytes
1897 ///
1898 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1899 /// </remarks>
1900 /// <param name="formatString">The format string.</param>
1901 /// <typeparam name="T1"><undoc /></typeparam>
1902 /// <typeparam name="T2"><undoc /></typeparam>
1903
1904 /// <param name="arg0">Value to interpolate into the format string.</param>
1905 /// <param name="arg1">Value to interpolate into the format string.</param>
1906 /// <param name="arg2">Value to interpolate into the format string.</param>
1907 /// <param name="arg3">Value to interpolate into the format string.</param>
1908 /// <returns>A new string produced by interpolating the format string.</returns>
1909 [ExcludeFromBurstCompatTesting("Takes managed string")]
1910 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, int arg3)
1911 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1912 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
1913
1914 {
1915 FixedString512Bytes result = default;
1916 FixedString32Bytes carg2 = default; carg2.Append(arg2);
1917 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1918
1919
1920 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
1921 return result;
1922 }
1923
1924 /// <summary>
1925 /// Returns a new string produced by interpolating a format string.
1926 /// </summary>
1927 /// <remarks>
1928 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1929 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1930 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1931 ///
1932 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1933 /// - FixedString*N*Bytes
1934 /// - string
1935 /// - int
1936 /// - float
1937 /// - structs implementing INativeList<byte> and IUTF8Bytes
1938 ///
1939 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1940 /// </remarks>
1941 /// <param name="formatString">The format string.</param>
1942 /// <typeparam name="T1"><undoc /></typeparam>
1943
1944 /// <param name="arg0">Value to interpolate into the format string.</param>
1945 /// <param name="arg1">Value to interpolate into the format string.</param>
1946 /// <param name="arg2">Value to interpolate into the format string.</param>
1947 /// <param name="arg3">Value to interpolate into the format string.</param>
1948 /// <returns>A new string produced by interpolating the format string.</returns>
1949 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
1950 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, int arg3)
1951 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1952
1953 {
1954 FixedString512Bytes result = default;
1955 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1956 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1957 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1958
1959
1960 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
1961 return result;
1962 }
1963
1964 /// <summary>
1965 /// Returns a new string produced by interpolating a format string.
1966 /// </summary>
1967 /// <remarks>
1968 /// Similar to StringBuilder.AppendFormat but with significant limitations:
1969 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
1970 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
1971 ///
1972 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
1973 /// - FixedString*N*Bytes
1974 /// - string
1975 /// - int
1976 /// - float
1977 /// - structs implementing INativeList<byte> and IUTF8Bytes
1978 ///
1979 /// <seealso cref="FixedStringMethods.AppendFormat"/>
1980 /// </remarks>
1981 /// <param name="formatString">The format string.</param>
1982 /// <typeparam name="T1"><undoc /></typeparam>
1983
1984 /// <param name="arg0">Value to interpolate into the format string.</param>
1985 /// <param name="arg1">Value to interpolate into the format string.</param>
1986 /// <param name="arg2">Value to interpolate into the format string.</param>
1987 /// <param name="arg3">Value to interpolate into the format string.</param>
1988 /// <returns>A new string produced by interpolating the format string.</returns>
1989 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
1990 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, int arg3)
1991 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
1992
1993 {
1994 FixedString512Bytes result = default;
1995 FixedString32Bytes carg0 = default; carg0.Append(arg0);
1996 FixedString32Bytes carg1 = default; carg1.Append(arg1);
1997 FixedString32Bytes carg3 = default; carg3.Append(arg3);
1998
1999
2000 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2001 return result;
2002 }
2003
2004 /// <summary>
2005 /// Returns a new string produced by interpolating a format string.
2006 /// </summary>
2007 /// <remarks>
2008 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2009 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2010 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2011 ///
2012 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2013 /// - FixedString*N*Bytes
2014 /// - string
2015 /// - int
2016 /// - float
2017 /// - structs implementing INativeList<byte> and IUTF8Bytes
2018 ///
2019 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2020 /// </remarks>
2021 /// <param name="formatString">The format string.</param>
2022 /// <typeparam name="T1"><undoc /></typeparam>
2023
2024 /// <param name="arg0">Value to interpolate into the format string.</param>
2025 /// <param name="arg1">Value to interpolate into the format string.</param>
2026 /// <param name="arg2">Value to interpolate into the format string.</param>
2027 /// <param name="arg3">Value to interpolate into the format string.</param>
2028 /// <returns>A new string produced by interpolating the format string.</returns>
2029 [ExcludeFromBurstCompatTesting("Takes managed string")]
2030 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, int arg3)
2031 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2032
2033 {
2034 FixedString512Bytes result = default;
2035 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2036 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2037 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2038
2039
2040 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2041 return result;
2042 }
2043
2044 /// <summary>
2045 /// Returns a new string produced by interpolating a format string.
2046 /// </summary>
2047 /// <remarks>
2048 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2049 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2050 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2051 ///
2052 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2053 /// - FixedString*N*Bytes
2054 /// - string
2055 /// - int
2056 /// - float
2057 /// - structs implementing INativeList<byte> and IUTF8Bytes
2058 ///
2059 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2060 /// </remarks>
2061 /// <param name="formatString">The format string.</param>
2062 /// <typeparam name="T1"><undoc /></typeparam>
2063 /// <typeparam name="T2"><undoc /></typeparam>
2064
2065 /// <param name="arg0">Value to interpolate into the format string.</param>
2066 /// <param name="arg1">Value to interpolate into the format string.</param>
2067 /// <param name="arg2">Value to interpolate into the format string.</param>
2068 /// <param name="arg3">Value to interpolate into the format string.</param>
2069 /// <returns>A new string produced by interpolating the format string.</returns>
2070 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
2071 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, int arg3)
2072 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2073 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2074
2075 {
2076 FixedString512Bytes result = default;
2077 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2078 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2079
2080
2081 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
2082 return result;
2083 }
2084
2085 /// <summary>
2086 /// Returns a new string produced by interpolating a format string.
2087 /// </summary>
2088 /// <remarks>
2089 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2090 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2091 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2092 ///
2093 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2094 /// - FixedString*N*Bytes
2095 /// - string
2096 /// - int
2097 /// - float
2098 /// - structs implementing INativeList<byte> and IUTF8Bytes
2099 ///
2100 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2101 /// </remarks>
2102 /// <param name="formatString">The format string.</param>
2103 /// <typeparam name="T1"><undoc /></typeparam>
2104
2105 /// <param name="arg0">Value to interpolate into the format string.</param>
2106 /// <param name="arg1">Value to interpolate into the format string.</param>
2107 /// <param name="arg2">Value to interpolate into the format string.</param>
2108 /// <param name="arg3">Value to interpolate into the format string.</param>
2109 /// <returns>A new string produced by interpolating the format string.</returns>
2110 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
2111 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, int arg3)
2112 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2113
2114 {
2115 FixedString512Bytes result = default;
2116 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2117 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2118 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2119
2120
2121 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2122 return result;
2123 }
2124
2125 /// <summary>
2126 /// Returns a new string produced by interpolating a format string.
2127 /// </summary>
2128 /// <remarks>
2129 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2130 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2131 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2132 ///
2133 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2134 /// - FixedString*N*Bytes
2135 /// - string
2136 /// - int
2137 /// - float
2138 /// - structs implementing INativeList<byte> and IUTF8Bytes
2139 ///
2140 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2141 /// </remarks>
2142 /// <param name="formatString">The format string.</param>
2143 /// <typeparam name="T1"><undoc /></typeparam>
2144
2145 /// <param name="arg0">Value to interpolate into the format string.</param>
2146 /// <param name="arg1">Value to interpolate into the format string.</param>
2147 /// <param name="arg2">Value to interpolate into the format string.</param>
2148 /// <param name="arg3">Value to interpolate into the format string.</param>
2149 /// <returns>A new string produced by interpolating the format string.</returns>
2150 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
2151 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, int arg3)
2152 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2153
2154 {
2155 FixedString512Bytes result = default;
2156 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2157 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2158 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2159
2160
2161 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2162 return result;
2163 }
2164
2165 /// <summary>
2166 /// Returns a new string produced by interpolating a format string.
2167 /// </summary>
2168 /// <remarks>
2169 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2170 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2171 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2172 ///
2173 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2174 /// - FixedString*N*Bytes
2175 /// - string
2176 /// - int
2177 /// - float
2178 /// - structs implementing INativeList<byte> and IUTF8Bytes
2179 ///
2180 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2181 /// </remarks>
2182 /// <param name="formatString">The format string.</param>
2183 /// <typeparam name="T1"><undoc /></typeparam>
2184
2185 /// <param name="arg0">Value to interpolate into the format string.</param>
2186 /// <param name="arg1">Value to interpolate into the format string.</param>
2187 /// <param name="arg2">Value to interpolate into the format string.</param>
2188 /// <param name="arg3">Value to interpolate into the format string.</param>
2189 /// <returns>A new string produced by interpolating the format string.</returns>
2190 [ExcludeFromBurstCompatTesting("Takes managed string")]
2191 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, int arg3)
2192 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2193
2194 {
2195 FixedString512Bytes result = default;
2196 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2197 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2198 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2199
2200
2201 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2202 return result;
2203 }
2204
2205 /// <summary>
2206 /// Returns a new string produced by interpolating a format string.
2207 /// </summary>
2208 /// <remarks>
2209 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2210 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2211 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2212 ///
2213 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2214 /// - FixedString*N*Bytes
2215 /// - string
2216 /// - int
2217 /// - float
2218 /// - structs implementing INativeList<byte> and IUTF8Bytes
2219 ///
2220 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2221 /// </remarks>
2222 /// <param name="formatString">The format string.</param>
2223 /// <typeparam name="T1"><undoc /></typeparam>
2224 /// <typeparam name="T2"><undoc /></typeparam>
2225
2226 /// <param name="arg0">Value to interpolate into the format string.</param>
2227 /// <param name="arg1">Value to interpolate into the format string.</param>
2228 /// <param name="arg2">Value to interpolate into the format string.</param>
2229 /// <param name="arg3">Value to interpolate into the format string.</param>
2230 /// <returns>A new string produced by interpolating the format string.</returns>
2231 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
2232 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, int arg3)
2233 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2234 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2235
2236 {
2237 FixedString512Bytes result = default;
2238 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2239 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2240
2241
2242 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
2243 return result;
2244 }
2245
2246 /// <summary>
2247 /// Returns a new string produced by interpolating a format string.
2248 /// </summary>
2249 /// <remarks>
2250 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2251 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2252 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2253 ///
2254 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2255 /// - FixedString*N*Bytes
2256 /// - string
2257 /// - int
2258 /// - float
2259 /// - structs implementing INativeList<byte> and IUTF8Bytes
2260 ///
2261 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2262 /// </remarks>
2263 /// <param name="formatString">The format string.</param>
2264 /// <typeparam name="T1"><undoc /></typeparam>
2265
2266 /// <param name="arg0">Value to interpolate into the format string.</param>
2267 /// <param name="arg1">Value to interpolate into the format string.</param>
2268 /// <param name="arg2">Value to interpolate into the format string.</param>
2269 /// <param name="arg3">Value to interpolate into the format string.</param>
2270 /// <returns>A new string produced by interpolating the format string.</returns>
2271 [ExcludeFromBurstCompatTesting("Takes managed string")]
2272 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, int arg3)
2273 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2274
2275 {
2276 FixedString512Bytes result = default;
2277 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2278 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2279 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2280
2281
2282 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2283 return result;
2284 }
2285
2286 /// <summary>
2287 /// Returns a new string produced by interpolating a format string.
2288 /// </summary>
2289 /// <remarks>
2290 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2291 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2292 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2293 ///
2294 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2295 /// - FixedString*N*Bytes
2296 /// - string
2297 /// - int
2298 /// - float
2299 /// - structs implementing INativeList<byte> and IUTF8Bytes
2300 ///
2301 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2302 /// </remarks>
2303 /// <param name="formatString">The format string.</param>
2304 /// <typeparam name="T1"><undoc /></typeparam>
2305
2306 /// <param name="arg0">Value to interpolate into the format string.</param>
2307 /// <param name="arg1">Value to interpolate into the format string.</param>
2308 /// <param name="arg2">Value to interpolate into the format string.</param>
2309 /// <param name="arg3">Value to interpolate into the format string.</param>
2310 /// <returns>A new string produced by interpolating the format string.</returns>
2311 [ExcludeFromBurstCompatTesting("Takes managed string")]
2312 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, int arg3)
2313 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2314
2315 {
2316 FixedString512Bytes result = default;
2317 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2318 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2319 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2320
2321
2322 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2323 return result;
2324 }
2325
2326 /// <summary>
2327 /// Returns a new string produced by interpolating a format string.
2328 /// </summary>
2329 /// <remarks>
2330 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2331 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2332 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2333 ///
2334 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2335 /// - FixedString*N*Bytes
2336 /// - string
2337 /// - int
2338 /// - float
2339 /// - structs implementing INativeList<byte> and IUTF8Bytes
2340 ///
2341 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2342 /// </remarks>
2343 /// <param name="formatString">The format string.</param>
2344 /// <typeparam name="T1"><undoc /></typeparam>
2345
2346 /// <param name="arg0">Value to interpolate into the format string.</param>
2347 /// <param name="arg1">Value to interpolate into the format string.</param>
2348 /// <param name="arg2">Value to interpolate into the format string.</param>
2349 /// <param name="arg3">Value to interpolate into the format string.</param>
2350 /// <returns>A new string produced by interpolating the format string.</returns>
2351 [ExcludeFromBurstCompatTesting("Takes managed string")]
2352 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, int arg3)
2353 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2354
2355 {
2356 FixedString512Bytes result = default;
2357 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2358 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2359 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2360
2361
2362 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
2363 return result;
2364 }
2365
2366 /// <summary>
2367 /// Returns a new string produced by interpolating a format string.
2368 /// </summary>
2369 /// <remarks>
2370 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2371 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2372 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2373 ///
2374 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2375 /// - FixedString*N*Bytes
2376 /// - string
2377 /// - int
2378 /// - float
2379 /// - structs implementing INativeList<byte> and IUTF8Bytes
2380 ///
2381 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2382 /// </remarks>
2383 /// <param name="formatString">The format string.</param>
2384 /// <typeparam name="T1"><undoc /></typeparam>
2385 /// <typeparam name="T2"><undoc /></typeparam>
2386
2387 /// <param name="arg0">Value to interpolate into the format string.</param>
2388 /// <param name="arg1">Value to interpolate into the format string.</param>
2389 /// <param name="arg2">Value to interpolate into the format string.</param>
2390 /// <param name="arg3">Value to interpolate into the format string.</param>
2391 /// <returns>A new string produced by interpolating the format string.</returns>
2392 [ExcludeFromBurstCompatTesting("Takes managed string")]
2393 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, int arg3)
2394 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2395 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2396
2397 {
2398 FixedString512Bytes result = default;
2399 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2400 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2401
2402
2403 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
2404 return result;
2405 }
2406
2407 /// <summary>
2408 /// Returns a new string produced by interpolating a format string.
2409 /// </summary>
2410 /// <remarks>
2411 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2412 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2413 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2414 ///
2415 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2416 /// - FixedString*N*Bytes
2417 /// - string
2418 /// - int
2419 /// - float
2420 /// - structs implementing INativeList<byte> and IUTF8Bytes
2421 ///
2422 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2423 /// </remarks>
2424 /// <param name="formatString">The format string.</param>
2425 /// <typeparam name="T1"><undoc /></typeparam>
2426 /// <typeparam name="T2"><undoc /></typeparam>
2427
2428 /// <param name="arg0">Value to interpolate into the format string.</param>
2429 /// <param name="arg1">Value to interpolate into the format string.</param>
2430 /// <param name="arg2">Value to interpolate into the format string.</param>
2431 /// <param name="arg3">Value to interpolate into the format string.</param>
2432 /// <returns>A new string produced by interpolating the format string.</returns>
2433 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
2434 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, int arg3)
2435 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2436 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2437
2438 {
2439 FixedString512Bytes result = default;
2440 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2441 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2442
2443
2444 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
2445 return result;
2446 }
2447
2448 /// <summary>
2449 /// Returns a new string produced by interpolating a format string.
2450 /// </summary>
2451 /// <remarks>
2452 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2453 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2454 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2455 ///
2456 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2457 /// - FixedString*N*Bytes
2458 /// - string
2459 /// - int
2460 /// - float
2461 /// - structs implementing INativeList<byte> and IUTF8Bytes
2462 ///
2463 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2464 /// </remarks>
2465 /// <param name="formatString">The format string.</param>
2466 /// <typeparam name="T1"><undoc /></typeparam>
2467 /// <typeparam name="T2"><undoc /></typeparam>
2468
2469 /// <param name="arg0">Value to interpolate into the format string.</param>
2470 /// <param name="arg1">Value to interpolate into the format string.</param>
2471 /// <param name="arg2">Value to interpolate into the format string.</param>
2472 /// <param name="arg3">Value to interpolate into the format string.</param>
2473 /// <returns>A new string produced by interpolating the format string.</returns>
2474 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
2475 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, int arg3)
2476 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2477 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2478
2479 {
2480 FixedString512Bytes result = default;
2481 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2482 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2483
2484
2485 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
2486 return result;
2487 }
2488
2489 /// <summary>
2490 /// Returns a new string produced by interpolating a format string.
2491 /// </summary>
2492 /// <remarks>
2493 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2494 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2495 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2496 ///
2497 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2498 /// - FixedString*N*Bytes
2499 /// - string
2500 /// - int
2501 /// - float
2502 /// - structs implementing INativeList<byte> and IUTF8Bytes
2503 ///
2504 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2505 /// </remarks>
2506 /// <param name="formatString">The format string.</param>
2507 /// <typeparam name="T1"><undoc /></typeparam>
2508 /// <typeparam name="T2"><undoc /></typeparam>
2509
2510 /// <param name="arg0">Value to interpolate into the format string.</param>
2511 /// <param name="arg1">Value to interpolate into the format string.</param>
2512 /// <param name="arg2">Value to interpolate into the format string.</param>
2513 /// <param name="arg3">Value to interpolate into the format string.</param>
2514 /// <returns>A new string produced by interpolating the format string.</returns>
2515 [ExcludeFromBurstCompatTesting("Takes managed string")]
2516 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, int arg3)
2517 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2518 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2519
2520 {
2521 FixedString512Bytes result = default;
2522 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2523 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2524
2525
2526 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
2527 return result;
2528 }
2529
2530 /// <summary>
2531 /// Returns a new string produced by interpolating a format string.
2532 /// </summary>
2533 /// <remarks>
2534 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2535 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2536 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2537 ///
2538 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2539 /// - FixedString*N*Bytes
2540 /// - string
2541 /// - int
2542 /// - float
2543 /// - structs implementing INativeList<byte> and IUTF8Bytes
2544 ///
2545 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2546 /// </remarks>
2547 /// <param name="formatString">The format string.</param>
2548 /// <typeparam name="T1"><undoc /></typeparam>
2549 /// <typeparam name="T2"><undoc /></typeparam>
2550 /// <typeparam name="T3"><undoc /></typeparam>
2551
2552 /// <param name="arg0">Value to interpolate into the format string.</param>
2553 /// <param name="arg1">Value to interpolate into the format string.</param>
2554 /// <param name="arg2">Value to interpolate into the format string.</param>
2555 /// <param name="arg3">Value to interpolate into the format string.</param>
2556 /// <returns>A new string produced by interpolating the format string.</returns>
2557 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
2558 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, int arg3)
2559 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2560 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
2561 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
2562
2563 {
2564 FixedString512Bytes result = default;
2565 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2566
2567
2568 result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
2569 return result;
2570 }
2571
2572 /// <summary>
2573 /// Returns a new string produced by interpolating a format string.
2574 /// </summary>
2575 /// <remarks>
2576 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2577 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2578 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2579 ///
2580 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2581 /// - FixedString*N*Bytes
2582 /// - string
2583 /// - int
2584 /// - float
2585 /// - structs implementing INativeList<byte> and IUTF8Bytes
2586 ///
2587 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2588 /// </remarks>
2589 /// <param name="formatString">The format string.</param>
2590
2591 /// <param name="arg0">Value to interpolate into the format string.</param>
2592 /// <param name="arg1">Value to interpolate into the format string.</param>
2593 /// <param name="arg2">Value to interpolate into the format string.</param>
2594 /// <param name="arg3">Value to interpolate into the format string.</param>
2595 /// <returns>A new string produced by interpolating the format string.</returns>
2596
2597 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, float arg3)
2598
2599 {
2600 FixedString512Bytes result = default;
2601 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2602 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2603 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2604 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2605
2606
2607 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2608 return result;
2609 }
2610
2611 /// <summary>
2612 /// Returns a new string produced by interpolating a format string.
2613 /// </summary>
2614 /// <remarks>
2615 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2616 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2617 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2618 ///
2619 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2620 /// - FixedString*N*Bytes
2621 /// - string
2622 /// - int
2623 /// - float
2624 /// - structs implementing INativeList<byte> and IUTF8Bytes
2625 ///
2626 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2627 /// </remarks>
2628 /// <param name="formatString">The format string.</param>
2629
2630 /// <param name="arg0">Value to interpolate into the format string.</param>
2631 /// <param name="arg1">Value to interpolate into the format string.</param>
2632 /// <param name="arg2">Value to interpolate into the format string.</param>
2633 /// <param name="arg3">Value to interpolate into the format string.</param>
2634 /// <returns>A new string produced by interpolating the format string.</returns>
2635
2636 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, float arg3)
2637
2638 {
2639 FixedString512Bytes result = default;
2640 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2641 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2642 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2643 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2644
2645
2646 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2647 return result;
2648 }
2649
2650 /// <summary>
2651 /// Returns a new string produced by interpolating a format string.
2652 /// </summary>
2653 /// <remarks>
2654 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2655 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2656 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2657 ///
2658 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2659 /// - FixedString*N*Bytes
2660 /// - string
2661 /// - int
2662 /// - float
2663 /// - structs implementing INativeList<byte> and IUTF8Bytes
2664 ///
2665 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2666 /// </remarks>
2667 /// <param name="formatString">The format string.</param>
2668
2669 /// <param name="arg0">Value to interpolate into the format string.</param>
2670 /// <param name="arg1">Value to interpolate into the format string.</param>
2671 /// <param name="arg2">Value to interpolate into the format string.</param>
2672 /// <param name="arg3">Value to interpolate into the format string.</param>
2673 /// <returns>A new string produced by interpolating the format string.</returns>
2674 [ExcludeFromBurstCompatTesting("Takes managed string")]
2675 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, float arg3)
2676
2677 {
2678 FixedString512Bytes result = default;
2679 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2680 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2681 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2682 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2683
2684
2685 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2686 return result;
2687 }
2688
2689 /// <summary>
2690 /// Returns a new string produced by interpolating a format string.
2691 /// </summary>
2692 /// <remarks>
2693 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2694 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2695 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2696 ///
2697 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2698 /// - FixedString*N*Bytes
2699 /// - string
2700 /// - int
2701 /// - float
2702 /// - structs implementing INativeList<byte> and IUTF8Bytes
2703 ///
2704 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2705 /// </remarks>
2706 /// <param name="formatString">The format string.</param>
2707 /// <typeparam name="T1"><undoc /></typeparam>
2708
2709 /// <param name="arg0">Value to interpolate into the format string.</param>
2710 /// <param name="arg1">Value to interpolate into the format string.</param>
2711 /// <param name="arg2">Value to interpolate into the format string.</param>
2712 /// <param name="arg3">Value to interpolate into the format string.</param>
2713 /// <returns>A new string produced by interpolating the format string.</returns>
2714 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
2715 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, float arg3)
2716 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2717
2718 {
2719 FixedString512Bytes result = default;
2720 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2721 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2722 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2723
2724
2725 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
2726 return result;
2727 }
2728
2729 /// <summary>
2730 /// Returns a new string produced by interpolating a format string.
2731 /// </summary>
2732 /// <remarks>
2733 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2734 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2735 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2736 ///
2737 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2738 /// - FixedString*N*Bytes
2739 /// - string
2740 /// - int
2741 /// - float
2742 /// - structs implementing INativeList<byte> and IUTF8Bytes
2743 ///
2744 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2745 /// </remarks>
2746 /// <param name="formatString">The format string.</param>
2747
2748 /// <param name="arg0">Value to interpolate into the format string.</param>
2749 /// <param name="arg1">Value to interpolate into the format string.</param>
2750 /// <param name="arg2">Value to interpolate into the format string.</param>
2751 /// <param name="arg3">Value to interpolate into the format string.</param>
2752 /// <returns>A new string produced by interpolating the format string.</returns>
2753
2754 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, float arg3)
2755
2756 {
2757 FixedString512Bytes result = default;
2758 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2759 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2760 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2761 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2762
2763
2764 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2765 return result;
2766 }
2767
2768 /// <summary>
2769 /// Returns a new string produced by interpolating a format string.
2770 /// </summary>
2771 /// <remarks>
2772 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2773 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2774 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2775 ///
2776 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2777 /// - FixedString*N*Bytes
2778 /// - string
2779 /// - int
2780 /// - float
2781 /// - structs implementing INativeList<byte> and IUTF8Bytes
2782 ///
2783 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2784 /// </remarks>
2785 /// <param name="formatString">The format string.</param>
2786
2787 /// <param name="arg0">Value to interpolate into the format string.</param>
2788 /// <param name="arg1">Value to interpolate into the format string.</param>
2789 /// <param name="arg2">Value to interpolate into the format string.</param>
2790 /// <param name="arg3">Value to interpolate into the format string.</param>
2791 /// <returns>A new string produced by interpolating the format string.</returns>
2792
2793 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, float arg3)
2794
2795 {
2796 FixedString512Bytes result = default;
2797 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2798 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2799 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2800 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2801
2802
2803 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2804 return result;
2805 }
2806
2807 /// <summary>
2808 /// Returns a new string produced by interpolating a format string.
2809 /// </summary>
2810 /// <remarks>
2811 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2812 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2813 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2814 ///
2815 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2816 /// - FixedString*N*Bytes
2817 /// - string
2818 /// - int
2819 /// - float
2820 /// - structs implementing INativeList<byte> and IUTF8Bytes
2821 ///
2822 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2823 /// </remarks>
2824 /// <param name="formatString">The format string.</param>
2825
2826 /// <param name="arg0">Value to interpolate into the format string.</param>
2827 /// <param name="arg1">Value to interpolate into the format string.</param>
2828 /// <param name="arg2">Value to interpolate into the format string.</param>
2829 /// <param name="arg3">Value to interpolate into the format string.</param>
2830 /// <returns>A new string produced by interpolating the format string.</returns>
2831 [ExcludeFromBurstCompatTesting("Takes managed string")]
2832 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, float arg3)
2833
2834 {
2835 FixedString512Bytes result = default;
2836 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2837 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2838 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2839 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2840
2841
2842 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2843 return result;
2844 }
2845
2846 /// <summary>
2847 /// Returns a new string produced by interpolating a format string.
2848 /// </summary>
2849 /// <remarks>
2850 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2851 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2852 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2853 ///
2854 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2855 /// - FixedString*N*Bytes
2856 /// - string
2857 /// - int
2858 /// - float
2859 /// - structs implementing INativeList<byte> and IUTF8Bytes
2860 ///
2861 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2862 /// </remarks>
2863 /// <param name="formatString">The format string.</param>
2864 /// <typeparam name="T1"><undoc /></typeparam>
2865
2866 /// <param name="arg0">Value to interpolate into the format string.</param>
2867 /// <param name="arg1">Value to interpolate into the format string.</param>
2868 /// <param name="arg2">Value to interpolate into the format string.</param>
2869 /// <param name="arg3">Value to interpolate into the format string.</param>
2870 /// <returns>A new string produced by interpolating the format string.</returns>
2871 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
2872 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, float arg3)
2873 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
2874
2875 {
2876 FixedString512Bytes result = default;
2877 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2878 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2879 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2880
2881
2882 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
2883 return result;
2884 }
2885
2886 /// <summary>
2887 /// Returns a new string produced by interpolating a format string.
2888 /// </summary>
2889 /// <remarks>
2890 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2891 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2892 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2893 ///
2894 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2895 /// - FixedString*N*Bytes
2896 /// - string
2897 /// - int
2898 /// - float
2899 /// - structs implementing INativeList<byte> and IUTF8Bytes
2900 ///
2901 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2902 /// </remarks>
2903 /// <param name="formatString">The format string.</param>
2904
2905 /// <param name="arg0">Value to interpolate into the format string.</param>
2906 /// <param name="arg1">Value to interpolate into the format string.</param>
2907 /// <param name="arg2">Value to interpolate into the format string.</param>
2908 /// <param name="arg3">Value to interpolate into the format string.</param>
2909 /// <returns>A new string produced by interpolating the format string.</returns>
2910 [ExcludeFromBurstCompatTesting("Takes managed string")]
2911 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, float arg3)
2912
2913 {
2914 FixedString512Bytes result = default;
2915 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2916 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2917 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2918 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2919
2920
2921 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2922 return result;
2923 }
2924
2925 /// <summary>
2926 /// Returns a new string produced by interpolating a format string.
2927 /// </summary>
2928 /// <remarks>
2929 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2930 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2931 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2932 ///
2933 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2934 /// - FixedString*N*Bytes
2935 /// - string
2936 /// - int
2937 /// - float
2938 /// - structs implementing INativeList<byte> and IUTF8Bytes
2939 ///
2940 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2941 /// </remarks>
2942 /// <param name="formatString">The format string.</param>
2943
2944 /// <param name="arg0">Value to interpolate into the format string.</param>
2945 /// <param name="arg1">Value to interpolate into the format string.</param>
2946 /// <param name="arg2">Value to interpolate into the format string.</param>
2947 /// <param name="arg3">Value to interpolate into the format string.</param>
2948 /// <returns>A new string produced by interpolating the format string.</returns>
2949 [ExcludeFromBurstCompatTesting("Takes managed string")]
2950 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, float arg3)
2951
2952 {
2953 FixedString512Bytes result = default;
2954 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2955 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2956 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2957 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2958
2959
2960 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
2961 return result;
2962 }
2963
2964 /// <summary>
2965 /// Returns a new string produced by interpolating a format string.
2966 /// </summary>
2967 /// <remarks>
2968 /// Similar to StringBuilder.AppendFormat but with significant limitations:
2969 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
2970 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
2971 ///
2972 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
2973 /// - FixedString*N*Bytes
2974 /// - string
2975 /// - int
2976 /// - float
2977 /// - structs implementing INativeList<byte> and IUTF8Bytes
2978 ///
2979 /// <seealso cref="FixedStringMethods.AppendFormat"/>
2980 /// </remarks>
2981 /// <param name="formatString">The format string.</param>
2982
2983 /// <param name="arg0">Value to interpolate into the format string.</param>
2984 /// <param name="arg1">Value to interpolate into the format string.</param>
2985 /// <param name="arg2">Value to interpolate into the format string.</param>
2986 /// <param name="arg3">Value to interpolate into the format string.</param>
2987 /// <returns>A new string produced by interpolating the format string.</returns>
2988 [ExcludeFromBurstCompatTesting("Takes managed string")]
2989 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, float arg3)
2990
2991 {
2992 FixedString512Bytes result = default;
2993 FixedString32Bytes carg0 = default; carg0.Append(arg0);
2994 FixedString32Bytes carg1 = default; carg1.Append(arg1);
2995 FixedString32Bytes carg2 = default; carg2.Append(arg2);
2996 FixedString32Bytes carg3 = default; carg3.Append(arg3);
2997
2998
2999 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3000 return result;
3001 }
3002
3003 /// <summary>
3004 /// Returns a new string produced by interpolating a format string.
3005 /// </summary>
3006 /// <remarks>
3007 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3008 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3009 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3010 ///
3011 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3012 /// - FixedString*N*Bytes
3013 /// - string
3014 /// - int
3015 /// - float
3016 /// - structs implementing INativeList<byte> and IUTF8Bytes
3017 ///
3018 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3019 /// </remarks>
3020 /// <param name="formatString">The format string.</param>
3021 /// <typeparam name="T1"><undoc /></typeparam>
3022
3023 /// <param name="arg0">Value to interpolate into the format string.</param>
3024 /// <param name="arg1">Value to interpolate into the format string.</param>
3025 /// <param name="arg2">Value to interpolate into the format string.</param>
3026 /// <param name="arg3">Value to interpolate into the format string.</param>
3027 /// <returns>A new string produced by interpolating the format string.</returns>
3028 [ExcludeFromBurstCompatTesting("Takes managed string")]
3029 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, float arg3)
3030 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3031
3032 {
3033 FixedString512Bytes result = default;
3034 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3035 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3036 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3037
3038
3039 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
3040 return result;
3041 }
3042
3043 /// <summary>
3044 /// Returns a new string produced by interpolating a format string.
3045 /// </summary>
3046 /// <remarks>
3047 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3048 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3049 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3050 ///
3051 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3052 /// - FixedString*N*Bytes
3053 /// - string
3054 /// - int
3055 /// - float
3056 /// - structs implementing INativeList<byte> and IUTF8Bytes
3057 ///
3058 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3059 /// </remarks>
3060 /// <param name="formatString">The format string.</param>
3061 /// <typeparam name="T1"><undoc /></typeparam>
3062
3063 /// <param name="arg0">Value to interpolate into the format string.</param>
3064 /// <param name="arg1">Value to interpolate into the format string.</param>
3065 /// <param name="arg2">Value to interpolate into the format string.</param>
3066 /// <param name="arg3">Value to interpolate into the format string.</param>
3067 /// <returns>A new string produced by interpolating the format string.</returns>
3068 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3069 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, float arg3)
3070 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3071
3072 {
3073 FixedString512Bytes result = default;
3074 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3075 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3076 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3077
3078
3079 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3080 return result;
3081 }
3082
3083 /// <summary>
3084 /// Returns a new string produced by interpolating a format string.
3085 /// </summary>
3086 /// <remarks>
3087 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3088 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3089 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3090 ///
3091 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3092 /// - FixedString*N*Bytes
3093 /// - string
3094 /// - int
3095 /// - float
3096 /// - structs implementing INativeList<byte> and IUTF8Bytes
3097 ///
3098 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3099 /// </remarks>
3100 /// <param name="formatString">The format string.</param>
3101 /// <typeparam name="T1"><undoc /></typeparam>
3102
3103 /// <param name="arg0">Value to interpolate into the format string.</param>
3104 /// <param name="arg1">Value to interpolate into the format string.</param>
3105 /// <param name="arg2">Value to interpolate into the format string.</param>
3106 /// <param name="arg3">Value to interpolate into the format string.</param>
3107 /// <returns>A new string produced by interpolating the format string.</returns>
3108 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3109 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, float arg3)
3110 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3111
3112 {
3113 FixedString512Bytes result = default;
3114 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3115 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3116 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3117
3118
3119 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3120 return result;
3121 }
3122
3123 /// <summary>
3124 /// Returns a new string produced by interpolating a format string.
3125 /// </summary>
3126 /// <remarks>
3127 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3128 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3129 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3130 ///
3131 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3132 /// - FixedString*N*Bytes
3133 /// - string
3134 /// - int
3135 /// - float
3136 /// - structs implementing INativeList<byte> and IUTF8Bytes
3137 ///
3138 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3139 /// </remarks>
3140 /// <param name="formatString">The format string.</param>
3141 /// <typeparam name="T1"><undoc /></typeparam>
3142
3143 /// <param name="arg0">Value to interpolate into the format string.</param>
3144 /// <param name="arg1">Value to interpolate into the format string.</param>
3145 /// <param name="arg2">Value to interpolate into the format string.</param>
3146 /// <param name="arg3">Value to interpolate into the format string.</param>
3147 /// <returns>A new string produced by interpolating the format string.</returns>
3148 [ExcludeFromBurstCompatTesting("Takes managed string")]
3149 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, float arg3)
3150 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3151
3152 {
3153 FixedString512Bytes result = default;
3154 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3155 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3156 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3157
3158
3159 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3160 return result;
3161 }
3162
3163 /// <summary>
3164 /// Returns a new string produced by interpolating a format string.
3165 /// </summary>
3166 /// <remarks>
3167 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3168 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3169 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3170 ///
3171 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3172 /// - FixedString*N*Bytes
3173 /// - string
3174 /// - int
3175 /// - float
3176 /// - structs implementing INativeList<byte> and IUTF8Bytes
3177 ///
3178 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3179 /// </remarks>
3180 /// <param name="formatString">The format string.</param>
3181 /// <typeparam name="T1"><undoc /></typeparam>
3182 /// <typeparam name="T2"><undoc /></typeparam>
3183
3184 /// <param name="arg0">Value to interpolate into the format string.</param>
3185 /// <param name="arg1">Value to interpolate into the format string.</param>
3186 /// <param name="arg2">Value to interpolate into the format string.</param>
3187 /// <param name="arg3">Value to interpolate into the format string.</param>
3188 /// <returns>A new string produced by interpolating the format string.</returns>
3189 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
3190 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, float arg3)
3191 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3192 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
3193
3194 {
3195 FixedString512Bytes result = default;
3196 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3197 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3198
3199
3200 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
3201 return result;
3202 }
3203
3204 /// <summary>
3205 /// Returns a new string produced by interpolating a format string.
3206 /// </summary>
3207 /// <remarks>
3208 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3209 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3210 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3211 ///
3212 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3213 /// - FixedString*N*Bytes
3214 /// - string
3215 /// - int
3216 /// - float
3217 /// - structs implementing INativeList<byte> and IUTF8Bytes
3218 ///
3219 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3220 /// </remarks>
3221 /// <param name="formatString">The format string.</param>
3222
3223 /// <param name="arg0">Value to interpolate into the format string.</param>
3224 /// <param name="arg1">Value to interpolate into the format string.</param>
3225 /// <param name="arg2">Value to interpolate into the format string.</param>
3226 /// <param name="arg3">Value to interpolate into the format string.</param>
3227 /// <returns>A new string produced by interpolating the format string.</returns>
3228
3229 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, float arg3)
3230
3231 {
3232 FixedString512Bytes result = default;
3233 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3234 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3235 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3236 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3237
3238
3239 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3240 return result;
3241 }
3242
3243 /// <summary>
3244 /// Returns a new string produced by interpolating a format string.
3245 /// </summary>
3246 /// <remarks>
3247 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3248 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3249 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3250 ///
3251 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3252 /// - FixedString*N*Bytes
3253 /// - string
3254 /// - int
3255 /// - float
3256 /// - structs implementing INativeList<byte> and IUTF8Bytes
3257 ///
3258 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3259 /// </remarks>
3260 /// <param name="formatString">The format string.</param>
3261
3262 /// <param name="arg0">Value to interpolate into the format string.</param>
3263 /// <param name="arg1">Value to interpolate into the format string.</param>
3264 /// <param name="arg2">Value to interpolate into the format string.</param>
3265 /// <param name="arg3">Value to interpolate into the format string.</param>
3266 /// <returns>A new string produced by interpolating the format string.</returns>
3267
3268 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, float arg3)
3269
3270 {
3271 FixedString512Bytes result = default;
3272 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3273 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3274 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3275 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3276
3277
3278 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3279 return result;
3280 }
3281
3282 /// <summary>
3283 /// Returns a new string produced by interpolating a format string.
3284 /// </summary>
3285 /// <remarks>
3286 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3287 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3288 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3289 ///
3290 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3291 /// - FixedString*N*Bytes
3292 /// - string
3293 /// - int
3294 /// - float
3295 /// - structs implementing INativeList<byte> and IUTF8Bytes
3296 ///
3297 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3298 /// </remarks>
3299 /// <param name="formatString">The format string.</param>
3300
3301 /// <param name="arg0">Value to interpolate into the format string.</param>
3302 /// <param name="arg1">Value to interpolate into the format string.</param>
3303 /// <param name="arg2">Value to interpolate into the format string.</param>
3304 /// <param name="arg3">Value to interpolate into the format string.</param>
3305 /// <returns>A new string produced by interpolating the format string.</returns>
3306 [ExcludeFromBurstCompatTesting("Takes managed string")]
3307 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, float arg3)
3308
3309 {
3310 FixedString512Bytes result = default;
3311 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3312 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3313 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3314 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3315
3316
3317 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3318 return result;
3319 }
3320
3321 /// <summary>
3322 /// Returns a new string produced by interpolating a format string.
3323 /// </summary>
3324 /// <remarks>
3325 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3326 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3327 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3328 ///
3329 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3330 /// - FixedString*N*Bytes
3331 /// - string
3332 /// - int
3333 /// - float
3334 /// - structs implementing INativeList<byte> and IUTF8Bytes
3335 ///
3336 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3337 /// </remarks>
3338 /// <param name="formatString">The format string.</param>
3339 /// <typeparam name="T1"><undoc /></typeparam>
3340
3341 /// <param name="arg0">Value to interpolate into the format string.</param>
3342 /// <param name="arg1">Value to interpolate into the format string.</param>
3343 /// <param name="arg2">Value to interpolate into the format string.</param>
3344 /// <param name="arg3">Value to interpolate into the format string.</param>
3345 /// <returns>A new string produced by interpolating the format string.</returns>
3346 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3347 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, float arg3)
3348 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3349
3350 {
3351 FixedString512Bytes result = default;
3352 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3353 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3354 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3355
3356
3357 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
3358 return result;
3359 }
3360
3361 /// <summary>
3362 /// Returns a new string produced by interpolating a format string.
3363 /// </summary>
3364 /// <remarks>
3365 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3366 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3367 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3368 ///
3369 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3370 /// - FixedString*N*Bytes
3371 /// - string
3372 /// - int
3373 /// - float
3374 /// - structs implementing INativeList<byte> and IUTF8Bytes
3375 ///
3376 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3377 /// </remarks>
3378 /// <param name="formatString">The format string.</param>
3379
3380 /// <param name="arg0">Value to interpolate into the format string.</param>
3381 /// <param name="arg1">Value to interpolate into the format string.</param>
3382 /// <param name="arg2">Value to interpolate into the format string.</param>
3383 /// <param name="arg3">Value to interpolate into the format string.</param>
3384 /// <returns>A new string produced by interpolating the format string.</returns>
3385
3386 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, float arg3)
3387
3388 {
3389 FixedString512Bytes result = default;
3390 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3391 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3392 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3393 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3394
3395
3396 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3397 return result;
3398 }
3399
3400 /// <summary>
3401 /// Returns a new string produced by interpolating a format string.
3402 /// </summary>
3403 /// <remarks>
3404 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3405 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3406 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3407 ///
3408 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3409 /// - FixedString*N*Bytes
3410 /// - string
3411 /// - int
3412 /// - float
3413 /// - structs implementing INativeList<byte> and IUTF8Bytes
3414 ///
3415 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3416 /// </remarks>
3417 /// <param name="formatString">The format string.</param>
3418
3419 /// <param name="arg0">Value to interpolate into the format string.</param>
3420 /// <param name="arg1">Value to interpolate into the format string.</param>
3421 /// <param name="arg2">Value to interpolate into the format string.</param>
3422 /// <param name="arg3">Value to interpolate into the format string.</param>
3423 /// <returns>A new string produced by interpolating the format string.</returns>
3424
3425 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, float arg3)
3426
3427 {
3428 FixedString512Bytes result = default;
3429 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3430 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3431 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3432 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3433
3434
3435 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3436 return result;
3437 }
3438
3439 /// <summary>
3440 /// Returns a new string produced by interpolating a format string.
3441 /// </summary>
3442 /// <remarks>
3443 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3444 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3445 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3446 ///
3447 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3448 /// - FixedString*N*Bytes
3449 /// - string
3450 /// - int
3451 /// - float
3452 /// - structs implementing INativeList<byte> and IUTF8Bytes
3453 ///
3454 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3455 /// </remarks>
3456 /// <param name="formatString">The format string.</param>
3457
3458 /// <param name="arg0">Value to interpolate into the format string.</param>
3459 /// <param name="arg1">Value to interpolate into the format string.</param>
3460 /// <param name="arg2">Value to interpolate into the format string.</param>
3461 /// <param name="arg3">Value to interpolate into the format string.</param>
3462 /// <returns>A new string produced by interpolating the format string.</returns>
3463 [ExcludeFromBurstCompatTesting("Takes managed string")]
3464 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, float arg3)
3465
3466 {
3467 FixedString512Bytes result = default;
3468 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3469 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3470 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3471 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3472
3473
3474 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3475 return result;
3476 }
3477
3478 /// <summary>
3479 /// Returns a new string produced by interpolating a format string.
3480 /// </summary>
3481 /// <remarks>
3482 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3483 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3484 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3485 ///
3486 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3487 /// - FixedString*N*Bytes
3488 /// - string
3489 /// - int
3490 /// - float
3491 /// - structs implementing INativeList<byte> and IUTF8Bytes
3492 ///
3493 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3494 /// </remarks>
3495 /// <param name="formatString">The format string.</param>
3496 /// <typeparam name="T1"><undoc /></typeparam>
3497
3498 /// <param name="arg0">Value to interpolate into the format string.</param>
3499 /// <param name="arg1">Value to interpolate into the format string.</param>
3500 /// <param name="arg2">Value to interpolate into the format string.</param>
3501 /// <param name="arg3">Value to interpolate into the format string.</param>
3502 /// <returns>A new string produced by interpolating the format string.</returns>
3503 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3504 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, float arg3)
3505 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3506
3507 {
3508 FixedString512Bytes result = default;
3509 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3510 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3511 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3512
3513
3514 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
3515 return result;
3516 }
3517
3518 /// <summary>
3519 /// Returns a new string produced by interpolating a format string.
3520 /// </summary>
3521 /// <remarks>
3522 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3523 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3524 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3525 ///
3526 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3527 /// - FixedString*N*Bytes
3528 /// - string
3529 /// - int
3530 /// - float
3531 /// - structs implementing INativeList<byte> and IUTF8Bytes
3532 ///
3533 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3534 /// </remarks>
3535 /// <param name="formatString">The format string.</param>
3536
3537 /// <param name="arg0">Value to interpolate into the format string.</param>
3538 /// <param name="arg1">Value to interpolate into the format string.</param>
3539 /// <param name="arg2">Value to interpolate into the format string.</param>
3540 /// <param name="arg3">Value to interpolate into the format string.</param>
3541 /// <returns>A new string produced by interpolating the format string.</returns>
3542 [ExcludeFromBurstCompatTesting("Takes managed string")]
3543 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, float arg3)
3544
3545 {
3546 FixedString512Bytes result = default;
3547 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3548 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3549 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3550 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3551
3552
3553 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3554 return result;
3555 }
3556
3557 /// <summary>
3558 /// Returns a new string produced by interpolating a format string.
3559 /// </summary>
3560 /// <remarks>
3561 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3562 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3563 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3564 ///
3565 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3566 /// - FixedString*N*Bytes
3567 /// - string
3568 /// - int
3569 /// - float
3570 /// - structs implementing INativeList<byte> and IUTF8Bytes
3571 ///
3572 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3573 /// </remarks>
3574 /// <param name="formatString">The format string.</param>
3575
3576 /// <param name="arg0">Value to interpolate into the format string.</param>
3577 /// <param name="arg1">Value to interpolate into the format string.</param>
3578 /// <param name="arg2">Value to interpolate into the format string.</param>
3579 /// <param name="arg3">Value to interpolate into the format string.</param>
3580 /// <returns>A new string produced by interpolating the format string.</returns>
3581 [ExcludeFromBurstCompatTesting("Takes managed string")]
3582 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, float arg3)
3583
3584 {
3585 FixedString512Bytes result = default;
3586 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3587 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3588 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3589 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3590
3591
3592 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3593 return result;
3594 }
3595
3596 /// <summary>
3597 /// Returns a new string produced by interpolating a format string.
3598 /// </summary>
3599 /// <remarks>
3600 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3601 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3602 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3603 ///
3604 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3605 /// - FixedString*N*Bytes
3606 /// - string
3607 /// - int
3608 /// - float
3609 /// - structs implementing INativeList<byte> and IUTF8Bytes
3610 ///
3611 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3612 /// </remarks>
3613 /// <param name="formatString">The format string.</param>
3614
3615 /// <param name="arg0">Value to interpolate into the format string.</param>
3616 /// <param name="arg1">Value to interpolate into the format string.</param>
3617 /// <param name="arg2">Value to interpolate into the format string.</param>
3618 /// <param name="arg3">Value to interpolate into the format string.</param>
3619 /// <returns>A new string produced by interpolating the format string.</returns>
3620 [ExcludeFromBurstCompatTesting("Takes managed string")]
3621 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, float arg3)
3622
3623 {
3624 FixedString512Bytes result = default;
3625 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3626 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3627 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3628 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3629
3630
3631 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3632 return result;
3633 }
3634
3635 /// <summary>
3636 /// Returns a new string produced by interpolating a format string.
3637 /// </summary>
3638 /// <remarks>
3639 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3640 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3641 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3642 ///
3643 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3644 /// - FixedString*N*Bytes
3645 /// - string
3646 /// - int
3647 /// - float
3648 /// - structs implementing INativeList<byte> and IUTF8Bytes
3649 ///
3650 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3651 /// </remarks>
3652 /// <param name="formatString">The format string.</param>
3653 /// <typeparam name="T1"><undoc /></typeparam>
3654
3655 /// <param name="arg0">Value to interpolate into the format string.</param>
3656 /// <param name="arg1">Value to interpolate into the format string.</param>
3657 /// <param name="arg2">Value to interpolate into the format string.</param>
3658 /// <param name="arg3">Value to interpolate into the format string.</param>
3659 /// <returns>A new string produced by interpolating the format string.</returns>
3660 [ExcludeFromBurstCompatTesting("Takes managed string")]
3661 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, float arg3)
3662 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3663
3664 {
3665 FixedString512Bytes result = default;
3666 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3667 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3668 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3669
3670
3671 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
3672 return result;
3673 }
3674
3675 /// <summary>
3676 /// Returns a new string produced by interpolating a format string.
3677 /// </summary>
3678 /// <remarks>
3679 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3680 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3681 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3682 ///
3683 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3684 /// - FixedString*N*Bytes
3685 /// - string
3686 /// - int
3687 /// - float
3688 /// - structs implementing INativeList<byte> and IUTF8Bytes
3689 ///
3690 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3691 /// </remarks>
3692 /// <param name="formatString">The format string.</param>
3693 /// <typeparam name="T1"><undoc /></typeparam>
3694
3695 /// <param name="arg0">Value to interpolate into the format string.</param>
3696 /// <param name="arg1">Value to interpolate into the format string.</param>
3697 /// <param name="arg2">Value to interpolate into the format string.</param>
3698 /// <param name="arg3">Value to interpolate into the format string.</param>
3699 /// <returns>A new string produced by interpolating the format string.</returns>
3700 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3701 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, float arg3)
3702 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3703
3704 {
3705 FixedString512Bytes result = default;
3706 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3707 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3708 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3709
3710
3711 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3712 return result;
3713 }
3714
3715 /// <summary>
3716 /// Returns a new string produced by interpolating a format string.
3717 /// </summary>
3718 /// <remarks>
3719 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3720 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3721 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3722 ///
3723 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3724 /// - FixedString*N*Bytes
3725 /// - string
3726 /// - int
3727 /// - float
3728 /// - structs implementing INativeList<byte> and IUTF8Bytes
3729 ///
3730 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3731 /// </remarks>
3732 /// <param name="formatString">The format string.</param>
3733 /// <typeparam name="T1"><undoc /></typeparam>
3734
3735 /// <param name="arg0">Value to interpolate into the format string.</param>
3736 /// <param name="arg1">Value to interpolate into the format string.</param>
3737 /// <param name="arg2">Value to interpolate into the format string.</param>
3738 /// <param name="arg3">Value to interpolate into the format string.</param>
3739 /// <returns>A new string produced by interpolating the format string.</returns>
3740 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
3741 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, float arg3)
3742 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3743
3744 {
3745 FixedString512Bytes result = default;
3746 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3747 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3748 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3749
3750
3751 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3752 return result;
3753 }
3754
3755 /// <summary>
3756 /// Returns a new string produced by interpolating a format string.
3757 /// </summary>
3758 /// <remarks>
3759 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3760 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3761 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3762 ///
3763 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3764 /// - FixedString*N*Bytes
3765 /// - string
3766 /// - int
3767 /// - float
3768 /// - structs implementing INativeList<byte> and IUTF8Bytes
3769 ///
3770 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3771 /// </remarks>
3772 /// <param name="formatString">The format string.</param>
3773 /// <typeparam name="T1"><undoc /></typeparam>
3774
3775 /// <param name="arg0">Value to interpolate into the format string.</param>
3776 /// <param name="arg1">Value to interpolate into the format string.</param>
3777 /// <param name="arg2">Value to interpolate into the format string.</param>
3778 /// <param name="arg3">Value to interpolate into the format string.</param>
3779 /// <returns>A new string produced by interpolating the format string.</returns>
3780 [ExcludeFromBurstCompatTesting("Takes managed string")]
3781 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, float arg3)
3782 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3783
3784 {
3785 FixedString512Bytes result = default;
3786 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3787 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3788 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3789
3790
3791 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
3792 return result;
3793 }
3794
3795 /// <summary>
3796 /// Returns a new string produced by interpolating a format string.
3797 /// </summary>
3798 /// <remarks>
3799 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3800 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3801 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3802 ///
3803 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3804 /// - FixedString*N*Bytes
3805 /// - string
3806 /// - int
3807 /// - float
3808 /// - structs implementing INativeList<byte> and IUTF8Bytes
3809 ///
3810 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3811 /// </remarks>
3812 /// <param name="formatString">The format string.</param>
3813 /// <typeparam name="T1"><undoc /></typeparam>
3814 /// <typeparam name="T2"><undoc /></typeparam>
3815
3816 /// <param name="arg0">Value to interpolate into the format string.</param>
3817 /// <param name="arg1">Value to interpolate into the format string.</param>
3818 /// <param name="arg2">Value to interpolate into the format string.</param>
3819 /// <param name="arg3">Value to interpolate into the format string.</param>
3820 /// <returns>A new string produced by interpolating the format string.</returns>
3821 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
3822 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, float arg3)
3823 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3824 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
3825
3826 {
3827 FixedString512Bytes result = default;
3828 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3829 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3830
3831
3832 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
3833 return result;
3834 }
3835
3836 /// <summary>
3837 /// Returns a new string produced by interpolating a format string.
3838 /// </summary>
3839 /// <remarks>
3840 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3841 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3842 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3843 ///
3844 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3845 /// - FixedString*N*Bytes
3846 /// - string
3847 /// - int
3848 /// - float
3849 /// - structs implementing INativeList<byte> and IUTF8Bytes
3850 ///
3851 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3852 /// </remarks>
3853 /// <param name="formatString">The format string.</param>
3854
3855 /// <param name="arg0">Value to interpolate into the format string.</param>
3856 /// <param name="arg1">Value to interpolate into the format string.</param>
3857 /// <param name="arg2">Value to interpolate into the format string.</param>
3858 /// <param name="arg3">Value to interpolate into the format string.</param>
3859 /// <returns>A new string produced by interpolating the format string.</returns>
3860 [ExcludeFromBurstCompatTesting("Takes managed string")]
3861 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, float arg3)
3862
3863 {
3864 FixedString512Bytes result = default;
3865 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3866 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3867 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3868 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3869
3870
3871 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3872 return result;
3873 }
3874
3875 /// <summary>
3876 /// Returns a new string produced by interpolating a format string.
3877 /// </summary>
3878 /// <remarks>
3879 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3880 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3881 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3882 ///
3883 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3884 /// - FixedString*N*Bytes
3885 /// - string
3886 /// - int
3887 /// - float
3888 /// - structs implementing INativeList<byte> and IUTF8Bytes
3889 ///
3890 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3891 /// </remarks>
3892 /// <param name="formatString">The format string.</param>
3893
3894 /// <param name="arg0">Value to interpolate into the format string.</param>
3895 /// <param name="arg1">Value to interpolate into the format string.</param>
3896 /// <param name="arg2">Value to interpolate into the format string.</param>
3897 /// <param name="arg3">Value to interpolate into the format string.</param>
3898 /// <returns>A new string produced by interpolating the format string.</returns>
3899 [ExcludeFromBurstCompatTesting("Takes managed string")]
3900 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, float arg3)
3901
3902 {
3903 FixedString512Bytes result = default;
3904 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3905 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3906 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3907 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3908
3909
3910 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3911 return result;
3912 }
3913
3914 /// <summary>
3915 /// Returns a new string produced by interpolating a format string.
3916 /// </summary>
3917 /// <remarks>
3918 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3919 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3920 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3921 ///
3922 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3923 /// - FixedString*N*Bytes
3924 /// - string
3925 /// - int
3926 /// - float
3927 /// - structs implementing INativeList<byte> and IUTF8Bytes
3928 ///
3929 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3930 /// </remarks>
3931 /// <param name="formatString">The format string.</param>
3932
3933 /// <param name="arg0">Value to interpolate into the format string.</param>
3934 /// <param name="arg1">Value to interpolate into the format string.</param>
3935 /// <param name="arg2">Value to interpolate into the format string.</param>
3936 /// <param name="arg3">Value to interpolate into the format string.</param>
3937 /// <returns>A new string produced by interpolating the format string.</returns>
3938 [ExcludeFromBurstCompatTesting("Takes managed string")]
3939 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, float arg3)
3940
3941 {
3942 FixedString512Bytes result = default;
3943 FixedString32Bytes carg0 = default; carg0.Append(arg0);
3944 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3945 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3946 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3947
3948
3949 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
3950 return result;
3951 }
3952
3953 /// <summary>
3954 /// Returns a new string produced by interpolating a format string.
3955 /// </summary>
3956 /// <remarks>
3957 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3958 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3959 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
3960 ///
3961 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
3962 /// - FixedString*N*Bytes
3963 /// - string
3964 /// - int
3965 /// - float
3966 /// - structs implementing INativeList<byte> and IUTF8Bytes
3967 ///
3968 /// <seealso cref="FixedStringMethods.AppendFormat"/>
3969 /// </remarks>
3970 /// <param name="formatString">The format string.</param>
3971 /// <typeparam name="T1"><undoc /></typeparam>
3972
3973 /// <param name="arg0">Value to interpolate into the format string.</param>
3974 /// <param name="arg1">Value to interpolate into the format string.</param>
3975 /// <param name="arg2">Value to interpolate into the format string.</param>
3976 /// <param name="arg3">Value to interpolate into the format string.</param>
3977 /// <returns>A new string produced by interpolating the format string.</returns>
3978 [ExcludeFromBurstCompatTesting("Takes managed string")]
3979 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, float arg3)
3980 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
3981
3982 {
3983 FixedString512Bytes result = default;
3984 FixedString32Bytes carg1 = default; carg1.Append(arg1);
3985 FixedString32Bytes carg2 = default; carg2.Append(arg2);
3986 FixedString32Bytes carg3 = default; carg3.Append(arg3);
3987
3988
3989 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
3990 return result;
3991 }
3992
3993 /// <summary>
3994 /// Returns a new string produced by interpolating a format string.
3995 /// </summary>
3996 /// <remarks>
3997 /// Similar to StringBuilder.AppendFormat but with significant limitations:
3998 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
3999 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4000 ///
4001 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4002 /// - FixedString*N*Bytes
4003 /// - string
4004 /// - int
4005 /// - float
4006 /// - structs implementing INativeList<byte> and IUTF8Bytes
4007 ///
4008 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4009 /// </remarks>
4010 /// <param name="formatString">The format string.</param>
4011
4012 /// <param name="arg0">Value to interpolate into the format string.</param>
4013 /// <param name="arg1">Value to interpolate into the format string.</param>
4014 /// <param name="arg2">Value to interpolate into the format string.</param>
4015 /// <param name="arg3">Value to interpolate into the format string.</param>
4016 /// <returns>A new string produced by interpolating the format string.</returns>
4017 [ExcludeFromBurstCompatTesting("Takes managed string")]
4018 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, float arg3)
4019
4020 {
4021 FixedString512Bytes result = default;
4022 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4023 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4024 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4025 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4026
4027
4028 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4029 return result;
4030 }
4031
4032 /// <summary>
4033 /// Returns a new string produced by interpolating a format string.
4034 /// </summary>
4035 /// <remarks>
4036 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4037 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4038 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4039 ///
4040 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4041 /// - FixedString*N*Bytes
4042 /// - string
4043 /// - int
4044 /// - float
4045 /// - structs implementing INativeList<byte> and IUTF8Bytes
4046 ///
4047 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4048 /// </remarks>
4049 /// <param name="formatString">The format string.</param>
4050
4051 /// <param name="arg0">Value to interpolate into the format string.</param>
4052 /// <param name="arg1">Value to interpolate into the format string.</param>
4053 /// <param name="arg2">Value to interpolate into the format string.</param>
4054 /// <param name="arg3">Value to interpolate into the format string.</param>
4055 /// <returns>A new string produced by interpolating the format string.</returns>
4056 [ExcludeFromBurstCompatTesting("Takes managed string")]
4057 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, float arg3)
4058
4059 {
4060 FixedString512Bytes result = default;
4061 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4062 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4063 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4064 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4065
4066
4067 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4068 return result;
4069 }
4070
4071 /// <summary>
4072 /// Returns a new string produced by interpolating a format string.
4073 /// </summary>
4074 /// <remarks>
4075 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4076 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4077 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4078 ///
4079 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4080 /// - FixedString*N*Bytes
4081 /// - string
4082 /// - int
4083 /// - float
4084 /// - structs implementing INativeList<byte> and IUTF8Bytes
4085 ///
4086 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4087 /// </remarks>
4088 /// <param name="formatString">The format string.</param>
4089
4090 /// <param name="arg0">Value to interpolate into the format string.</param>
4091 /// <param name="arg1">Value to interpolate into the format string.</param>
4092 /// <param name="arg2">Value to interpolate into the format string.</param>
4093 /// <param name="arg3">Value to interpolate into the format string.</param>
4094 /// <returns>A new string produced by interpolating the format string.</returns>
4095 [ExcludeFromBurstCompatTesting("Takes managed string")]
4096 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, float arg3)
4097
4098 {
4099 FixedString512Bytes result = default;
4100 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4101 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4102 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4103 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4104
4105
4106 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4107 return result;
4108 }
4109
4110 /// <summary>
4111 /// Returns a new string produced by interpolating a format string.
4112 /// </summary>
4113 /// <remarks>
4114 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4115 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4116 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4117 ///
4118 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4119 /// - FixedString*N*Bytes
4120 /// - string
4121 /// - int
4122 /// - float
4123 /// - structs implementing INativeList<byte> and IUTF8Bytes
4124 ///
4125 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4126 /// </remarks>
4127 /// <param name="formatString">The format string.</param>
4128 /// <typeparam name="T1"><undoc /></typeparam>
4129
4130 /// <param name="arg0">Value to interpolate into the format string.</param>
4131 /// <param name="arg1">Value to interpolate into the format string.</param>
4132 /// <param name="arg2">Value to interpolate into the format string.</param>
4133 /// <param name="arg3">Value to interpolate into the format string.</param>
4134 /// <returns>A new string produced by interpolating the format string.</returns>
4135 [ExcludeFromBurstCompatTesting("Takes managed string")]
4136 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, float arg3)
4137 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4138
4139 {
4140 FixedString512Bytes result = default;
4141 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4142 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4143 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4144
4145
4146 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
4147 return result;
4148 }
4149
4150 /// <summary>
4151 /// Returns a new string produced by interpolating a format string.
4152 /// </summary>
4153 /// <remarks>
4154 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4155 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4156 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4157 ///
4158 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4159 /// - FixedString*N*Bytes
4160 /// - string
4161 /// - int
4162 /// - float
4163 /// - structs implementing INativeList<byte> and IUTF8Bytes
4164 ///
4165 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4166 /// </remarks>
4167 /// <param name="formatString">The format string.</param>
4168
4169 /// <param name="arg0">Value to interpolate into the format string.</param>
4170 /// <param name="arg1">Value to interpolate into the format string.</param>
4171 /// <param name="arg2">Value to interpolate into the format string.</param>
4172 /// <param name="arg3">Value to interpolate into the format string.</param>
4173 /// <returns>A new string produced by interpolating the format string.</returns>
4174 [ExcludeFromBurstCompatTesting("Takes managed string")]
4175 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, float arg3)
4176
4177 {
4178 FixedString512Bytes result = default;
4179 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4180 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4181 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4182 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4183
4184
4185 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4186 return result;
4187 }
4188
4189 /// <summary>
4190 /// Returns a new string produced by interpolating a format string.
4191 /// </summary>
4192 /// <remarks>
4193 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4194 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4195 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4196 ///
4197 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4198 /// - FixedString*N*Bytes
4199 /// - string
4200 /// - int
4201 /// - float
4202 /// - structs implementing INativeList<byte> and IUTF8Bytes
4203 ///
4204 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4205 /// </remarks>
4206 /// <param name="formatString">The format string.</param>
4207
4208 /// <param name="arg0">Value to interpolate into the format string.</param>
4209 /// <param name="arg1">Value to interpolate into the format string.</param>
4210 /// <param name="arg2">Value to interpolate into the format string.</param>
4211 /// <param name="arg3">Value to interpolate into the format string.</param>
4212 /// <returns>A new string produced by interpolating the format string.</returns>
4213 [ExcludeFromBurstCompatTesting("Takes managed string")]
4214 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, float arg3)
4215
4216 {
4217 FixedString512Bytes result = default;
4218 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4219 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4220 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4221 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4222
4223
4224 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4225 return result;
4226 }
4227
4228 /// <summary>
4229 /// Returns a new string produced by interpolating a format string.
4230 /// </summary>
4231 /// <remarks>
4232 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4233 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4234 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4235 ///
4236 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4237 /// - FixedString*N*Bytes
4238 /// - string
4239 /// - int
4240 /// - float
4241 /// - structs implementing INativeList<byte> and IUTF8Bytes
4242 ///
4243 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4244 /// </remarks>
4245 /// <param name="formatString">The format string.</param>
4246
4247 /// <param name="arg0">Value to interpolate into the format string.</param>
4248 /// <param name="arg1">Value to interpolate into the format string.</param>
4249 /// <param name="arg2">Value to interpolate into the format string.</param>
4250 /// <param name="arg3">Value to interpolate into the format string.</param>
4251 /// <returns>A new string produced by interpolating the format string.</returns>
4252 [ExcludeFromBurstCompatTesting("Takes managed string")]
4253 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, float arg3)
4254
4255 {
4256 FixedString512Bytes result = default;
4257 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4258 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4259 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4260 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4261
4262
4263 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
4264 return result;
4265 }
4266
4267 /// <summary>
4268 /// Returns a new string produced by interpolating a format string.
4269 /// </summary>
4270 /// <remarks>
4271 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4272 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4273 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4274 ///
4275 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4276 /// - FixedString*N*Bytes
4277 /// - string
4278 /// - int
4279 /// - float
4280 /// - structs implementing INativeList<byte> and IUTF8Bytes
4281 ///
4282 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4283 /// </remarks>
4284 /// <param name="formatString">The format string.</param>
4285 /// <typeparam name="T1"><undoc /></typeparam>
4286
4287 /// <param name="arg0">Value to interpolate into the format string.</param>
4288 /// <param name="arg1">Value to interpolate into the format string.</param>
4289 /// <param name="arg2">Value to interpolate into the format string.</param>
4290 /// <param name="arg3">Value to interpolate into the format string.</param>
4291 /// <returns>A new string produced by interpolating the format string.</returns>
4292 [ExcludeFromBurstCompatTesting("Takes managed string")]
4293 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, float arg3)
4294 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4295
4296 {
4297 FixedString512Bytes result = default;
4298 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4299 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4300 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4301
4302
4303 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
4304 return result;
4305 }
4306
4307 /// <summary>
4308 /// Returns a new string produced by interpolating a format string.
4309 /// </summary>
4310 /// <remarks>
4311 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4312 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4313 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4314 ///
4315 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4316 /// - FixedString*N*Bytes
4317 /// - string
4318 /// - int
4319 /// - float
4320 /// - structs implementing INativeList<byte> and IUTF8Bytes
4321 ///
4322 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4323 /// </remarks>
4324 /// <param name="formatString">The format string.</param>
4325 /// <typeparam name="T1"><undoc /></typeparam>
4326
4327 /// <param name="arg0">Value to interpolate into the format string.</param>
4328 /// <param name="arg1">Value to interpolate into the format string.</param>
4329 /// <param name="arg2">Value to interpolate into the format string.</param>
4330 /// <param name="arg3">Value to interpolate into the format string.</param>
4331 /// <returns>A new string produced by interpolating the format string.</returns>
4332 [ExcludeFromBurstCompatTesting("Takes managed string")]
4333 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, float arg3)
4334 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4335
4336 {
4337 FixedString512Bytes result = default;
4338 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4339 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4340 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4341
4342
4343 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
4344 return result;
4345 }
4346
4347 /// <summary>
4348 /// Returns a new string produced by interpolating a format string.
4349 /// </summary>
4350 /// <remarks>
4351 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4352 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4353 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4354 ///
4355 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4356 /// - FixedString*N*Bytes
4357 /// - string
4358 /// - int
4359 /// - float
4360 /// - structs implementing INativeList<byte> and IUTF8Bytes
4361 ///
4362 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4363 /// </remarks>
4364 /// <param name="formatString">The format string.</param>
4365 /// <typeparam name="T1"><undoc /></typeparam>
4366
4367 /// <param name="arg0">Value to interpolate into the format string.</param>
4368 /// <param name="arg1">Value to interpolate into the format string.</param>
4369 /// <param name="arg2">Value to interpolate into the format string.</param>
4370 /// <param name="arg3">Value to interpolate into the format string.</param>
4371 /// <returns>A new string produced by interpolating the format string.</returns>
4372 [ExcludeFromBurstCompatTesting("Takes managed string")]
4373 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, float arg3)
4374 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4375
4376 {
4377 FixedString512Bytes result = default;
4378 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4379 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4380 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4381
4382
4383 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
4384 return result;
4385 }
4386
4387 /// <summary>
4388 /// Returns a new string produced by interpolating a format string.
4389 /// </summary>
4390 /// <remarks>
4391 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4392 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4393 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4394 ///
4395 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4396 /// - FixedString*N*Bytes
4397 /// - string
4398 /// - int
4399 /// - float
4400 /// - structs implementing INativeList<byte> and IUTF8Bytes
4401 ///
4402 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4403 /// </remarks>
4404 /// <param name="formatString">The format string.</param>
4405 /// <typeparam name="T1"><undoc /></typeparam>
4406
4407 /// <param name="arg0">Value to interpolate into the format string.</param>
4408 /// <param name="arg1">Value to interpolate into the format string.</param>
4409 /// <param name="arg2">Value to interpolate into the format string.</param>
4410 /// <param name="arg3">Value to interpolate into the format string.</param>
4411 /// <returns>A new string produced by interpolating the format string.</returns>
4412 [ExcludeFromBurstCompatTesting("Takes managed string")]
4413 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, float arg3)
4414 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4415
4416 {
4417 FixedString512Bytes result = default;
4418 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4419 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4420 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4421
4422
4423 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
4424 return result;
4425 }
4426
4427 /// <summary>
4428 /// Returns a new string produced by interpolating a format string.
4429 /// </summary>
4430 /// <remarks>
4431 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4432 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4433 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4434 ///
4435 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4436 /// - FixedString*N*Bytes
4437 /// - string
4438 /// - int
4439 /// - float
4440 /// - structs implementing INativeList<byte> and IUTF8Bytes
4441 ///
4442 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4443 /// </remarks>
4444 /// <param name="formatString">The format string.</param>
4445 /// <typeparam name="T1"><undoc /></typeparam>
4446 /// <typeparam name="T2"><undoc /></typeparam>
4447
4448 /// <param name="arg0">Value to interpolate into the format string.</param>
4449 /// <param name="arg1">Value to interpolate into the format string.</param>
4450 /// <param name="arg2">Value to interpolate into the format string.</param>
4451 /// <param name="arg3">Value to interpolate into the format string.</param>
4452 /// <returns>A new string produced by interpolating the format string.</returns>
4453 [ExcludeFromBurstCompatTesting("Takes managed string")]
4454 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, float arg3)
4455 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4456 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
4457
4458 {
4459 FixedString512Bytes result = default;
4460 FixedString32Bytes carg2 = default; carg2.Append(arg2);
4461 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4462
4463
4464 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
4465 return result;
4466 }
4467
4468 /// <summary>
4469 /// Returns a new string produced by interpolating a format string.
4470 /// </summary>
4471 /// <remarks>
4472 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4473 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4474 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4475 ///
4476 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4477 /// - FixedString*N*Bytes
4478 /// - string
4479 /// - int
4480 /// - float
4481 /// - structs implementing INativeList<byte> and IUTF8Bytes
4482 ///
4483 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4484 /// </remarks>
4485 /// <param name="formatString">The format string.</param>
4486 /// <typeparam name="T1"><undoc /></typeparam>
4487
4488 /// <param name="arg0">Value to interpolate into the format string.</param>
4489 /// <param name="arg1">Value to interpolate into the format string.</param>
4490 /// <param name="arg2">Value to interpolate into the format string.</param>
4491 /// <param name="arg3">Value to interpolate into the format string.</param>
4492 /// <returns>A new string produced by interpolating the format string.</returns>
4493 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
4494 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, float arg3)
4495 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4496
4497 {
4498 FixedString512Bytes result = default;
4499 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4500 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4501 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4502
4503
4504 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4505 return result;
4506 }
4507
4508 /// <summary>
4509 /// Returns a new string produced by interpolating a format string.
4510 /// </summary>
4511 /// <remarks>
4512 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4513 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4514 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4515 ///
4516 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4517 /// - FixedString*N*Bytes
4518 /// - string
4519 /// - int
4520 /// - float
4521 /// - structs implementing INativeList<byte> and IUTF8Bytes
4522 ///
4523 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4524 /// </remarks>
4525 /// <param name="formatString">The format string.</param>
4526 /// <typeparam name="T1"><undoc /></typeparam>
4527
4528 /// <param name="arg0">Value to interpolate into the format string.</param>
4529 /// <param name="arg1">Value to interpolate into the format string.</param>
4530 /// <param name="arg2">Value to interpolate into the format string.</param>
4531 /// <param name="arg3">Value to interpolate into the format string.</param>
4532 /// <returns>A new string produced by interpolating the format string.</returns>
4533 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
4534 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, float arg3)
4535 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4536
4537 {
4538 FixedString512Bytes result = default;
4539 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4540 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4541 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4542
4543
4544 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4545 return result;
4546 }
4547
4548 /// <summary>
4549 /// Returns a new string produced by interpolating a format string.
4550 /// </summary>
4551 /// <remarks>
4552 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4553 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4554 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4555 ///
4556 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4557 /// - FixedString*N*Bytes
4558 /// - string
4559 /// - int
4560 /// - float
4561 /// - structs implementing INativeList<byte> and IUTF8Bytes
4562 ///
4563 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4564 /// </remarks>
4565 /// <param name="formatString">The format string.</param>
4566 /// <typeparam name="T1"><undoc /></typeparam>
4567
4568 /// <param name="arg0">Value to interpolate into the format string.</param>
4569 /// <param name="arg1">Value to interpolate into the format string.</param>
4570 /// <param name="arg2">Value to interpolate into the format string.</param>
4571 /// <param name="arg3">Value to interpolate into the format string.</param>
4572 /// <returns>A new string produced by interpolating the format string.</returns>
4573 [ExcludeFromBurstCompatTesting("Takes managed string")]
4574 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, float arg3)
4575 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4576
4577 {
4578 FixedString512Bytes result = default;
4579 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4580 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4581 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4582
4583
4584 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4585 return result;
4586 }
4587
4588 /// <summary>
4589 /// Returns a new string produced by interpolating a format string.
4590 /// </summary>
4591 /// <remarks>
4592 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4593 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4594 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4595 ///
4596 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4597 /// - FixedString*N*Bytes
4598 /// - string
4599 /// - int
4600 /// - float
4601 /// - structs implementing INativeList<byte> and IUTF8Bytes
4602 ///
4603 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4604 /// </remarks>
4605 /// <param name="formatString">The format string.</param>
4606 /// <typeparam name="T1"><undoc /></typeparam>
4607 /// <typeparam name="T2"><undoc /></typeparam>
4608
4609 /// <param name="arg0">Value to interpolate into the format string.</param>
4610 /// <param name="arg1">Value to interpolate into the format string.</param>
4611 /// <param name="arg2">Value to interpolate into the format string.</param>
4612 /// <param name="arg3">Value to interpolate into the format string.</param>
4613 /// <returns>A new string produced by interpolating the format string.</returns>
4614 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
4615 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, float arg3)
4616 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4617 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
4618
4619 {
4620 FixedString512Bytes result = default;
4621 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4622 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4623
4624
4625 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
4626 return result;
4627 }
4628
4629 /// <summary>
4630 /// Returns a new string produced by interpolating a format string.
4631 /// </summary>
4632 /// <remarks>
4633 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4634 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4635 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4636 ///
4637 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4638 /// - FixedString*N*Bytes
4639 /// - string
4640 /// - int
4641 /// - float
4642 /// - structs implementing INativeList<byte> and IUTF8Bytes
4643 ///
4644 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4645 /// </remarks>
4646 /// <param name="formatString">The format string.</param>
4647 /// <typeparam name="T1"><undoc /></typeparam>
4648
4649 /// <param name="arg0">Value to interpolate into the format string.</param>
4650 /// <param name="arg1">Value to interpolate into the format string.</param>
4651 /// <param name="arg2">Value to interpolate into the format string.</param>
4652 /// <param name="arg3">Value to interpolate into the format string.</param>
4653 /// <returns>A new string produced by interpolating the format string.</returns>
4654 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
4655 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, float arg3)
4656 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4657
4658 {
4659 FixedString512Bytes result = default;
4660 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4661 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4662 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4663
4664
4665 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4666 return result;
4667 }
4668
4669 /// <summary>
4670 /// Returns a new string produced by interpolating a format string.
4671 /// </summary>
4672 /// <remarks>
4673 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4674 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4675 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4676 ///
4677 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4678 /// - FixedString*N*Bytes
4679 /// - string
4680 /// - int
4681 /// - float
4682 /// - structs implementing INativeList<byte> and IUTF8Bytes
4683 ///
4684 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4685 /// </remarks>
4686 /// <param name="formatString">The format string.</param>
4687 /// <typeparam name="T1"><undoc /></typeparam>
4688
4689 /// <param name="arg0">Value to interpolate into the format string.</param>
4690 /// <param name="arg1">Value to interpolate into the format string.</param>
4691 /// <param name="arg2">Value to interpolate into the format string.</param>
4692 /// <param name="arg3">Value to interpolate into the format string.</param>
4693 /// <returns>A new string produced by interpolating the format string.</returns>
4694 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
4695 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, float arg3)
4696 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4697
4698 {
4699 FixedString512Bytes result = default;
4700 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4701 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4702 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4703
4704
4705 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4706 return result;
4707 }
4708
4709 /// <summary>
4710 /// Returns a new string produced by interpolating a format string.
4711 /// </summary>
4712 /// <remarks>
4713 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4714 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4715 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4716 ///
4717 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4718 /// - FixedString*N*Bytes
4719 /// - string
4720 /// - int
4721 /// - float
4722 /// - structs implementing INativeList<byte> and IUTF8Bytes
4723 ///
4724 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4725 /// </remarks>
4726 /// <param name="formatString">The format string.</param>
4727 /// <typeparam name="T1"><undoc /></typeparam>
4728
4729 /// <param name="arg0">Value to interpolate into the format string.</param>
4730 /// <param name="arg1">Value to interpolate into the format string.</param>
4731 /// <param name="arg2">Value to interpolate into the format string.</param>
4732 /// <param name="arg3">Value to interpolate into the format string.</param>
4733 /// <returns>A new string produced by interpolating the format string.</returns>
4734 [ExcludeFromBurstCompatTesting("Takes managed string")]
4735 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, float arg3)
4736 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4737
4738 {
4739 FixedString512Bytes result = default;
4740 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4741 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4742 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4743
4744
4745 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4746 return result;
4747 }
4748
4749 /// <summary>
4750 /// Returns a new string produced by interpolating a format string.
4751 /// </summary>
4752 /// <remarks>
4753 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4754 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4755 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4756 ///
4757 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4758 /// - FixedString*N*Bytes
4759 /// - string
4760 /// - int
4761 /// - float
4762 /// - structs implementing INativeList<byte> and IUTF8Bytes
4763 ///
4764 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4765 /// </remarks>
4766 /// <param name="formatString">The format string.</param>
4767 /// <typeparam name="T1"><undoc /></typeparam>
4768 /// <typeparam name="T2"><undoc /></typeparam>
4769
4770 /// <param name="arg0">Value to interpolate into the format string.</param>
4771 /// <param name="arg1">Value to interpolate into the format string.</param>
4772 /// <param name="arg2">Value to interpolate into the format string.</param>
4773 /// <param name="arg3">Value to interpolate into the format string.</param>
4774 /// <returns>A new string produced by interpolating the format string.</returns>
4775 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
4776 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, float arg3)
4777 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4778 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
4779
4780 {
4781 FixedString512Bytes result = default;
4782 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4783 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4784
4785
4786 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
4787 return result;
4788 }
4789
4790 /// <summary>
4791 /// Returns a new string produced by interpolating a format string.
4792 /// </summary>
4793 /// <remarks>
4794 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4795 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4796 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4797 ///
4798 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4799 /// - FixedString*N*Bytes
4800 /// - string
4801 /// - int
4802 /// - float
4803 /// - structs implementing INativeList<byte> and IUTF8Bytes
4804 ///
4805 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4806 /// </remarks>
4807 /// <param name="formatString">The format string.</param>
4808 /// <typeparam name="T1"><undoc /></typeparam>
4809
4810 /// <param name="arg0">Value to interpolate into the format string.</param>
4811 /// <param name="arg1">Value to interpolate into the format string.</param>
4812 /// <param name="arg2">Value to interpolate into the format string.</param>
4813 /// <param name="arg3">Value to interpolate into the format string.</param>
4814 /// <returns>A new string produced by interpolating the format string.</returns>
4815 [ExcludeFromBurstCompatTesting("Takes managed string")]
4816 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, float arg3)
4817 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4818
4819 {
4820 FixedString512Bytes result = default;
4821 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4822 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4823 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4824
4825
4826 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4827 return result;
4828 }
4829
4830 /// <summary>
4831 /// Returns a new string produced by interpolating a format string.
4832 /// </summary>
4833 /// <remarks>
4834 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4835 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4836 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4837 ///
4838 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4839 /// - FixedString*N*Bytes
4840 /// - string
4841 /// - int
4842 /// - float
4843 /// - structs implementing INativeList<byte> and IUTF8Bytes
4844 ///
4845 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4846 /// </remarks>
4847 /// <param name="formatString">The format string.</param>
4848 /// <typeparam name="T1"><undoc /></typeparam>
4849
4850 /// <param name="arg0">Value to interpolate into the format string.</param>
4851 /// <param name="arg1">Value to interpolate into the format string.</param>
4852 /// <param name="arg2">Value to interpolate into the format string.</param>
4853 /// <param name="arg3">Value to interpolate into the format string.</param>
4854 /// <returns>A new string produced by interpolating the format string.</returns>
4855 [ExcludeFromBurstCompatTesting("Takes managed string")]
4856 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, float arg3)
4857 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4858
4859 {
4860 FixedString512Bytes result = default;
4861 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4862 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4863 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4864
4865
4866 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4867 return result;
4868 }
4869
4870 /// <summary>
4871 /// Returns a new string produced by interpolating a format string.
4872 /// </summary>
4873 /// <remarks>
4874 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4875 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4876 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4877 ///
4878 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4879 /// - FixedString*N*Bytes
4880 /// - string
4881 /// - int
4882 /// - float
4883 /// - structs implementing INativeList<byte> and IUTF8Bytes
4884 ///
4885 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4886 /// </remarks>
4887 /// <param name="formatString">The format string.</param>
4888 /// <typeparam name="T1"><undoc /></typeparam>
4889
4890 /// <param name="arg0">Value to interpolate into the format string.</param>
4891 /// <param name="arg1">Value to interpolate into the format string.</param>
4892 /// <param name="arg2">Value to interpolate into the format string.</param>
4893 /// <param name="arg3">Value to interpolate into the format string.</param>
4894 /// <returns>A new string produced by interpolating the format string.</returns>
4895 [ExcludeFromBurstCompatTesting("Takes managed string")]
4896 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, float arg3)
4897 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4898
4899 {
4900 FixedString512Bytes result = default;
4901 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4902 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4903 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4904
4905
4906 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
4907 return result;
4908 }
4909
4910 /// <summary>
4911 /// Returns a new string produced by interpolating a format string.
4912 /// </summary>
4913 /// <remarks>
4914 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4915 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4916 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4917 ///
4918 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4919 /// - FixedString*N*Bytes
4920 /// - string
4921 /// - int
4922 /// - float
4923 /// - structs implementing INativeList<byte> and IUTF8Bytes
4924 ///
4925 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4926 /// </remarks>
4927 /// <param name="formatString">The format string.</param>
4928 /// <typeparam name="T1"><undoc /></typeparam>
4929 /// <typeparam name="T2"><undoc /></typeparam>
4930
4931 /// <param name="arg0">Value to interpolate into the format string.</param>
4932 /// <param name="arg1">Value to interpolate into the format string.</param>
4933 /// <param name="arg2">Value to interpolate into the format string.</param>
4934 /// <param name="arg3">Value to interpolate into the format string.</param>
4935 /// <returns>A new string produced by interpolating the format string.</returns>
4936 [ExcludeFromBurstCompatTesting("Takes managed string")]
4937 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, float arg3)
4938 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4939 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
4940
4941 {
4942 FixedString512Bytes result = default;
4943 FixedString32Bytes carg1 = default; carg1.Append(arg1);
4944 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4945
4946
4947 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
4948 return result;
4949 }
4950
4951 /// <summary>
4952 /// Returns a new string produced by interpolating a format string.
4953 /// </summary>
4954 /// <remarks>
4955 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4956 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4957 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4958 ///
4959 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
4960 /// - FixedString*N*Bytes
4961 /// - string
4962 /// - int
4963 /// - float
4964 /// - structs implementing INativeList<byte> and IUTF8Bytes
4965 ///
4966 /// <seealso cref="FixedStringMethods.AppendFormat"/>
4967 /// </remarks>
4968 /// <param name="formatString">The format string.</param>
4969 /// <typeparam name="T1"><undoc /></typeparam>
4970 /// <typeparam name="T2"><undoc /></typeparam>
4971
4972 /// <param name="arg0">Value to interpolate into the format string.</param>
4973 /// <param name="arg1">Value to interpolate into the format string.</param>
4974 /// <param name="arg2">Value to interpolate into the format string.</param>
4975 /// <param name="arg3">Value to interpolate into the format string.</param>
4976 /// <returns>A new string produced by interpolating the format string.</returns>
4977 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
4978 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, float arg3)
4979 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
4980 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
4981
4982 {
4983 FixedString512Bytes result = default;
4984 FixedString32Bytes carg0 = default; carg0.Append(arg0);
4985 FixedString32Bytes carg3 = default; carg3.Append(arg3);
4986
4987
4988 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
4989 return result;
4990 }
4991
4992 /// <summary>
4993 /// Returns a new string produced by interpolating a format string.
4994 /// </summary>
4995 /// <remarks>
4996 /// Similar to StringBuilder.AppendFormat but with significant limitations:
4997 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
4998 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
4999 ///
5000 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5001 /// - FixedString*N*Bytes
5002 /// - string
5003 /// - int
5004 /// - float
5005 /// - structs implementing INativeList<byte> and IUTF8Bytes
5006 ///
5007 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5008 /// </remarks>
5009 /// <param name="formatString">The format string.</param>
5010 /// <typeparam name="T1"><undoc /></typeparam>
5011 /// <typeparam name="T2"><undoc /></typeparam>
5012
5013 /// <param name="arg0">Value to interpolate into the format string.</param>
5014 /// <param name="arg1">Value to interpolate into the format string.</param>
5015 /// <param name="arg2">Value to interpolate into the format string.</param>
5016 /// <param name="arg3">Value to interpolate into the format string.</param>
5017 /// <returns>A new string produced by interpolating the format string.</returns>
5018 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
5019 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, float arg3)
5020 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5021 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
5022
5023 {
5024 FixedString512Bytes result = default;
5025 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5026 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5027
5028
5029 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
5030 return result;
5031 }
5032
5033 /// <summary>
5034 /// Returns a new string produced by interpolating a format string.
5035 /// </summary>
5036 /// <remarks>
5037 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5038 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5039 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5040 ///
5041 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5042 /// - FixedString*N*Bytes
5043 /// - string
5044 /// - int
5045 /// - float
5046 /// - structs implementing INativeList<byte> and IUTF8Bytes
5047 ///
5048 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5049 /// </remarks>
5050 /// <param name="formatString">The format string.</param>
5051 /// <typeparam name="T1"><undoc /></typeparam>
5052 /// <typeparam name="T2"><undoc /></typeparam>
5053
5054 /// <param name="arg0">Value to interpolate into the format string.</param>
5055 /// <param name="arg1">Value to interpolate into the format string.</param>
5056 /// <param name="arg2">Value to interpolate into the format string.</param>
5057 /// <param name="arg3">Value to interpolate into the format string.</param>
5058 /// <returns>A new string produced by interpolating the format string.</returns>
5059 [ExcludeFromBurstCompatTesting("Takes managed string")]
5060 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, float arg3)
5061 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5062 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
5063
5064 {
5065 FixedString512Bytes result = default;
5066 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5067 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5068
5069
5070 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
5071 return result;
5072 }
5073
5074 /// <summary>
5075 /// Returns a new string produced by interpolating a format string.
5076 /// </summary>
5077 /// <remarks>
5078 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5079 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5080 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5081 ///
5082 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5083 /// - FixedString*N*Bytes
5084 /// - string
5085 /// - int
5086 /// - float
5087 /// - structs implementing INativeList<byte> and IUTF8Bytes
5088 ///
5089 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5090 /// </remarks>
5091 /// <param name="formatString">The format string.</param>
5092 /// <typeparam name="T1"><undoc /></typeparam>
5093 /// <typeparam name="T2"><undoc /></typeparam>
5094 /// <typeparam name="T3"><undoc /></typeparam>
5095
5096 /// <param name="arg0">Value to interpolate into the format string.</param>
5097 /// <param name="arg1">Value to interpolate into the format string.</param>
5098 /// <param name="arg2">Value to interpolate into the format string.</param>
5099 /// <param name="arg3">Value to interpolate into the format string.</param>
5100 /// <returns>A new string produced by interpolating the format string.</returns>
5101 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
5102 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, float arg3)
5103 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5104 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
5105 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
5106
5107 {
5108 FixedString512Bytes result = default;
5109 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5110
5111
5112 result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
5113 return result;
5114 }
5115
5116 /// <summary>
5117 /// Returns a new string produced by interpolating a format string.
5118 /// </summary>
5119 /// <remarks>
5120 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5121 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5122 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5123 ///
5124 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5125 /// - FixedString*N*Bytes
5126 /// - string
5127 /// - int
5128 /// - float
5129 /// - structs implementing INativeList<byte> and IUTF8Bytes
5130 ///
5131 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5132 /// </remarks>
5133 /// <param name="formatString">The format string.</param>
5134
5135 /// <param name="arg0">Value to interpolate into the format string.</param>
5136 /// <param name="arg1">Value to interpolate into the format string.</param>
5137 /// <param name="arg2">Value to interpolate into the format string.</param>
5138 /// <param name="arg3">Value to interpolate into the format string.</param>
5139 /// <returns>A new string produced by interpolating the format string.</returns>
5140 [ExcludeFromBurstCompatTesting("Takes managed string")]
5141 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, int arg2, string arg3)
5142
5143 {
5144 FixedString512Bytes result = default;
5145 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5146 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5147 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5148 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5149
5150
5151 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5152 return result;
5153 }
5154
5155 /// <summary>
5156 /// Returns a new string produced by interpolating a format string.
5157 /// </summary>
5158 /// <remarks>
5159 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5160 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5161 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5162 ///
5163 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5164 /// - FixedString*N*Bytes
5165 /// - string
5166 /// - int
5167 /// - float
5168 /// - structs implementing INativeList<byte> and IUTF8Bytes
5169 ///
5170 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5171 /// </remarks>
5172 /// <param name="formatString">The format string.</param>
5173
5174 /// <param name="arg0">Value to interpolate into the format string.</param>
5175 /// <param name="arg1">Value to interpolate into the format string.</param>
5176 /// <param name="arg2">Value to interpolate into the format string.</param>
5177 /// <param name="arg3">Value to interpolate into the format string.</param>
5178 /// <returns>A new string produced by interpolating the format string.</returns>
5179 [ExcludeFromBurstCompatTesting("Takes managed string")]
5180 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, int arg2, string arg3)
5181
5182 {
5183 FixedString512Bytes result = default;
5184 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5185 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5186 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5187 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5188
5189
5190 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5191 return result;
5192 }
5193
5194 /// <summary>
5195 /// Returns a new string produced by interpolating a format string.
5196 /// </summary>
5197 /// <remarks>
5198 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5199 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5200 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5201 ///
5202 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5203 /// - FixedString*N*Bytes
5204 /// - string
5205 /// - int
5206 /// - float
5207 /// - structs implementing INativeList<byte> and IUTF8Bytes
5208 ///
5209 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5210 /// </remarks>
5211 /// <param name="formatString">The format string.</param>
5212
5213 /// <param name="arg0">Value to interpolate into the format string.</param>
5214 /// <param name="arg1">Value to interpolate into the format string.</param>
5215 /// <param name="arg2">Value to interpolate into the format string.</param>
5216 /// <param name="arg3">Value to interpolate into the format string.</param>
5217 /// <returns>A new string produced by interpolating the format string.</returns>
5218 [ExcludeFromBurstCompatTesting("Takes managed string")]
5219 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, int arg2, string arg3)
5220
5221 {
5222 FixedString512Bytes result = default;
5223 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5224 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5225 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5226 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5227
5228
5229 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5230 return result;
5231 }
5232
5233 /// <summary>
5234 /// Returns a new string produced by interpolating a format string.
5235 /// </summary>
5236 /// <remarks>
5237 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5238 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5239 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5240 ///
5241 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5242 /// - FixedString*N*Bytes
5243 /// - string
5244 /// - int
5245 /// - float
5246 /// - structs implementing INativeList<byte> and IUTF8Bytes
5247 ///
5248 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5249 /// </remarks>
5250 /// <param name="formatString">The format string.</param>
5251 /// <typeparam name="T1"><undoc /></typeparam>
5252
5253 /// <param name="arg0">Value to interpolate into the format string.</param>
5254 /// <param name="arg1">Value to interpolate into the format string.</param>
5255 /// <param name="arg2">Value to interpolate into the format string.</param>
5256 /// <param name="arg3">Value to interpolate into the format string.</param>
5257 /// <returns>A new string produced by interpolating the format string.</returns>
5258 [ExcludeFromBurstCompatTesting("Takes managed string")]
5259 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, string arg3)
5260 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5261
5262 {
5263 FixedString512Bytes result = default;
5264 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5265 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5266 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5267
5268
5269 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
5270 return result;
5271 }
5272
5273 /// <summary>
5274 /// Returns a new string produced by interpolating a format string.
5275 /// </summary>
5276 /// <remarks>
5277 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5278 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5279 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5280 ///
5281 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5282 /// - FixedString*N*Bytes
5283 /// - string
5284 /// - int
5285 /// - float
5286 /// - structs implementing INativeList<byte> and IUTF8Bytes
5287 ///
5288 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5289 /// </remarks>
5290 /// <param name="formatString">The format string.</param>
5291
5292 /// <param name="arg0">Value to interpolate into the format string.</param>
5293 /// <param name="arg1">Value to interpolate into the format string.</param>
5294 /// <param name="arg2">Value to interpolate into the format string.</param>
5295 /// <param name="arg3">Value to interpolate into the format string.</param>
5296 /// <returns>A new string produced by interpolating the format string.</returns>
5297 [ExcludeFromBurstCompatTesting("Takes managed string")]
5298 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, int arg2, string arg3)
5299
5300 {
5301 FixedString512Bytes result = default;
5302 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5303 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5304 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5305 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5306
5307
5308 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5309 return result;
5310 }
5311
5312 /// <summary>
5313 /// Returns a new string produced by interpolating a format string.
5314 /// </summary>
5315 /// <remarks>
5316 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5317 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5318 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5319 ///
5320 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5321 /// - FixedString*N*Bytes
5322 /// - string
5323 /// - int
5324 /// - float
5325 /// - structs implementing INativeList<byte> and IUTF8Bytes
5326 ///
5327 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5328 /// </remarks>
5329 /// <param name="formatString">The format string.</param>
5330
5331 /// <param name="arg0">Value to interpolate into the format string.</param>
5332 /// <param name="arg1">Value to interpolate into the format string.</param>
5333 /// <param name="arg2">Value to interpolate into the format string.</param>
5334 /// <param name="arg3">Value to interpolate into the format string.</param>
5335 /// <returns>A new string produced by interpolating the format string.</returns>
5336 [ExcludeFromBurstCompatTesting("Takes managed string")]
5337 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, int arg2, string arg3)
5338
5339 {
5340 FixedString512Bytes result = default;
5341 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5342 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5343 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5344 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5345
5346
5347 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5348 return result;
5349 }
5350
5351 /// <summary>
5352 /// Returns a new string produced by interpolating a format string.
5353 /// </summary>
5354 /// <remarks>
5355 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5356 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5357 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5358 ///
5359 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5360 /// - FixedString*N*Bytes
5361 /// - string
5362 /// - int
5363 /// - float
5364 /// - structs implementing INativeList<byte> and IUTF8Bytes
5365 ///
5366 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5367 /// </remarks>
5368 /// <param name="formatString">The format string.</param>
5369
5370 /// <param name="arg0">Value to interpolate into the format string.</param>
5371 /// <param name="arg1">Value to interpolate into the format string.</param>
5372 /// <param name="arg2">Value to interpolate into the format string.</param>
5373 /// <param name="arg3">Value to interpolate into the format string.</param>
5374 /// <returns>A new string produced by interpolating the format string.</returns>
5375 [ExcludeFromBurstCompatTesting("Takes managed string")]
5376 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, int arg2, string arg3)
5377
5378 {
5379 FixedString512Bytes result = default;
5380 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5381 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5382 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5383 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5384
5385
5386 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5387 return result;
5388 }
5389
5390 /// <summary>
5391 /// Returns a new string produced by interpolating a format string.
5392 /// </summary>
5393 /// <remarks>
5394 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5395 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5396 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5397 ///
5398 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5399 /// - FixedString*N*Bytes
5400 /// - string
5401 /// - int
5402 /// - float
5403 /// - structs implementing INativeList<byte> and IUTF8Bytes
5404 ///
5405 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5406 /// </remarks>
5407 /// <param name="formatString">The format string.</param>
5408 /// <typeparam name="T1"><undoc /></typeparam>
5409
5410 /// <param name="arg0">Value to interpolate into the format string.</param>
5411 /// <param name="arg1">Value to interpolate into the format string.</param>
5412 /// <param name="arg2">Value to interpolate into the format string.</param>
5413 /// <param name="arg3">Value to interpolate into the format string.</param>
5414 /// <returns>A new string produced by interpolating the format string.</returns>
5415 [ExcludeFromBurstCompatTesting("Takes managed string")]
5416 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, string arg3)
5417 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5418
5419 {
5420 FixedString512Bytes result = default;
5421 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5422 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5423 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5424
5425
5426 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
5427 return result;
5428 }
5429
5430 /// <summary>
5431 /// Returns a new string produced by interpolating a format string.
5432 /// </summary>
5433 /// <remarks>
5434 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5435 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5436 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5437 ///
5438 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5439 /// - FixedString*N*Bytes
5440 /// - string
5441 /// - int
5442 /// - float
5443 /// - structs implementing INativeList<byte> and IUTF8Bytes
5444 ///
5445 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5446 /// </remarks>
5447 /// <param name="formatString">The format string.</param>
5448
5449 /// <param name="arg0">Value to interpolate into the format string.</param>
5450 /// <param name="arg1">Value to interpolate into the format string.</param>
5451 /// <param name="arg2">Value to interpolate into the format string.</param>
5452 /// <param name="arg3">Value to interpolate into the format string.</param>
5453 /// <returns>A new string produced by interpolating the format string.</returns>
5454 [ExcludeFromBurstCompatTesting("Takes managed string")]
5455 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, int arg2, string arg3)
5456
5457 {
5458 FixedString512Bytes result = default;
5459 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5460 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5461 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5462 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5463
5464
5465 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5466 return result;
5467 }
5468
5469 /// <summary>
5470 /// Returns a new string produced by interpolating a format string.
5471 /// </summary>
5472 /// <remarks>
5473 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5474 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5475 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5476 ///
5477 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5478 /// - FixedString*N*Bytes
5479 /// - string
5480 /// - int
5481 /// - float
5482 /// - structs implementing INativeList<byte> and IUTF8Bytes
5483 ///
5484 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5485 /// </remarks>
5486 /// <param name="formatString">The format string.</param>
5487
5488 /// <param name="arg0">Value to interpolate into the format string.</param>
5489 /// <param name="arg1">Value to interpolate into the format string.</param>
5490 /// <param name="arg2">Value to interpolate into the format string.</param>
5491 /// <param name="arg3">Value to interpolate into the format string.</param>
5492 /// <returns>A new string produced by interpolating the format string.</returns>
5493 [ExcludeFromBurstCompatTesting("Takes managed string")]
5494 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, int arg2, string arg3)
5495
5496 {
5497 FixedString512Bytes result = default;
5498 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5499 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5500 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5501 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5502
5503
5504 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5505 return result;
5506 }
5507
5508 /// <summary>
5509 /// Returns a new string produced by interpolating a format string.
5510 /// </summary>
5511 /// <remarks>
5512 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5513 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5514 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5515 ///
5516 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5517 /// - FixedString*N*Bytes
5518 /// - string
5519 /// - int
5520 /// - float
5521 /// - structs implementing INativeList<byte> and IUTF8Bytes
5522 ///
5523 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5524 /// </remarks>
5525 /// <param name="formatString">The format string.</param>
5526
5527 /// <param name="arg0">Value to interpolate into the format string.</param>
5528 /// <param name="arg1">Value to interpolate into the format string.</param>
5529 /// <param name="arg2">Value to interpolate into the format string.</param>
5530 /// <param name="arg3">Value to interpolate into the format string.</param>
5531 /// <returns>A new string produced by interpolating the format string.</returns>
5532 [ExcludeFromBurstCompatTesting("Takes managed string")]
5533 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, int arg2, string arg3)
5534
5535 {
5536 FixedString512Bytes result = default;
5537 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5538 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5539 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5540 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5541
5542
5543 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5544 return result;
5545 }
5546
5547 /// <summary>
5548 /// Returns a new string produced by interpolating a format string.
5549 /// </summary>
5550 /// <remarks>
5551 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5552 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5553 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5554 ///
5555 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5556 /// - FixedString*N*Bytes
5557 /// - string
5558 /// - int
5559 /// - float
5560 /// - structs implementing INativeList<byte> and IUTF8Bytes
5561 ///
5562 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5563 /// </remarks>
5564 /// <param name="formatString">The format string.</param>
5565 /// <typeparam name="T1"><undoc /></typeparam>
5566
5567 /// <param name="arg0">Value to interpolate into the format string.</param>
5568 /// <param name="arg1">Value to interpolate into the format string.</param>
5569 /// <param name="arg2">Value to interpolate into the format string.</param>
5570 /// <param name="arg3">Value to interpolate into the format string.</param>
5571 /// <returns>A new string produced by interpolating the format string.</returns>
5572 [ExcludeFromBurstCompatTesting("Takes managed string")]
5573 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, string arg3)
5574 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5575
5576 {
5577 FixedString512Bytes result = default;
5578 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5579 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5580 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5581
5582
5583 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
5584 return result;
5585 }
5586
5587 /// <summary>
5588 /// Returns a new string produced by interpolating a format string.
5589 /// </summary>
5590 /// <remarks>
5591 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5592 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5593 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5594 ///
5595 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5596 /// - FixedString*N*Bytes
5597 /// - string
5598 /// - int
5599 /// - float
5600 /// - structs implementing INativeList<byte> and IUTF8Bytes
5601 ///
5602 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5603 /// </remarks>
5604 /// <param name="formatString">The format string.</param>
5605 /// <typeparam name="T1"><undoc /></typeparam>
5606
5607 /// <param name="arg0">Value to interpolate into the format string.</param>
5608 /// <param name="arg1">Value to interpolate into the format string.</param>
5609 /// <param name="arg2">Value to interpolate into the format string.</param>
5610 /// <param name="arg3">Value to interpolate into the format string.</param>
5611 /// <returns>A new string produced by interpolating the format string.</returns>
5612 [ExcludeFromBurstCompatTesting("Takes managed string")]
5613 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, string arg3)
5614 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5615
5616 {
5617 FixedString512Bytes result = default;
5618 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5619 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5620 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5621
5622
5623 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
5624 return result;
5625 }
5626
5627 /// <summary>
5628 /// Returns a new string produced by interpolating a format string.
5629 /// </summary>
5630 /// <remarks>
5631 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5632 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5633 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5634 ///
5635 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5636 /// - FixedString*N*Bytes
5637 /// - string
5638 /// - int
5639 /// - float
5640 /// - structs implementing INativeList<byte> and IUTF8Bytes
5641 ///
5642 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5643 /// </remarks>
5644 /// <param name="formatString">The format string.</param>
5645 /// <typeparam name="T1"><undoc /></typeparam>
5646
5647 /// <param name="arg0">Value to interpolate into the format string.</param>
5648 /// <param name="arg1">Value to interpolate into the format string.</param>
5649 /// <param name="arg2">Value to interpolate into the format string.</param>
5650 /// <param name="arg3">Value to interpolate into the format string.</param>
5651 /// <returns>A new string produced by interpolating the format string.</returns>
5652 [ExcludeFromBurstCompatTesting("Takes managed string")]
5653 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, string arg3)
5654 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5655
5656 {
5657 FixedString512Bytes result = default;
5658 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5659 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5660 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5661
5662
5663 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
5664 return result;
5665 }
5666
5667 /// <summary>
5668 /// Returns a new string produced by interpolating a format string.
5669 /// </summary>
5670 /// <remarks>
5671 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5672 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5673 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5674 ///
5675 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5676 /// - FixedString*N*Bytes
5677 /// - string
5678 /// - int
5679 /// - float
5680 /// - structs implementing INativeList<byte> and IUTF8Bytes
5681 ///
5682 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5683 /// </remarks>
5684 /// <param name="formatString">The format string.</param>
5685 /// <typeparam name="T1"><undoc /></typeparam>
5686
5687 /// <param name="arg0">Value to interpolate into the format string.</param>
5688 /// <param name="arg1">Value to interpolate into the format string.</param>
5689 /// <param name="arg2">Value to interpolate into the format string.</param>
5690 /// <param name="arg3">Value to interpolate into the format string.</param>
5691 /// <returns>A new string produced by interpolating the format string.</returns>
5692 [ExcludeFromBurstCompatTesting("Takes managed string")]
5693 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, string arg3)
5694 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5695
5696 {
5697 FixedString512Bytes result = default;
5698 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5699 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5700 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5701
5702
5703 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
5704 return result;
5705 }
5706
5707 /// <summary>
5708 /// Returns a new string produced by interpolating a format string.
5709 /// </summary>
5710 /// <remarks>
5711 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5712 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5713 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5714 ///
5715 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5716 /// - FixedString*N*Bytes
5717 /// - string
5718 /// - int
5719 /// - float
5720 /// - structs implementing INativeList<byte> and IUTF8Bytes
5721 ///
5722 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5723 /// </remarks>
5724 /// <param name="formatString">The format string.</param>
5725 /// <typeparam name="T1"><undoc /></typeparam>
5726 /// <typeparam name="T2"><undoc /></typeparam>
5727
5728 /// <param name="arg0">Value to interpolate into the format string.</param>
5729 /// <param name="arg1">Value to interpolate into the format string.</param>
5730 /// <param name="arg2">Value to interpolate into the format string.</param>
5731 /// <param name="arg3">Value to interpolate into the format string.</param>
5732 /// <returns>A new string produced by interpolating the format string.</returns>
5733 [ExcludeFromBurstCompatTesting("Takes managed string")]
5734 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, string arg3)
5735 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5736 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
5737
5738 {
5739 FixedString512Bytes result = default;
5740 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5741 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5742
5743
5744 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
5745 return result;
5746 }
5747
5748 /// <summary>
5749 /// Returns a new string produced by interpolating a format string.
5750 /// </summary>
5751 /// <remarks>
5752 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5753 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5754 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5755 ///
5756 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5757 /// - FixedString*N*Bytes
5758 /// - string
5759 /// - int
5760 /// - float
5761 /// - structs implementing INativeList<byte> and IUTF8Bytes
5762 ///
5763 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5764 /// </remarks>
5765 /// <param name="formatString">The format string.</param>
5766
5767 /// <param name="arg0">Value to interpolate into the format string.</param>
5768 /// <param name="arg1">Value to interpolate into the format string.</param>
5769 /// <param name="arg2">Value to interpolate into the format string.</param>
5770 /// <param name="arg3">Value to interpolate into the format string.</param>
5771 /// <returns>A new string produced by interpolating the format string.</returns>
5772 [ExcludeFromBurstCompatTesting("Takes managed string")]
5773 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, float arg2, string arg3)
5774
5775 {
5776 FixedString512Bytes result = default;
5777 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5778 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5779 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5780 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5781
5782
5783 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5784 return result;
5785 }
5786
5787 /// <summary>
5788 /// Returns a new string produced by interpolating a format string.
5789 /// </summary>
5790 /// <remarks>
5791 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5792 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5793 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5794 ///
5795 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5796 /// - FixedString*N*Bytes
5797 /// - string
5798 /// - int
5799 /// - float
5800 /// - structs implementing INativeList<byte> and IUTF8Bytes
5801 ///
5802 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5803 /// </remarks>
5804 /// <param name="formatString">The format string.</param>
5805
5806 /// <param name="arg0">Value to interpolate into the format string.</param>
5807 /// <param name="arg1">Value to interpolate into the format string.</param>
5808 /// <param name="arg2">Value to interpolate into the format string.</param>
5809 /// <param name="arg3">Value to interpolate into the format string.</param>
5810 /// <returns>A new string produced by interpolating the format string.</returns>
5811 [ExcludeFromBurstCompatTesting("Takes managed string")]
5812 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, float arg2, string arg3)
5813
5814 {
5815 FixedString512Bytes result = default;
5816 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5817 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5818 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5819 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5820
5821
5822 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5823 return result;
5824 }
5825
5826 /// <summary>
5827 /// Returns a new string produced by interpolating a format string.
5828 /// </summary>
5829 /// <remarks>
5830 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5831 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5832 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5833 ///
5834 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5835 /// - FixedString*N*Bytes
5836 /// - string
5837 /// - int
5838 /// - float
5839 /// - structs implementing INativeList<byte> and IUTF8Bytes
5840 ///
5841 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5842 /// </remarks>
5843 /// <param name="formatString">The format string.</param>
5844
5845 /// <param name="arg0">Value to interpolate into the format string.</param>
5846 /// <param name="arg1">Value to interpolate into the format string.</param>
5847 /// <param name="arg2">Value to interpolate into the format string.</param>
5848 /// <param name="arg3">Value to interpolate into the format string.</param>
5849 /// <returns>A new string produced by interpolating the format string.</returns>
5850 [ExcludeFromBurstCompatTesting("Takes managed string")]
5851 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, float arg2, string arg3)
5852
5853 {
5854 FixedString512Bytes result = default;
5855 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5856 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5857 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5858 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5859
5860
5861 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5862 return result;
5863 }
5864
5865 /// <summary>
5866 /// Returns a new string produced by interpolating a format string.
5867 /// </summary>
5868 /// <remarks>
5869 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5870 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5871 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5872 ///
5873 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5874 /// - FixedString*N*Bytes
5875 /// - string
5876 /// - int
5877 /// - float
5878 /// - structs implementing INativeList<byte> and IUTF8Bytes
5879 ///
5880 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5881 /// </remarks>
5882 /// <param name="formatString">The format string.</param>
5883 /// <typeparam name="T1"><undoc /></typeparam>
5884
5885 /// <param name="arg0">Value to interpolate into the format string.</param>
5886 /// <param name="arg1">Value to interpolate into the format string.</param>
5887 /// <param name="arg2">Value to interpolate into the format string.</param>
5888 /// <param name="arg3">Value to interpolate into the format string.</param>
5889 /// <returns>A new string produced by interpolating the format string.</returns>
5890 [ExcludeFromBurstCompatTesting("Takes managed string")]
5891 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, string arg3)
5892 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
5893
5894 {
5895 FixedString512Bytes result = default;
5896 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5897 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5898 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5899
5900
5901 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
5902 return result;
5903 }
5904
5905 /// <summary>
5906 /// Returns a new string produced by interpolating a format string.
5907 /// </summary>
5908 /// <remarks>
5909 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5910 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5911 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5912 ///
5913 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5914 /// - FixedString*N*Bytes
5915 /// - string
5916 /// - int
5917 /// - float
5918 /// - structs implementing INativeList<byte> and IUTF8Bytes
5919 ///
5920 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5921 /// </remarks>
5922 /// <param name="formatString">The format string.</param>
5923
5924 /// <param name="arg0">Value to interpolate into the format string.</param>
5925 /// <param name="arg1">Value to interpolate into the format string.</param>
5926 /// <param name="arg2">Value to interpolate into the format string.</param>
5927 /// <param name="arg3">Value to interpolate into the format string.</param>
5928 /// <returns>A new string produced by interpolating the format string.</returns>
5929 [ExcludeFromBurstCompatTesting("Takes managed string")]
5930 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, float arg2, string arg3)
5931
5932 {
5933 FixedString512Bytes result = default;
5934 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5935 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5936 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5937 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5938
5939
5940 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5941 return result;
5942 }
5943
5944 /// <summary>
5945 /// Returns a new string produced by interpolating a format string.
5946 /// </summary>
5947 /// <remarks>
5948 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5949 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5950 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5951 ///
5952 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5953 /// - FixedString*N*Bytes
5954 /// - string
5955 /// - int
5956 /// - float
5957 /// - structs implementing INativeList<byte> and IUTF8Bytes
5958 ///
5959 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5960 /// </remarks>
5961 /// <param name="formatString">The format string.</param>
5962
5963 /// <param name="arg0">Value to interpolate into the format string.</param>
5964 /// <param name="arg1">Value to interpolate into the format string.</param>
5965 /// <param name="arg2">Value to interpolate into the format string.</param>
5966 /// <param name="arg3">Value to interpolate into the format string.</param>
5967 /// <returns>A new string produced by interpolating the format string.</returns>
5968 [ExcludeFromBurstCompatTesting("Takes managed string")]
5969 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, float arg2, string arg3)
5970
5971 {
5972 FixedString512Bytes result = default;
5973 FixedString32Bytes carg0 = default; carg0.Append(arg0);
5974 FixedString32Bytes carg1 = default; carg1.Append(arg1);
5975 FixedString32Bytes carg2 = default; carg2.Append(arg2);
5976 FixedString32Bytes carg3 = default; carg3.Append(arg3);
5977
5978
5979 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
5980 return result;
5981 }
5982
5983 /// <summary>
5984 /// Returns a new string produced by interpolating a format string.
5985 /// </summary>
5986 /// <remarks>
5987 /// Similar to StringBuilder.AppendFormat but with significant limitations:
5988 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
5989 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
5990 ///
5991 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
5992 /// - FixedString*N*Bytes
5993 /// - string
5994 /// - int
5995 /// - float
5996 /// - structs implementing INativeList<byte> and IUTF8Bytes
5997 ///
5998 /// <seealso cref="FixedStringMethods.AppendFormat"/>
5999 /// </remarks>
6000 /// <param name="formatString">The format string.</param>
6001
6002 /// <param name="arg0">Value to interpolate into the format string.</param>
6003 /// <param name="arg1">Value to interpolate into the format string.</param>
6004 /// <param name="arg2">Value to interpolate into the format string.</param>
6005 /// <param name="arg3">Value to interpolate into the format string.</param>
6006 /// <returns>A new string produced by interpolating the format string.</returns>
6007 [ExcludeFromBurstCompatTesting("Takes managed string")]
6008 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, float arg2, string arg3)
6009
6010 {
6011 FixedString512Bytes result = default;
6012 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6013 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6014 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6015 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6016
6017
6018 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6019 return result;
6020 }
6021
6022 /// <summary>
6023 /// Returns a new string produced by interpolating a format string.
6024 /// </summary>
6025 /// <remarks>
6026 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6027 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6028 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6029 ///
6030 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6031 /// - FixedString*N*Bytes
6032 /// - string
6033 /// - int
6034 /// - float
6035 /// - structs implementing INativeList<byte> and IUTF8Bytes
6036 ///
6037 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6038 /// </remarks>
6039 /// <param name="formatString">The format string.</param>
6040 /// <typeparam name="T1"><undoc /></typeparam>
6041
6042 /// <param name="arg0">Value to interpolate into the format string.</param>
6043 /// <param name="arg1">Value to interpolate into the format string.</param>
6044 /// <param name="arg2">Value to interpolate into the format string.</param>
6045 /// <param name="arg3">Value to interpolate into the format string.</param>
6046 /// <returns>A new string produced by interpolating the format string.</returns>
6047 [ExcludeFromBurstCompatTesting("Takes managed string")]
6048 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, string arg3)
6049 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6050
6051 {
6052 FixedString512Bytes result = default;
6053 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6054 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6055 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6056
6057
6058 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
6059 return result;
6060 }
6061
6062 /// <summary>
6063 /// Returns a new string produced by interpolating a format string.
6064 /// </summary>
6065 /// <remarks>
6066 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6067 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6068 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6069 ///
6070 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6071 /// - FixedString*N*Bytes
6072 /// - string
6073 /// - int
6074 /// - float
6075 /// - structs implementing INativeList<byte> and IUTF8Bytes
6076 ///
6077 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6078 /// </remarks>
6079 /// <param name="formatString">The format string.</param>
6080
6081 /// <param name="arg0">Value to interpolate into the format string.</param>
6082 /// <param name="arg1">Value to interpolate into the format string.</param>
6083 /// <param name="arg2">Value to interpolate into the format string.</param>
6084 /// <param name="arg3">Value to interpolate into the format string.</param>
6085 /// <returns>A new string produced by interpolating the format string.</returns>
6086 [ExcludeFromBurstCompatTesting("Takes managed string")]
6087 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, float arg2, string arg3)
6088
6089 {
6090 FixedString512Bytes result = default;
6091 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6092 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6093 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6094 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6095
6096
6097 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6098 return result;
6099 }
6100
6101 /// <summary>
6102 /// Returns a new string produced by interpolating a format string.
6103 /// </summary>
6104 /// <remarks>
6105 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6106 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6107 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6108 ///
6109 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6110 /// - FixedString*N*Bytes
6111 /// - string
6112 /// - int
6113 /// - float
6114 /// - structs implementing INativeList<byte> and IUTF8Bytes
6115 ///
6116 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6117 /// </remarks>
6118 /// <param name="formatString">The format string.</param>
6119
6120 /// <param name="arg0">Value to interpolate into the format string.</param>
6121 /// <param name="arg1">Value to interpolate into the format string.</param>
6122 /// <param name="arg2">Value to interpolate into the format string.</param>
6123 /// <param name="arg3">Value to interpolate into the format string.</param>
6124 /// <returns>A new string produced by interpolating the format string.</returns>
6125 [ExcludeFromBurstCompatTesting("Takes managed string")]
6126 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, float arg2, string arg3)
6127
6128 {
6129 FixedString512Bytes result = default;
6130 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6131 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6132 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6133 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6134
6135
6136 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6137 return result;
6138 }
6139
6140 /// <summary>
6141 /// Returns a new string produced by interpolating a format string.
6142 /// </summary>
6143 /// <remarks>
6144 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6145 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6146 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6147 ///
6148 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6149 /// - FixedString*N*Bytes
6150 /// - string
6151 /// - int
6152 /// - float
6153 /// - structs implementing INativeList<byte> and IUTF8Bytes
6154 ///
6155 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6156 /// </remarks>
6157 /// <param name="formatString">The format string.</param>
6158
6159 /// <param name="arg0">Value to interpolate into the format string.</param>
6160 /// <param name="arg1">Value to interpolate into the format string.</param>
6161 /// <param name="arg2">Value to interpolate into the format string.</param>
6162 /// <param name="arg3">Value to interpolate into the format string.</param>
6163 /// <returns>A new string produced by interpolating the format string.</returns>
6164 [ExcludeFromBurstCompatTesting("Takes managed string")]
6165 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, float arg2, string arg3)
6166
6167 {
6168 FixedString512Bytes result = default;
6169 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6170 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6171 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6172 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6173
6174
6175 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6176 return result;
6177 }
6178
6179 /// <summary>
6180 /// Returns a new string produced by interpolating a format string.
6181 /// </summary>
6182 /// <remarks>
6183 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6184 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6185 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6186 ///
6187 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6188 /// - FixedString*N*Bytes
6189 /// - string
6190 /// - int
6191 /// - float
6192 /// - structs implementing INativeList<byte> and IUTF8Bytes
6193 ///
6194 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6195 /// </remarks>
6196 /// <param name="formatString">The format string.</param>
6197 /// <typeparam name="T1"><undoc /></typeparam>
6198
6199 /// <param name="arg0">Value to interpolate into the format string.</param>
6200 /// <param name="arg1">Value to interpolate into the format string.</param>
6201 /// <param name="arg2">Value to interpolate into the format string.</param>
6202 /// <param name="arg3">Value to interpolate into the format string.</param>
6203 /// <returns>A new string produced by interpolating the format string.</returns>
6204 [ExcludeFromBurstCompatTesting("Takes managed string")]
6205 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, string arg3)
6206 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6207
6208 {
6209 FixedString512Bytes result = default;
6210 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6211 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6212 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6213
6214
6215 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
6216 return result;
6217 }
6218
6219 /// <summary>
6220 /// Returns a new string produced by interpolating a format string.
6221 /// </summary>
6222 /// <remarks>
6223 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6224 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6225 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6226 ///
6227 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6228 /// - FixedString*N*Bytes
6229 /// - string
6230 /// - int
6231 /// - float
6232 /// - structs implementing INativeList<byte> and IUTF8Bytes
6233 ///
6234 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6235 /// </remarks>
6236 /// <param name="formatString">The format string.</param>
6237 /// <typeparam name="T1"><undoc /></typeparam>
6238
6239 /// <param name="arg0">Value to interpolate into the format string.</param>
6240 /// <param name="arg1">Value to interpolate into the format string.</param>
6241 /// <param name="arg2">Value to interpolate into the format string.</param>
6242 /// <param name="arg3">Value to interpolate into the format string.</param>
6243 /// <returns>A new string produced by interpolating the format string.</returns>
6244 [ExcludeFromBurstCompatTesting("Takes managed string")]
6245 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, string arg3)
6246 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6247
6248 {
6249 FixedString512Bytes result = default;
6250 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6251 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6252 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6253
6254
6255 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6256 return result;
6257 }
6258
6259 /// <summary>
6260 /// Returns a new string produced by interpolating a format string.
6261 /// </summary>
6262 /// <remarks>
6263 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6264 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6265 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6266 ///
6267 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6268 /// - FixedString*N*Bytes
6269 /// - string
6270 /// - int
6271 /// - float
6272 /// - structs implementing INativeList<byte> and IUTF8Bytes
6273 ///
6274 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6275 /// </remarks>
6276 /// <param name="formatString">The format string.</param>
6277 /// <typeparam name="T1"><undoc /></typeparam>
6278
6279 /// <param name="arg0">Value to interpolate into the format string.</param>
6280 /// <param name="arg1">Value to interpolate into the format string.</param>
6281 /// <param name="arg2">Value to interpolate into the format string.</param>
6282 /// <param name="arg3">Value to interpolate into the format string.</param>
6283 /// <returns>A new string produced by interpolating the format string.</returns>
6284 [ExcludeFromBurstCompatTesting("Takes managed string")]
6285 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, string arg3)
6286 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6287
6288 {
6289 FixedString512Bytes result = default;
6290 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6291 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6292 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6293
6294
6295 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6296 return result;
6297 }
6298
6299 /// <summary>
6300 /// Returns a new string produced by interpolating a format string.
6301 /// </summary>
6302 /// <remarks>
6303 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6304 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6305 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6306 ///
6307 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6308 /// - FixedString*N*Bytes
6309 /// - string
6310 /// - int
6311 /// - float
6312 /// - structs implementing INativeList<byte> and IUTF8Bytes
6313 ///
6314 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6315 /// </remarks>
6316 /// <param name="formatString">The format string.</param>
6317 /// <typeparam name="T1"><undoc /></typeparam>
6318
6319 /// <param name="arg0">Value to interpolate into the format string.</param>
6320 /// <param name="arg1">Value to interpolate into the format string.</param>
6321 /// <param name="arg2">Value to interpolate into the format string.</param>
6322 /// <param name="arg3">Value to interpolate into the format string.</param>
6323 /// <returns>A new string produced by interpolating the format string.</returns>
6324 [ExcludeFromBurstCompatTesting("Takes managed string")]
6325 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, string arg3)
6326 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6327
6328 {
6329 FixedString512Bytes result = default;
6330 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6331 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6332 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6333
6334
6335 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6336 return result;
6337 }
6338
6339 /// <summary>
6340 /// Returns a new string produced by interpolating a format string.
6341 /// </summary>
6342 /// <remarks>
6343 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6344 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6345 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6346 ///
6347 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6348 /// - FixedString*N*Bytes
6349 /// - string
6350 /// - int
6351 /// - float
6352 /// - structs implementing INativeList<byte> and IUTF8Bytes
6353 ///
6354 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6355 /// </remarks>
6356 /// <param name="formatString">The format string.</param>
6357 /// <typeparam name="T1"><undoc /></typeparam>
6358 /// <typeparam name="T2"><undoc /></typeparam>
6359
6360 /// <param name="arg0">Value to interpolate into the format string.</param>
6361 /// <param name="arg1">Value to interpolate into the format string.</param>
6362 /// <param name="arg2">Value to interpolate into the format string.</param>
6363 /// <param name="arg3">Value to interpolate into the format string.</param>
6364 /// <returns>A new string produced by interpolating the format string.</returns>
6365 [ExcludeFromBurstCompatTesting("Takes managed string")]
6366 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, string arg3)
6367 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6368 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
6369
6370 {
6371 FixedString512Bytes result = default;
6372 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6373 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6374
6375
6376 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
6377 return result;
6378 }
6379
6380 /// <summary>
6381 /// Returns a new string produced by interpolating a format string.
6382 /// </summary>
6383 /// <remarks>
6384 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6385 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6386 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6387 ///
6388 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6389 /// - FixedString*N*Bytes
6390 /// - string
6391 /// - int
6392 /// - float
6393 /// - structs implementing INativeList<byte> and IUTF8Bytes
6394 ///
6395 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6396 /// </remarks>
6397 /// <param name="formatString">The format string.</param>
6398
6399 /// <param name="arg0">Value to interpolate into the format string.</param>
6400 /// <param name="arg1">Value to interpolate into the format string.</param>
6401 /// <param name="arg2">Value to interpolate into the format string.</param>
6402 /// <param name="arg3">Value to interpolate into the format string.</param>
6403 /// <returns>A new string produced by interpolating the format string.</returns>
6404 [ExcludeFromBurstCompatTesting("Takes managed string")]
6405 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, int arg1, string arg2, string arg3)
6406
6407 {
6408 FixedString512Bytes result = default;
6409 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6410 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6411 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6412 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6413
6414
6415 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6416 return result;
6417 }
6418
6419 /// <summary>
6420 /// Returns a new string produced by interpolating a format string.
6421 /// </summary>
6422 /// <remarks>
6423 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6424 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6425 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6426 ///
6427 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6428 /// - FixedString*N*Bytes
6429 /// - string
6430 /// - int
6431 /// - float
6432 /// - structs implementing INativeList<byte> and IUTF8Bytes
6433 ///
6434 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6435 /// </remarks>
6436 /// <param name="formatString">The format string.</param>
6437
6438 /// <param name="arg0">Value to interpolate into the format string.</param>
6439 /// <param name="arg1">Value to interpolate into the format string.</param>
6440 /// <param name="arg2">Value to interpolate into the format string.</param>
6441 /// <param name="arg3">Value to interpolate into the format string.</param>
6442 /// <returns>A new string produced by interpolating the format string.</returns>
6443 [ExcludeFromBurstCompatTesting("Takes managed string")]
6444 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, int arg1, string arg2, string arg3)
6445
6446 {
6447 FixedString512Bytes result = default;
6448 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6449 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6450 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6451 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6452
6453
6454 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6455 return result;
6456 }
6457
6458 /// <summary>
6459 /// Returns a new string produced by interpolating a format string.
6460 /// </summary>
6461 /// <remarks>
6462 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6463 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6464 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6465 ///
6466 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6467 /// - FixedString*N*Bytes
6468 /// - string
6469 /// - int
6470 /// - float
6471 /// - structs implementing INativeList<byte> and IUTF8Bytes
6472 ///
6473 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6474 /// </remarks>
6475 /// <param name="formatString">The format string.</param>
6476
6477 /// <param name="arg0">Value to interpolate into the format string.</param>
6478 /// <param name="arg1">Value to interpolate into the format string.</param>
6479 /// <param name="arg2">Value to interpolate into the format string.</param>
6480 /// <param name="arg3">Value to interpolate into the format string.</param>
6481 /// <returns>A new string produced by interpolating the format string.</returns>
6482 [ExcludeFromBurstCompatTesting("Takes managed string")]
6483 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, int arg1, string arg2, string arg3)
6484
6485 {
6486 FixedString512Bytes result = default;
6487 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6488 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6489 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6490 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6491
6492
6493 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6494 return result;
6495 }
6496
6497 /// <summary>
6498 /// Returns a new string produced by interpolating a format string.
6499 /// </summary>
6500 /// <remarks>
6501 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6502 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6503 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6504 ///
6505 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6506 /// - FixedString*N*Bytes
6507 /// - string
6508 /// - int
6509 /// - float
6510 /// - structs implementing INativeList<byte> and IUTF8Bytes
6511 ///
6512 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6513 /// </remarks>
6514 /// <param name="formatString">The format string.</param>
6515 /// <typeparam name="T1"><undoc /></typeparam>
6516
6517 /// <param name="arg0">Value to interpolate into the format string.</param>
6518 /// <param name="arg1">Value to interpolate into the format string.</param>
6519 /// <param name="arg2">Value to interpolate into the format string.</param>
6520 /// <param name="arg3">Value to interpolate into the format string.</param>
6521 /// <returns>A new string produced by interpolating the format string.</returns>
6522 [ExcludeFromBurstCompatTesting("Takes managed string")]
6523 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, string arg3)
6524 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6525
6526 {
6527 FixedString512Bytes result = default;
6528 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6529 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6530 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6531
6532
6533 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
6534 return result;
6535 }
6536
6537 /// <summary>
6538 /// Returns a new string produced by interpolating a format string.
6539 /// </summary>
6540 /// <remarks>
6541 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6542 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6543 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6544 ///
6545 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6546 /// - FixedString*N*Bytes
6547 /// - string
6548 /// - int
6549 /// - float
6550 /// - structs implementing INativeList<byte> and IUTF8Bytes
6551 ///
6552 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6553 /// </remarks>
6554 /// <param name="formatString">The format string.</param>
6555
6556 /// <param name="arg0">Value to interpolate into the format string.</param>
6557 /// <param name="arg1">Value to interpolate into the format string.</param>
6558 /// <param name="arg2">Value to interpolate into the format string.</param>
6559 /// <param name="arg3">Value to interpolate into the format string.</param>
6560 /// <returns>A new string produced by interpolating the format string.</returns>
6561 [ExcludeFromBurstCompatTesting("Takes managed string")]
6562 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, float arg1, string arg2, string arg3)
6563
6564 {
6565 FixedString512Bytes result = default;
6566 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6567 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6568 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6569 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6570
6571
6572 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6573 return result;
6574 }
6575
6576 /// <summary>
6577 /// Returns a new string produced by interpolating a format string.
6578 /// </summary>
6579 /// <remarks>
6580 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6581 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6582 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6583 ///
6584 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6585 /// - FixedString*N*Bytes
6586 /// - string
6587 /// - int
6588 /// - float
6589 /// - structs implementing INativeList<byte> and IUTF8Bytes
6590 ///
6591 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6592 /// </remarks>
6593 /// <param name="formatString">The format string.</param>
6594
6595 /// <param name="arg0">Value to interpolate into the format string.</param>
6596 /// <param name="arg1">Value to interpolate into the format string.</param>
6597 /// <param name="arg2">Value to interpolate into the format string.</param>
6598 /// <param name="arg3">Value to interpolate into the format string.</param>
6599 /// <returns>A new string produced by interpolating the format string.</returns>
6600 [ExcludeFromBurstCompatTesting("Takes managed string")]
6601 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, float arg1, string arg2, string arg3)
6602
6603 {
6604 FixedString512Bytes result = default;
6605 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6606 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6607 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6608 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6609
6610
6611 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6612 return result;
6613 }
6614
6615 /// <summary>
6616 /// Returns a new string produced by interpolating a format string.
6617 /// </summary>
6618 /// <remarks>
6619 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6620 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6621 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6622 ///
6623 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6624 /// - FixedString*N*Bytes
6625 /// - string
6626 /// - int
6627 /// - float
6628 /// - structs implementing INativeList<byte> and IUTF8Bytes
6629 ///
6630 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6631 /// </remarks>
6632 /// <param name="formatString">The format string.</param>
6633
6634 /// <param name="arg0">Value to interpolate into the format string.</param>
6635 /// <param name="arg1">Value to interpolate into the format string.</param>
6636 /// <param name="arg2">Value to interpolate into the format string.</param>
6637 /// <param name="arg3">Value to interpolate into the format string.</param>
6638 /// <returns>A new string produced by interpolating the format string.</returns>
6639 [ExcludeFromBurstCompatTesting("Takes managed string")]
6640 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, float arg1, string arg2, string arg3)
6641
6642 {
6643 FixedString512Bytes result = default;
6644 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6645 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6646 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6647 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6648
6649
6650 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6651 return result;
6652 }
6653
6654 /// <summary>
6655 /// Returns a new string produced by interpolating a format string.
6656 /// </summary>
6657 /// <remarks>
6658 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6659 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6660 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6661 ///
6662 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6663 /// - FixedString*N*Bytes
6664 /// - string
6665 /// - int
6666 /// - float
6667 /// - structs implementing INativeList<byte> and IUTF8Bytes
6668 ///
6669 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6670 /// </remarks>
6671 /// <param name="formatString">The format string.</param>
6672 /// <typeparam name="T1"><undoc /></typeparam>
6673
6674 /// <param name="arg0">Value to interpolate into the format string.</param>
6675 /// <param name="arg1">Value to interpolate into the format string.</param>
6676 /// <param name="arg2">Value to interpolate into the format string.</param>
6677 /// <param name="arg3">Value to interpolate into the format string.</param>
6678 /// <returns>A new string produced by interpolating the format string.</returns>
6679 [ExcludeFromBurstCompatTesting("Takes managed string")]
6680 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, string arg3)
6681 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6682
6683 {
6684 FixedString512Bytes result = default;
6685 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6686 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6687 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6688
6689
6690 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
6691 return result;
6692 }
6693
6694 /// <summary>
6695 /// Returns a new string produced by interpolating a format string.
6696 /// </summary>
6697 /// <remarks>
6698 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6699 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6700 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6701 ///
6702 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6703 /// - FixedString*N*Bytes
6704 /// - string
6705 /// - int
6706 /// - float
6707 /// - structs implementing INativeList<byte> and IUTF8Bytes
6708 ///
6709 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6710 /// </remarks>
6711 /// <param name="formatString">The format string.</param>
6712
6713 /// <param name="arg0">Value to interpolate into the format string.</param>
6714 /// <param name="arg1">Value to interpolate into the format string.</param>
6715 /// <param name="arg2">Value to interpolate into the format string.</param>
6716 /// <param name="arg3">Value to interpolate into the format string.</param>
6717 /// <returns>A new string produced by interpolating the format string.</returns>
6718 [ExcludeFromBurstCompatTesting("Takes managed string")]
6719 public static FixedString512Bytes Format(FixedString512Bytes formatString, int arg0, string arg1, string arg2, string arg3)
6720
6721 {
6722 FixedString512Bytes result = default;
6723 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6724 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6725 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6726 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6727
6728
6729 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6730 return result;
6731 }
6732
6733 /// <summary>
6734 /// Returns a new string produced by interpolating a format string.
6735 /// </summary>
6736 /// <remarks>
6737 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6738 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6739 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6740 ///
6741 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6742 /// - FixedString*N*Bytes
6743 /// - string
6744 /// - int
6745 /// - float
6746 /// - structs implementing INativeList<byte> and IUTF8Bytes
6747 ///
6748 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6749 /// </remarks>
6750 /// <param name="formatString">The format string.</param>
6751
6752 /// <param name="arg0">Value to interpolate into the format string.</param>
6753 /// <param name="arg1">Value to interpolate into the format string.</param>
6754 /// <param name="arg2">Value to interpolate into the format string.</param>
6755 /// <param name="arg3">Value to interpolate into the format string.</param>
6756 /// <returns>A new string produced by interpolating the format string.</returns>
6757 [ExcludeFromBurstCompatTesting("Takes managed string")]
6758 public static FixedString512Bytes Format(FixedString512Bytes formatString, float arg0, string arg1, string arg2, string arg3)
6759
6760 {
6761 FixedString512Bytes result = default;
6762 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6763 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6764 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6765 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6766
6767
6768 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6769 return result;
6770 }
6771
6772 /// <summary>
6773 /// Returns a new string produced by interpolating a format string.
6774 /// </summary>
6775 /// <remarks>
6776 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6777 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6778 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6779 ///
6780 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6781 /// - FixedString*N*Bytes
6782 /// - string
6783 /// - int
6784 /// - float
6785 /// - structs implementing INativeList<byte> and IUTF8Bytes
6786 ///
6787 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6788 /// </remarks>
6789 /// <param name="formatString">The format string.</param>
6790
6791 /// <param name="arg0">Value to interpolate into the format string.</param>
6792 /// <param name="arg1">Value to interpolate into the format string.</param>
6793 /// <param name="arg2">Value to interpolate into the format string.</param>
6794 /// <param name="arg3">Value to interpolate into the format string.</param>
6795 /// <returns>A new string produced by interpolating the format string.</returns>
6796 [ExcludeFromBurstCompatTesting("Takes managed string")]
6797 public static FixedString512Bytes Format(FixedString512Bytes formatString, string arg0, string arg1, string arg2, string arg3)
6798
6799 {
6800 FixedString512Bytes result = default;
6801 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6802 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6803 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6804 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6805
6806
6807 result.AppendFormat(formatString, carg0, carg1, carg2, carg3);
6808 return result;
6809 }
6810
6811 /// <summary>
6812 /// Returns a new string produced by interpolating a format string.
6813 /// </summary>
6814 /// <remarks>
6815 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6816 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6817 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6818 ///
6819 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6820 /// - FixedString*N*Bytes
6821 /// - string
6822 /// - int
6823 /// - float
6824 /// - structs implementing INativeList<byte> and IUTF8Bytes
6825 ///
6826 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6827 /// </remarks>
6828 /// <param name="formatString">The format string.</param>
6829 /// <typeparam name="T1"><undoc /></typeparam>
6830
6831 /// <param name="arg0">Value to interpolate into the format string.</param>
6832 /// <param name="arg1">Value to interpolate into the format string.</param>
6833 /// <param name="arg2">Value to interpolate into the format string.</param>
6834 /// <param name="arg3">Value to interpolate into the format string.</param>
6835 /// <returns>A new string produced by interpolating the format string.</returns>
6836 [ExcludeFromBurstCompatTesting("Takes managed string")]
6837 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, string arg3)
6838 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6839
6840 {
6841 FixedString512Bytes result = default;
6842 FixedString32Bytes carg1 = default; carg1.Append(arg1);
6843 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6844 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6845
6846
6847 result.AppendFormat(formatString, arg0, carg1, carg2, carg3);
6848 return result;
6849 }
6850
6851 /// <summary>
6852 /// Returns a new string produced by interpolating a format string.
6853 /// </summary>
6854 /// <remarks>
6855 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6856 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6857 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6858 ///
6859 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6860 /// - FixedString*N*Bytes
6861 /// - string
6862 /// - int
6863 /// - float
6864 /// - structs implementing INativeList<byte> and IUTF8Bytes
6865 ///
6866 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6867 /// </remarks>
6868 /// <param name="formatString">The format string.</param>
6869 /// <typeparam name="T1"><undoc /></typeparam>
6870
6871 /// <param name="arg0">Value to interpolate into the format string.</param>
6872 /// <param name="arg1">Value to interpolate into the format string.</param>
6873 /// <param name="arg2">Value to interpolate into the format string.</param>
6874 /// <param name="arg3">Value to interpolate into the format string.</param>
6875 /// <returns>A new string produced by interpolating the format string.</returns>
6876 [ExcludeFromBurstCompatTesting("Takes managed string")]
6877 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, string arg3)
6878 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6879
6880 {
6881 FixedString512Bytes result = default;
6882 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6883 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6884 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6885
6886
6887 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6888 return result;
6889 }
6890
6891 /// <summary>
6892 /// Returns a new string produced by interpolating a format string.
6893 /// </summary>
6894 /// <remarks>
6895 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6896 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6897 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6898 ///
6899 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6900 /// - FixedString*N*Bytes
6901 /// - string
6902 /// - int
6903 /// - float
6904 /// - structs implementing INativeList<byte> and IUTF8Bytes
6905 ///
6906 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6907 /// </remarks>
6908 /// <param name="formatString">The format string.</param>
6909 /// <typeparam name="T1"><undoc /></typeparam>
6910
6911 /// <param name="arg0">Value to interpolate into the format string.</param>
6912 /// <param name="arg1">Value to interpolate into the format string.</param>
6913 /// <param name="arg2">Value to interpolate into the format string.</param>
6914 /// <param name="arg3">Value to interpolate into the format string.</param>
6915 /// <returns>A new string produced by interpolating the format string.</returns>
6916 [ExcludeFromBurstCompatTesting("Takes managed string")]
6917 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, string arg3)
6918 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6919
6920 {
6921 FixedString512Bytes result = default;
6922 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6923 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6924 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6925
6926
6927 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6928 return result;
6929 }
6930
6931 /// <summary>
6932 /// Returns a new string produced by interpolating a format string.
6933 /// </summary>
6934 /// <remarks>
6935 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6936 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6937 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6938 ///
6939 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6940 /// - FixedString*N*Bytes
6941 /// - string
6942 /// - int
6943 /// - float
6944 /// - structs implementing INativeList<byte> and IUTF8Bytes
6945 ///
6946 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6947 /// </remarks>
6948 /// <param name="formatString">The format string.</param>
6949 /// <typeparam name="T1"><undoc /></typeparam>
6950
6951 /// <param name="arg0">Value to interpolate into the format string.</param>
6952 /// <param name="arg1">Value to interpolate into the format string.</param>
6953 /// <param name="arg2">Value to interpolate into the format string.</param>
6954 /// <param name="arg3">Value to interpolate into the format string.</param>
6955 /// <returns>A new string produced by interpolating the format string.</returns>
6956 [ExcludeFromBurstCompatTesting("Takes managed string")]
6957 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, string arg3)
6958 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
6959
6960 {
6961 FixedString512Bytes result = default;
6962 FixedString32Bytes carg0 = default; carg0.Append(arg0);
6963 FixedString32Bytes carg2 = default; carg2.Append(arg2);
6964 FixedString32Bytes carg3 = default; carg3.Append(arg3);
6965
6966
6967 result.AppendFormat(formatString, carg0, arg1, carg2, carg3);
6968 return result;
6969 }
6970
6971 /// <summary>
6972 /// Returns a new string produced by interpolating a format string.
6973 /// </summary>
6974 /// <remarks>
6975 /// Similar to StringBuilder.AppendFormat but with significant limitations:
6976 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
6977 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
6978 ///
6979 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
6980 /// - FixedString*N*Bytes
6981 /// - string
6982 /// - int
6983 /// - float
6984 /// - structs implementing INativeList<byte> and IUTF8Bytes
6985 ///
6986 /// <seealso cref="FixedStringMethods.AppendFormat"/>
6987 /// </remarks>
6988 /// <param name="formatString">The format string.</param>
6989 /// <typeparam name="T1"><undoc /></typeparam>
6990 /// <typeparam name="T2"><undoc /></typeparam>
6991
6992 /// <param name="arg0">Value to interpolate into the format string.</param>
6993 /// <param name="arg1">Value to interpolate into the format string.</param>
6994 /// <param name="arg2">Value to interpolate into the format string.</param>
6995 /// <param name="arg3">Value to interpolate into the format string.</param>
6996 /// <returns>A new string produced by interpolating the format string.</returns>
6997 [ExcludeFromBurstCompatTesting("Takes managed string")]
6998 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, string arg3)
6999 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7000 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7001
7002 {
7003 FixedString512Bytes result = default;
7004 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7005 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7006
7007
7008 result.AppendFormat(formatString, arg0, arg1, carg2, carg3);
7009 return result;
7010 }
7011
7012 /// <summary>
7013 /// Returns a new string produced by interpolating a format string.
7014 /// </summary>
7015 /// <remarks>
7016 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7017 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7018 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7019 ///
7020 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7021 /// - FixedString*N*Bytes
7022 /// - string
7023 /// - int
7024 /// - float
7025 /// - structs implementing INativeList<byte> and IUTF8Bytes
7026 ///
7027 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7028 /// </remarks>
7029 /// <param name="formatString">The format string.</param>
7030 /// <typeparam name="T1"><undoc /></typeparam>
7031
7032 /// <param name="arg0">Value to interpolate into the format string.</param>
7033 /// <param name="arg1">Value to interpolate into the format string.</param>
7034 /// <param name="arg2">Value to interpolate into the format string.</param>
7035 /// <param name="arg3">Value to interpolate into the format string.</param>
7036 /// <returns>A new string produced by interpolating the format string.</returns>
7037 [ExcludeFromBurstCompatTesting("Takes managed string")]
7038 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, string arg3)
7039 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7040
7041 {
7042 FixedString512Bytes result = default;
7043 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7044 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7045 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7046
7047
7048 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7049 return result;
7050 }
7051
7052 /// <summary>
7053 /// Returns a new string produced by interpolating a format string.
7054 /// </summary>
7055 /// <remarks>
7056 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7057 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7058 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7059 ///
7060 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7061 /// - FixedString*N*Bytes
7062 /// - string
7063 /// - int
7064 /// - float
7065 /// - structs implementing INativeList<byte> and IUTF8Bytes
7066 ///
7067 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7068 /// </remarks>
7069 /// <param name="formatString">The format string.</param>
7070 /// <typeparam name="T1"><undoc /></typeparam>
7071
7072 /// <param name="arg0">Value to interpolate into the format string.</param>
7073 /// <param name="arg1">Value to interpolate into the format string.</param>
7074 /// <param name="arg2">Value to interpolate into the format string.</param>
7075 /// <param name="arg3">Value to interpolate into the format string.</param>
7076 /// <returns>A new string produced by interpolating the format string.</returns>
7077 [ExcludeFromBurstCompatTesting("Takes managed string")]
7078 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, string arg3)
7079 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7080
7081 {
7082 FixedString512Bytes result = default;
7083 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7084 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7085 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7086
7087
7088 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7089 return result;
7090 }
7091
7092 /// <summary>
7093 /// Returns a new string produced by interpolating a format string.
7094 /// </summary>
7095 /// <remarks>
7096 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7097 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7098 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7099 ///
7100 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7101 /// - FixedString*N*Bytes
7102 /// - string
7103 /// - int
7104 /// - float
7105 /// - structs implementing INativeList<byte> and IUTF8Bytes
7106 ///
7107 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7108 /// </remarks>
7109 /// <param name="formatString">The format string.</param>
7110 /// <typeparam name="T1"><undoc /></typeparam>
7111
7112 /// <param name="arg0">Value to interpolate into the format string.</param>
7113 /// <param name="arg1">Value to interpolate into the format string.</param>
7114 /// <param name="arg2">Value to interpolate into the format string.</param>
7115 /// <param name="arg3">Value to interpolate into the format string.</param>
7116 /// <returns>A new string produced by interpolating the format string.</returns>
7117 [ExcludeFromBurstCompatTesting("Takes managed string")]
7118 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, string arg3)
7119 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7120
7121 {
7122 FixedString512Bytes result = default;
7123 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7124 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7125 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7126
7127
7128 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7129 return result;
7130 }
7131
7132 /// <summary>
7133 /// Returns a new string produced by interpolating a format string.
7134 /// </summary>
7135 /// <remarks>
7136 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7137 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7138 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7139 ///
7140 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7141 /// - FixedString*N*Bytes
7142 /// - string
7143 /// - int
7144 /// - float
7145 /// - structs implementing INativeList<byte> and IUTF8Bytes
7146 ///
7147 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7148 /// </remarks>
7149 /// <param name="formatString">The format string.</param>
7150 /// <typeparam name="T1"><undoc /></typeparam>
7151 /// <typeparam name="T2"><undoc /></typeparam>
7152
7153 /// <param name="arg0">Value to interpolate into the format string.</param>
7154 /// <param name="arg1">Value to interpolate into the format string.</param>
7155 /// <param name="arg2">Value to interpolate into the format string.</param>
7156 /// <param name="arg3">Value to interpolate into the format string.</param>
7157 /// <returns>A new string produced by interpolating the format string.</returns>
7158 [ExcludeFromBurstCompatTesting("Takes managed string")]
7159 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, string arg3)
7160 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7161 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7162
7163 {
7164 FixedString512Bytes result = default;
7165 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7166 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7167
7168
7169 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
7170 return result;
7171 }
7172
7173 /// <summary>
7174 /// Returns a new string produced by interpolating a format string.
7175 /// </summary>
7176 /// <remarks>
7177 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7178 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7179 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7180 ///
7181 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7182 /// - FixedString*N*Bytes
7183 /// - string
7184 /// - int
7185 /// - float
7186 /// - structs implementing INativeList<byte> and IUTF8Bytes
7187 ///
7188 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7189 /// </remarks>
7190 /// <param name="formatString">The format string.</param>
7191 /// <typeparam name="T1"><undoc /></typeparam>
7192
7193 /// <param name="arg0">Value to interpolate into the format string.</param>
7194 /// <param name="arg1">Value to interpolate into the format string.</param>
7195 /// <param name="arg2">Value to interpolate into the format string.</param>
7196 /// <param name="arg3">Value to interpolate into the format string.</param>
7197 /// <returns>A new string produced by interpolating the format string.</returns>
7198 [ExcludeFromBurstCompatTesting("Takes managed string")]
7199 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, string arg3)
7200 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7201
7202 {
7203 FixedString512Bytes result = default;
7204 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7205 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7206 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7207
7208
7209 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7210 return result;
7211 }
7212
7213 /// <summary>
7214 /// Returns a new string produced by interpolating a format string.
7215 /// </summary>
7216 /// <remarks>
7217 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7218 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7219 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7220 ///
7221 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7222 /// - FixedString*N*Bytes
7223 /// - string
7224 /// - int
7225 /// - float
7226 /// - structs implementing INativeList<byte> and IUTF8Bytes
7227 ///
7228 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7229 /// </remarks>
7230 /// <param name="formatString">The format string.</param>
7231 /// <typeparam name="T1"><undoc /></typeparam>
7232
7233 /// <param name="arg0">Value to interpolate into the format string.</param>
7234 /// <param name="arg1">Value to interpolate into the format string.</param>
7235 /// <param name="arg2">Value to interpolate into the format string.</param>
7236 /// <param name="arg3">Value to interpolate into the format string.</param>
7237 /// <returns>A new string produced by interpolating the format string.</returns>
7238 [ExcludeFromBurstCompatTesting("Takes managed string")]
7239 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, string arg3)
7240 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7241
7242 {
7243 FixedString512Bytes result = default;
7244 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7245 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7246 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7247
7248
7249 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7250 return result;
7251 }
7252
7253 /// <summary>
7254 /// Returns a new string produced by interpolating a format string.
7255 /// </summary>
7256 /// <remarks>
7257 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7258 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7259 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7260 ///
7261 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7262 /// - FixedString*N*Bytes
7263 /// - string
7264 /// - int
7265 /// - float
7266 /// - structs implementing INativeList<byte> and IUTF8Bytes
7267 ///
7268 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7269 /// </remarks>
7270 /// <param name="formatString">The format string.</param>
7271 /// <typeparam name="T1"><undoc /></typeparam>
7272
7273 /// <param name="arg0">Value to interpolate into the format string.</param>
7274 /// <param name="arg1">Value to interpolate into the format string.</param>
7275 /// <param name="arg2">Value to interpolate into the format string.</param>
7276 /// <param name="arg3">Value to interpolate into the format string.</param>
7277 /// <returns>A new string produced by interpolating the format string.</returns>
7278 [ExcludeFromBurstCompatTesting("Takes managed string")]
7279 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, string arg3)
7280 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7281
7282 {
7283 FixedString512Bytes result = default;
7284 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7285 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7286 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7287
7288
7289 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7290 return result;
7291 }
7292
7293 /// <summary>
7294 /// Returns a new string produced by interpolating a format string.
7295 /// </summary>
7296 /// <remarks>
7297 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7298 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7299 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7300 ///
7301 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7302 /// - FixedString*N*Bytes
7303 /// - string
7304 /// - int
7305 /// - float
7306 /// - structs implementing INativeList<byte> and IUTF8Bytes
7307 ///
7308 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7309 /// </remarks>
7310 /// <param name="formatString">The format string.</param>
7311 /// <typeparam name="T1"><undoc /></typeparam>
7312 /// <typeparam name="T2"><undoc /></typeparam>
7313
7314 /// <param name="arg0">Value to interpolate into the format string.</param>
7315 /// <param name="arg1">Value to interpolate into the format string.</param>
7316 /// <param name="arg2">Value to interpolate into the format string.</param>
7317 /// <param name="arg3">Value to interpolate into the format string.</param>
7318 /// <returns>A new string produced by interpolating the format string.</returns>
7319 [ExcludeFromBurstCompatTesting("Takes managed string")]
7320 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, string arg3)
7321 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7322 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7323
7324 {
7325 FixedString512Bytes result = default;
7326 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7327 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7328
7329
7330 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
7331 return result;
7332 }
7333
7334 /// <summary>
7335 /// Returns a new string produced by interpolating a format string.
7336 /// </summary>
7337 /// <remarks>
7338 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7339 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7340 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7341 ///
7342 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7343 /// - FixedString*N*Bytes
7344 /// - string
7345 /// - int
7346 /// - float
7347 /// - structs implementing INativeList<byte> and IUTF8Bytes
7348 ///
7349 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7350 /// </remarks>
7351 /// <param name="formatString">The format string.</param>
7352 /// <typeparam name="T1"><undoc /></typeparam>
7353
7354 /// <param name="arg0">Value to interpolate into the format string.</param>
7355 /// <param name="arg1">Value to interpolate into the format string.</param>
7356 /// <param name="arg2">Value to interpolate into the format string.</param>
7357 /// <param name="arg3">Value to interpolate into the format string.</param>
7358 /// <returns>A new string produced by interpolating the format string.</returns>
7359 [ExcludeFromBurstCompatTesting("Takes managed string")]
7360 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, string arg3)
7361 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7362
7363 {
7364 FixedString512Bytes result = default;
7365 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7366 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7367 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7368
7369
7370 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7371 return result;
7372 }
7373
7374 /// <summary>
7375 /// Returns a new string produced by interpolating a format string.
7376 /// </summary>
7377 /// <remarks>
7378 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7379 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7380 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7381 ///
7382 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7383 /// - FixedString*N*Bytes
7384 /// - string
7385 /// - int
7386 /// - float
7387 /// - structs implementing INativeList<byte> and IUTF8Bytes
7388 ///
7389 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7390 /// </remarks>
7391 /// <param name="formatString">The format string.</param>
7392 /// <typeparam name="T1"><undoc /></typeparam>
7393
7394 /// <param name="arg0">Value to interpolate into the format string.</param>
7395 /// <param name="arg1">Value to interpolate into the format string.</param>
7396 /// <param name="arg2">Value to interpolate into the format string.</param>
7397 /// <param name="arg3">Value to interpolate into the format string.</param>
7398 /// <returns>A new string produced by interpolating the format string.</returns>
7399 [ExcludeFromBurstCompatTesting("Takes managed string")]
7400 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, string arg3)
7401 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7402
7403 {
7404 FixedString512Bytes result = default;
7405 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7406 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7407 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7408
7409
7410 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7411 return result;
7412 }
7413
7414 /// <summary>
7415 /// Returns a new string produced by interpolating a format string.
7416 /// </summary>
7417 /// <remarks>
7418 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7419 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7420 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7421 ///
7422 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7423 /// - FixedString*N*Bytes
7424 /// - string
7425 /// - int
7426 /// - float
7427 /// - structs implementing INativeList<byte> and IUTF8Bytes
7428 ///
7429 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7430 /// </remarks>
7431 /// <param name="formatString">The format string.</param>
7432 /// <typeparam name="T1"><undoc /></typeparam>
7433
7434 /// <param name="arg0">Value to interpolate into the format string.</param>
7435 /// <param name="arg1">Value to interpolate into the format string.</param>
7436 /// <param name="arg2">Value to interpolate into the format string.</param>
7437 /// <param name="arg3">Value to interpolate into the format string.</param>
7438 /// <returns>A new string produced by interpolating the format string.</returns>
7439 [ExcludeFromBurstCompatTesting("Takes managed string")]
7440 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, string arg3)
7441 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7442
7443 {
7444 FixedString512Bytes result = default;
7445 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7446 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7447 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7448
7449
7450 result.AppendFormat(formatString, carg0, carg1, arg2, carg3);
7451 return result;
7452 }
7453
7454 /// <summary>
7455 /// Returns a new string produced by interpolating a format string.
7456 /// </summary>
7457 /// <remarks>
7458 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7459 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7460 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7461 ///
7462 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7463 /// - FixedString*N*Bytes
7464 /// - string
7465 /// - int
7466 /// - float
7467 /// - structs implementing INativeList<byte> and IUTF8Bytes
7468 ///
7469 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7470 /// </remarks>
7471 /// <param name="formatString">The format string.</param>
7472 /// <typeparam name="T1"><undoc /></typeparam>
7473 /// <typeparam name="T2"><undoc /></typeparam>
7474
7475 /// <param name="arg0">Value to interpolate into the format string.</param>
7476 /// <param name="arg1">Value to interpolate into the format string.</param>
7477 /// <param name="arg2">Value to interpolate into the format string.</param>
7478 /// <param name="arg3">Value to interpolate into the format string.</param>
7479 /// <returns>A new string produced by interpolating the format string.</returns>
7480 [ExcludeFromBurstCompatTesting("Takes managed string")]
7481 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, string arg3)
7482 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7483 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7484
7485 {
7486 FixedString512Bytes result = default;
7487 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7488 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7489
7490
7491 result.AppendFormat(formatString, arg0, carg1, arg2, carg3);
7492 return result;
7493 }
7494
7495 /// <summary>
7496 /// Returns a new string produced by interpolating a format string.
7497 /// </summary>
7498 /// <remarks>
7499 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7500 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7501 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7502 ///
7503 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7504 /// - FixedString*N*Bytes
7505 /// - string
7506 /// - int
7507 /// - float
7508 /// - structs implementing INativeList<byte> and IUTF8Bytes
7509 ///
7510 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7511 /// </remarks>
7512 /// <param name="formatString">The format string.</param>
7513 /// <typeparam name="T1"><undoc /></typeparam>
7514 /// <typeparam name="T2"><undoc /></typeparam>
7515
7516 /// <param name="arg0">Value to interpolate into the format string.</param>
7517 /// <param name="arg1">Value to interpolate into the format string.</param>
7518 /// <param name="arg2">Value to interpolate into the format string.</param>
7519 /// <param name="arg3">Value to interpolate into the format string.</param>
7520 /// <returns>A new string produced by interpolating the format string.</returns>
7521 [ExcludeFromBurstCompatTesting("Takes managed string")]
7522 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, string arg3)
7523 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7524 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7525
7526 {
7527 FixedString512Bytes result = default;
7528 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7529 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7530
7531
7532 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
7533 return result;
7534 }
7535
7536 /// <summary>
7537 /// Returns a new string produced by interpolating a format string.
7538 /// </summary>
7539 /// <remarks>
7540 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7541 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7542 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7543 ///
7544 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7545 /// - FixedString*N*Bytes
7546 /// - string
7547 /// - int
7548 /// - float
7549 /// - structs implementing INativeList<byte> and IUTF8Bytes
7550 ///
7551 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7552 /// </remarks>
7553 /// <param name="formatString">The format string.</param>
7554 /// <typeparam name="T1"><undoc /></typeparam>
7555 /// <typeparam name="T2"><undoc /></typeparam>
7556
7557 /// <param name="arg0">Value to interpolate into the format string.</param>
7558 /// <param name="arg1">Value to interpolate into the format string.</param>
7559 /// <param name="arg2">Value to interpolate into the format string.</param>
7560 /// <param name="arg3">Value to interpolate into the format string.</param>
7561 /// <returns>A new string produced by interpolating the format string.</returns>
7562 [ExcludeFromBurstCompatTesting("Takes managed string")]
7563 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, string arg3)
7564 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7565 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7566
7567 {
7568 FixedString512Bytes result = default;
7569 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7570 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7571
7572
7573 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
7574 return result;
7575 }
7576
7577 /// <summary>
7578 /// Returns a new string produced by interpolating a format string.
7579 /// </summary>
7580 /// <remarks>
7581 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7582 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7583 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7584 ///
7585 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7586 /// - FixedString*N*Bytes
7587 /// - string
7588 /// - int
7589 /// - float
7590 /// - structs implementing INativeList<byte> and IUTF8Bytes
7591 ///
7592 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7593 /// </remarks>
7594 /// <param name="formatString">The format string.</param>
7595 /// <typeparam name="T1"><undoc /></typeparam>
7596 /// <typeparam name="T2"><undoc /></typeparam>
7597
7598 /// <param name="arg0">Value to interpolate into the format string.</param>
7599 /// <param name="arg1">Value to interpolate into the format string.</param>
7600 /// <param name="arg2">Value to interpolate into the format string.</param>
7601 /// <param name="arg3">Value to interpolate into the format string.</param>
7602 /// <returns>A new string produced by interpolating the format string.</returns>
7603 [ExcludeFromBurstCompatTesting("Takes managed string")]
7604 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, string arg3)
7605 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7606 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7607
7608 {
7609 FixedString512Bytes result = default;
7610 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7611 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7612
7613
7614 result.AppendFormat(formatString, carg0, arg1, arg2, carg3);
7615 return result;
7616 }
7617
7618 /// <summary>
7619 /// Returns a new string produced by interpolating a format string.
7620 /// </summary>
7621 /// <remarks>
7622 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7623 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7624 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7625 ///
7626 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7627 /// - FixedString*N*Bytes
7628 /// - string
7629 /// - int
7630 /// - float
7631 /// - structs implementing INativeList<byte> and IUTF8Bytes
7632 ///
7633 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7634 /// </remarks>
7635 /// <param name="formatString">The format string.</param>
7636 /// <typeparam name="T1"><undoc /></typeparam>
7637 /// <typeparam name="T2"><undoc /></typeparam>
7638 /// <typeparam name="T3"><undoc /></typeparam>
7639
7640 /// <param name="arg0">Value to interpolate into the format string.</param>
7641 /// <param name="arg1">Value to interpolate into the format string.</param>
7642 /// <param name="arg2">Value to interpolate into the format string.</param>
7643 /// <param name="arg3">Value to interpolate into the format string.</param>
7644 /// <returns>A new string produced by interpolating the format string.</returns>
7645 [ExcludeFromBurstCompatTesting("Takes managed string")]
7646 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, string arg3)
7647 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7648 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7649 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
7650
7651 {
7652 FixedString512Bytes result = default;
7653 FixedString32Bytes carg3 = default; carg3.Append(arg3);
7654
7655
7656 result.AppendFormat(formatString, arg0, arg1, arg2, carg3);
7657 return result;
7658 }
7659
7660 /// <summary>
7661 /// Returns a new string produced by interpolating a format string.
7662 /// </summary>
7663 /// <remarks>
7664 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7665 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7666 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7667 ///
7668 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7669 /// - FixedString*N*Bytes
7670 /// - string
7671 /// - int
7672 /// - float
7673 /// - structs implementing INativeList<byte> and IUTF8Bytes
7674 ///
7675 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7676 /// </remarks>
7677 /// <param name="formatString">The format string.</param>
7678 /// <typeparam name="T1"><undoc /></typeparam>
7679
7680 /// <param name="arg0">Value to interpolate into the format string.</param>
7681 /// <param name="arg1">Value to interpolate into the format string.</param>
7682 /// <param name="arg2">Value to interpolate into the format string.</param>
7683 /// <param name="arg3">Value to interpolate into the format string.</param>
7684 /// <returns>A new string produced by interpolating the format string.</returns>
7685 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
7686 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, int arg2, T1 arg3)
7687 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7688
7689 {
7690 FixedString512Bytes result = default;
7691 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7692 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7693 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7694
7695
7696 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7697 return result;
7698 }
7699
7700 /// <summary>
7701 /// Returns a new string produced by interpolating a format string.
7702 /// </summary>
7703 /// <remarks>
7704 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7705 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7706 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7707 ///
7708 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7709 /// - FixedString*N*Bytes
7710 /// - string
7711 /// - int
7712 /// - float
7713 /// - structs implementing INativeList<byte> and IUTF8Bytes
7714 ///
7715 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7716 /// </remarks>
7717 /// <param name="formatString">The format string.</param>
7718 /// <typeparam name="T1"><undoc /></typeparam>
7719
7720 /// <param name="arg0">Value to interpolate into the format string.</param>
7721 /// <param name="arg1">Value to interpolate into the format string.</param>
7722 /// <param name="arg2">Value to interpolate into the format string.</param>
7723 /// <param name="arg3">Value to interpolate into the format string.</param>
7724 /// <returns>A new string produced by interpolating the format string.</returns>
7725 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
7726 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, int arg2, T1 arg3)
7727 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7728
7729 {
7730 FixedString512Bytes result = default;
7731 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7732 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7733 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7734
7735
7736 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7737 return result;
7738 }
7739
7740 /// <summary>
7741 /// Returns a new string produced by interpolating a format string.
7742 /// </summary>
7743 /// <remarks>
7744 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7745 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7746 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7747 ///
7748 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7749 /// - FixedString*N*Bytes
7750 /// - string
7751 /// - int
7752 /// - float
7753 /// - structs implementing INativeList<byte> and IUTF8Bytes
7754 ///
7755 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7756 /// </remarks>
7757 /// <param name="formatString">The format string.</param>
7758 /// <typeparam name="T1"><undoc /></typeparam>
7759
7760 /// <param name="arg0">Value to interpolate into the format string.</param>
7761 /// <param name="arg1">Value to interpolate into the format string.</param>
7762 /// <param name="arg2">Value to interpolate into the format string.</param>
7763 /// <param name="arg3">Value to interpolate into the format string.</param>
7764 /// <returns>A new string produced by interpolating the format string.</returns>
7765 [ExcludeFromBurstCompatTesting("Takes managed string")]
7766 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, int arg2, T1 arg3)
7767 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7768
7769 {
7770 FixedString512Bytes result = default;
7771 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7772 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7773 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7774
7775
7776 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7777 return result;
7778 }
7779
7780 /// <summary>
7781 /// Returns a new string produced by interpolating a format string.
7782 /// </summary>
7783 /// <remarks>
7784 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7785 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7786 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7787 ///
7788 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7789 /// - FixedString*N*Bytes
7790 /// - string
7791 /// - int
7792 /// - float
7793 /// - structs implementing INativeList<byte> and IUTF8Bytes
7794 ///
7795 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7796 /// </remarks>
7797 /// <param name="formatString">The format string.</param>
7798 /// <typeparam name="T1"><undoc /></typeparam>
7799 /// <typeparam name="T2"><undoc /></typeparam>
7800
7801 /// <param name="arg0">Value to interpolate into the format string.</param>
7802 /// <param name="arg1">Value to interpolate into the format string.</param>
7803 /// <param name="arg2">Value to interpolate into the format string.</param>
7804 /// <param name="arg3">Value to interpolate into the format string.</param>
7805 /// <returns>A new string produced by interpolating the format string.</returns>
7806 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
7807 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, int arg2, T2 arg3)
7808 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7809 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7810
7811 {
7812 FixedString512Bytes result = default;
7813 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7814 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7815
7816
7817 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
7818 return result;
7819 }
7820
7821 /// <summary>
7822 /// Returns a new string produced by interpolating a format string.
7823 /// </summary>
7824 /// <remarks>
7825 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7826 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7827 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7828 ///
7829 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7830 /// - FixedString*N*Bytes
7831 /// - string
7832 /// - int
7833 /// - float
7834 /// - structs implementing INativeList<byte> and IUTF8Bytes
7835 ///
7836 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7837 /// </remarks>
7838 /// <param name="formatString">The format string.</param>
7839 /// <typeparam name="T1"><undoc /></typeparam>
7840
7841 /// <param name="arg0">Value to interpolate into the format string.</param>
7842 /// <param name="arg1">Value to interpolate into the format string.</param>
7843 /// <param name="arg2">Value to interpolate into the format string.</param>
7844 /// <param name="arg3">Value to interpolate into the format string.</param>
7845 /// <returns>A new string produced by interpolating the format string.</returns>
7846 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
7847 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, int arg2, T1 arg3)
7848 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7849
7850 {
7851 FixedString512Bytes result = default;
7852 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7853 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7854 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7855
7856
7857 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7858 return result;
7859 }
7860
7861 /// <summary>
7862 /// Returns a new string produced by interpolating a format string.
7863 /// </summary>
7864 /// <remarks>
7865 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7866 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7867 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7868 ///
7869 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7870 /// - FixedString*N*Bytes
7871 /// - string
7872 /// - int
7873 /// - float
7874 /// - structs implementing INativeList<byte> and IUTF8Bytes
7875 ///
7876 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7877 /// </remarks>
7878 /// <param name="formatString">The format string.</param>
7879 /// <typeparam name="T1"><undoc /></typeparam>
7880
7881 /// <param name="arg0">Value to interpolate into the format string.</param>
7882 /// <param name="arg1">Value to interpolate into the format string.</param>
7883 /// <param name="arg2">Value to interpolate into the format string.</param>
7884 /// <param name="arg3">Value to interpolate into the format string.</param>
7885 /// <returns>A new string produced by interpolating the format string.</returns>
7886 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
7887 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, int arg2, T1 arg3)
7888 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7889
7890 {
7891 FixedString512Bytes result = default;
7892 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7893 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7894 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7895
7896
7897 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7898 return result;
7899 }
7900
7901 /// <summary>
7902 /// Returns a new string produced by interpolating a format string.
7903 /// </summary>
7904 /// <remarks>
7905 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7906 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7907 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7908 ///
7909 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7910 /// - FixedString*N*Bytes
7911 /// - string
7912 /// - int
7913 /// - float
7914 /// - structs implementing INativeList<byte> and IUTF8Bytes
7915 ///
7916 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7917 /// </remarks>
7918 /// <param name="formatString">The format string.</param>
7919 /// <typeparam name="T1"><undoc /></typeparam>
7920
7921 /// <param name="arg0">Value to interpolate into the format string.</param>
7922 /// <param name="arg1">Value to interpolate into the format string.</param>
7923 /// <param name="arg2">Value to interpolate into the format string.</param>
7924 /// <param name="arg3">Value to interpolate into the format string.</param>
7925 /// <returns>A new string produced by interpolating the format string.</returns>
7926 [ExcludeFromBurstCompatTesting("Takes managed string")]
7927 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, int arg2, T1 arg3)
7928 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7929
7930 {
7931 FixedString512Bytes result = default;
7932 FixedString32Bytes carg0 = default; carg0.Append(arg0);
7933 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7934 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7935
7936
7937 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
7938 return result;
7939 }
7940
7941 /// <summary>
7942 /// Returns a new string produced by interpolating a format string.
7943 /// </summary>
7944 /// <remarks>
7945 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7946 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7947 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7948 ///
7949 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7950 /// - FixedString*N*Bytes
7951 /// - string
7952 /// - int
7953 /// - float
7954 /// - structs implementing INativeList<byte> and IUTF8Bytes
7955 ///
7956 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7957 /// </remarks>
7958 /// <param name="formatString">The format string.</param>
7959 /// <typeparam name="T1"><undoc /></typeparam>
7960 /// <typeparam name="T2"><undoc /></typeparam>
7961
7962 /// <param name="arg0">Value to interpolate into the format string.</param>
7963 /// <param name="arg1">Value to interpolate into the format string.</param>
7964 /// <param name="arg2">Value to interpolate into the format string.</param>
7965 /// <param name="arg3">Value to interpolate into the format string.</param>
7966 /// <returns>A new string produced by interpolating the format string.</returns>
7967 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
7968 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, int arg2, T2 arg3)
7969 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
7970 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
7971
7972 {
7973 FixedString512Bytes result = default;
7974 FixedString32Bytes carg1 = default; carg1.Append(arg1);
7975 FixedString32Bytes carg2 = default; carg2.Append(arg2);
7976
7977
7978 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
7979 return result;
7980 }
7981
7982 /// <summary>
7983 /// Returns a new string produced by interpolating a format string.
7984 /// </summary>
7985 /// <remarks>
7986 /// Similar to StringBuilder.AppendFormat but with significant limitations:
7987 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
7988 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
7989 ///
7990 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
7991 /// - FixedString*N*Bytes
7992 /// - string
7993 /// - int
7994 /// - float
7995 /// - structs implementing INativeList<byte> and IUTF8Bytes
7996 ///
7997 /// <seealso cref="FixedStringMethods.AppendFormat"/>
7998 /// </remarks>
7999 /// <param name="formatString">The format string.</param>
8000 /// <typeparam name="T1"><undoc /></typeparam>
8001
8002 /// <param name="arg0">Value to interpolate into the format string.</param>
8003 /// <param name="arg1">Value to interpolate into the format string.</param>
8004 /// <param name="arg2">Value to interpolate into the format string.</param>
8005 /// <param name="arg3">Value to interpolate into the format string.</param>
8006 /// <returns>A new string produced by interpolating the format string.</returns>
8007 [ExcludeFromBurstCompatTesting("Takes managed string")]
8008 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, int arg2, T1 arg3)
8009 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8010
8011 {
8012 FixedString512Bytes result = default;
8013 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8014 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8015 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8016
8017
8018 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8019 return result;
8020 }
8021
8022 /// <summary>
8023 /// Returns a new string produced by interpolating a format string.
8024 /// </summary>
8025 /// <remarks>
8026 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8027 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8028 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8029 ///
8030 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8031 /// - FixedString*N*Bytes
8032 /// - string
8033 /// - int
8034 /// - float
8035 /// - structs implementing INativeList<byte> and IUTF8Bytes
8036 ///
8037 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8038 /// </remarks>
8039 /// <param name="formatString">The format string.</param>
8040 /// <typeparam name="T1"><undoc /></typeparam>
8041
8042 /// <param name="arg0">Value to interpolate into the format string.</param>
8043 /// <param name="arg1">Value to interpolate into the format string.</param>
8044 /// <param name="arg2">Value to interpolate into the format string.</param>
8045 /// <param name="arg3">Value to interpolate into the format string.</param>
8046 /// <returns>A new string produced by interpolating the format string.</returns>
8047 [ExcludeFromBurstCompatTesting("Takes managed string")]
8048 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, int arg2, T1 arg3)
8049 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8050
8051 {
8052 FixedString512Bytes result = default;
8053 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8054 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8055 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8056
8057
8058 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8059 return result;
8060 }
8061
8062 /// <summary>
8063 /// Returns a new string produced by interpolating a format string.
8064 /// </summary>
8065 /// <remarks>
8066 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8067 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8068 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8069 ///
8070 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8071 /// - FixedString*N*Bytes
8072 /// - string
8073 /// - int
8074 /// - float
8075 /// - structs implementing INativeList<byte> and IUTF8Bytes
8076 ///
8077 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8078 /// </remarks>
8079 /// <param name="formatString">The format string.</param>
8080 /// <typeparam name="T1"><undoc /></typeparam>
8081
8082 /// <param name="arg0">Value to interpolate into the format string.</param>
8083 /// <param name="arg1">Value to interpolate into the format string.</param>
8084 /// <param name="arg2">Value to interpolate into the format string.</param>
8085 /// <param name="arg3">Value to interpolate into the format string.</param>
8086 /// <returns>A new string produced by interpolating the format string.</returns>
8087 [ExcludeFromBurstCompatTesting("Takes managed string")]
8088 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, int arg2, T1 arg3)
8089 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8090
8091 {
8092 FixedString512Bytes result = default;
8093 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8094 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8095 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8096
8097
8098 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8099 return result;
8100 }
8101
8102 /// <summary>
8103 /// Returns a new string produced by interpolating a format string.
8104 /// </summary>
8105 /// <remarks>
8106 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8107 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8108 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8109 ///
8110 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8111 /// - FixedString*N*Bytes
8112 /// - string
8113 /// - int
8114 /// - float
8115 /// - structs implementing INativeList<byte> and IUTF8Bytes
8116 ///
8117 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8118 /// </remarks>
8119 /// <param name="formatString">The format string.</param>
8120 /// <typeparam name="T1"><undoc /></typeparam>
8121 /// <typeparam name="T2"><undoc /></typeparam>
8122
8123 /// <param name="arg0">Value to interpolate into the format string.</param>
8124 /// <param name="arg1">Value to interpolate into the format string.</param>
8125 /// <param name="arg2">Value to interpolate into the format string.</param>
8126 /// <param name="arg3">Value to interpolate into the format string.</param>
8127 /// <returns>A new string produced by interpolating the format string.</returns>
8128 [ExcludeFromBurstCompatTesting("Takes managed string")]
8129 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, int arg2, T2 arg3)
8130 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8131 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8132
8133 {
8134 FixedString512Bytes result = default;
8135 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8136 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8137
8138
8139 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
8140 return result;
8141 }
8142
8143 /// <summary>
8144 /// Returns a new string produced by interpolating a format string.
8145 /// </summary>
8146 /// <remarks>
8147 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8148 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8149 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8150 ///
8151 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8152 /// - FixedString*N*Bytes
8153 /// - string
8154 /// - int
8155 /// - float
8156 /// - structs implementing INativeList<byte> and IUTF8Bytes
8157 ///
8158 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8159 /// </remarks>
8160 /// <param name="formatString">The format string.</param>
8161 /// <typeparam name="T1"><undoc /></typeparam>
8162 /// <typeparam name="T2"><undoc /></typeparam>
8163
8164 /// <param name="arg0">Value to interpolate into the format string.</param>
8165 /// <param name="arg1">Value to interpolate into the format string.</param>
8166 /// <param name="arg2">Value to interpolate into the format string.</param>
8167 /// <param name="arg3">Value to interpolate into the format string.</param>
8168 /// <returns>A new string produced by interpolating the format string.</returns>
8169 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8170 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, int arg2, T2 arg3)
8171 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8172 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8173
8174 {
8175 FixedString512Bytes result = default;
8176 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8177 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8178
8179
8180 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8181 return result;
8182 }
8183
8184 /// <summary>
8185 /// Returns a new string produced by interpolating a format string.
8186 /// </summary>
8187 /// <remarks>
8188 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8189 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8190 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8191 ///
8192 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8193 /// - FixedString*N*Bytes
8194 /// - string
8195 /// - int
8196 /// - float
8197 /// - structs implementing INativeList<byte> and IUTF8Bytes
8198 ///
8199 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8200 /// </remarks>
8201 /// <param name="formatString">The format string.</param>
8202 /// <typeparam name="T1"><undoc /></typeparam>
8203 /// <typeparam name="T2"><undoc /></typeparam>
8204
8205 /// <param name="arg0">Value to interpolate into the format string.</param>
8206 /// <param name="arg1">Value to interpolate into the format string.</param>
8207 /// <param name="arg2">Value to interpolate into the format string.</param>
8208 /// <param name="arg3">Value to interpolate into the format string.</param>
8209 /// <returns>A new string produced by interpolating the format string.</returns>
8210 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8211 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, int arg2, T2 arg3)
8212 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8213 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8214
8215 {
8216 FixedString512Bytes result = default;
8217 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8218 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8219
8220
8221 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8222 return result;
8223 }
8224
8225 /// <summary>
8226 /// Returns a new string produced by interpolating a format string.
8227 /// </summary>
8228 /// <remarks>
8229 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8230 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8231 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8232 ///
8233 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8234 /// - FixedString*N*Bytes
8235 /// - string
8236 /// - int
8237 /// - float
8238 /// - structs implementing INativeList<byte> and IUTF8Bytes
8239 ///
8240 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8241 /// </remarks>
8242 /// <param name="formatString">The format string.</param>
8243 /// <typeparam name="T1"><undoc /></typeparam>
8244 /// <typeparam name="T2"><undoc /></typeparam>
8245
8246 /// <param name="arg0">Value to interpolate into the format string.</param>
8247 /// <param name="arg1">Value to interpolate into the format string.</param>
8248 /// <param name="arg2">Value to interpolate into the format string.</param>
8249 /// <param name="arg3">Value to interpolate into the format string.</param>
8250 /// <returns>A new string produced by interpolating the format string.</returns>
8251 [ExcludeFromBurstCompatTesting("Takes managed string")]
8252 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, int arg2, T2 arg3)
8253 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8254 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8255
8256 {
8257 FixedString512Bytes result = default;
8258 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8259 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8260
8261
8262 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8263 return result;
8264 }
8265
8266 /// <summary>
8267 /// Returns a new string produced by interpolating a format string.
8268 /// </summary>
8269 /// <remarks>
8270 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8271 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8272 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8273 ///
8274 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8275 /// - FixedString*N*Bytes
8276 /// - string
8277 /// - int
8278 /// - float
8279 /// - structs implementing INativeList<byte> and IUTF8Bytes
8280 ///
8281 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8282 /// </remarks>
8283 /// <param name="formatString">The format string.</param>
8284 /// <typeparam name="T1"><undoc /></typeparam>
8285 /// <typeparam name="T2"><undoc /></typeparam>
8286 /// <typeparam name="T3"><undoc /></typeparam>
8287
8288 /// <param name="arg0">Value to interpolate into the format string.</param>
8289 /// <param name="arg1">Value to interpolate into the format string.</param>
8290 /// <param name="arg2">Value to interpolate into the format string.</param>
8291 /// <param name="arg3">Value to interpolate into the format string.</param>
8292 /// <returns>A new string produced by interpolating the format string.</returns>
8293 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
8294 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, int arg2, T3 arg3)
8295 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8296 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8297 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
8298
8299 {
8300 FixedString512Bytes result = default;
8301 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8302
8303
8304 result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
8305 return result;
8306 }
8307
8308 /// <summary>
8309 /// Returns a new string produced by interpolating a format string.
8310 /// </summary>
8311 /// <remarks>
8312 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8313 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8314 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8315 ///
8316 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8317 /// - FixedString*N*Bytes
8318 /// - string
8319 /// - int
8320 /// - float
8321 /// - structs implementing INativeList<byte> and IUTF8Bytes
8322 ///
8323 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8324 /// </remarks>
8325 /// <param name="formatString">The format string.</param>
8326 /// <typeparam name="T1"><undoc /></typeparam>
8327
8328 /// <param name="arg0">Value to interpolate into the format string.</param>
8329 /// <param name="arg1">Value to interpolate into the format string.</param>
8330 /// <param name="arg2">Value to interpolate into the format string.</param>
8331 /// <param name="arg3">Value to interpolate into the format string.</param>
8332 /// <returns>A new string produced by interpolating the format string.</returns>
8333 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
8334 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, float arg2, T1 arg3)
8335 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8336
8337 {
8338 FixedString512Bytes result = default;
8339 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8340 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8341 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8342
8343
8344 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8345 return result;
8346 }
8347
8348 /// <summary>
8349 /// Returns a new string produced by interpolating a format string.
8350 /// </summary>
8351 /// <remarks>
8352 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8353 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8354 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8355 ///
8356 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8357 /// - FixedString*N*Bytes
8358 /// - string
8359 /// - int
8360 /// - float
8361 /// - structs implementing INativeList<byte> and IUTF8Bytes
8362 ///
8363 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8364 /// </remarks>
8365 /// <param name="formatString">The format string.</param>
8366 /// <typeparam name="T1"><undoc /></typeparam>
8367
8368 /// <param name="arg0">Value to interpolate into the format string.</param>
8369 /// <param name="arg1">Value to interpolate into the format string.</param>
8370 /// <param name="arg2">Value to interpolate into the format string.</param>
8371 /// <param name="arg3">Value to interpolate into the format string.</param>
8372 /// <returns>A new string produced by interpolating the format string.</returns>
8373 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
8374 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, float arg2, T1 arg3)
8375 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8376
8377 {
8378 FixedString512Bytes result = default;
8379 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8380 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8381 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8382
8383
8384 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8385 return result;
8386 }
8387
8388 /// <summary>
8389 /// Returns a new string produced by interpolating a format string.
8390 /// </summary>
8391 /// <remarks>
8392 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8393 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8394 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8395 ///
8396 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8397 /// - FixedString*N*Bytes
8398 /// - string
8399 /// - int
8400 /// - float
8401 /// - structs implementing INativeList<byte> and IUTF8Bytes
8402 ///
8403 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8404 /// </remarks>
8405 /// <param name="formatString">The format string.</param>
8406 /// <typeparam name="T1"><undoc /></typeparam>
8407
8408 /// <param name="arg0">Value to interpolate into the format string.</param>
8409 /// <param name="arg1">Value to interpolate into the format string.</param>
8410 /// <param name="arg2">Value to interpolate into the format string.</param>
8411 /// <param name="arg3">Value to interpolate into the format string.</param>
8412 /// <returns>A new string produced by interpolating the format string.</returns>
8413 [ExcludeFromBurstCompatTesting("Takes managed string")]
8414 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, float arg2, T1 arg3)
8415 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8416
8417 {
8418 FixedString512Bytes result = default;
8419 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8420 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8421 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8422
8423
8424 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8425 return result;
8426 }
8427
8428 /// <summary>
8429 /// Returns a new string produced by interpolating a format string.
8430 /// </summary>
8431 /// <remarks>
8432 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8433 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8434 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8435 ///
8436 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8437 /// - FixedString*N*Bytes
8438 /// - string
8439 /// - int
8440 /// - float
8441 /// - structs implementing INativeList<byte> and IUTF8Bytes
8442 ///
8443 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8444 /// </remarks>
8445 /// <param name="formatString">The format string.</param>
8446 /// <typeparam name="T1"><undoc /></typeparam>
8447 /// <typeparam name="T2"><undoc /></typeparam>
8448
8449 /// <param name="arg0">Value to interpolate into the format string.</param>
8450 /// <param name="arg1">Value to interpolate into the format string.</param>
8451 /// <param name="arg2">Value to interpolate into the format string.</param>
8452 /// <param name="arg3">Value to interpolate into the format string.</param>
8453 /// <returns>A new string produced by interpolating the format string.</returns>
8454 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8455 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, float arg2, T2 arg3)
8456 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8457 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8458
8459 {
8460 FixedString512Bytes result = default;
8461 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8462 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8463
8464
8465 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
8466 return result;
8467 }
8468
8469 /// <summary>
8470 /// Returns a new string produced by interpolating a format string.
8471 /// </summary>
8472 /// <remarks>
8473 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8474 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8475 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8476 ///
8477 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8478 /// - FixedString*N*Bytes
8479 /// - string
8480 /// - int
8481 /// - float
8482 /// - structs implementing INativeList<byte> and IUTF8Bytes
8483 ///
8484 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8485 /// </remarks>
8486 /// <param name="formatString">The format string.</param>
8487 /// <typeparam name="T1"><undoc /></typeparam>
8488
8489 /// <param name="arg0">Value to interpolate into the format string.</param>
8490 /// <param name="arg1">Value to interpolate into the format string.</param>
8491 /// <param name="arg2">Value to interpolate into the format string.</param>
8492 /// <param name="arg3">Value to interpolate into the format string.</param>
8493 /// <returns>A new string produced by interpolating the format string.</returns>
8494 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
8495 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, float arg2, T1 arg3)
8496 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8497
8498 {
8499 FixedString512Bytes result = default;
8500 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8501 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8502 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8503
8504
8505 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8506 return result;
8507 }
8508
8509 /// <summary>
8510 /// Returns a new string produced by interpolating a format string.
8511 /// </summary>
8512 /// <remarks>
8513 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8514 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8515 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8516 ///
8517 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8518 /// - FixedString*N*Bytes
8519 /// - string
8520 /// - int
8521 /// - float
8522 /// - structs implementing INativeList<byte> and IUTF8Bytes
8523 ///
8524 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8525 /// </remarks>
8526 /// <param name="formatString">The format string.</param>
8527 /// <typeparam name="T1"><undoc /></typeparam>
8528
8529 /// <param name="arg0">Value to interpolate into the format string.</param>
8530 /// <param name="arg1">Value to interpolate into the format string.</param>
8531 /// <param name="arg2">Value to interpolate into the format string.</param>
8532 /// <param name="arg3">Value to interpolate into the format string.</param>
8533 /// <returns>A new string produced by interpolating the format string.</returns>
8534 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
8535 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, float arg2, T1 arg3)
8536 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8537
8538 {
8539 FixedString512Bytes result = default;
8540 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8541 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8542 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8543
8544
8545 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8546 return result;
8547 }
8548
8549 /// <summary>
8550 /// Returns a new string produced by interpolating a format string.
8551 /// </summary>
8552 /// <remarks>
8553 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8554 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8555 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8556 ///
8557 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8558 /// - FixedString*N*Bytes
8559 /// - string
8560 /// - int
8561 /// - float
8562 /// - structs implementing INativeList<byte> and IUTF8Bytes
8563 ///
8564 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8565 /// </remarks>
8566 /// <param name="formatString">The format string.</param>
8567 /// <typeparam name="T1"><undoc /></typeparam>
8568
8569 /// <param name="arg0">Value to interpolate into the format string.</param>
8570 /// <param name="arg1">Value to interpolate into the format string.</param>
8571 /// <param name="arg2">Value to interpolate into the format string.</param>
8572 /// <param name="arg3">Value to interpolate into the format string.</param>
8573 /// <returns>A new string produced by interpolating the format string.</returns>
8574 [ExcludeFromBurstCompatTesting("Takes managed string")]
8575 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, float arg2, T1 arg3)
8576 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8577
8578 {
8579 FixedString512Bytes result = default;
8580 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8581 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8582 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8583
8584
8585 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8586 return result;
8587 }
8588
8589 /// <summary>
8590 /// Returns a new string produced by interpolating a format string.
8591 /// </summary>
8592 /// <remarks>
8593 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8594 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8595 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8596 ///
8597 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8598 /// - FixedString*N*Bytes
8599 /// - string
8600 /// - int
8601 /// - float
8602 /// - structs implementing INativeList<byte> and IUTF8Bytes
8603 ///
8604 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8605 /// </remarks>
8606 /// <param name="formatString">The format string.</param>
8607 /// <typeparam name="T1"><undoc /></typeparam>
8608 /// <typeparam name="T2"><undoc /></typeparam>
8609
8610 /// <param name="arg0">Value to interpolate into the format string.</param>
8611 /// <param name="arg1">Value to interpolate into the format string.</param>
8612 /// <param name="arg2">Value to interpolate into the format string.</param>
8613 /// <param name="arg3">Value to interpolate into the format string.</param>
8614 /// <returns>A new string produced by interpolating the format string.</returns>
8615 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8616 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, float arg2, T2 arg3)
8617 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8618 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8619
8620 {
8621 FixedString512Bytes result = default;
8622 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8623 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8624
8625
8626 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
8627 return result;
8628 }
8629
8630 /// <summary>
8631 /// Returns a new string produced by interpolating a format string.
8632 /// </summary>
8633 /// <remarks>
8634 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8635 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8636 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8637 ///
8638 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8639 /// - FixedString*N*Bytes
8640 /// - string
8641 /// - int
8642 /// - float
8643 /// - structs implementing INativeList<byte> and IUTF8Bytes
8644 ///
8645 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8646 /// </remarks>
8647 /// <param name="formatString">The format string.</param>
8648 /// <typeparam name="T1"><undoc /></typeparam>
8649
8650 /// <param name="arg0">Value to interpolate into the format string.</param>
8651 /// <param name="arg1">Value to interpolate into the format string.</param>
8652 /// <param name="arg2">Value to interpolate into the format string.</param>
8653 /// <param name="arg3">Value to interpolate into the format string.</param>
8654 /// <returns>A new string produced by interpolating the format string.</returns>
8655 [ExcludeFromBurstCompatTesting("Takes managed string")]
8656 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, float arg2, T1 arg3)
8657 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8658
8659 {
8660 FixedString512Bytes result = default;
8661 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8662 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8663 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8664
8665
8666 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8667 return result;
8668 }
8669
8670 /// <summary>
8671 /// Returns a new string produced by interpolating a format string.
8672 /// </summary>
8673 /// <remarks>
8674 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8675 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8676 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8677 ///
8678 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8679 /// - FixedString*N*Bytes
8680 /// - string
8681 /// - int
8682 /// - float
8683 /// - structs implementing INativeList<byte> and IUTF8Bytes
8684 ///
8685 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8686 /// </remarks>
8687 /// <param name="formatString">The format string.</param>
8688 /// <typeparam name="T1"><undoc /></typeparam>
8689
8690 /// <param name="arg0">Value to interpolate into the format string.</param>
8691 /// <param name="arg1">Value to interpolate into the format string.</param>
8692 /// <param name="arg2">Value to interpolate into the format string.</param>
8693 /// <param name="arg3">Value to interpolate into the format string.</param>
8694 /// <returns>A new string produced by interpolating the format string.</returns>
8695 [ExcludeFromBurstCompatTesting("Takes managed string")]
8696 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, float arg2, T1 arg3)
8697 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8698
8699 {
8700 FixedString512Bytes result = default;
8701 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8702 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8703 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8704
8705
8706 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8707 return result;
8708 }
8709
8710 /// <summary>
8711 /// Returns a new string produced by interpolating a format string.
8712 /// </summary>
8713 /// <remarks>
8714 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8715 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8716 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8717 ///
8718 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8719 /// - FixedString*N*Bytes
8720 /// - string
8721 /// - int
8722 /// - float
8723 /// - structs implementing INativeList<byte> and IUTF8Bytes
8724 ///
8725 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8726 /// </remarks>
8727 /// <param name="formatString">The format string.</param>
8728 /// <typeparam name="T1"><undoc /></typeparam>
8729
8730 /// <param name="arg0">Value to interpolate into the format string.</param>
8731 /// <param name="arg1">Value to interpolate into the format string.</param>
8732 /// <param name="arg2">Value to interpolate into the format string.</param>
8733 /// <param name="arg3">Value to interpolate into the format string.</param>
8734 /// <returns>A new string produced by interpolating the format string.</returns>
8735 [ExcludeFromBurstCompatTesting("Takes managed string")]
8736 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, float arg2, T1 arg3)
8737 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8738
8739 {
8740 FixedString512Bytes result = default;
8741 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8742 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8743 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8744
8745
8746 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8747 return result;
8748 }
8749
8750 /// <summary>
8751 /// Returns a new string produced by interpolating a format string.
8752 /// </summary>
8753 /// <remarks>
8754 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8755 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8756 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8757 ///
8758 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8759 /// - FixedString*N*Bytes
8760 /// - string
8761 /// - int
8762 /// - float
8763 /// - structs implementing INativeList<byte> and IUTF8Bytes
8764 ///
8765 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8766 /// </remarks>
8767 /// <param name="formatString">The format string.</param>
8768 /// <typeparam name="T1"><undoc /></typeparam>
8769 /// <typeparam name="T2"><undoc /></typeparam>
8770
8771 /// <param name="arg0">Value to interpolate into the format string.</param>
8772 /// <param name="arg1">Value to interpolate into the format string.</param>
8773 /// <param name="arg2">Value to interpolate into the format string.</param>
8774 /// <param name="arg3">Value to interpolate into the format string.</param>
8775 /// <returns>A new string produced by interpolating the format string.</returns>
8776 [ExcludeFromBurstCompatTesting("Takes managed string")]
8777 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, float arg2, T2 arg3)
8778 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8779 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8780
8781 {
8782 FixedString512Bytes result = default;
8783 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8784 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8785
8786
8787 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
8788 return result;
8789 }
8790
8791 /// <summary>
8792 /// Returns a new string produced by interpolating a format string.
8793 /// </summary>
8794 /// <remarks>
8795 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8796 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8797 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8798 ///
8799 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8800 /// - FixedString*N*Bytes
8801 /// - string
8802 /// - int
8803 /// - float
8804 /// - structs implementing INativeList<byte> and IUTF8Bytes
8805 ///
8806 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8807 /// </remarks>
8808 /// <param name="formatString">The format string.</param>
8809 /// <typeparam name="T1"><undoc /></typeparam>
8810 /// <typeparam name="T2"><undoc /></typeparam>
8811
8812 /// <param name="arg0">Value to interpolate into the format string.</param>
8813 /// <param name="arg1">Value to interpolate into the format string.</param>
8814 /// <param name="arg2">Value to interpolate into the format string.</param>
8815 /// <param name="arg3">Value to interpolate into the format string.</param>
8816 /// <returns>A new string produced by interpolating the format string.</returns>
8817 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8818 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, float arg2, T2 arg3)
8819 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8820 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8821
8822 {
8823 FixedString512Bytes result = default;
8824 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8825 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8826
8827
8828 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8829 return result;
8830 }
8831
8832 /// <summary>
8833 /// Returns a new string produced by interpolating a format string.
8834 /// </summary>
8835 /// <remarks>
8836 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8837 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8838 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8839 ///
8840 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8841 /// - FixedString*N*Bytes
8842 /// - string
8843 /// - int
8844 /// - float
8845 /// - structs implementing INativeList<byte> and IUTF8Bytes
8846 ///
8847 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8848 /// </remarks>
8849 /// <param name="formatString">The format string.</param>
8850 /// <typeparam name="T1"><undoc /></typeparam>
8851 /// <typeparam name="T2"><undoc /></typeparam>
8852
8853 /// <param name="arg0">Value to interpolate into the format string.</param>
8854 /// <param name="arg1">Value to interpolate into the format string.</param>
8855 /// <param name="arg2">Value to interpolate into the format string.</param>
8856 /// <param name="arg3">Value to interpolate into the format string.</param>
8857 /// <returns>A new string produced by interpolating the format string.</returns>
8858 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
8859 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, float arg2, T2 arg3)
8860 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8861 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8862
8863 {
8864 FixedString512Bytes result = default;
8865 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8866 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8867
8868
8869 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8870 return result;
8871 }
8872
8873 /// <summary>
8874 /// Returns a new string produced by interpolating a format string.
8875 /// </summary>
8876 /// <remarks>
8877 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8878 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8879 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8880 ///
8881 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8882 /// - FixedString*N*Bytes
8883 /// - string
8884 /// - int
8885 /// - float
8886 /// - structs implementing INativeList<byte> and IUTF8Bytes
8887 ///
8888 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8889 /// </remarks>
8890 /// <param name="formatString">The format string.</param>
8891 /// <typeparam name="T1"><undoc /></typeparam>
8892 /// <typeparam name="T2"><undoc /></typeparam>
8893
8894 /// <param name="arg0">Value to interpolate into the format string.</param>
8895 /// <param name="arg1">Value to interpolate into the format string.</param>
8896 /// <param name="arg2">Value to interpolate into the format string.</param>
8897 /// <param name="arg3">Value to interpolate into the format string.</param>
8898 /// <returns>A new string produced by interpolating the format string.</returns>
8899 [ExcludeFromBurstCompatTesting("Takes managed string")]
8900 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, float arg2, T2 arg3)
8901 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8902 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8903
8904 {
8905 FixedString512Bytes result = default;
8906 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8907 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8908
8909
8910 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
8911 return result;
8912 }
8913
8914 /// <summary>
8915 /// Returns a new string produced by interpolating a format string.
8916 /// </summary>
8917 /// <remarks>
8918 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8919 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8920 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8921 ///
8922 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8923 /// - FixedString*N*Bytes
8924 /// - string
8925 /// - int
8926 /// - float
8927 /// - structs implementing INativeList<byte> and IUTF8Bytes
8928 ///
8929 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8930 /// </remarks>
8931 /// <param name="formatString">The format string.</param>
8932 /// <typeparam name="T1"><undoc /></typeparam>
8933 /// <typeparam name="T2"><undoc /></typeparam>
8934 /// <typeparam name="T3"><undoc /></typeparam>
8935
8936 /// <param name="arg0">Value to interpolate into the format string.</param>
8937 /// <param name="arg1">Value to interpolate into the format string.</param>
8938 /// <param name="arg2">Value to interpolate into the format string.</param>
8939 /// <param name="arg3">Value to interpolate into the format string.</param>
8940 /// <returns>A new string produced by interpolating the format string.</returns>
8941 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
8942 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, float arg2, T3 arg3)
8943 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8944 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
8945 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
8946
8947 {
8948 FixedString512Bytes result = default;
8949 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8950
8951
8952 result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
8953 return result;
8954 }
8955
8956 /// <summary>
8957 /// Returns a new string produced by interpolating a format string.
8958 /// </summary>
8959 /// <remarks>
8960 /// Similar to StringBuilder.AppendFormat but with significant limitations:
8961 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
8962 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
8963 ///
8964 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
8965 /// - FixedString*N*Bytes
8966 /// - string
8967 /// - int
8968 /// - float
8969 /// - structs implementing INativeList<byte> and IUTF8Bytes
8970 ///
8971 /// <seealso cref="FixedStringMethods.AppendFormat"/>
8972 /// </remarks>
8973 /// <param name="formatString">The format string.</param>
8974 /// <typeparam name="T1"><undoc /></typeparam>
8975
8976 /// <param name="arg0">Value to interpolate into the format string.</param>
8977 /// <param name="arg1">Value to interpolate into the format string.</param>
8978 /// <param name="arg2">Value to interpolate into the format string.</param>
8979 /// <param name="arg3">Value to interpolate into the format string.</param>
8980 /// <returns>A new string produced by interpolating the format string.</returns>
8981 [ExcludeFromBurstCompatTesting("Takes managed string")]
8982 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, int arg1, string arg2, T1 arg3)
8983 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
8984
8985 {
8986 FixedString512Bytes result = default;
8987 FixedString32Bytes carg0 = default; carg0.Append(arg0);
8988 FixedString32Bytes carg1 = default; carg1.Append(arg1);
8989 FixedString32Bytes carg2 = default; carg2.Append(arg2);
8990
8991
8992 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
8993 return result;
8994 }
8995
8996 /// <summary>
8997 /// Returns a new string produced by interpolating a format string.
8998 /// </summary>
8999 /// <remarks>
9000 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9001 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9002 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9003 ///
9004 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9005 /// - FixedString*N*Bytes
9006 /// - string
9007 /// - int
9008 /// - float
9009 /// - structs implementing INativeList<byte> and IUTF8Bytes
9010 ///
9011 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9012 /// </remarks>
9013 /// <param name="formatString">The format string.</param>
9014 /// <typeparam name="T1"><undoc /></typeparam>
9015
9016 /// <param name="arg0">Value to interpolate into the format string.</param>
9017 /// <param name="arg1">Value to interpolate into the format string.</param>
9018 /// <param name="arg2">Value to interpolate into the format string.</param>
9019 /// <param name="arg3">Value to interpolate into the format string.</param>
9020 /// <returns>A new string produced by interpolating the format string.</returns>
9021 [ExcludeFromBurstCompatTesting("Takes managed string")]
9022 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, int arg1, string arg2, T1 arg3)
9023 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9024
9025 {
9026 FixedString512Bytes result = default;
9027 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9028 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9029 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9030
9031
9032 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9033 return result;
9034 }
9035
9036 /// <summary>
9037 /// Returns a new string produced by interpolating a format string.
9038 /// </summary>
9039 /// <remarks>
9040 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9041 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9042 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9043 ///
9044 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9045 /// - FixedString*N*Bytes
9046 /// - string
9047 /// - int
9048 /// - float
9049 /// - structs implementing INativeList<byte> and IUTF8Bytes
9050 ///
9051 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9052 /// </remarks>
9053 /// <param name="formatString">The format string.</param>
9054 /// <typeparam name="T1"><undoc /></typeparam>
9055
9056 /// <param name="arg0">Value to interpolate into the format string.</param>
9057 /// <param name="arg1">Value to interpolate into the format string.</param>
9058 /// <param name="arg2">Value to interpolate into the format string.</param>
9059 /// <param name="arg3">Value to interpolate into the format string.</param>
9060 /// <returns>A new string produced by interpolating the format string.</returns>
9061 [ExcludeFromBurstCompatTesting("Takes managed string")]
9062 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, int arg1, string arg2, T1 arg3)
9063 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9064
9065 {
9066 FixedString512Bytes result = default;
9067 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9068 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9069 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9070
9071
9072 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9073 return result;
9074 }
9075
9076 /// <summary>
9077 /// Returns a new string produced by interpolating a format string.
9078 /// </summary>
9079 /// <remarks>
9080 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9081 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9082 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9083 ///
9084 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9085 /// - FixedString*N*Bytes
9086 /// - string
9087 /// - int
9088 /// - float
9089 /// - structs implementing INativeList<byte> and IUTF8Bytes
9090 ///
9091 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9092 /// </remarks>
9093 /// <param name="formatString">The format string.</param>
9094 /// <typeparam name="T1"><undoc /></typeparam>
9095 /// <typeparam name="T2"><undoc /></typeparam>
9096
9097 /// <param name="arg0">Value to interpolate into the format string.</param>
9098 /// <param name="arg1">Value to interpolate into the format string.</param>
9099 /// <param name="arg2">Value to interpolate into the format string.</param>
9100 /// <param name="arg3">Value to interpolate into the format string.</param>
9101 /// <returns>A new string produced by interpolating the format string.</returns>
9102 [ExcludeFromBurstCompatTesting("Takes managed string")]
9103 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, int arg1, string arg2, T2 arg3)
9104 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9105 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9106
9107 {
9108 FixedString512Bytes result = default;
9109 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9110 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9111
9112
9113 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
9114 return result;
9115 }
9116
9117 /// <summary>
9118 /// Returns a new string produced by interpolating a format string.
9119 /// </summary>
9120 /// <remarks>
9121 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9122 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9123 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9124 ///
9125 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9126 /// - FixedString*N*Bytes
9127 /// - string
9128 /// - int
9129 /// - float
9130 /// - structs implementing INativeList<byte> and IUTF8Bytes
9131 ///
9132 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9133 /// </remarks>
9134 /// <param name="formatString">The format string.</param>
9135 /// <typeparam name="T1"><undoc /></typeparam>
9136
9137 /// <param name="arg0">Value to interpolate into the format string.</param>
9138 /// <param name="arg1">Value to interpolate into the format string.</param>
9139 /// <param name="arg2">Value to interpolate into the format string.</param>
9140 /// <param name="arg3">Value to interpolate into the format string.</param>
9141 /// <returns>A new string produced by interpolating the format string.</returns>
9142 [ExcludeFromBurstCompatTesting("Takes managed string")]
9143 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, float arg1, string arg2, T1 arg3)
9144 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9145
9146 {
9147 FixedString512Bytes result = default;
9148 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9149 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9150 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9151
9152
9153 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9154 return result;
9155 }
9156
9157 /// <summary>
9158 /// Returns a new string produced by interpolating a format string.
9159 /// </summary>
9160 /// <remarks>
9161 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9162 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9163 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9164 ///
9165 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9166 /// - FixedString*N*Bytes
9167 /// - string
9168 /// - int
9169 /// - float
9170 /// - structs implementing INativeList<byte> and IUTF8Bytes
9171 ///
9172 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9173 /// </remarks>
9174 /// <param name="formatString">The format string.</param>
9175 /// <typeparam name="T1"><undoc /></typeparam>
9176
9177 /// <param name="arg0">Value to interpolate into the format string.</param>
9178 /// <param name="arg1">Value to interpolate into the format string.</param>
9179 /// <param name="arg2">Value to interpolate into the format string.</param>
9180 /// <param name="arg3">Value to interpolate into the format string.</param>
9181 /// <returns>A new string produced by interpolating the format string.</returns>
9182 [ExcludeFromBurstCompatTesting("Takes managed string")]
9183 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, float arg1, string arg2, T1 arg3)
9184 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9185
9186 {
9187 FixedString512Bytes result = default;
9188 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9189 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9190 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9191
9192
9193 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9194 return result;
9195 }
9196
9197 /// <summary>
9198 /// Returns a new string produced by interpolating a format string.
9199 /// </summary>
9200 /// <remarks>
9201 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9202 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9203 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9204 ///
9205 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9206 /// - FixedString*N*Bytes
9207 /// - string
9208 /// - int
9209 /// - float
9210 /// - structs implementing INativeList<byte> and IUTF8Bytes
9211 ///
9212 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9213 /// </remarks>
9214 /// <param name="formatString">The format string.</param>
9215 /// <typeparam name="T1"><undoc /></typeparam>
9216
9217 /// <param name="arg0">Value to interpolate into the format string.</param>
9218 /// <param name="arg1">Value to interpolate into the format string.</param>
9219 /// <param name="arg2">Value to interpolate into the format string.</param>
9220 /// <param name="arg3">Value to interpolate into the format string.</param>
9221 /// <returns>A new string produced by interpolating the format string.</returns>
9222 [ExcludeFromBurstCompatTesting("Takes managed string")]
9223 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, float arg1, string arg2, T1 arg3)
9224 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9225
9226 {
9227 FixedString512Bytes result = default;
9228 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9229 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9230 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9231
9232
9233 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9234 return result;
9235 }
9236
9237 /// <summary>
9238 /// Returns a new string produced by interpolating a format string.
9239 /// </summary>
9240 /// <remarks>
9241 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9242 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9243 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9244 ///
9245 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9246 /// - FixedString*N*Bytes
9247 /// - string
9248 /// - int
9249 /// - float
9250 /// - structs implementing INativeList<byte> and IUTF8Bytes
9251 ///
9252 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9253 /// </remarks>
9254 /// <param name="formatString">The format string.</param>
9255 /// <typeparam name="T1"><undoc /></typeparam>
9256 /// <typeparam name="T2"><undoc /></typeparam>
9257
9258 /// <param name="arg0">Value to interpolate into the format string.</param>
9259 /// <param name="arg1">Value to interpolate into the format string.</param>
9260 /// <param name="arg2">Value to interpolate into the format string.</param>
9261 /// <param name="arg3">Value to interpolate into the format string.</param>
9262 /// <returns>A new string produced by interpolating the format string.</returns>
9263 [ExcludeFromBurstCompatTesting("Takes managed string")]
9264 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, float arg1, string arg2, T2 arg3)
9265 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9266 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9267
9268 {
9269 FixedString512Bytes result = default;
9270 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9271 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9272
9273
9274 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
9275 return result;
9276 }
9277
9278 /// <summary>
9279 /// Returns a new string produced by interpolating a format string.
9280 /// </summary>
9281 /// <remarks>
9282 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9283 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9284 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9285 ///
9286 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9287 /// - FixedString*N*Bytes
9288 /// - string
9289 /// - int
9290 /// - float
9291 /// - structs implementing INativeList<byte> and IUTF8Bytes
9292 ///
9293 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9294 /// </remarks>
9295 /// <param name="formatString">The format string.</param>
9296 /// <typeparam name="T1"><undoc /></typeparam>
9297
9298 /// <param name="arg0">Value to interpolate into the format string.</param>
9299 /// <param name="arg1">Value to interpolate into the format string.</param>
9300 /// <param name="arg2">Value to interpolate into the format string.</param>
9301 /// <param name="arg3">Value to interpolate into the format string.</param>
9302 /// <returns>A new string produced by interpolating the format string.</returns>
9303 [ExcludeFromBurstCompatTesting("Takes managed string")]
9304 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, int arg0, string arg1, string arg2, T1 arg3)
9305 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9306
9307 {
9308 FixedString512Bytes result = default;
9309 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9310 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9311 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9312
9313
9314 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9315 return result;
9316 }
9317
9318 /// <summary>
9319 /// Returns a new string produced by interpolating a format string.
9320 /// </summary>
9321 /// <remarks>
9322 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9323 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9324 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9325 ///
9326 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9327 /// - FixedString*N*Bytes
9328 /// - string
9329 /// - int
9330 /// - float
9331 /// - structs implementing INativeList<byte> and IUTF8Bytes
9332 ///
9333 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9334 /// </remarks>
9335 /// <param name="formatString">The format string.</param>
9336 /// <typeparam name="T1"><undoc /></typeparam>
9337
9338 /// <param name="arg0">Value to interpolate into the format string.</param>
9339 /// <param name="arg1">Value to interpolate into the format string.</param>
9340 /// <param name="arg2">Value to interpolate into the format string.</param>
9341 /// <param name="arg3">Value to interpolate into the format string.</param>
9342 /// <returns>A new string produced by interpolating the format string.</returns>
9343 [ExcludeFromBurstCompatTesting("Takes managed string")]
9344 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, float arg0, string arg1, string arg2, T1 arg3)
9345 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9346
9347 {
9348 FixedString512Bytes result = default;
9349 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9350 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9351 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9352
9353
9354 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9355 return result;
9356 }
9357
9358 /// <summary>
9359 /// Returns a new string produced by interpolating a format string.
9360 /// </summary>
9361 /// <remarks>
9362 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9363 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9364 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9365 ///
9366 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9367 /// - FixedString*N*Bytes
9368 /// - string
9369 /// - int
9370 /// - float
9371 /// - structs implementing INativeList<byte> and IUTF8Bytes
9372 ///
9373 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9374 /// </remarks>
9375 /// <param name="formatString">The format string.</param>
9376 /// <typeparam name="T1"><undoc /></typeparam>
9377
9378 /// <param name="arg0">Value to interpolate into the format string.</param>
9379 /// <param name="arg1">Value to interpolate into the format string.</param>
9380 /// <param name="arg2">Value to interpolate into the format string.</param>
9381 /// <param name="arg3">Value to interpolate into the format string.</param>
9382 /// <returns>A new string produced by interpolating the format string.</returns>
9383 [ExcludeFromBurstCompatTesting("Takes managed string")]
9384 public static FixedString512Bytes Format<T1>(FixedString512Bytes formatString, string arg0, string arg1, string arg2, T1 arg3)
9385 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9386
9387 {
9388 FixedString512Bytes result = default;
9389 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9390 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9391 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9392
9393
9394 result.AppendFormat(formatString, carg0, carg1, carg2, arg3);
9395 return result;
9396 }
9397
9398 /// <summary>
9399 /// Returns a new string produced by interpolating a format string.
9400 /// </summary>
9401 /// <remarks>
9402 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9403 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9404 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9405 ///
9406 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9407 /// - FixedString*N*Bytes
9408 /// - string
9409 /// - int
9410 /// - float
9411 /// - structs implementing INativeList<byte> and IUTF8Bytes
9412 ///
9413 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9414 /// </remarks>
9415 /// <param name="formatString">The format string.</param>
9416 /// <typeparam name="T1"><undoc /></typeparam>
9417 /// <typeparam name="T2"><undoc /></typeparam>
9418
9419 /// <param name="arg0">Value to interpolate into the format string.</param>
9420 /// <param name="arg1">Value to interpolate into the format string.</param>
9421 /// <param name="arg2">Value to interpolate into the format string.</param>
9422 /// <param name="arg3">Value to interpolate into the format string.</param>
9423 /// <returns>A new string produced by interpolating the format string.</returns>
9424 [ExcludeFromBurstCompatTesting("Takes managed string")]
9425 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, T1 arg0, string arg1, string arg2, T2 arg3)
9426 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9427 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9428
9429 {
9430 FixedString512Bytes result = default;
9431 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9432 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9433
9434
9435 result.AppendFormat(formatString, arg0, carg1, carg2, arg3);
9436 return result;
9437 }
9438
9439 /// <summary>
9440 /// Returns a new string produced by interpolating a format string.
9441 /// </summary>
9442 /// <remarks>
9443 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9444 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9445 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9446 ///
9447 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9448 /// - FixedString*N*Bytes
9449 /// - string
9450 /// - int
9451 /// - float
9452 /// - structs implementing INativeList<byte> and IUTF8Bytes
9453 ///
9454 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9455 /// </remarks>
9456 /// <param name="formatString">The format string.</param>
9457 /// <typeparam name="T1"><undoc /></typeparam>
9458 /// <typeparam name="T2"><undoc /></typeparam>
9459
9460 /// <param name="arg0">Value to interpolate into the format string.</param>
9461 /// <param name="arg1">Value to interpolate into the format string.</param>
9462 /// <param name="arg2">Value to interpolate into the format string.</param>
9463 /// <param name="arg3">Value to interpolate into the format string.</param>
9464 /// <returns>A new string produced by interpolating the format string.</returns>
9465 [ExcludeFromBurstCompatTesting("Takes managed string")]
9466 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, T1 arg1, string arg2, T2 arg3)
9467 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9468 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9469
9470 {
9471 FixedString512Bytes result = default;
9472 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9473 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9474
9475
9476 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
9477 return result;
9478 }
9479
9480 /// <summary>
9481 /// Returns a new string produced by interpolating a format string.
9482 /// </summary>
9483 /// <remarks>
9484 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9485 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9486 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9487 ///
9488 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9489 /// - FixedString*N*Bytes
9490 /// - string
9491 /// - int
9492 /// - float
9493 /// - structs implementing INativeList<byte> and IUTF8Bytes
9494 ///
9495 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9496 /// </remarks>
9497 /// <param name="formatString">The format string.</param>
9498 /// <typeparam name="T1"><undoc /></typeparam>
9499 /// <typeparam name="T2"><undoc /></typeparam>
9500
9501 /// <param name="arg0">Value to interpolate into the format string.</param>
9502 /// <param name="arg1">Value to interpolate into the format string.</param>
9503 /// <param name="arg2">Value to interpolate into the format string.</param>
9504 /// <param name="arg3">Value to interpolate into the format string.</param>
9505 /// <returns>A new string produced by interpolating the format string.</returns>
9506 [ExcludeFromBurstCompatTesting("Takes managed string")]
9507 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, T1 arg1, string arg2, T2 arg3)
9508 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9509 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9510
9511 {
9512 FixedString512Bytes result = default;
9513 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9514 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9515
9516
9517 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
9518 return result;
9519 }
9520
9521 /// <summary>
9522 /// Returns a new string produced by interpolating a format string.
9523 /// </summary>
9524 /// <remarks>
9525 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9526 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9527 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9528 ///
9529 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9530 /// - FixedString*N*Bytes
9531 /// - string
9532 /// - int
9533 /// - float
9534 /// - structs implementing INativeList<byte> and IUTF8Bytes
9535 ///
9536 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9537 /// </remarks>
9538 /// <param name="formatString">The format string.</param>
9539 /// <typeparam name="T1"><undoc /></typeparam>
9540 /// <typeparam name="T2"><undoc /></typeparam>
9541
9542 /// <param name="arg0">Value to interpolate into the format string.</param>
9543 /// <param name="arg1">Value to interpolate into the format string.</param>
9544 /// <param name="arg2">Value to interpolate into the format string.</param>
9545 /// <param name="arg3">Value to interpolate into the format string.</param>
9546 /// <returns>A new string produced by interpolating the format string.</returns>
9547 [ExcludeFromBurstCompatTesting("Takes managed string")]
9548 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, T1 arg1, string arg2, T2 arg3)
9549 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9550 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9551
9552 {
9553 FixedString512Bytes result = default;
9554 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9555 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9556
9557
9558 result.AppendFormat(formatString, carg0, arg1, carg2, arg3);
9559 return result;
9560 }
9561
9562 /// <summary>
9563 /// Returns a new string produced by interpolating a format string.
9564 /// </summary>
9565 /// <remarks>
9566 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9567 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9568 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9569 ///
9570 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9571 /// - FixedString*N*Bytes
9572 /// - string
9573 /// - int
9574 /// - float
9575 /// - structs implementing INativeList<byte> and IUTF8Bytes
9576 ///
9577 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9578 /// </remarks>
9579 /// <param name="formatString">The format string.</param>
9580 /// <typeparam name="T1"><undoc /></typeparam>
9581 /// <typeparam name="T2"><undoc /></typeparam>
9582 /// <typeparam name="T3"><undoc /></typeparam>
9583
9584 /// <param name="arg0">Value to interpolate into the format string.</param>
9585 /// <param name="arg1">Value to interpolate into the format string.</param>
9586 /// <param name="arg2">Value to interpolate into the format string.</param>
9587 /// <param name="arg3">Value to interpolate into the format string.</param>
9588 /// <returns>A new string produced by interpolating the format string.</returns>
9589 [ExcludeFromBurstCompatTesting("Takes managed string")]
9590 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, T2 arg1, string arg2, T3 arg3)
9591 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9592 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9593 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
9594
9595 {
9596 FixedString512Bytes result = default;
9597 FixedString32Bytes carg2 = default; carg2.Append(arg2);
9598
9599
9600 result.AppendFormat(formatString, arg0, arg1, carg2, arg3);
9601 return result;
9602 }
9603
9604 /// <summary>
9605 /// Returns a new string produced by interpolating a format string.
9606 /// </summary>
9607 /// <remarks>
9608 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9609 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9610 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9611 ///
9612 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9613 /// - FixedString*N*Bytes
9614 /// - string
9615 /// - int
9616 /// - float
9617 /// - structs implementing INativeList<byte> and IUTF8Bytes
9618 ///
9619 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9620 /// </remarks>
9621 /// <param name="formatString">The format string.</param>
9622 /// <typeparam name="T1"><undoc /></typeparam>
9623 /// <typeparam name="T2"><undoc /></typeparam>
9624
9625 /// <param name="arg0">Value to interpolate into the format string.</param>
9626 /// <param name="arg1">Value to interpolate into the format string.</param>
9627 /// <param name="arg2">Value to interpolate into the format string.</param>
9628 /// <param name="arg3">Value to interpolate into the format string.</param>
9629 /// <returns>A new string produced by interpolating the format string.</returns>
9630 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
9631 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, int arg1, T1 arg2, T2 arg3)
9632 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9633 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9634
9635 {
9636 FixedString512Bytes result = default;
9637 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9638 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9639
9640
9641 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9642 return result;
9643 }
9644
9645 /// <summary>
9646 /// Returns a new string produced by interpolating a format string.
9647 /// </summary>
9648 /// <remarks>
9649 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9650 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9651 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9652 ///
9653 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9654 /// - FixedString*N*Bytes
9655 /// - string
9656 /// - int
9657 /// - float
9658 /// - structs implementing INativeList<byte> and IUTF8Bytes
9659 ///
9660 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9661 /// </remarks>
9662 /// <param name="formatString">The format string.</param>
9663 /// <typeparam name="T1"><undoc /></typeparam>
9664 /// <typeparam name="T2"><undoc /></typeparam>
9665
9666 /// <param name="arg0">Value to interpolate into the format string.</param>
9667 /// <param name="arg1">Value to interpolate into the format string.</param>
9668 /// <param name="arg2">Value to interpolate into the format string.</param>
9669 /// <param name="arg3">Value to interpolate into the format string.</param>
9670 /// <returns>A new string produced by interpolating the format string.</returns>
9671 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
9672 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, int arg1, T1 arg2, T2 arg3)
9673 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9674 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9675
9676 {
9677 FixedString512Bytes result = default;
9678 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9679 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9680
9681
9682 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9683 return result;
9684 }
9685
9686 /// <summary>
9687 /// Returns a new string produced by interpolating a format string.
9688 /// </summary>
9689 /// <remarks>
9690 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9691 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9692 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9693 ///
9694 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9695 /// - FixedString*N*Bytes
9696 /// - string
9697 /// - int
9698 /// - float
9699 /// - structs implementing INativeList<byte> and IUTF8Bytes
9700 ///
9701 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9702 /// </remarks>
9703 /// <param name="formatString">The format string.</param>
9704 /// <typeparam name="T1"><undoc /></typeparam>
9705 /// <typeparam name="T2"><undoc /></typeparam>
9706
9707 /// <param name="arg0">Value to interpolate into the format string.</param>
9708 /// <param name="arg1">Value to interpolate into the format string.</param>
9709 /// <param name="arg2">Value to interpolate into the format string.</param>
9710 /// <param name="arg3">Value to interpolate into the format string.</param>
9711 /// <returns>A new string produced by interpolating the format string.</returns>
9712 [ExcludeFromBurstCompatTesting("Takes managed string")]
9713 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, int arg1, T1 arg2, T2 arg3)
9714 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9715 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9716
9717 {
9718 FixedString512Bytes result = default;
9719 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9720 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9721
9722
9723 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9724 return result;
9725 }
9726
9727 /// <summary>
9728 /// Returns a new string produced by interpolating a format string.
9729 /// </summary>
9730 /// <remarks>
9731 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9732 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9733 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9734 ///
9735 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9736 /// - FixedString*N*Bytes
9737 /// - string
9738 /// - int
9739 /// - float
9740 /// - structs implementing INativeList<byte> and IUTF8Bytes
9741 ///
9742 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9743 /// </remarks>
9744 /// <param name="formatString">The format string.</param>
9745 /// <typeparam name="T1"><undoc /></typeparam>
9746 /// <typeparam name="T2"><undoc /></typeparam>
9747 /// <typeparam name="T3"><undoc /></typeparam>
9748
9749 /// <param name="arg0">Value to interpolate into the format string.</param>
9750 /// <param name="arg1">Value to interpolate into the format string.</param>
9751 /// <param name="arg2">Value to interpolate into the format string.</param>
9752 /// <param name="arg3">Value to interpolate into the format string.</param>
9753 /// <returns>A new string produced by interpolating the format string.</returns>
9754 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
9755 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, int arg1, T2 arg2, T3 arg3)
9756 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9757 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9758 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
9759
9760 {
9761 FixedString512Bytes result = default;
9762 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9763
9764
9765 result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
9766 return result;
9767 }
9768
9769 /// <summary>
9770 /// Returns a new string produced by interpolating a format string.
9771 /// </summary>
9772 /// <remarks>
9773 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9774 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9775 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9776 ///
9777 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9778 /// - FixedString*N*Bytes
9779 /// - string
9780 /// - int
9781 /// - float
9782 /// - structs implementing INativeList<byte> and IUTF8Bytes
9783 ///
9784 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9785 /// </remarks>
9786 /// <param name="formatString">The format string.</param>
9787 /// <typeparam name="T1"><undoc /></typeparam>
9788 /// <typeparam name="T2"><undoc /></typeparam>
9789
9790 /// <param name="arg0">Value to interpolate into the format string.</param>
9791 /// <param name="arg1">Value to interpolate into the format string.</param>
9792 /// <param name="arg2">Value to interpolate into the format string.</param>
9793 /// <param name="arg3">Value to interpolate into the format string.</param>
9794 /// <returns>A new string produced by interpolating the format string.</returns>
9795 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
9796 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, float arg1, T1 arg2, T2 arg3)
9797 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9798 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9799
9800 {
9801 FixedString512Bytes result = default;
9802 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9803 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9804
9805
9806 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9807 return result;
9808 }
9809
9810 /// <summary>
9811 /// Returns a new string produced by interpolating a format string.
9812 /// </summary>
9813 /// <remarks>
9814 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9815 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9816 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9817 ///
9818 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9819 /// - FixedString*N*Bytes
9820 /// - string
9821 /// - int
9822 /// - float
9823 /// - structs implementing INativeList<byte> and IUTF8Bytes
9824 ///
9825 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9826 /// </remarks>
9827 /// <param name="formatString">The format string.</param>
9828 /// <typeparam name="T1"><undoc /></typeparam>
9829 /// <typeparam name="T2"><undoc /></typeparam>
9830
9831 /// <param name="arg0">Value to interpolate into the format string.</param>
9832 /// <param name="arg1">Value to interpolate into the format string.</param>
9833 /// <param name="arg2">Value to interpolate into the format string.</param>
9834 /// <param name="arg3">Value to interpolate into the format string.</param>
9835 /// <returns>A new string produced by interpolating the format string.</returns>
9836 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
9837 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, float arg1, T1 arg2, T2 arg3)
9838 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9839 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9840
9841 {
9842 FixedString512Bytes result = default;
9843 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9844 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9845
9846
9847 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9848 return result;
9849 }
9850
9851 /// <summary>
9852 /// Returns a new string produced by interpolating a format string.
9853 /// </summary>
9854 /// <remarks>
9855 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9856 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9857 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9858 ///
9859 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9860 /// - FixedString*N*Bytes
9861 /// - string
9862 /// - int
9863 /// - float
9864 /// - structs implementing INativeList<byte> and IUTF8Bytes
9865 ///
9866 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9867 /// </remarks>
9868 /// <param name="formatString">The format string.</param>
9869 /// <typeparam name="T1"><undoc /></typeparam>
9870 /// <typeparam name="T2"><undoc /></typeparam>
9871
9872 /// <param name="arg0">Value to interpolate into the format string.</param>
9873 /// <param name="arg1">Value to interpolate into the format string.</param>
9874 /// <param name="arg2">Value to interpolate into the format string.</param>
9875 /// <param name="arg3">Value to interpolate into the format string.</param>
9876 /// <returns>A new string produced by interpolating the format string.</returns>
9877 [ExcludeFromBurstCompatTesting("Takes managed string")]
9878 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, float arg1, T1 arg2, T2 arg3)
9879 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9880 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9881
9882 {
9883 FixedString512Bytes result = default;
9884 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9885 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9886
9887
9888 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9889 return result;
9890 }
9891
9892 /// <summary>
9893 /// Returns a new string produced by interpolating a format string.
9894 /// </summary>
9895 /// <remarks>
9896 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9897 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9898 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9899 ///
9900 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9901 /// - FixedString*N*Bytes
9902 /// - string
9903 /// - int
9904 /// - float
9905 /// - structs implementing INativeList<byte> and IUTF8Bytes
9906 ///
9907 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9908 /// </remarks>
9909 /// <param name="formatString">The format string.</param>
9910 /// <typeparam name="T1"><undoc /></typeparam>
9911 /// <typeparam name="T2"><undoc /></typeparam>
9912 /// <typeparam name="T3"><undoc /></typeparam>
9913
9914 /// <param name="arg0">Value to interpolate into the format string.</param>
9915 /// <param name="arg1">Value to interpolate into the format string.</param>
9916 /// <param name="arg2">Value to interpolate into the format string.</param>
9917 /// <param name="arg3">Value to interpolate into the format string.</param>
9918 /// <returns>A new string produced by interpolating the format string.</returns>
9919 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
9920 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, float arg1, T2 arg2, T3 arg3)
9921 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9922 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9923 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
9924
9925 {
9926 FixedString512Bytes result = default;
9927 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9928
9929
9930 result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
9931 return result;
9932 }
9933
9934 /// <summary>
9935 /// Returns a new string produced by interpolating a format string.
9936 /// </summary>
9937 /// <remarks>
9938 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9939 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9940 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9941 ///
9942 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9943 /// - FixedString*N*Bytes
9944 /// - string
9945 /// - int
9946 /// - float
9947 /// - structs implementing INativeList<byte> and IUTF8Bytes
9948 ///
9949 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9950 /// </remarks>
9951 /// <param name="formatString">The format string.</param>
9952 /// <typeparam name="T1"><undoc /></typeparam>
9953 /// <typeparam name="T2"><undoc /></typeparam>
9954
9955 /// <param name="arg0">Value to interpolate into the format string.</param>
9956 /// <param name="arg1">Value to interpolate into the format string.</param>
9957 /// <param name="arg2">Value to interpolate into the format string.</param>
9958 /// <param name="arg3">Value to interpolate into the format string.</param>
9959 /// <returns>A new string produced by interpolating the format string.</returns>
9960 [ExcludeFromBurstCompatTesting("Takes managed string")]
9961 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, int arg0, string arg1, T1 arg2, T2 arg3)
9962 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
9963 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
9964
9965 {
9966 FixedString512Bytes result = default;
9967 FixedString32Bytes carg0 = default; carg0.Append(arg0);
9968 FixedString32Bytes carg1 = default; carg1.Append(arg1);
9969
9970
9971 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
9972 return result;
9973 }
9974
9975 /// <summary>
9976 /// Returns a new string produced by interpolating a format string.
9977 /// </summary>
9978 /// <remarks>
9979 /// Similar to StringBuilder.AppendFormat but with significant limitations:
9980 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
9981 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
9982 ///
9983 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
9984 /// - FixedString*N*Bytes
9985 /// - string
9986 /// - int
9987 /// - float
9988 /// - structs implementing INativeList<byte> and IUTF8Bytes
9989 ///
9990 /// <seealso cref="FixedStringMethods.AppendFormat"/>
9991 /// </remarks>
9992 /// <param name="formatString">The format string.</param>
9993 /// <typeparam name="T1"><undoc /></typeparam>
9994 /// <typeparam name="T2"><undoc /></typeparam>
9995
9996 /// <param name="arg0">Value to interpolate into the format string.</param>
9997 /// <param name="arg1">Value to interpolate into the format string.</param>
9998 /// <param name="arg2">Value to interpolate into the format string.</param>
9999 /// <param name="arg3">Value to interpolate into the format string.</param>
10000 /// <returns>A new string produced by interpolating the format string.</returns>
10001 [ExcludeFromBurstCompatTesting("Takes managed string")]
10002 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, float arg0, string arg1, T1 arg2, T2 arg3)
10003 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10004 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10005
10006 {
10007 FixedString512Bytes result = default;
10008 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10009 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10010
10011
10012 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
10013 return result;
10014 }
10015
10016 /// <summary>
10017 /// Returns a new string produced by interpolating a format string.
10018 /// </summary>
10019 /// <remarks>
10020 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10021 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10022 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10023 ///
10024 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10025 /// - FixedString*N*Bytes
10026 /// - string
10027 /// - int
10028 /// - float
10029 /// - structs implementing INativeList<byte> and IUTF8Bytes
10030 ///
10031 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10032 /// </remarks>
10033 /// <param name="formatString">The format string.</param>
10034 /// <typeparam name="T1"><undoc /></typeparam>
10035 /// <typeparam name="T2"><undoc /></typeparam>
10036
10037 /// <param name="arg0">Value to interpolate into the format string.</param>
10038 /// <param name="arg1">Value to interpolate into the format string.</param>
10039 /// <param name="arg2">Value to interpolate into the format string.</param>
10040 /// <param name="arg3">Value to interpolate into the format string.</param>
10041 /// <returns>A new string produced by interpolating the format string.</returns>
10042 [ExcludeFromBurstCompatTesting("Takes managed string")]
10043 public static FixedString512Bytes Format<T1,T2>(FixedString512Bytes formatString, string arg0, string arg1, T1 arg2, T2 arg3)
10044 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10045 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10046
10047 {
10048 FixedString512Bytes result = default;
10049 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10050 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10051
10052
10053 result.AppendFormat(formatString, carg0, carg1, arg2, arg3);
10054 return result;
10055 }
10056
10057 /// <summary>
10058 /// Returns a new string produced by interpolating a format string.
10059 /// </summary>
10060 /// <remarks>
10061 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10062 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10063 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10064 ///
10065 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10066 /// - FixedString*N*Bytes
10067 /// - string
10068 /// - int
10069 /// - float
10070 /// - structs implementing INativeList<byte> and IUTF8Bytes
10071 ///
10072 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10073 /// </remarks>
10074 /// <param name="formatString">The format string.</param>
10075 /// <typeparam name="T1"><undoc /></typeparam>
10076 /// <typeparam name="T2"><undoc /></typeparam>
10077 /// <typeparam name="T3"><undoc /></typeparam>
10078
10079 /// <param name="arg0">Value to interpolate into the format string.</param>
10080 /// <param name="arg1">Value to interpolate into the format string.</param>
10081 /// <param name="arg2">Value to interpolate into the format string.</param>
10082 /// <param name="arg3">Value to interpolate into the format string.</param>
10083 /// <returns>A new string produced by interpolating the format string.</returns>
10084 [ExcludeFromBurstCompatTesting("Takes managed string")]
10085 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, T1 arg0, string arg1, T2 arg2, T3 arg3)
10086 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10087 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10088 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
10089
10090 {
10091 FixedString512Bytes result = default;
10092 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10093
10094
10095 result.AppendFormat(formatString, arg0, carg1, arg2, arg3);
10096 return result;
10097 }
10098
10099 /// <summary>
10100 /// Returns a new string produced by interpolating a format string.
10101 /// </summary>
10102 /// <remarks>
10103 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10104 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10105 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10106 ///
10107 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10108 /// - FixedString*N*Bytes
10109 /// - string
10110 /// - int
10111 /// - float
10112 /// - structs implementing INativeList<byte> and IUTF8Bytes
10113 ///
10114 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10115 /// </remarks>
10116 /// <param name="formatString">The format string.</param>
10117 /// <typeparam name="T1"><undoc /></typeparam>
10118 /// <typeparam name="T2"><undoc /></typeparam>
10119 /// <typeparam name="T3"><undoc /></typeparam>
10120
10121 /// <param name="arg0">Value to interpolate into the format string.</param>
10122 /// <param name="arg1">Value to interpolate into the format string.</param>
10123 /// <param name="arg2">Value to interpolate into the format string.</param>
10124 /// <param name="arg3">Value to interpolate into the format string.</param>
10125 /// <returns>A new string produced by interpolating the format string.</returns>
10126 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
10127 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, int arg0, T1 arg1, T2 arg2, T3 arg3)
10128 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10129 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10130 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
10131
10132 {
10133 FixedString512Bytes result = default;
10134 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10135
10136
10137 result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
10138 return result;
10139 }
10140
10141 /// <summary>
10142 /// Returns a new string produced by interpolating a format string.
10143 /// </summary>
10144 /// <remarks>
10145 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10146 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10147 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10148 ///
10149 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10150 /// - FixedString*N*Bytes
10151 /// - string
10152 /// - int
10153 /// - float
10154 /// - structs implementing INativeList<byte> and IUTF8Bytes
10155 ///
10156 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10157 /// </remarks>
10158 /// <param name="formatString">The format string.</param>
10159 /// <typeparam name="T1"><undoc /></typeparam>
10160 /// <typeparam name="T2"><undoc /></typeparam>
10161 /// <typeparam name="T3"><undoc /></typeparam>
10162
10163 /// <param name="arg0">Value to interpolate into the format string.</param>
10164 /// <param name="arg1">Value to interpolate into the format string.</param>
10165 /// <param name="arg2">Value to interpolate into the format string.</param>
10166 /// <param name="arg3">Value to interpolate into the format string.</param>
10167 /// <returns>A new string produced by interpolating the format string.</returns>
10168 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
10169 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, float arg0, T1 arg1, T2 arg2, T3 arg3)
10170 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10171 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10172 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
10173
10174 {
10175 FixedString512Bytes result = default;
10176 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10177
10178
10179 result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
10180 return result;
10181 }
10182
10183 /// <summary>
10184 /// Returns a new string produced by interpolating a format string.
10185 /// </summary>
10186 /// <remarks>
10187 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10188 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10189 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10190 ///
10191 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10192 /// - FixedString*N*Bytes
10193 /// - string
10194 /// - int
10195 /// - float
10196 /// - structs implementing INativeList<byte> and IUTF8Bytes
10197 ///
10198 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10199 /// </remarks>
10200 /// <param name="formatString">The format string.</param>
10201 /// <typeparam name="T1"><undoc /></typeparam>
10202 /// <typeparam name="T2"><undoc /></typeparam>
10203 /// <typeparam name="T3"><undoc /></typeparam>
10204
10205 /// <param name="arg0">Value to interpolate into the format string.</param>
10206 /// <param name="arg1">Value to interpolate into the format string.</param>
10207 /// <param name="arg2">Value to interpolate into the format string.</param>
10208 /// <param name="arg3">Value to interpolate into the format string.</param>
10209 /// <returns>A new string produced by interpolating the format string.</returns>
10210 [ExcludeFromBurstCompatTesting("Takes managed string")]
10211 public static FixedString512Bytes Format<T1,T2,T3>(FixedString512Bytes formatString, string arg0, T1 arg1, T2 arg2, T3 arg3)
10212 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10213 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10214 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
10215
10216 {
10217 FixedString512Bytes result = default;
10218 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10219
10220
10221 result.AppendFormat(formatString, carg0, arg1, arg2, arg3);
10222 return result;
10223 }
10224
10225 /// <summary>
10226 /// Returns a new string produced by interpolating a format string.
10227 /// </summary>
10228 /// <remarks>
10229 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10230 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10231 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10232 ///
10233 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10234 /// - FixedString*N*Bytes
10235 /// - string
10236 /// - int
10237 /// - float
10238 /// - structs implementing INativeList<byte> and IUTF8Bytes
10239 ///
10240 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10241 /// </remarks>
10242 /// <param name="formatString">The format string.</param>
10243 /// <typeparam name="T1"><undoc /></typeparam>
10244 /// <typeparam name="T2"><undoc /></typeparam>
10245 /// <typeparam name="T3"><undoc /></typeparam>
10246 /// <typeparam name="T4"><undoc /></typeparam>
10247
10248 /// <param name="arg0">Value to interpolate into the format string.</param>
10249 /// <param name="arg1">Value to interpolate into the format string.</param>
10250 /// <param name="arg2">Value to interpolate into the format string.</param>
10251 /// <param name="arg3">Value to interpolate into the format string.</param>
10252 /// <returns>A new string produced by interpolating the format string.</returns>
10253 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/), typeof(FixedString32Bytes /*$T4*/) } )]
10254 public static FixedString512Bytes Format<T1,T2,T3,T4>(FixedString512Bytes formatString, T1 arg0, T2 arg1, T3 arg2, T4 arg3)
10255 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10256 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10257 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
10258 where T4 : unmanaged, INativeList<byte>, IUTF8Bytes
10259
10260 {
10261 FixedString512Bytes result = default;
10262
10263
10264 result.AppendFormat(formatString, arg0, arg1, arg2, arg3);
10265 return result;
10266 }
10267
10268 /// <summary>
10269 /// Returns a new string produced by interpolating a format string.
10270 /// </summary>
10271 /// <remarks>
10272 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10273 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10274 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10275 ///
10276 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10277 /// - FixedString*N*Bytes
10278 /// - string
10279 /// - int
10280 /// - float
10281 /// - structs implementing INativeList<byte> and IUTF8Bytes
10282 ///
10283 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10284 /// </remarks>
10285 /// <param name="formatString">The format string.</param>
10286
10287 /// <param name="arg0">Value to interpolate into the format string.</param>
10288 /// <param name="arg1">Value to interpolate into the format string.</param>
10289 /// <param name="arg2">Value to interpolate into the format string.</param>
10290 /// <returns>A new string produced by interpolating the format string.</returns>
10291
10292 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, int arg2)
10293
10294 {
10295 FixedString128Bytes result = default;
10296 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10297 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10298 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10299
10300
10301 result.AppendFormat(formatString, carg0, carg1, carg2);
10302 return result;
10303 }
10304
10305 /// <summary>
10306 /// Returns a new string produced by interpolating a format string.
10307 /// </summary>
10308 /// <remarks>
10309 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10310 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10311 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10312 ///
10313 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10314 /// - FixedString*N*Bytes
10315 /// - string
10316 /// - int
10317 /// - float
10318 /// - structs implementing INativeList<byte> and IUTF8Bytes
10319 ///
10320 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10321 /// </remarks>
10322 /// <param name="formatString">The format string.</param>
10323
10324 /// <param name="arg0">Value to interpolate into the format string.</param>
10325 /// <param name="arg1">Value to interpolate into the format string.</param>
10326 /// <param name="arg2">Value to interpolate into the format string.</param>
10327 /// <returns>A new string produced by interpolating the format string.</returns>
10328
10329 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, int arg2)
10330
10331 {
10332 FixedString128Bytes result = default;
10333 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10334 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10335 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10336
10337
10338 result.AppendFormat(formatString, carg0, carg1, carg2);
10339 return result;
10340 }
10341
10342 /// <summary>
10343 /// Returns a new string produced by interpolating a format string.
10344 /// </summary>
10345 /// <remarks>
10346 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10347 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10348 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10349 ///
10350 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10351 /// - FixedString*N*Bytes
10352 /// - string
10353 /// - int
10354 /// - float
10355 /// - structs implementing INativeList<byte> and IUTF8Bytes
10356 ///
10357 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10358 /// </remarks>
10359 /// <param name="formatString">The format string.</param>
10360
10361 /// <param name="arg0">Value to interpolate into the format string.</param>
10362 /// <param name="arg1">Value to interpolate into the format string.</param>
10363 /// <param name="arg2">Value to interpolate into the format string.</param>
10364 /// <returns>A new string produced by interpolating the format string.</returns>
10365 [ExcludeFromBurstCompatTesting("Takes managed string")]
10366 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, int arg2)
10367
10368 {
10369 FixedString128Bytes result = default;
10370 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10371 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10372 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10373
10374
10375 result.AppendFormat(formatString, carg0, carg1, carg2);
10376 return result;
10377 }
10378
10379 /// <summary>
10380 /// Returns a new string produced by interpolating a format string.
10381 /// </summary>
10382 /// <remarks>
10383 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10384 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10385 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10386 ///
10387 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10388 /// - FixedString*N*Bytes
10389 /// - string
10390 /// - int
10391 /// - float
10392 /// - structs implementing INativeList<byte> and IUTF8Bytes
10393 ///
10394 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10395 /// </remarks>
10396 /// <param name="formatString">The format string.</param>
10397 /// <typeparam name="T1"><undoc /></typeparam>
10398
10399 /// <param name="arg0">Value to interpolate into the format string.</param>
10400 /// <param name="arg1">Value to interpolate into the format string.</param>
10401 /// <param name="arg2">Value to interpolate into the format string.</param>
10402 /// <returns>A new string produced by interpolating the format string.</returns>
10403 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
10404 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, int arg2)
10405 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10406
10407 {
10408 FixedString128Bytes result = default;
10409 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10410 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10411
10412
10413 result.AppendFormat(formatString, arg0, carg1, carg2);
10414 return result;
10415 }
10416
10417 /// <summary>
10418 /// Returns a new string produced by interpolating a format string.
10419 /// </summary>
10420 /// <remarks>
10421 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10422 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10423 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10424 ///
10425 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10426 /// - FixedString*N*Bytes
10427 /// - string
10428 /// - int
10429 /// - float
10430 /// - structs implementing INativeList<byte> and IUTF8Bytes
10431 ///
10432 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10433 /// </remarks>
10434 /// <param name="formatString">The format string.</param>
10435
10436 /// <param name="arg0">Value to interpolate into the format string.</param>
10437 /// <param name="arg1">Value to interpolate into the format string.</param>
10438 /// <param name="arg2">Value to interpolate into the format string.</param>
10439 /// <returns>A new string produced by interpolating the format string.</returns>
10440
10441 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, int arg2)
10442
10443 {
10444 FixedString128Bytes result = default;
10445 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10446 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10447 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10448
10449
10450 result.AppendFormat(formatString, carg0, carg1, carg2);
10451 return result;
10452 }
10453
10454 /// <summary>
10455 /// Returns a new string produced by interpolating a format string.
10456 /// </summary>
10457 /// <remarks>
10458 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10459 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10460 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10461 ///
10462 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10463 /// - FixedString*N*Bytes
10464 /// - string
10465 /// - int
10466 /// - float
10467 /// - structs implementing INativeList<byte> and IUTF8Bytes
10468 ///
10469 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10470 /// </remarks>
10471 /// <param name="formatString">The format string.</param>
10472
10473 /// <param name="arg0">Value to interpolate into the format string.</param>
10474 /// <param name="arg1">Value to interpolate into the format string.</param>
10475 /// <param name="arg2">Value to interpolate into the format string.</param>
10476 /// <returns>A new string produced by interpolating the format string.</returns>
10477
10478 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, int arg2)
10479
10480 {
10481 FixedString128Bytes result = default;
10482 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10483 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10484 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10485
10486
10487 result.AppendFormat(formatString, carg0, carg1, carg2);
10488 return result;
10489 }
10490
10491 /// <summary>
10492 /// Returns a new string produced by interpolating a format string.
10493 /// </summary>
10494 /// <remarks>
10495 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10496 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10497 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10498 ///
10499 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10500 /// - FixedString*N*Bytes
10501 /// - string
10502 /// - int
10503 /// - float
10504 /// - structs implementing INativeList<byte> and IUTF8Bytes
10505 ///
10506 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10507 /// </remarks>
10508 /// <param name="formatString">The format string.</param>
10509
10510 /// <param name="arg0">Value to interpolate into the format string.</param>
10511 /// <param name="arg1">Value to interpolate into the format string.</param>
10512 /// <param name="arg2">Value to interpolate into the format string.</param>
10513 /// <returns>A new string produced by interpolating the format string.</returns>
10514 [ExcludeFromBurstCompatTesting("Takes managed string")]
10515 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, int arg2)
10516
10517 {
10518 FixedString128Bytes result = default;
10519 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10520 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10521 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10522
10523
10524 result.AppendFormat(formatString, carg0, carg1, carg2);
10525 return result;
10526 }
10527
10528 /// <summary>
10529 /// Returns a new string produced by interpolating a format string.
10530 /// </summary>
10531 /// <remarks>
10532 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10533 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10534 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10535 ///
10536 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10537 /// - FixedString*N*Bytes
10538 /// - string
10539 /// - int
10540 /// - float
10541 /// - structs implementing INativeList<byte> and IUTF8Bytes
10542 ///
10543 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10544 /// </remarks>
10545 /// <param name="formatString">The format string.</param>
10546 /// <typeparam name="T1"><undoc /></typeparam>
10547
10548 /// <param name="arg0">Value to interpolate into the format string.</param>
10549 /// <param name="arg1">Value to interpolate into the format string.</param>
10550 /// <param name="arg2">Value to interpolate into the format string.</param>
10551 /// <returns>A new string produced by interpolating the format string.</returns>
10552 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
10553 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, int arg2)
10554 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10555
10556 {
10557 FixedString128Bytes result = default;
10558 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10559 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10560
10561
10562 result.AppendFormat(formatString, arg0, carg1, carg2);
10563 return result;
10564 }
10565
10566 /// <summary>
10567 /// Returns a new string produced by interpolating a format string.
10568 /// </summary>
10569 /// <remarks>
10570 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10571 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10572 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10573 ///
10574 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10575 /// - FixedString*N*Bytes
10576 /// - string
10577 /// - int
10578 /// - float
10579 /// - structs implementing INativeList<byte> and IUTF8Bytes
10580 ///
10581 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10582 /// </remarks>
10583 /// <param name="formatString">The format string.</param>
10584
10585 /// <param name="arg0">Value to interpolate into the format string.</param>
10586 /// <param name="arg1">Value to interpolate into the format string.</param>
10587 /// <param name="arg2">Value to interpolate into the format string.</param>
10588 /// <returns>A new string produced by interpolating the format string.</returns>
10589 [ExcludeFromBurstCompatTesting("Takes managed string")]
10590 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, int arg2)
10591
10592 {
10593 FixedString128Bytes result = default;
10594 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10595 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10596 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10597
10598
10599 result.AppendFormat(formatString, carg0, carg1, carg2);
10600 return result;
10601 }
10602
10603 /// <summary>
10604 /// Returns a new string produced by interpolating a format string.
10605 /// </summary>
10606 /// <remarks>
10607 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10608 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10609 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10610 ///
10611 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10612 /// - FixedString*N*Bytes
10613 /// - string
10614 /// - int
10615 /// - float
10616 /// - structs implementing INativeList<byte> and IUTF8Bytes
10617 ///
10618 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10619 /// </remarks>
10620 /// <param name="formatString">The format string.</param>
10621
10622 /// <param name="arg0">Value to interpolate into the format string.</param>
10623 /// <param name="arg1">Value to interpolate into the format string.</param>
10624 /// <param name="arg2">Value to interpolate into the format string.</param>
10625 /// <returns>A new string produced by interpolating the format string.</returns>
10626 [ExcludeFromBurstCompatTesting("Takes managed string")]
10627 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, int arg2)
10628
10629 {
10630 FixedString128Bytes result = default;
10631 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10632 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10633 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10634
10635
10636 result.AppendFormat(formatString, carg0, carg1, carg2);
10637 return result;
10638 }
10639
10640 /// <summary>
10641 /// Returns a new string produced by interpolating a format string.
10642 /// </summary>
10643 /// <remarks>
10644 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10645 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10646 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10647 ///
10648 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10649 /// - FixedString*N*Bytes
10650 /// - string
10651 /// - int
10652 /// - float
10653 /// - structs implementing INativeList<byte> and IUTF8Bytes
10654 ///
10655 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10656 /// </remarks>
10657 /// <param name="formatString">The format string.</param>
10658
10659 /// <param name="arg0">Value to interpolate into the format string.</param>
10660 /// <param name="arg1">Value to interpolate into the format string.</param>
10661 /// <param name="arg2">Value to interpolate into the format string.</param>
10662 /// <returns>A new string produced by interpolating the format string.</returns>
10663 [ExcludeFromBurstCompatTesting("Takes managed string")]
10664 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, int arg2)
10665
10666 {
10667 FixedString128Bytes result = default;
10668 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10669 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10670 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10671
10672
10673 result.AppendFormat(formatString, carg0, carg1, carg2);
10674 return result;
10675 }
10676
10677 /// <summary>
10678 /// Returns a new string produced by interpolating a format string.
10679 /// </summary>
10680 /// <remarks>
10681 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10682 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10683 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10684 ///
10685 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10686 /// - FixedString*N*Bytes
10687 /// - string
10688 /// - int
10689 /// - float
10690 /// - structs implementing INativeList<byte> and IUTF8Bytes
10691 ///
10692 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10693 /// </remarks>
10694 /// <param name="formatString">The format string.</param>
10695 /// <typeparam name="T1"><undoc /></typeparam>
10696
10697 /// <param name="arg0">Value to interpolate into the format string.</param>
10698 /// <param name="arg1">Value to interpolate into the format string.</param>
10699 /// <param name="arg2">Value to interpolate into the format string.</param>
10700 /// <returns>A new string produced by interpolating the format string.</returns>
10701 [ExcludeFromBurstCompatTesting("Takes managed string")]
10702 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, int arg2)
10703 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10704
10705 {
10706 FixedString128Bytes result = default;
10707 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10708 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10709
10710
10711 result.AppendFormat(formatString, arg0, carg1, carg2);
10712 return result;
10713 }
10714
10715 /// <summary>
10716 /// Returns a new string produced by interpolating a format string.
10717 /// </summary>
10718 /// <remarks>
10719 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10720 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10721 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10722 ///
10723 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10724 /// - FixedString*N*Bytes
10725 /// - string
10726 /// - int
10727 /// - float
10728 /// - structs implementing INativeList<byte> and IUTF8Bytes
10729 ///
10730 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10731 /// </remarks>
10732 /// <param name="formatString">The format string.</param>
10733 /// <typeparam name="T1"><undoc /></typeparam>
10734
10735 /// <param name="arg0">Value to interpolate into the format string.</param>
10736 /// <param name="arg1">Value to interpolate into the format string.</param>
10737 /// <param name="arg2">Value to interpolate into the format string.</param>
10738 /// <returns>A new string produced by interpolating the format string.</returns>
10739 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
10740 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, int arg2)
10741 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10742
10743 {
10744 FixedString128Bytes result = default;
10745 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10746 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10747
10748
10749 result.AppendFormat(formatString, carg0, arg1, carg2);
10750 return result;
10751 }
10752
10753 /// <summary>
10754 /// Returns a new string produced by interpolating a format string.
10755 /// </summary>
10756 /// <remarks>
10757 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10758 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10759 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10760 ///
10761 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10762 /// - FixedString*N*Bytes
10763 /// - string
10764 /// - int
10765 /// - float
10766 /// - structs implementing INativeList<byte> and IUTF8Bytes
10767 ///
10768 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10769 /// </remarks>
10770 /// <param name="formatString">The format string.</param>
10771 /// <typeparam name="T1"><undoc /></typeparam>
10772
10773 /// <param name="arg0">Value to interpolate into the format string.</param>
10774 /// <param name="arg1">Value to interpolate into the format string.</param>
10775 /// <param name="arg2">Value to interpolate into the format string.</param>
10776 /// <returns>A new string produced by interpolating the format string.</returns>
10777 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
10778 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, int arg2)
10779 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10780
10781 {
10782 FixedString128Bytes result = default;
10783 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10784 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10785
10786
10787 result.AppendFormat(formatString, carg0, arg1, carg2);
10788 return result;
10789 }
10790
10791 /// <summary>
10792 /// Returns a new string produced by interpolating a format string.
10793 /// </summary>
10794 /// <remarks>
10795 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10796 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10797 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10798 ///
10799 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10800 /// - FixedString*N*Bytes
10801 /// - string
10802 /// - int
10803 /// - float
10804 /// - structs implementing INativeList<byte> and IUTF8Bytes
10805 ///
10806 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10807 /// </remarks>
10808 /// <param name="formatString">The format string.</param>
10809 /// <typeparam name="T1"><undoc /></typeparam>
10810
10811 /// <param name="arg0">Value to interpolate into the format string.</param>
10812 /// <param name="arg1">Value to interpolate into the format string.</param>
10813 /// <param name="arg2">Value to interpolate into the format string.</param>
10814 /// <returns>A new string produced by interpolating the format string.</returns>
10815 [ExcludeFromBurstCompatTesting("Takes managed string")]
10816 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, int arg2)
10817 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10818
10819 {
10820 FixedString128Bytes result = default;
10821 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10822 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10823
10824
10825 result.AppendFormat(formatString, carg0, arg1, carg2);
10826 return result;
10827 }
10828
10829 /// <summary>
10830 /// Returns a new string produced by interpolating a format string.
10831 /// </summary>
10832 /// <remarks>
10833 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10834 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10835 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10836 ///
10837 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10838 /// - FixedString*N*Bytes
10839 /// - string
10840 /// - int
10841 /// - float
10842 /// - structs implementing INativeList<byte> and IUTF8Bytes
10843 ///
10844 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10845 /// </remarks>
10846 /// <param name="formatString">The format string.</param>
10847 /// <typeparam name="T1"><undoc /></typeparam>
10848 /// <typeparam name="T2"><undoc /></typeparam>
10849
10850 /// <param name="arg0">Value to interpolate into the format string.</param>
10851 /// <param name="arg1">Value to interpolate into the format string.</param>
10852 /// <param name="arg2">Value to interpolate into the format string.</param>
10853 /// <returns>A new string produced by interpolating the format string.</returns>
10854 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
10855 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, int arg2)
10856 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
10857 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
10858
10859 {
10860 FixedString128Bytes result = default;
10861 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10862
10863
10864 result.AppendFormat(formatString, arg0, arg1, carg2);
10865 return result;
10866 }
10867
10868 /// <summary>
10869 /// Returns a new string produced by interpolating a format string.
10870 /// </summary>
10871 /// <remarks>
10872 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10873 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10874 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10875 ///
10876 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10877 /// - FixedString*N*Bytes
10878 /// - string
10879 /// - int
10880 /// - float
10881 /// - structs implementing INativeList<byte> and IUTF8Bytes
10882 ///
10883 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10884 /// </remarks>
10885 /// <param name="formatString">The format string.</param>
10886
10887 /// <param name="arg0">Value to interpolate into the format string.</param>
10888 /// <param name="arg1">Value to interpolate into the format string.</param>
10889 /// <param name="arg2">Value to interpolate into the format string.</param>
10890 /// <returns>A new string produced by interpolating the format string.</returns>
10891
10892 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, float arg2)
10893
10894 {
10895 FixedString128Bytes result = default;
10896 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10897 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10898 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10899
10900
10901 result.AppendFormat(formatString, carg0, carg1, carg2);
10902 return result;
10903 }
10904
10905 /// <summary>
10906 /// Returns a new string produced by interpolating a format string.
10907 /// </summary>
10908 /// <remarks>
10909 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10910 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10911 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10912 ///
10913 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10914 /// - FixedString*N*Bytes
10915 /// - string
10916 /// - int
10917 /// - float
10918 /// - structs implementing INativeList<byte> and IUTF8Bytes
10919 ///
10920 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10921 /// </remarks>
10922 /// <param name="formatString">The format string.</param>
10923
10924 /// <param name="arg0">Value to interpolate into the format string.</param>
10925 /// <param name="arg1">Value to interpolate into the format string.</param>
10926 /// <param name="arg2">Value to interpolate into the format string.</param>
10927 /// <returns>A new string produced by interpolating the format string.</returns>
10928
10929 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, float arg2)
10930
10931 {
10932 FixedString128Bytes result = default;
10933 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10934 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10935 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10936
10937
10938 result.AppendFormat(formatString, carg0, carg1, carg2);
10939 return result;
10940 }
10941
10942 /// <summary>
10943 /// Returns a new string produced by interpolating a format string.
10944 /// </summary>
10945 /// <remarks>
10946 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10947 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10948 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10949 ///
10950 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10951 /// - FixedString*N*Bytes
10952 /// - string
10953 /// - int
10954 /// - float
10955 /// - structs implementing INativeList<byte> and IUTF8Bytes
10956 ///
10957 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10958 /// </remarks>
10959 /// <param name="formatString">The format string.</param>
10960
10961 /// <param name="arg0">Value to interpolate into the format string.</param>
10962 /// <param name="arg1">Value to interpolate into the format string.</param>
10963 /// <param name="arg2">Value to interpolate into the format string.</param>
10964 /// <returns>A new string produced by interpolating the format string.</returns>
10965 [ExcludeFromBurstCompatTesting("Takes managed string")]
10966 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, float arg2)
10967
10968 {
10969 FixedString128Bytes result = default;
10970 FixedString32Bytes carg0 = default; carg0.Append(arg0);
10971 FixedString32Bytes carg1 = default; carg1.Append(arg1);
10972 FixedString32Bytes carg2 = default; carg2.Append(arg2);
10973
10974
10975 result.AppendFormat(formatString, carg0, carg1, carg2);
10976 return result;
10977 }
10978
10979 /// <summary>
10980 /// Returns a new string produced by interpolating a format string.
10981 /// </summary>
10982 /// <remarks>
10983 /// Similar to StringBuilder.AppendFormat but with significant limitations:
10984 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
10985 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
10986 ///
10987 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
10988 /// - FixedString*N*Bytes
10989 /// - string
10990 /// - int
10991 /// - float
10992 /// - structs implementing INativeList<byte> and IUTF8Bytes
10993 ///
10994 /// <seealso cref="FixedStringMethods.AppendFormat"/>
10995 /// </remarks>
10996 /// <param name="formatString">The format string.</param>
10997 /// <typeparam name="T1"><undoc /></typeparam>
10998
10999 /// <param name="arg0">Value to interpolate into the format string.</param>
11000 /// <param name="arg1">Value to interpolate into the format string.</param>
11001 /// <param name="arg2">Value to interpolate into the format string.</param>
11002 /// <returns>A new string produced by interpolating the format string.</returns>
11003 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
11004 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, float arg2)
11005 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11006
11007 {
11008 FixedString128Bytes result = default;
11009 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11010 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11011
11012
11013 result.AppendFormat(formatString, arg0, carg1, carg2);
11014 return result;
11015 }
11016
11017 /// <summary>
11018 /// Returns a new string produced by interpolating a format string.
11019 /// </summary>
11020 /// <remarks>
11021 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11022 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11023 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11024 ///
11025 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11026 /// - FixedString*N*Bytes
11027 /// - string
11028 /// - int
11029 /// - float
11030 /// - structs implementing INativeList<byte> and IUTF8Bytes
11031 ///
11032 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11033 /// </remarks>
11034 /// <param name="formatString">The format string.</param>
11035
11036 /// <param name="arg0">Value to interpolate into the format string.</param>
11037 /// <param name="arg1">Value to interpolate into the format string.</param>
11038 /// <param name="arg2">Value to interpolate into the format string.</param>
11039 /// <returns>A new string produced by interpolating the format string.</returns>
11040
11041 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, float arg2)
11042
11043 {
11044 FixedString128Bytes result = default;
11045 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11046 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11047 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11048
11049
11050 result.AppendFormat(formatString, carg0, carg1, carg2);
11051 return result;
11052 }
11053
11054 /// <summary>
11055 /// Returns a new string produced by interpolating a format string.
11056 /// </summary>
11057 /// <remarks>
11058 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11059 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11060 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11061 ///
11062 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11063 /// - FixedString*N*Bytes
11064 /// - string
11065 /// - int
11066 /// - float
11067 /// - structs implementing INativeList<byte> and IUTF8Bytes
11068 ///
11069 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11070 /// </remarks>
11071 /// <param name="formatString">The format string.</param>
11072
11073 /// <param name="arg0">Value to interpolate into the format string.</param>
11074 /// <param name="arg1">Value to interpolate into the format string.</param>
11075 /// <param name="arg2">Value to interpolate into the format string.</param>
11076 /// <returns>A new string produced by interpolating the format string.</returns>
11077
11078 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, float arg2)
11079
11080 {
11081 FixedString128Bytes result = default;
11082 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11083 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11084 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11085
11086
11087 result.AppendFormat(formatString, carg0, carg1, carg2);
11088 return result;
11089 }
11090
11091 /// <summary>
11092 /// Returns a new string produced by interpolating a format string.
11093 /// </summary>
11094 /// <remarks>
11095 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11096 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11097 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11098 ///
11099 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11100 /// - FixedString*N*Bytes
11101 /// - string
11102 /// - int
11103 /// - float
11104 /// - structs implementing INativeList<byte> and IUTF8Bytes
11105 ///
11106 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11107 /// </remarks>
11108 /// <param name="formatString">The format string.</param>
11109
11110 /// <param name="arg0">Value to interpolate into the format string.</param>
11111 /// <param name="arg1">Value to interpolate into the format string.</param>
11112 /// <param name="arg2">Value to interpolate into the format string.</param>
11113 /// <returns>A new string produced by interpolating the format string.</returns>
11114 [ExcludeFromBurstCompatTesting("Takes managed string")]
11115 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, float arg2)
11116
11117 {
11118 FixedString128Bytes result = default;
11119 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11120 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11121 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11122
11123
11124 result.AppendFormat(formatString, carg0, carg1, carg2);
11125 return result;
11126 }
11127
11128 /// <summary>
11129 /// Returns a new string produced by interpolating a format string.
11130 /// </summary>
11131 /// <remarks>
11132 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11133 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11134 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11135 ///
11136 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11137 /// - FixedString*N*Bytes
11138 /// - string
11139 /// - int
11140 /// - float
11141 /// - structs implementing INativeList<byte> and IUTF8Bytes
11142 ///
11143 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11144 /// </remarks>
11145 /// <param name="formatString">The format string.</param>
11146 /// <typeparam name="T1"><undoc /></typeparam>
11147
11148 /// <param name="arg0">Value to interpolate into the format string.</param>
11149 /// <param name="arg1">Value to interpolate into the format string.</param>
11150 /// <param name="arg2">Value to interpolate into the format string.</param>
11151 /// <returns>A new string produced by interpolating the format string.</returns>
11152 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
11153 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, float arg2)
11154 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11155
11156 {
11157 FixedString128Bytes result = default;
11158 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11159 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11160
11161
11162 result.AppendFormat(formatString, arg0, carg1, carg2);
11163 return result;
11164 }
11165
11166 /// <summary>
11167 /// Returns a new string produced by interpolating a format string.
11168 /// </summary>
11169 /// <remarks>
11170 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11171 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11172 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11173 ///
11174 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11175 /// - FixedString*N*Bytes
11176 /// - string
11177 /// - int
11178 /// - float
11179 /// - structs implementing INativeList<byte> and IUTF8Bytes
11180 ///
11181 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11182 /// </remarks>
11183 /// <param name="formatString">The format string.</param>
11184
11185 /// <param name="arg0">Value to interpolate into the format string.</param>
11186 /// <param name="arg1">Value to interpolate into the format string.</param>
11187 /// <param name="arg2">Value to interpolate into the format string.</param>
11188 /// <returns>A new string produced by interpolating the format string.</returns>
11189 [ExcludeFromBurstCompatTesting("Takes managed string")]
11190 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, float arg2)
11191
11192 {
11193 FixedString128Bytes result = default;
11194 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11195 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11196 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11197
11198
11199 result.AppendFormat(formatString, carg0, carg1, carg2);
11200 return result;
11201 }
11202
11203 /// <summary>
11204 /// Returns a new string produced by interpolating a format string.
11205 /// </summary>
11206 /// <remarks>
11207 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11208 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11209 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11210 ///
11211 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11212 /// - FixedString*N*Bytes
11213 /// - string
11214 /// - int
11215 /// - float
11216 /// - structs implementing INativeList<byte> and IUTF8Bytes
11217 ///
11218 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11219 /// </remarks>
11220 /// <param name="formatString">The format string.</param>
11221
11222 /// <param name="arg0">Value to interpolate into the format string.</param>
11223 /// <param name="arg1">Value to interpolate into the format string.</param>
11224 /// <param name="arg2">Value to interpolate into the format string.</param>
11225 /// <returns>A new string produced by interpolating the format string.</returns>
11226 [ExcludeFromBurstCompatTesting("Takes managed string")]
11227 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, float arg2)
11228
11229 {
11230 FixedString128Bytes result = default;
11231 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11232 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11233 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11234
11235
11236 result.AppendFormat(formatString, carg0, carg1, carg2);
11237 return result;
11238 }
11239
11240 /// <summary>
11241 /// Returns a new string produced by interpolating a format string.
11242 /// </summary>
11243 /// <remarks>
11244 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11245 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11246 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11247 ///
11248 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11249 /// - FixedString*N*Bytes
11250 /// - string
11251 /// - int
11252 /// - float
11253 /// - structs implementing INativeList<byte> and IUTF8Bytes
11254 ///
11255 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11256 /// </remarks>
11257 /// <param name="formatString">The format string.</param>
11258
11259 /// <param name="arg0">Value to interpolate into the format string.</param>
11260 /// <param name="arg1">Value to interpolate into the format string.</param>
11261 /// <param name="arg2">Value to interpolate into the format string.</param>
11262 /// <returns>A new string produced by interpolating the format string.</returns>
11263 [ExcludeFromBurstCompatTesting("Takes managed string")]
11264 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, float arg2)
11265
11266 {
11267 FixedString128Bytes result = default;
11268 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11269 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11270 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11271
11272
11273 result.AppendFormat(formatString, carg0, carg1, carg2);
11274 return result;
11275 }
11276
11277 /// <summary>
11278 /// Returns a new string produced by interpolating a format string.
11279 /// </summary>
11280 /// <remarks>
11281 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11282 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11283 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11284 ///
11285 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11286 /// - FixedString*N*Bytes
11287 /// - string
11288 /// - int
11289 /// - float
11290 /// - structs implementing INativeList<byte> and IUTF8Bytes
11291 ///
11292 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11293 /// </remarks>
11294 /// <param name="formatString">The format string.</param>
11295 /// <typeparam name="T1"><undoc /></typeparam>
11296
11297 /// <param name="arg0">Value to interpolate into the format string.</param>
11298 /// <param name="arg1">Value to interpolate into the format string.</param>
11299 /// <param name="arg2">Value to interpolate into the format string.</param>
11300 /// <returns>A new string produced by interpolating the format string.</returns>
11301 [ExcludeFromBurstCompatTesting("Takes managed string")]
11302 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, float arg2)
11303 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11304
11305 {
11306 FixedString128Bytes result = default;
11307 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11308 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11309
11310
11311 result.AppendFormat(formatString, arg0, carg1, carg2);
11312 return result;
11313 }
11314
11315 /// <summary>
11316 /// Returns a new string produced by interpolating a format string.
11317 /// </summary>
11318 /// <remarks>
11319 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11320 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11321 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11322 ///
11323 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11324 /// - FixedString*N*Bytes
11325 /// - string
11326 /// - int
11327 /// - float
11328 /// - structs implementing INativeList<byte> and IUTF8Bytes
11329 ///
11330 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11331 /// </remarks>
11332 /// <param name="formatString">The format string.</param>
11333 /// <typeparam name="T1"><undoc /></typeparam>
11334
11335 /// <param name="arg0">Value to interpolate into the format string.</param>
11336 /// <param name="arg1">Value to interpolate into the format string.</param>
11337 /// <param name="arg2">Value to interpolate into the format string.</param>
11338 /// <returns>A new string produced by interpolating the format string.</returns>
11339 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
11340 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, float arg2)
11341 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11342
11343 {
11344 FixedString128Bytes result = default;
11345 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11346 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11347
11348
11349 result.AppendFormat(formatString, carg0, arg1, carg2);
11350 return result;
11351 }
11352
11353 /// <summary>
11354 /// Returns a new string produced by interpolating a format string.
11355 /// </summary>
11356 /// <remarks>
11357 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11358 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11359 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11360 ///
11361 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11362 /// - FixedString*N*Bytes
11363 /// - string
11364 /// - int
11365 /// - float
11366 /// - structs implementing INativeList<byte> and IUTF8Bytes
11367 ///
11368 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11369 /// </remarks>
11370 /// <param name="formatString">The format string.</param>
11371 /// <typeparam name="T1"><undoc /></typeparam>
11372
11373 /// <param name="arg0">Value to interpolate into the format string.</param>
11374 /// <param name="arg1">Value to interpolate into the format string.</param>
11375 /// <param name="arg2">Value to interpolate into the format string.</param>
11376 /// <returns>A new string produced by interpolating the format string.</returns>
11377 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
11378 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, float arg2)
11379 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11380
11381 {
11382 FixedString128Bytes result = default;
11383 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11384 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11385
11386
11387 result.AppendFormat(formatString, carg0, arg1, carg2);
11388 return result;
11389 }
11390
11391 /// <summary>
11392 /// Returns a new string produced by interpolating a format string.
11393 /// </summary>
11394 /// <remarks>
11395 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11396 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11397 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11398 ///
11399 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11400 /// - FixedString*N*Bytes
11401 /// - string
11402 /// - int
11403 /// - float
11404 /// - structs implementing INativeList<byte> and IUTF8Bytes
11405 ///
11406 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11407 /// </remarks>
11408 /// <param name="formatString">The format string.</param>
11409 /// <typeparam name="T1"><undoc /></typeparam>
11410
11411 /// <param name="arg0">Value to interpolate into the format string.</param>
11412 /// <param name="arg1">Value to interpolate into the format string.</param>
11413 /// <param name="arg2">Value to interpolate into the format string.</param>
11414 /// <returns>A new string produced by interpolating the format string.</returns>
11415 [ExcludeFromBurstCompatTesting("Takes managed string")]
11416 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, float arg2)
11417 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11418
11419 {
11420 FixedString128Bytes result = default;
11421 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11422 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11423
11424
11425 result.AppendFormat(formatString, carg0, arg1, carg2);
11426 return result;
11427 }
11428
11429 /// <summary>
11430 /// Returns a new string produced by interpolating a format string.
11431 /// </summary>
11432 /// <remarks>
11433 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11434 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11435 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11436 ///
11437 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11438 /// - FixedString*N*Bytes
11439 /// - string
11440 /// - int
11441 /// - float
11442 /// - structs implementing INativeList<byte> and IUTF8Bytes
11443 ///
11444 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11445 /// </remarks>
11446 /// <param name="formatString">The format string.</param>
11447 /// <typeparam name="T1"><undoc /></typeparam>
11448 /// <typeparam name="T2"><undoc /></typeparam>
11449
11450 /// <param name="arg0">Value to interpolate into the format string.</param>
11451 /// <param name="arg1">Value to interpolate into the format string.</param>
11452 /// <param name="arg2">Value to interpolate into the format string.</param>
11453 /// <returns>A new string produced by interpolating the format string.</returns>
11454 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
11455 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, float arg2)
11456 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11457 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
11458
11459 {
11460 FixedString128Bytes result = default;
11461 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11462
11463
11464 result.AppendFormat(formatString, arg0, arg1, carg2);
11465 return result;
11466 }
11467
11468 /// <summary>
11469 /// Returns a new string produced by interpolating a format string.
11470 /// </summary>
11471 /// <remarks>
11472 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11473 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11474 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11475 ///
11476 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11477 /// - FixedString*N*Bytes
11478 /// - string
11479 /// - int
11480 /// - float
11481 /// - structs implementing INativeList<byte> and IUTF8Bytes
11482 ///
11483 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11484 /// </remarks>
11485 /// <param name="formatString">The format string.</param>
11486
11487 /// <param name="arg0">Value to interpolate into the format string.</param>
11488 /// <param name="arg1">Value to interpolate into the format string.</param>
11489 /// <param name="arg2">Value to interpolate into the format string.</param>
11490 /// <returns>A new string produced by interpolating the format string.</returns>
11491 [ExcludeFromBurstCompatTesting("Takes managed string")]
11492 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1, string arg2)
11493
11494 {
11495 FixedString128Bytes result = default;
11496 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11497 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11498 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11499
11500
11501 result.AppendFormat(formatString, carg0, carg1, carg2);
11502 return result;
11503 }
11504
11505 /// <summary>
11506 /// Returns a new string produced by interpolating a format string.
11507 /// </summary>
11508 /// <remarks>
11509 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11510 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11511 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11512 ///
11513 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11514 /// - FixedString*N*Bytes
11515 /// - string
11516 /// - int
11517 /// - float
11518 /// - structs implementing INativeList<byte> and IUTF8Bytes
11519 ///
11520 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11521 /// </remarks>
11522 /// <param name="formatString">The format string.</param>
11523
11524 /// <param name="arg0">Value to interpolate into the format string.</param>
11525 /// <param name="arg1">Value to interpolate into the format string.</param>
11526 /// <param name="arg2">Value to interpolate into the format string.</param>
11527 /// <returns>A new string produced by interpolating the format string.</returns>
11528 [ExcludeFromBurstCompatTesting("Takes managed string")]
11529 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1, string arg2)
11530
11531 {
11532 FixedString128Bytes result = default;
11533 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11534 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11535 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11536
11537
11538 result.AppendFormat(formatString, carg0, carg1, carg2);
11539 return result;
11540 }
11541
11542 /// <summary>
11543 /// Returns a new string produced by interpolating a format string.
11544 /// </summary>
11545 /// <remarks>
11546 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11547 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11548 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11549 ///
11550 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11551 /// - FixedString*N*Bytes
11552 /// - string
11553 /// - int
11554 /// - float
11555 /// - structs implementing INativeList<byte> and IUTF8Bytes
11556 ///
11557 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11558 /// </remarks>
11559 /// <param name="formatString">The format string.</param>
11560
11561 /// <param name="arg0">Value to interpolate into the format string.</param>
11562 /// <param name="arg1">Value to interpolate into the format string.</param>
11563 /// <param name="arg2">Value to interpolate into the format string.</param>
11564 /// <returns>A new string produced by interpolating the format string.</returns>
11565 [ExcludeFromBurstCompatTesting("Takes managed string")]
11566 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1, string arg2)
11567
11568 {
11569 FixedString128Bytes result = default;
11570 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11571 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11572 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11573
11574
11575 result.AppendFormat(formatString, carg0, carg1, carg2);
11576 return result;
11577 }
11578
11579 /// <summary>
11580 /// Returns a new string produced by interpolating a format string.
11581 /// </summary>
11582 /// <remarks>
11583 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11584 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11585 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11586 ///
11587 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11588 /// - FixedString*N*Bytes
11589 /// - string
11590 /// - int
11591 /// - float
11592 /// - structs implementing INativeList<byte> and IUTF8Bytes
11593 ///
11594 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11595 /// </remarks>
11596 /// <param name="formatString">The format string.</param>
11597 /// <typeparam name="T1"><undoc /></typeparam>
11598
11599 /// <param name="arg0">Value to interpolate into the format string.</param>
11600 /// <param name="arg1">Value to interpolate into the format string.</param>
11601 /// <param name="arg2">Value to interpolate into the format string.</param>
11602 /// <returns>A new string produced by interpolating the format string.</returns>
11603 [ExcludeFromBurstCompatTesting("Takes managed string")]
11604 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1, string arg2)
11605 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11606
11607 {
11608 FixedString128Bytes result = default;
11609 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11610 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11611
11612
11613 result.AppendFormat(formatString, arg0, carg1, carg2);
11614 return result;
11615 }
11616
11617 /// <summary>
11618 /// Returns a new string produced by interpolating a format string.
11619 /// </summary>
11620 /// <remarks>
11621 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11622 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11623 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11624 ///
11625 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11626 /// - FixedString*N*Bytes
11627 /// - string
11628 /// - int
11629 /// - float
11630 /// - structs implementing INativeList<byte> and IUTF8Bytes
11631 ///
11632 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11633 /// </remarks>
11634 /// <param name="formatString">The format string.</param>
11635
11636 /// <param name="arg0">Value to interpolate into the format string.</param>
11637 /// <param name="arg1">Value to interpolate into the format string.</param>
11638 /// <param name="arg2">Value to interpolate into the format string.</param>
11639 /// <returns>A new string produced by interpolating the format string.</returns>
11640 [ExcludeFromBurstCompatTesting("Takes managed string")]
11641 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1, string arg2)
11642
11643 {
11644 FixedString128Bytes result = default;
11645 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11646 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11647 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11648
11649
11650 result.AppendFormat(formatString, carg0, carg1, carg2);
11651 return result;
11652 }
11653
11654 /// <summary>
11655 /// Returns a new string produced by interpolating a format string.
11656 /// </summary>
11657 /// <remarks>
11658 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11659 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11660 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11661 ///
11662 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11663 /// - FixedString*N*Bytes
11664 /// - string
11665 /// - int
11666 /// - float
11667 /// - structs implementing INativeList<byte> and IUTF8Bytes
11668 ///
11669 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11670 /// </remarks>
11671 /// <param name="formatString">The format string.</param>
11672
11673 /// <param name="arg0">Value to interpolate into the format string.</param>
11674 /// <param name="arg1">Value to interpolate into the format string.</param>
11675 /// <param name="arg2">Value to interpolate into the format string.</param>
11676 /// <returns>A new string produced by interpolating the format string.</returns>
11677 [ExcludeFromBurstCompatTesting("Takes managed string")]
11678 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1, string arg2)
11679
11680 {
11681 FixedString128Bytes result = default;
11682 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11683 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11684 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11685
11686
11687 result.AppendFormat(formatString, carg0, carg1, carg2);
11688 return result;
11689 }
11690
11691 /// <summary>
11692 /// Returns a new string produced by interpolating a format string.
11693 /// </summary>
11694 /// <remarks>
11695 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11696 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11697 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11698 ///
11699 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11700 /// - FixedString*N*Bytes
11701 /// - string
11702 /// - int
11703 /// - float
11704 /// - structs implementing INativeList<byte> and IUTF8Bytes
11705 ///
11706 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11707 /// </remarks>
11708 /// <param name="formatString">The format string.</param>
11709
11710 /// <param name="arg0">Value to interpolate into the format string.</param>
11711 /// <param name="arg1">Value to interpolate into the format string.</param>
11712 /// <param name="arg2">Value to interpolate into the format string.</param>
11713 /// <returns>A new string produced by interpolating the format string.</returns>
11714 [ExcludeFromBurstCompatTesting("Takes managed string")]
11715 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1, string arg2)
11716
11717 {
11718 FixedString128Bytes result = default;
11719 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11720 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11721 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11722
11723
11724 result.AppendFormat(formatString, carg0, carg1, carg2);
11725 return result;
11726 }
11727
11728 /// <summary>
11729 /// Returns a new string produced by interpolating a format string.
11730 /// </summary>
11731 /// <remarks>
11732 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11733 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11734 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11735 ///
11736 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11737 /// - FixedString*N*Bytes
11738 /// - string
11739 /// - int
11740 /// - float
11741 /// - structs implementing INativeList<byte> and IUTF8Bytes
11742 ///
11743 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11744 /// </remarks>
11745 /// <param name="formatString">The format string.</param>
11746 /// <typeparam name="T1"><undoc /></typeparam>
11747
11748 /// <param name="arg0">Value to interpolate into the format string.</param>
11749 /// <param name="arg1">Value to interpolate into the format string.</param>
11750 /// <param name="arg2">Value to interpolate into the format string.</param>
11751 /// <returns>A new string produced by interpolating the format string.</returns>
11752 [ExcludeFromBurstCompatTesting("Takes managed string")]
11753 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1, string arg2)
11754 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11755
11756 {
11757 FixedString128Bytes result = default;
11758 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11759 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11760
11761
11762 result.AppendFormat(formatString, arg0, carg1, carg2);
11763 return result;
11764 }
11765
11766 /// <summary>
11767 /// Returns a new string produced by interpolating a format string.
11768 /// </summary>
11769 /// <remarks>
11770 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11771 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11772 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11773 ///
11774 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11775 /// - FixedString*N*Bytes
11776 /// - string
11777 /// - int
11778 /// - float
11779 /// - structs implementing INativeList<byte> and IUTF8Bytes
11780 ///
11781 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11782 /// </remarks>
11783 /// <param name="formatString">The format string.</param>
11784
11785 /// <param name="arg0">Value to interpolate into the format string.</param>
11786 /// <param name="arg1">Value to interpolate into the format string.</param>
11787 /// <param name="arg2">Value to interpolate into the format string.</param>
11788 /// <returns>A new string produced by interpolating the format string.</returns>
11789 [ExcludeFromBurstCompatTesting("Takes managed string")]
11790 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1, string arg2)
11791
11792 {
11793 FixedString128Bytes result = default;
11794 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11795 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11796 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11797
11798
11799 result.AppendFormat(formatString, carg0, carg1, carg2);
11800 return result;
11801 }
11802
11803 /// <summary>
11804 /// Returns a new string produced by interpolating a format string.
11805 /// </summary>
11806 /// <remarks>
11807 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11808 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11809 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11810 ///
11811 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11812 /// - FixedString*N*Bytes
11813 /// - string
11814 /// - int
11815 /// - float
11816 /// - structs implementing INativeList<byte> and IUTF8Bytes
11817 ///
11818 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11819 /// </remarks>
11820 /// <param name="formatString">The format string.</param>
11821
11822 /// <param name="arg0">Value to interpolate into the format string.</param>
11823 /// <param name="arg1">Value to interpolate into the format string.</param>
11824 /// <param name="arg2">Value to interpolate into the format string.</param>
11825 /// <returns>A new string produced by interpolating the format string.</returns>
11826 [ExcludeFromBurstCompatTesting("Takes managed string")]
11827 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1, string arg2)
11828
11829 {
11830 FixedString128Bytes result = default;
11831 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11832 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11833 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11834
11835
11836 result.AppendFormat(formatString, carg0, carg1, carg2);
11837 return result;
11838 }
11839
11840 /// <summary>
11841 /// Returns a new string produced by interpolating a format string.
11842 /// </summary>
11843 /// <remarks>
11844 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11845 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11846 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11847 ///
11848 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11849 /// - FixedString*N*Bytes
11850 /// - string
11851 /// - int
11852 /// - float
11853 /// - structs implementing INativeList<byte> and IUTF8Bytes
11854 ///
11855 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11856 /// </remarks>
11857 /// <param name="formatString">The format string.</param>
11858
11859 /// <param name="arg0">Value to interpolate into the format string.</param>
11860 /// <param name="arg1">Value to interpolate into the format string.</param>
11861 /// <param name="arg2">Value to interpolate into the format string.</param>
11862 /// <returns>A new string produced by interpolating the format string.</returns>
11863 [ExcludeFromBurstCompatTesting("Takes managed string")]
11864 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1, string arg2)
11865
11866 {
11867 FixedString128Bytes result = default;
11868 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11869 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11870 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11871
11872
11873 result.AppendFormat(formatString, carg0, carg1, carg2);
11874 return result;
11875 }
11876
11877 /// <summary>
11878 /// Returns a new string produced by interpolating a format string.
11879 /// </summary>
11880 /// <remarks>
11881 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11882 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11883 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11884 ///
11885 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11886 /// - FixedString*N*Bytes
11887 /// - string
11888 /// - int
11889 /// - float
11890 /// - structs implementing INativeList<byte> and IUTF8Bytes
11891 ///
11892 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11893 /// </remarks>
11894 /// <param name="formatString">The format string.</param>
11895 /// <typeparam name="T1"><undoc /></typeparam>
11896
11897 /// <param name="arg0">Value to interpolate into the format string.</param>
11898 /// <param name="arg1">Value to interpolate into the format string.</param>
11899 /// <param name="arg2">Value to interpolate into the format string.</param>
11900 /// <returns>A new string produced by interpolating the format string.</returns>
11901 [ExcludeFromBurstCompatTesting("Takes managed string")]
11902 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1, string arg2)
11903 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11904
11905 {
11906 FixedString128Bytes result = default;
11907 FixedString32Bytes carg1 = default; carg1.Append(arg1);
11908 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11909
11910
11911 result.AppendFormat(formatString, arg0, carg1, carg2);
11912 return result;
11913 }
11914
11915 /// <summary>
11916 /// Returns a new string produced by interpolating a format string.
11917 /// </summary>
11918 /// <remarks>
11919 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11920 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11921 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11922 ///
11923 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11924 /// - FixedString*N*Bytes
11925 /// - string
11926 /// - int
11927 /// - float
11928 /// - structs implementing INativeList<byte> and IUTF8Bytes
11929 ///
11930 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11931 /// </remarks>
11932 /// <param name="formatString">The format string.</param>
11933 /// <typeparam name="T1"><undoc /></typeparam>
11934
11935 /// <param name="arg0">Value to interpolate into the format string.</param>
11936 /// <param name="arg1">Value to interpolate into the format string.</param>
11937 /// <param name="arg2">Value to interpolate into the format string.</param>
11938 /// <returns>A new string produced by interpolating the format string.</returns>
11939 [ExcludeFromBurstCompatTesting("Takes managed string")]
11940 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1, string arg2)
11941 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11942
11943 {
11944 FixedString128Bytes result = default;
11945 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11946 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11947
11948
11949 result.AppendFormat(formatString, carg0, arg1, carg2);
11950 return result;
11951 }
11952
11953 /// <summary>
11954 /// Returns a new string produced by interpolating a format string.
11955 /// </summary>
11956 /// <remarks>
11957 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11958 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11959 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11960 ///
11961 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
11962 /// - FixedString*N*Bytes
11963 /// - string
11964 /// - int
11965 /// - float
11966 /// - structs implementing INativeList<byte> and IUTF8Bytes
11967 ///
11968 /// <seealso cref="FixedStringMethods.AppendFormat"/>
11969 /// </remarks>
11970 /// <param name="formatString">The format string.</param>
11971 /// <typeparam name="T1"><undoc /></typeparam>
11972
11973 /// <param name="arg0">Value to interpolate into the format string.</param>
11974 /// <param name="arg1">Value to interpolate into the format string.</param>
11975 /// <param name="arg2">Value to interpolate into the format string.</param>
11976 /// <returns>A new string produced by interpolating the format string.</returns>
11977 [ExcludeFromBurstCompatTesting("Takes managed string")]
11978 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1, string arg2)
11979 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
11980
11981 {
11982 FixedString128Bytes result = default;
11983 FixedString32Bytes carg0 = default; carg0.Append(arg0);
11984 FixedString32Bytes carg2 = default; carg2.Append(arg2);
11985
11986
11987 result.AppendFormat(formatString, carg0, arg1, carg2);
11988 return result;
11989 }
11990
11991 /// <summary>
11992 /// Returns a new string produced by interpolating a format string.
11993 /// </summary>
11994 /// <remarks>
11995 /// Similar to StringBuilder.AppendFormat but with significant limitations:
11996 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
11997 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
11998 ///
11999 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12000 /// - FixedString*N*Bytes
12001 /// - string
12002 /// - int
12003 /// - float
12004 /// - structs implementing INativeList<byte> and IUTF8Bytes
12005 ///
12006 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12007 /// </remarks>
12008 /// <param name="formatString">The format string.</param>
12009 /// <typeparam name="T1"><undoc /></typeparam>
12010
12011 /// <param name="arg0">Value to interpolate into the format string.</param>
12012 /// <param name="arg1">Value to interpolate into the format string.</param>
12013 /// <param name="arg2">Value to interpolate into the format string.</param>
12014 /// <returns>A new string produced by interpolating the format string.</returns>
12015 [ExcludeFromBurstCompatTesting("Takes managed string")]
12016 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1, string arg2)
12017 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12018
12019 {
12020 FixedString128Bytes result = default;
12021 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12022 FixedString32Bytes carg2 = default; carg2.Append(arg2);
12023
12024
12025 result.AppendFormat(formatString, carg0, arg1, carg2);
12026 return result;
12027 }
12028
12029 /// <summary>
12030 /// Returns a new string produced by interpolating a format string.
12031 /// </summary>
12032 /// <remarks>
12033 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12034 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12035 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12036 ///
12037 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12038 /// - FixedString*N*Bytes
12039 /// - string
12040 /// - int
12041 /// - float
12042 /// - structs implementing INativeList<byte> and IUTF8Bytes
12043 ///
12044 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12045 /// </remarks>
12046 /// <param name="formatString">The format string.</param>
12047 /// <typeparam name="T1"><undoc /></typeparam>
12048 /// <typeparam name="T2"><undoc /></typeparam>
12049
12050 /// <param name="arg0">Value to interpolate into the format string.</param>
12051 /// <param name="arg1">Value to interpolate into the format string.</param>
12052 /// <param name="arg2">Value to interpolate into the format string.</param>
12053 /// <returns>A new string produced by interpolating the format string.</returns>
12054 [ExcludeFromBurstCompatTesting("Takes managed string")]
12055 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1, string arg2)
12056 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12057 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12058
12059 {
12060 FixedString128Bytes result = default;
12061 FixedString32Bytes carg2 = default; carg2.Append(arg2);
12062
12063
12064 result.AppendFormat(formatString, arg0, arg1, carg2);
12065 return result;
12066 }
12067
12068 /// <summary>
12069 /// Returns a new string produced by interpolating a format string.
12070 /// </summary>
12071 /// <remarks>
12072 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12073 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12074 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12075 ///
12076 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12077 /// - FixedString*N*Bytes
12078 /// - string
12079 /// - int
12080 /// - float
12081 /// - structs implementing INativeList<byte> and IUTF8Bytes
12082 ///
12083 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12084 /// </remarks>
12085 /// <param name="formatString">The format string.</param>
12086 /// <typeparam name="T1"><undoc /></typeparam>
12087
12088 /// <param name="arg0">Value to interpolate into the format string.</param>
12089 /// <param name="arg1">Value to interpolate into the format string.</param>
12090 /// <param name="arg2">Value to interpolate into the format string.</param>
12091 /// <returns>A new string produced by interpolating the format string.</returns>
12092 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12093 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, int arg1, T1 arg2)
12094 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12095
12096 {
12097 FixedString128Bytes result = default;
12098 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12099 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12100
12101
12102 result.AppendFormat(formatString, carg0, carg1, arg2);
12103 return result;
12104 }
12105
12106 /// <summary>
12107 /// Returns a new string produced by interpolating a format string.
12108 /// </summary>
12109 /// <remarks>
12110 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12111 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12112 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12113 ///
12114 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12115 /// - FixedString*N*Bytes
12116 /// - string
12117 /// - int
12118 /// - float
12119 /// - structs implementing INativeList<byte> and IUTF8Bytes
12120 ///
12121 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12122 /// </remarks>
12123 /// <param name="formatString">The format string.</param>
12124 /// <typeparam name="T1"><undoc /></typeparam>
12125
12126 /// <param name="arg0">Value to interpolate into the format string.</param>
12127 /// <param name="arg1">Value to interpolate into the format string.</param>
12128 /// <param name="arg2">Value to interpolate into the format string.</param>
12129 /// <returns>A new string produced by interpolating the format string.</returns>
12130 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12131 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, int arg1, T1 arg2)
12132 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12133
12134 {
12135 FixedString128Bytes result = default;
12136 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12137 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12138
12139
12140 result.AppendFormat(formatString, carg0, carg1, arg2);
12141 return result;
12142 }
12143
12144 /// <summary>
12145 /// Returns a new string produced by interpolating a format string.
12146 /// </summary>
12147 /// <remarks>
12148 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12149 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12150 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12151 ///
12152 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12153 /// - FixedString*N*Bytes
12154 /// - string
12155 /// - int
12156 /// - float
12157 /// - structs implementing INativeList<byte> and IUTF8Bytes
12158 ///
12159 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12160 /// </remarks>
12161 /// <param name="formatString">The format string.</param>
12162 /// <typeparam name="T1"><undoc /></typeparam>
12163
12164 /// <param name="arg0">Value to interpolate into the format string.</param>
12165 /// <param name="arg1">Value to interpolate into the format string.</param>
12166 /// <param name="arg2">Value to interpolate into the format string.</param>
12167 /// <returns>A new string produced by interpolating the format string.</returns>
12168 [ExcludeFromBurstCompatTesting("Takes managed string")]
12169 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, int arg1, T1 arg2)
12170 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12171
12172 {
12173 FixedString128Bytes result = default;
12174 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12175 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12176
12177
12178 result.AppendFormat(formatString, carg0, carg1, arg2);
12179 return result;
12180 }
12181
12182 /// <summary>
12183 /// Returns a new string produced by interpolating a format string.
12184 /// </summary>
12185 /// <remarks>
12186 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12187 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12188 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12189 ///
12190 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12191 /// - FixedString*N*Bytes
12192 /// - string
12193 /// - int
12194 /// - float
12195 /// - structs implementing INativeList<byte> and IUTF8Bytes
12196 ///
12197 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12198 /// </remarks>
12199 /// <param name="formatString">The format string.</param>
12200 /// <typeparam name="T1"><undoc /></typeparam>
12201 /// <typeparam name="T2"><undoc /></typeparam>
12202
12203 /// <param name="arg0">Value to interpolate into the format string.</param>
12204 /// <param name="arg1">Value to interpolate into the format string.</param>
12205 /// <param name="arg2">Value to interpolate into the format string.</param>
12206 /// <returns>A new string produced by interpolating the format string.</returns>
12207 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
12208 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, int arg1, T2 arg2)
12209 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12210 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12211
12212 {
12213 FixedString128Bytes result = default;
12214 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12215
12216
12217 result.AppendFormat(formatString, arg0, carg1, arg2);
12218 return result;
12219 }
12220
12221 /// <summary>
12222 /// Returns a new string produced by interpolating a format string.
12223 /// </summary>
12224 /// <remarks>
12225 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12226 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12227 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12228 ///
12229 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12230 /// - FixedString*N*Bytes
12231 /// - string
12232 /// - int
12233 /// - float
12234 /// - structs implementing INativeList<byte> and IUTF8Bytes
12235 ///
12236 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12237 /// </remarks>
12238 /// <param name="formatString">The format string.</param>
12239 /// <typeparam name="T1"><undoc /></typeparam>
12240
12241 /// <param name="arg0">Value to interpolate into the format string.</param>
12242 /// <param name="arg1">Value to interpolate into the format string.</param>
12243 /// <param name="arg2">Value to interpolate into the format string.</param>
12244 /// <returns>A new string produced by interpolating the format string.</returns>
12245 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12246 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, float arg1, T1 arg2)
12247 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12248
12249 {
12250 FixedString128Bytes result = default;
12251 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12252 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12253
12254
12255 result.AppendFormat(formatString, carg0, carg1, arg2);
12256 return result;
12257 }
12258
12259 /// <summary>
12260 /// Returns a new string produced by interpolating a format string.
12261 /// </summary>
12262 /// <remarks>
12263 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12264 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12265 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12266 ///
12267 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12268 /// - FixedString*N*Bytes
12269 /// - string
12270 /// - int
12271 /// - float
12272 /// - structs implementing INativeList<byte> and IUTF8Bytes
12273 ///
12274 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12275 /// </remarks>
12276 /// <param name="formatString">The format string.</param>
12277 /// <typeparam name="T1"><undoc /></typeparam>
12278
12279 /// <param name="arg0">Value to interpolate into the format string.</param>
12280 /// <param name="arg1">Value to interpolate into the format string.</param>
12281 /// <param name="arg2">Value to interpolate into the format string.</param>
12282 /// <returns>A new string produced by interpolating the format string.</returns>
12283 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12284 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, float arg1, T1 arg2)
12285 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12286
12287 {
12288 FixedString128Bytes result = default;
12289 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12290 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12291
12292
12293 result.AppendFormat(formatString, carg0, carg1, arg2);
12294 return result;
12295 }
12296
12297 /// <summary>
12298 /// Returns a new string produced by interpolating a format string.
12299 /// </summary>
12300 /// <remarks>
12301 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12302 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12303 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12304 ///
12305 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12306 /// - FixedString*N*Bytes
12307 /// - string
12308 /// - int
12309 /// - float
12310 /// - structs implementing INativeList<byte> and IUTF8Bytes
12311 ///
12312 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12313 /// </remarks>
12314 /// <param name="formatString">The format string.</param>
12315 /// <typeparam name="T1"><undoc /></typeparam>
12316
12317 /// <param name="arg0">Value to interpolate into the format string.</param>
12318 /// <param name="arg1">Value to interpolate into the format string.</param>
12319 /// <param name="arg2">Value to interpolate into the format string.</param>
12320 /// <returns>A new string produced by interpolating the format string.</returns>
12321 [ExcludeFromBurstCompatTesting("Takes managed string")]
12322 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, float arg1, T1 arg2)
12323 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12324
12325 {
12326 FixedString128Bytes result = default;
12327 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12328 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12329
12330
12331 result.AppendFormat(formatString, carg0, carg1, arg2);
12332 return result;
12333 }
12334
12335 /// <summary>
12336 /// Returns a new string produced by interpolating a format string.
12337 /// </summary>
12338 /// <remarks>
12339 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12340 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12341 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12342 ///
12343 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12344 /// - FixedString*N*Bytes
12345 /// - string
12346 /// - int
12347 /// - float
12348 /// - structs implementing INativeList<byte> and IUTF8Bytes
12349 ///
12350 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12351 /// </remarks>
12352 /// <param name="formatString">The format string.</param>
12353 /// <typeparam name="T1"><undoc /></typeparam>
12354 /// <typeparam name="T2"><undoc /></typeparam>
12355
12356 /// <param name="arg0">Value to interpolate into the format string.</param>
12357 /// <param name="arg1">Value to interpolate into the format string.</param>
12358 /// <param name="arg2">Value to interpolate into the format string.</param>
12359 /// <returns>A new string produced by interpolating the format string.</returns>
12360 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
12361 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, float arg1, T2 arg2)
12362 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12363 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12364
12365 {
12366 FixedString128Bytes result = default;
12367 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12368
12369
12370 result.AppendFormat(formatString, arg0, carg1, arg2);
12371 return result;
12372 }
12373
12374 /// <summary>
12375 /// Returns a new string produced by interpolating a format string.
12376 /// </summary>
12377 /// <remarks>
12378 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12379 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12380 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12381 ///
12382 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12383 /// - FixedString*N*Bytes
12384 /// - string
12385 /// - int
12386 /// - float
12387 /// - structs implementing INativeList<byte> and IUTF8Bytes
12388 ///
12389 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12390 /// </remarks>
12391 /// <param name="formatString">The format string.</param>
12392 /// <typeparam name="T1"><undoc /></typeparam>
12393
12394 /// <param name="arg0">Value to interpolate into the format string.</param>
12395 /// <param name="arg1">Value to interpolate into the format string.</param>
12396 /// <param name="arg2">Value to interpolate into the format string.</param>
12397 /// <returns>A new string produced by interpolating the format string.</returns>
12398 [ExcludeFromBurstCompatTesting("Takes managed string")]
12399 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, string arg1, T1 arg2)
12400 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12401
12402 {
12403 FixedString128Bytes result = default;
12404 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12405 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12406
12407
12408 result.AppendFormat(formatString, carg0, carg1, arg2);
12409 return result;
12410 }
12411
12412 /// <summary>
12413 /// Returns a new string produced by interpolating a format string.
12414 /// </summary>
12415 /// <remarks>
12416 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12417 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12418 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12419 ///
12420 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12421 /// - FixedString*N*Bytes
12422 /// - string
12423 /// - int
12424 /// - float
12425 /// - structs implementing INativeList<byte> and IUTF8Bytes
12426 ///
12427 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12428 /// </remarks>
12429 /// <param name="formatString">The format string.</param>
12430 /// <typeparam name="T1"><undoc /></typeparam>
12431
12432 /// <param name="arg0">Value to interpolate into the format string.</param>
12433 /// <param name="arg1">Value to interpolate into the format string.</param>
12434 /// <param name="arg2">Value to interpolate into the format string.</param>
12435 /// <returns>A new string produced by interpolating the format string.</returns>
12436 [ExcludeFromBurstCompatTesting("Takes managed string")]
12437 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, string arg1, T1 arg2)
12438 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12439
12440 {
12441 FixedString128Bytes result = default;
12442 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12443 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12444
12445
12446 result.AppendFormat(formatString, carg0, carg1, arg2);
12447 return result;
12448 }
12449
12450 /// <summary>
12451 /// Returns a new string produced by interpolating a format string.
12452 /// </summary>
12453 /// <remarks>
12454 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12455 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12456 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12457 ///
12458 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12459 /// - FixedString*N*Bytes
12460 /// - string
12461 /// - int
12462 /// - float
12463 /// - structs implementing INativeList<byte> and IUTF8Bytes
12464 ///
12465 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12466 /// </remarks>
12467 /// <param name="formatString">The format string.</param>
12468 /// <typeparam name="T1"><undoc /></typeparam>
12469
12470 /// <param name="arg0">Value to interpolate into the format string.</param>
12471 /// <param name="arg1">Value to interpolate into the format string.</param>
12472 /// <param name="arg2">Value to interpolate into the format string.</param>
12473 /// <returns>A new string produced by interpolating the format string.</returns>
12474 [ExcludeFromBurstCompatTesting("Takes managed string")]
12475 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, string arg1, T1 arg2)
12476 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12477
12478 {
12479 FixedString128Bytes result = default;
12480 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12481 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12482
12483
12484 result.AppendFormat(formatString, carg0, carg1, arg2);
12485 return result;
12486 }
12487
12488 /// <summary>
12489 /// Returns a new string produced by interpolating a format string.
12490 /// </summary>
12491 /// <remarks>
12492 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12493 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12494 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12495 ///
12496 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12497 /// - FixedString*N*Bytes
12498 /// - string
12499 /// - int
12500 /// - float
12501 /// - structs implementing INativeList<byte> and IUTF8Bytes
12502 ///
12503 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12504 /// </remarks>
12505 /// <param name="formatString">The format string.</param>
12506 /// <typeparam name="T1"><undoc /></typeparam>
12507 /// <typeparam name="T2"><undoc /></typeparam>
12508
12509 /// <param name="arg0">Value to interpolate into the format string.</param>
12510 /// <param name="arg1">Value to interpolate into the format string.</param>
12511 /// <param name="arg2">Value to interpolate into the format string.</param>
12512 /// <returns>A new string produced by interpolating the format string.</returns>
12513 [ExcludeFromBurstCompatTesting("Takes managed string")]
12514 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, string arg1, T2 arg2)
12515 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12516 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12517
12518 {
12519 FixedString128Bytes result = default;
12520 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12521
12522
12523 result.AppendFormat(formatString, arg0, carg1, arg2);
12524 return result;
12525 }
12526
12527 /// <summary>
12528 /// Returns a new string produced by interpolating a format string.
12529 /// </summary>
12530 /// <remarks>
12531 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12532 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12533 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12534 ///
12535 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12536 /// - FixedString*N*Bytes
12537 /// - string
12538 /// - int
12539 /// - float
12540 /// - structs implementing INativeList<byte> and IUTF8Bytes
12541 ///
12542 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12543 /// </remarks>
12544 /// <param name="formatString">The format string.</param>
12545 /// <typeparam name="T1"><undoc /></typeparam>
12546 /// <typeparam name="T2"><undoc /></typeparam>
12547
12548 /// <param name="arg0">Value to interpolate into the format string.</param>
12549 /// <param name="arg1">Value to interpolate into the format string.</param>
12550 /// <param name="arg2">Value to interpolate into the format string.</param>
12551 /// <returns>A new string produced by interpolating the format string.</returns>
12552 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
12553 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, int arg0, T1 arg1, T2 arg2)
12554 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12555 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12556
12557 {
12558 FixedString128Bytes result = default;
12559 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12560
12561
12562 result.AppendFormat(formatString, carg0, arg1, arg2);
12563 return result;
12564 }
12565
12566 /// <summary>
12567 /// Returns a new string produced by interpolating a format string.
12568 /// </summary>
12569 /// <remarks>
12570 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12571 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12572 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12573 ///
12574 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12575 /// - FixedString*N*Bytes
12576 /// - string
12577 /// - int
12578 /// - float
12579 /// - structs implementing INativeList<byte> and IUTF8Bytes
12580 ///
12581 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12582 /// </remarks>
12583 /// <param name="formatString">The format string.</param>
12584 /// <typeparam name="T1"><undoc /></typeparam>
12585 /// <typeparam name="T2"><undoc /></typeparam>
12586
12587 /// <param name="arg0">Value to interpolate into the format string.</param>
12588 /// <param name="arg1">Value to interpolate into the format string.</param>
12589 /// <param name="arg2">Value to interpolate into the format string.</param>
12590 /// <returns>A new string produced by interpolating the format string.</returns>
12591 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
12592 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, float arg0, T1 arg1, T2 arg2)
12593 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12594 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12595
12596 {
12597 FixedString128Bytes result = default;
12598 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12599
12600
12601 result.AppendFormat(formatString, carg0, arg1, arg2);
12602 return result;
12603 }
12604
12605 /// <summary>
12606 /// Returns a new string produced by interpolating a format string.
12607 /// </summary>
12608 /// <remarks>
12609 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12610 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12611 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12612 ///
12613 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12614 /// - FixedString*N*Bytes
12615 /// - string
12616 /// - int
12617 /// - float
12618 /// - structs implementing INativeList<byte> and IUTF8Bytes
12619 ///
12620 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12621 /// </remarks>
12622 /// <param name="formatString">The format string.</param>
12623 /// <typeparam name="T1"><undoc /></typeparam>
12624 /// <typeparam name="T2"><undoc /></typeparam>
12625
12626 /// <param name="arg0">Value to interpolate into the format string.</param>
12627 /// <param name="arg1">Value to interpolate into the format string.</param>
12628 /// <param name="arg2">Value to interpolate into the format string.</param>
12629 /// <returns>A new string produced by interpolating the format string.</returns>
12630 [ExcludeFromBurstCompatTesting("Takes managed string")]
12631 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, string arg0, T1 arg1, T2 arg2)
12632 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12633 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12634
12635 {
12636 FixedString128Bytes result = default;
12637 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12638
12639
12640 result.AppendFormat(formatString, carg0, arg1, arg2);
12641 return result;
12642 }
12643
12644 /// <summary>
12645 /// Returns a new string produced by interpolating a format string.
12646 /// </summary>
12647 /// <remarks>
12648 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12649 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12650 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12651 ///
12652 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12653 /// - FixedString*N*Bytes
12654 /// - string
12655 /// - int
12656 /// - float
12657 /// - structs implementing INativeList<byte> and IUTF8Bytes
12658 ///
12659 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12660 /// </remarks>
12661 /// <param name="formatString">The format string.</param>
12662 /// <typeparam name="T1"><undoc /></typeparam>
12663 /// <typeparam name="T2"><undoc /></typeparam>
12664 /// <typeparam name="T3"><undoc /></typeparam>
12665
12666 /// <param name="arg0">Value to interpolate into the format string.</param>
12667 /// <param name="arg1">Value to interpolate into the format string.</param>
12668 /// <param name="arg2">Value to interpolate into the format string.</param>
12669 /// <returns>A new string produced by interpolating the format string.</returns>
12670 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/), typeof(FixedString32Bytes /*$T3*/) } )]
12671 public static FixedString128Bytes Format<T1,T2,T3>(FixedString128Bytes formatString, T1 arg0, T2 arg1, T3 arg2)
12672 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12673 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
12674 where T3 : unmanaged, INativeList<byte>, IUTF8Bytes
12675
12676 {
12677 FixedString128Bytes result = default;
12678
12679
12680 result.AppendFormat(formatString, arg0, arg1, arg2);
12681 return result;
12682 }
12683
12684 /// <summary>
12685 /// Returns a new string produced by interpolating a format string.
12686 /// </summary>
12687 /// <remarks>
12688 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12689 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12690 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12691 ///
12692 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12693 /// - FixedString*N*Bytes
12694 /// - string
12695 /// - int
12696 /// - float
12697 /// - structs implementing INativeList<byte> and IUTF8Bytes
12698 ///
12699 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12700 /// </remarks>
12701 /// <param name="formatString">The format string.</param>
12702
12703 /// <param name="arg0">Value to interpolate into the format string.</param>
12704 /// <param name="arg1">Value to interpolate into the format string.</param>
12705 /// <returns>A new string produced by interpolating the format string.</returns>
12706
12707 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, int arg1)
12708
12709 {
12710 FixedString128Bytes result = default;
12711 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12712 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12713
12714
12715 result.AppendFormat(formatString, carg0, carg1);
12716 return result;
12717 }
12718
12719 /// <summary>
12720 /// Returns a new string produced by interpolating a format string.
12721 /// </summary>
12722 /// <remarks>
12723 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12724 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12725 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12726 ///
12727 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12728 /// - FixedString*N*Bytes
12729 /// - string
12730 /// - int
12731 /// - float
12732 /// - structs implementing INativeList<byte> and IUTF8Bytes
12733 ///
12734 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12735 /// </remarks>
12736 /// <param name="formatString">The format string.</param>
12737
12738 /// <param name="arg0">Value to interpolate into the format string.</param>
12739 /// <param name="arg1">Value to interpolate into the format string.</param>
12740 /// <returns>A new string produced by interpolating the format string.</returns>
12741
12742 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, int arg1)
12743
12744 {
12745 FixedString128Bytes result = default;
12746 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12747 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12748
12749
12750 result.AppendFormat(formatString, carg0, carg1);
12751 return result;
12752 }
12753
12754 /// <summary>
12755 /// Returns a new string produced by interpolating a format string.
12756 /// </summary>
12757 /// <remarks>
12758 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12759 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12760 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12761 ///
12762 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12763 /// - FixedString*N*Bytes
12764 /// - string
12765 /// - int
12766 /// - float
12767 /// - structs implementing INativeList<byte> and IUTF8Bytes
12768 ///
12769 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12770 /// </remarks>
12771 /// <param name="formatString">The format string.</param>
12772
12773 /// <param name="arg0">Value to interpolate into the format string.</param>
12774 /// <param name="arg1">Value to interpolate into the format string.</param>
12775 /// <returns>A new string produced by interpolating the format string.</returns>
12776 [ExcludeFromBurstCompatTesting("Takes managed string")]
12777 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, int arg1)
12778
12779 {
12780 FixedString128Bytes result = default;
12781 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12782 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12783
12784
12785 result.AppendFormat(formatString, carg0, carg1);
12786 return result;
12787 }
12788
12789 /// <summary>
12790 /// Returns a new string produced by interpolating a format string.
12791 /// </summary>
12792 /// <remarks>
12793 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12794 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12795 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12796 ///
12797 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12798 /// - FixedString*N*Bytes
12799 /// - string
12800 /// - int
12801 /// - float
12802 /// - structs implementing INativeList<byte> and IUTF8Bytes
12803 ///
12804 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12805 /// </remarks>
12806 /// <param name="formatString">The format string.</param>
12807 /// <typeparam name="T1"><undoc /></typeparam>
12808
12809 /// <param name="arg0">Value to interpolate into the format string.</param>
12810 /// <param name="arg1">Value to interpolate into the format string.</param>
12811 /// <returns>A new string produced by interpolating the format string.</returns>
12812 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12813 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, int arg1)
12814 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12815
12816 {
12817 FixedString128Bytes result = default;
12818 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12819
12820
12821 result.AppendFormat(formatString, arg0, carg1);
12822 return result;
12823 }
12824
12825 /// <summary>
12826 /// Returns a new string produced by interpolating a format string.
12827 /// </summary>
12828 /// <remarks>
12829 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12830 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12831 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12832 ///
12833 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12834 /// - FixedString*N*Bytes
12835 /// - string
12836 /// - int
12837 /// - float
12838 /// - structs implementing INativeList<byte> and IUTF8Bytes
12839 ///
12840 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12841 /// </remarks>
12842 /// <param name="formatString">The format string.</param>
12843
12844 /// <param name="arg0">Value to interpolate into the format string.</param>
12845 /// <param name="arg1">Value to interpolate into the format string.</param>
12846 /// <returns>A new string produced by interpolating the format string.</returns>
12847
12848 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, float arg1)
12849
12850 {
12851 FixedString128Bytes result = default;
12852 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12853 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12854
12855
12856 result.AppendFormat(formatString, carg0, carg1);
12857 return result;
12858 }
12859
12860 /// <summary>
12861 /// Returns a new string produced by interpolating a format string.
12862 /// </summary>
12863 /// <remarks>
12864 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12865 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12866 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12867 ///
12868 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12869 /// - FixedString*N*Bytes
12870 /// - string
12871 /// - int
12872 /// - float
12873 /// - structs implementing INativeList<byte> and IUTF8Bytes
12874 ///
12875 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12876 /// </remarks>
12877 /// <param name="formatString">The format string.</param>
12878
12879 /// <param name="arg0">Value to interpolate into the format string.</param>
12880 /// <param name="arg1">Value to interpolate into the format string.</param>
12881 /// <returns>A new string produced by interpolating the format string.</returns>
12882
12883 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, float arg1)
12884
12885 {
12886 FixedString128Bytes result = default;
12887 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12888 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12889
12890
12891 result.AppendFormat(formatString, carg0, carg1);
12892 return result;
12893 }
12894
12895 /// <summary>
12896 /// Returns a new string produced by interpolating a format string.
12897 /// </summary>
12898 /// <remarks>
12899 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12900 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12901 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12902 ///
12903 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12904 /// - FixedString*N*Bytes
12905 /// - string
12906 /// - int
12907 /// - float
12908 /// - structs implementing INativeList<byte> and IUTF8Bytes
12909 ///
12910 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12911 /// </remarks>
12912 /// <param name="formatString">The format string.</param>
12913
12914 /// <param name="arg0">Value to interpolate into the format string.</param>
12915 /// <param name="arg1">Value to interpolate into the format string.</param>
12916 /// <returns>A new string produced by interpolating the format string.</returns>
12917 [ExcludeFromBurstCompatTesting("Takes managed string")]
12918 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, float arg1)
12919
12920 {
12921 FixedString128Bytes result = default;
12922 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12923 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12924
12925
12926 result.AppendFormat(formatString, carg0, carg1);
12927 return result;
12928 }
12929
12930 /// <summary>
12931 /// Returns a new string produced by interpolating a format string.
12932 /// </summary>
12933 /// <remarks>
12934 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12935 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12936 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12937 ///
12938 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12939 /// - FixedString*N*Bytes
12940 /// - string
12941 /// - int
12942 /// - float
12943 /// - structs implementing INativeList<byte> and IUTF8Bytes
12944 ///
12945 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12946 /// </remarks>
12947 /// <param name="formatString">The format string.</param>
12948 /// <typeparam name="T1"><undoc /></typeparam>
12949
12950 /// <param name="arg0">Value to interpolate into the format string.</param>
12951 /// <param name="arg1">Value to interpolate into the format string.</param>
12952 /// <returns>A new string produced by interpolating the format string.</returns>
12953 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
12954 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, float arg1)
12955 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
12956
12957 {
12958 FixedString128Bytes result = default;
12959 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12960
12961
12962 result.AppendFormat(formatString, arg0, carg1);
12963 return result;
12964 }
12965
12966 /// <summary>
12967 /// Returns a new string produced by interpolating a format string.
12968 /// </summary>
12969 /// <remarks>
12970 /// Similar to StringBuilder.AppendFormat but with significant limitations:
12971 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
12972 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
12973 ///
12974 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
12975 /// - FixedString*N*Bytes
12976 /// - string
12977 /// - int
12978 /// - float
12979 /// - structs implementing INativeList<byte> and IUTF8Bytes
12980 ///
12981 /// <seealso cref="FixedStringMethods.AppendFormat"/>
12982 /// </remarks>
12983 /// <param name="formatString">The format string.</param>
12984
12985 /// <param name="arg0">Value to interpolate into the format string.</param>
12986 /// <param name="arg1">Value to interpolate into the format string.</param>
12987 /// <returns>A new string produced by interpolating the format string.</returns>
12988 [ExcludeFromBurstCompatTesting("Takes managed string")]
12989 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0, string arg1)
12990
12991 {
12992 FixedString128Bytes result = default;
12993 FixedString32Bytes carg0 = default; carg0.Append(arg0);
12994 FixedString32Bytes carg1 = default; carg1.Append(arg1);
12995
12996
12997 result.AppendFormat(formatString, carg0, carg1);
12998 return result;
12999 }
13000
13001 /// <summary>
13002 /// Returns a new string produced by interpolating a format string.
13003 /// </summary>
13004 /// <remarks>
13005 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13006 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13007 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13008 ///
13009 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13010 /// - FixedString*N*Bytes
13011 /// - string
13012 /// - int
13013 /// - float
13014 /// - structs implementing INativeList<byte> and IUTF8Bytes
13015 ///
13016 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13017 /// </remarks>
13018 /// <param name="formatString">The format string.</param>
13019
13020 /// <param name="arg0">Value to interpolate into the format string.</param>
13021 /// <param name="arg1">Value to interpolate into the format string.</param>
13022 /// <returns>A new string produced by interpolating the format string.</returns>
13023 [ExcludeFromBurstCompatTesting("Takes managed string")]
13024 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0, string arg1)
13025
13026 {
13027 FixedString128Bytes result = default;
13028 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13029 FixedString32Bytes carg1 = default; carg1.Append(arg1);
13030
13031
13032 result.AppendFormat(formatString, carg0, carg1);
13033 return result;
13034 }
13035
13036 /// <summary>
13037 /// Returns a new string produced by interpolating a format string.
13038 /// </summary>
13039 /// <remarks>
13040 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13041 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13042 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13043 ///
13044 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13045 /// - FixedString*N*Bytes
13046 /// - string
13047 /// - int
13048 /// - float
13049 /// - structs implementing INativeList<byte> and IUTF8Bytes
13050 ///
13051 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13052 /// </remarks>
13053 /// <param name="formatString">The format string.</param>
13054
13055 /// <param name="arg0">Value to interpolate into the format string.</param>
13056 /// <param name="arg1">Value to interpolate into the format string.</param>
13057 /// <returns>A new string produced by interpolating the format string.</returns>
13058 [ExcludeFromBurstCompatTesting("Takes managed string")]
13059 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0, string arg1)
13060
13061 {
13062 FixedString128Bytes result = default;
13063 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13064 FixedString32Bytes carg1 = default; carg1.Append(arg1);
13065
13066
13067 result.AppendFormat(formatString, carg0, carg1);
13068 return result;
13069 }
13070
13071 /// <summary>
13072 /// Returns a new string produced by interpolating a format string.
13073 /// </summary>
13074 /// <remarks>
13075 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13076 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13077 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13078 ///
13079 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13080 /// - FixedString*N*Bytes
13081 /// - string
13082 /// - int
13083 /// - float
13084 /// - structs implementing INativeList<byte> and IUTF8Bytes
13085 ///
13086 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13087 /// </remarks>
13088 /// <param name="formatString">The format string.</param>
13089 /// <typeparam name="T1"><undoc /></typeparam>
13090
13091 /// <param name="arg0">Value to interpolate into the format string.</param>
13092 /// <param name="arg1">Value to interpolate into the format string.</param>
13093 /// <returns>A new string produced by interpolating the format string.</returns>
13094 [ExcludeFromBurstCompatTesting("Takes managed string")]
13095 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0, string arg1)
13096 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13097
13098 {
13099 FixedString128Bytes result = default;
13100 FixedString32Bytes carg1 = default; carg1.Append(arg1);
13101
13102
13103 result.AppendFormat(formatString, arg0, carg1);
13104 return result;
13105 }
13106
13107 /// <summary>
13108 /// Returns a new string produced by interpolating a format string.
13109 /// </summary>
13110 /// <remarks>
13111 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13112 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13113 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13114 ///
13115 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13116 /// - FixedString*N*Bytes
13117 /// - string
13118 /// - int
13119 /// - float
13120 /// - structs implementing INativeList<byte> and IUTF8Bytes
13121 ///
13122 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13123 /// </remarks>
13124 /// <param name="formatString">The format string.</param>
13125 /// <typeparam name="T1"><undoc /></typeparam>
13126
13127 /// <param name="arg0">Value to interpolate into the format string.</param>
13128 /// <param name="arg1">Value to interpolate into the format string.</param>
13129 /// <returns>A new string produced by interpolating the format string.</returns>
13130 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
13131 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, int arg0, T1 arg1)
13132 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13133
13134 {
13135 FixedString128Bytes result = default;
13136 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13137
13138
13139 result.AppendFormat(formatString, carg0, arg1);
13140 return result;
13141 }
13142
13143 /// <summary>
13144 /// Returns a new string produced by interpolating a format string.
13145 /// </summary>
13146 /// <remarks>
13147 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13148 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13149 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13150 ///
13151 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13152 /// - FixedString*N*Bytes
13153 /// - string
13154 /// - int
13155 /// - float
13156 /// - structs implementing INativeList<byte> and IUTF8Bytes
13157 ///
13158 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13159 /// </remarks>
13160 /// <param name="formatString">The format string.</param>
13161 /// <typeparam name="T1"><undoc /></typeparam>
13162
13163 /// <param name="arg0">Value to interpolate into the format string.</param>
13164 /// <param name="arg1">Value to interpolate into the format string.</param>
13165 /// <returns>A new string produced by interpolating the format string.</returns>
13166 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
13167 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, float arg0, T1 arg1)
13168 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13169
13170 {
13171 FixedString128Bytes result = default;
13172 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13173
13174
13175 result.AppendFormat(formatString, carg0, arg1);
13176 return result;
13177 }
13178
13179 /// <summary>
13180 /// Returns a new string produced by interpolating a format string.
13181 /// </summary>
13182 /// <remarks>
13183 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13184 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13185 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13186 ///
13187 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13188 /// - FixedString*N*Bytes
13189 /// - string
13190 /// - int
13191 /// - float
13192 /// - structs implementing INativeList<byte> and IUTF8Bytes
13193 ///
13194 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13195 /// </remarks>
13196 /// <param name="formatString">The format string.</param>
13197 /// <typeparam name="T1"><undoc /></typeparam>
13198
13199 /// <param name="arg0">Value to interpolate into the format string.</param>
13200 /// <param name="arg1">Value to interpolate into the format string.</param>
13201 /// <returns>A new string produced by interpolating the format string.</returns>
13202 [ExcludeFromBurstCompatTesting("Takes managed string")]
13203 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, string arg0, T1 arg1)
13204 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13205
13206 {
13207 FixedString128Bytes result = default;
13208 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13209
13210
13211 result.AppendFormat(formatString, carg0, arg1);
13212 return result;
13213 }
13214
13215 /// <summary>
13216 /// Returns a new string produced by interpolating a format string.
13217 /// </summary>
13218 /// <remarks>
13219 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13220 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13221 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13222 ///
13223 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13224 /// - FixedString*N*Bytes
13225 /// - string
13226 /// - int
13227 /// - float
13228 /// - structs implementing INativeList<byte> and IUTF8Bytes
13229 ///
13230 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13231 /// </remarks>
13232 /// <param name="formatString">The format string.</param>
13233 /// <typeparam name="T1"><undoc /></typeparam>
13234 /// <typeparam name="T2"><undoc /></typeparam>
13235
13236 /// <param name="arg0">Value to interpolate into the format string.</param>
13237 /// <param name="arg1">Value to interpolate into the format string.</param>
13238 /// <returns>A new string produced by interpolating the format string.</returns>
13239 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/), typeof(FixedString32Bytes /*$T2*/) } )]
13240 public static FixedString128Bytes Format<T1,T2>(FixedString128Bytes formatString, T1 arg0, T2 arg1)
13241 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13242 where T2 : unmanaged, INativeList<byte>, IUTF8Bytes
13243
13244 {
13245 FixedString128Bytes result = default;
13246
13247
13248 result.AppendFormat(formatString, arg0, arg1);
13249 return result;
13250 }
13251
13252 /// <summary>
13253 /// Returns a new string produced by interpolating a format string.
13254 /// </summary>
13255 /// <remarks>
13256 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13257 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13258 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13259 ///
13260 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13261 /// - FixedString*N*Bytes
13262 /// - string
13263 /// - int
13264 /// - float
13265 /// - structs implementing INativeList<byte> and IUTF8Bytes
13266 ///
13267 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13268 /// </remarks>
13269 /// <param name="formatString">The format string.</param>
13270
13271 /// <param name="arg0">Value to interpolate into the format string.</param>
13272 /// <returns>A new string produced by interpolating the format string.</returns>
13273
13274 public static FixedString128Bytes Format(FixedString128Bytes formatString, int arg0)
13275
13276 {
13277 FixedString128Bytes result = default;
13278 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13279
13280
13281 result.AppendFormat(formatString, carg0);
13282 return result;
13283 }
13284
13285 /// <summary>
13286 /// Returns a new string produced by interpolating a format string.
13287 /// </summary>
13288 /// <remarks>
13289 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13290 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13291 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13292 ///
13293 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13294 /// - FixedString*N*Bytes
13295 /// - string
13296 /// - int
13297 /// - float
13298 /// - structs implementing INativeList<byte> and IUTF8Bytes
13299 ///
13300 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13301 /// </remarks>
13302 /// <param name="formatString">The format string.</param>
13303
13304 /// <param name="arg0">Value to interpolate into the format string.</param>
13305 /// <returns>A new string produced by interpolating the format string.</returns>
13306
13307 public static FixedString128Bytes Format(FixedString128Bytes formatString, float arg0)
13308
13309 {
13310 FixedString128Bytes result = default;
13311 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13312
13313
13314 result.AppendFormat(formatString, carg0);
13315 return result;
13316 }
13317
13318 /// <summary>
13319 /// Returns a new string produced by interpolating a format string.
13320 /// </summary>
13321 /// <remarks>
13322 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13323 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13324 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13325 ///
13326 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13327 /// - FixedString*N*Bytes
13328 /// - string
13329 /// - int
13330 /// - float
13331 /// - structs implementing INativeList<byte> and IUTF8Bytes
13332 ///
13333 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13334 /// </remarks>
13335 /// <param name="formatString">The format string.</param>
13336
13337 /// <param name="arg0">Value to interpolate into the format string.</param>
13338 /// <returns>A new string produced by interpolating the format string.</returns>
13339 [ExcludeFromBurstCompatTesting("Takes managed string")]
13340 public static FixedString128Bytes Format(FixedString128Bytes formatString, string arg0)
13341
13342 {
13343 FixedString128Bytes result = default;
13344 FixedString32Bytes carg0 = default; carg0.Append(arg0);
13345
13346
13347 result.AppendFormat(formatString, carg0);
13348 return result;
13349 }
13350
13351 /// <summary>
13352 /// Returns a new string produced by interpolating a format string.
13353 /// </summary>
13354 /// <remarks>
13355 /// Similar to StringBuilder.AppendFormat but with significant limitations:
13356 /// - Only supports numeric format placeholders of the form `{0}` .. `{N}`.
13357 /// - No format modifiers (*e.g.* `{0:x}`) are supported.
13358 ///
13359 /// The various overloads of this method take up to four values for interpolation. The allowed argument types are:
13360 /// - FixedString*N*Bytes
13361 /// - string
13362 /// - int
13363 /// - float
13364 /// - structs implementing INativeList<byte> and IUTF8Bytes
13365 ///
13366 /// <seealso cref="FixedStringMethods.AppendFormat"/>
13367 /// </remarks>
13368 /// <param name="formatString">The format string.</param>
13369 /// <typeparam name="T1"><undoc /></typeparam>
13370
13371 /// <param name="arg0">Value to interpolate into the format string.</param>
13372 /// <returns>A new string produced by interpolating the format string.</returns>
13373 [GenerateTestsForBurstCompatibility(GenericTypeArguments = new[] { typeof(FixedString32Bytes /*$T1*/) } )]
13374 public static FixedString128Bytes Format<T1>(FixedString128Bytes formatString, T1 arg0)
13375 where T1 : unmanaged, INativeList<byte>, IUTF8Bytes
13376
13377 {
13378 FixedString128Bytes result = default;
13379
13380
13381 result.AppendFormat(formatString, arg0);
13382 return result;
13383 }
13384
13385 }
13386}