Class: CharacterSet

Inherits:
Object
  • Object
show all
Extended by:
PredefinedSets
Includes:
SetMethodAdapters, SharedMethods, Enumerable
Defined in:
lib/character_set/pure.rb,
lib/character_set.rb,
lib/character_set/parser.rb,
lib/character_set/writer.rb,
lib/character_set/version.rb,
lib/character_set/character.rb,
lib/character_set/ruby_fallback.rb,
lib/character_set/shared_methods.rb,
lib/character_set/predefined_sets.rb,
lib/character_set/core_ext/regexp_ext.rb,
lib/character_set/core_ext/string_ext.rb,
lib/character_set/set_method_adapters.rb,
lib/character_set/expression_converter.rb,
lib/character_set/ruby_fallback/set_methods.rb,
lib/character_set/ruby_fallback/character_set_methods.rb,
ext/character_set/character_set.c

Overview

Various methods shared by the pure-Ruby and the extended implementation.

Many of these methods are hotspots, so they are defined directly on the including classes for better performance.

Defined Under Namespace

Modules: CoreExt, ExpressionConverter, Parser, PredefinedSets, RubyFallback, SetMethodAdapters, SharedMethods, Writer Classes: Character, Pure

Constant Summary collapse

VERSION = 
'1.8.0'

Class Method Summary collapse

Instance Method Summary collapse

Methods included from PredefinedSets

build_from_cps_file

Methods included from SharedMethods

included

Class Method Details

.from_ranges(ranges) ⇒ Object

******************************



694
695
696
697
698
699
700
701
702
703
704
705
 
# File 'ext/character_set/character_set.c', line 694

static VALUE
cs_class_method_from_ranges(VALUE self, VALUE ranges)
{
  VALUE new_cs, range_count, i;
  new_cs = rb_class_new_instance(0, 0, self);
  range_count = RARRAY_LEN(ranges);
  for (i = 0; i < range_count; i++)
  {
    cs_merge_rb_range(new_cs, RARRAY_AREF(ranges, i));
  }
  return new_cs;
}

.of_string(string) ⇒ Object 



1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
 
# File 'ext/character_set/character_set.c', line 1071

static VALUE
cs_class_method_of_string(VALUE self, VALUE string)
{
  VALUE new_cs;
  struct cs_data *new_data;

  raise_arg_err_unless_string(string);
  new_cs = cs_alloc(self, &new_data);
  each_cp(string, add_str_cp_to_arr, 0, 0, new_data, 0);
  return new_cs;
}

Instance Method Details

#&(other) ⇒ Object 



335
336
337
338
339
 
# File 'ext/character_set/character_set.c', line 335

static VALUE
cs_method_intersection(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, &&);
}

#+(other) ⇒ Object 



347
348
349
350
351
 
# File 'ext/character_set/character_set.c', line 347

static VALUE
cs_method_union(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, ||);
}

#-(other) ⇒ Object 



353
354
355
356
357
 
# File 'ext/character_set/character_set.c', line 353

static VALUE
cs_method_difference(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, >);
}

#<(other) ⇒ Object 



656
657
658
659
660
661
662
 
# File 'ext/character_set/character_set.c', line 656

static VALUE
cs_method_proper_subset_p(VALUE self, VALUE other)
{
  int is_subset, is_proper;
  is_subset = cs_a_subset_of_b(self, other, &is_proper);
  return (is_subset && is_proper) ? Qtrue : Qfalse;
}

#<<(cp_num) ⇒ Object 



395
396
397
398
399
 
# File 'ext/character_set/character_set.c', line 395

static VALUE
cs_method_add(VALUE self, VALUE cp_num)
{
  return cs_toggle_codepoint(self, cp_num, 1, 0);
}

#<=(other) ⇒ Object 



650
651
652
653
654
 
# File 'ext/character_set/character_set.c', line 650

static VALUE
cs_method_subset_p(VALUE self, VALUE other)
{
  return cs_a_subset_of_b(self, other, NULL) ? Qtrue : Qfalse;
}

#<=>(other) ⇒ Object 



678
679
680
681
682
683
684
685
686
687
688
 
# File 'ext/character_set/character_set.c', line 678

static VALUE
cs_method_spaceship_operator(VALUE self, VALUE other)
{
  if (cs_method_eql_p(self, other))
    return INT2FIX(0);
  if (cs_method_proper_subset_p(self, other))
    return INT2FIX(-1);
  if (cs_method_proper_superset_p(self, other))
    return INT2FIX(1);
  return Qnil;
}

#==(other) ⇒ Object 



465
466
467
468
469
470
471
472
473
474
475
476
477
 
# File 'ext/character_set/character_set.c', line 465

static VALUE
cs_method_eql_p(VALUE self, VALUE other)
{
  if (!cs_check_type(other))
  {
    return Qfalse;
  }
  if (self == other) // same object_id
  {
    return Qtrue;
  }
  return cs_cps_eql(self, other);
}

#===(num) ⇒ Object 



359
360
361
362
363
364
365
366
 
# File 'ext/character_set/character_set.c', line 359

static VALUE
cs_method_include_p(VALUE self, VALUE num)
{
  cs_ar *cps;
  cs_cp len;
  cps = cs_fetch_cps(self, &len);
  return (tst_cp(cps, len, FIX2ULONG(num)) ? Qtrue : Qfalse);
}

#>(other) ⇒ Object 



670
671
672
673
674
675
676
 
# File 'ext/character_set/character_set.c', line 670

static VALUE
cs_method_proper_superset_p(VALUE self, VALUE other)
{
  int is_superset, is_proper;
  is_superset = cs_a_subset_of_b(other, self, &is_proper);
  return (is_superset && is_proper) ? Qtrue : Qfalse;
}

#>=(other) ⇒ Object 



664
665
666
667
668
 
# File 'ext/character_set/character_set.c', line 664

static VALUE
cs_method_superset_p(VALUE self, VALUE other)
{
  return cs_a_subset_of_b(other, self, NULL) ? Qtrue : Qfalse;
}

#^(other) ⇒ Object 



341
342
343
344
345
 
# File 'ext/character_set/character_set.c', line 341

static VALUE
cs_method_exclusion(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, ^);
}

#add(cp_num) ⇒ Object 



395
396
397
398
399
 
# File 'ext/character_set/character_set.c', line 395

static VALUE
cs_method_add(VALUE self, VALUE cp_num)
{
  return cs_toggle_codepoint(self, cp_num, 1, 0);
}

#add?(cp_num) ⇒ Boolean

Returns:

  • (Boolean) 


401
402
403
404
405
 
# File 'ext/character_set/character_set.c', line 401

static VALUE
cs_method_add_p(VALUE self, VALUE cp_num)
{
  return cs_toggle_codepoint(self, cp_num, 1, 1);
}

#allocated_length ⇒ Object 



1273
1274
1275
1276
1277
 
# File 'ext/character_set/character_set.c', line 1273

static VALUE
cs_method_allocated_length(VALUE self)
{
  return LONG2FIX(cs_fetch_data(self)->len);
}

#case_insensitive ⇒ Object 



939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
 
# File 'ext/character_set/character_set.c', line 939

static VALUE
cs_method_case_insensitive(VALUE self)
{
  cs_cp i, len;
  cs_ar *cps;
  VALUE new_cs;
  struct cs_data *new_data;

  cps = cs_fetch_cps(self, &len);
  new_cs = cs_alloc(RBASIC(self)->klass, &new_data);
  cs_merge_cs(new_cs, self);

  for (i = 0; i < CASEFOLD_COUNT; i++)
  {
    casefold_mapping m = unicode_casefold_table[i];

    if (tst_cp(cps, len, m.from))
    {
      set_cp(new_data, m.to);
    }
    else if (tst_cp(cps, len, m.to))
    {
      set_cp(new_data, m.from);
    }
  }

  return new_cs;

  // OnigCaseFoldType flags;
  // rb_encoding *enc;
  //
  // enc = rb_utf8_encoding();
  //
  // ONIGENC_CASE_UPCASE | ONIGENC_CASE_DOWNCASE (not public on ruby < 2.4)
  // flags = (1<<13) | (1<<14);
  //
  // // case_map args: flags, pp, end, to, to_end, enc
  // enc->case_map(flags, (const OnigUChar**)&cp, ?, ?, ?, enc);
}

#clear ⇒ Object 



271
272
273
274
275
276
277
278
279
 
# File 'ext/character_set/character_set.c', line 271

static VALUE
cs_method_clear(VALUE self)
{
  struct cs_data *data;
  rb_check_frozen(self);
  data = cs_fetch_data(self);
  memset(data->cps, 0, CS_MSIZE(data->len));
  return self;
}

#count_in(str) ⇒ Object 



1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
 
# File 'ext/character_set/character_set.c', line 1093

static VALUE
cs_method_count_in(VALUE self, VALUE str)
{
  long count;
  struct cs_data *data;
  raise_arg_err_unless_string(str);
  data = cs_fetch_data(self);
  count = 0;
  each_cp(str, count_str_cp, data->cps, data->len, data, (VALUE)&count);
  return LONG2FIX(count);
}

#cover?(str) ⇒ Boolean

Returns:

  • (Boolean) 


1111
1112
1113
1114
1115
1116
1117
1118
 
# File 'ext/character_set/character_set.c', line 1111

static VALUE
cs_method_cover_p(VALUE self, VALUE str)
{
  struct cs_data *data;
  raise_arg_err_unless_string(str);
  data = cs_fetch_data(self);
  return each_cp(str, str_cp_in_arr, data->cps, data->len, data, 0);
}

#delete(cp_num) ⇒ Object 



407
408
409
410
411
 
# File 'ext/character_set/character_set.c', line 407

static VALUE
cs_method_delete(VALUE self, VALUE cp_num)
{
  return cs_toggle_codepoint(self, cp_num, 0, 0);
}

#delete?(cp_num) ⇒ Boolean

Returns:

  • (Boolean) 


413
414
415
416
417
 
# File 'ext/character_set/character_set.c', line 413

static VALUE
cs_method_delete_p(VALUE self, VALUE cp_num)
{
  return cs_toggle_codepoint(self, cp_num, 0, 1);
}

#delete_if ⇒ Object 



257
258
259
260
261
262
 
# File 'ext/character_set/character_set.c', line 257

static VALUE
cs_method_delete_if(VALUE self)
{
  RETURN_SIZED_ENUMERATOR(self, 0, 0, cs_enumerator_length);
  return cs_delete_if_block_result(self, 1);
}

#delete_in(str) ⇒ Object 



1249
1250
1251
1252
1253
 
# File 'ext/character_set/character_set.c', line 1249

static VALUE
cs_method_delete_in(VALUE self, VALUE str)
{
  return cs_apply_to_str(self, str, 1, 0);
}

#delete_in!(str) ⇒ Object 



1255
1256
1257
1258
1259
 
# File 'ext/character_set/character_set.c', line 1255

static VALUE
cs_method_delete_in_bang(VALUE self, VALUE str)
{
  return cs_apply_to_str(self, str, 1, 1);
}

#difference(other) ⇒ Object 



353
354
355
356
357
 
# File 'ext/character_set/character_set.c', line 353

static VALUE
cs_method_difference(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, >);
}

#disjoint?(other) ⇒ Boolean

Returns:

  • (Boolean) 


436
437
438
439
440
 
# File 'ext/character_set/character_set.c', line 436

static VALUE
cs_method_disjoint_p(VALUE self, VALUE other)
{
  return cs_method_intersect_p(self, other) ? Qfalse : Qtrue;
}

#each ⇒ Object

‘Set` compatibility methods



179
180
181
182
183
184
185
 
# File 'ext/character_set/character_set.c', line 179

static VALUE
cs_method_each(VALUE self)
{
  RETURN_SIZED_ENUMERATOR(self, 0, 0, cs_enumerator_length);
  FOR_EACH_ACTIVE_CODEPOINT(rb_yield(LONG2FIX(cp)));
  return self;
}

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


210
211
212
213
214
215
 
# File 'ext/character_set/character_set.c', line 210

static VALUE
cs_method_empty_p(VALUE self)
{
  FOR_EACH_ACTIVE_CODEPOINT(return Qfalse);
  return Qtrue;
}

#eql?(other) ⇒ Boolean

Returns:

  • (Boolean) 


465
466
467
468
469
470
471
472
473
474
475
476
477
 
# File 'ext/character_set/character_set.c', line 465

static VALUE
cs_method_eql_p(VALUE self, VALUE other)
{
  if (!cs_check_type(other))
  {
    return Qfalse;
  }
  if (self == other) // same object_id
  {
    return Qtrue;
  }
  return cs_cps_eql(self, other);
}

#ext_count_in_section(from, upto) ⇒ Object 



788
789
790
791
792
793
794
 
# File 'ext/character_set/character_set.c', line 788

static VALUE
cs_method_ext_count_in_section(VALUE self, VALUE from, VALUE upto)
{
  cs_cp count;
  count = cs_active_cp_count_in_section(self, FIX2ULONG(from), FIX2ULONG(upto));
  return LONG2FIX(count);
}

#ext_inversion(*args) ⇒ Object 



903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
 
# File 'ext/character_set/character_set.c', line 903

static VALUE
cs_method_ext_inversion(int argc, VALUE *argv, VALUE self)
{
  int inc_surr;
  cs_cp upto, cp, len;
  cs_ar *cps;
  VALUE new_cs;
  struct cs_data *new_data;

  rb_check_arity(argc, 0, 2);

  cps = cs_fetch_cps(self, &len);
  inc_surr = argc && argv[0] == Qtrue;
  new_cs = cs_alloc(RBASIC(self)->klass, &new_data);
  upto = argc > 1 && FIXNUM_P(argv[1]) ? FIX2ULONG(argv[1]) : UNICODE_CP_COUNT;

  for (cp = 0; cp < UNICODE_CP_COUNT; cp++)
  {
    if (cp <= upto && !tst_cp(cps, len, cp) && (inc_surr || NON_SURROGATE(cp)))
    {
      set_cp(new_data, cp);
    }
  }

  return new_cs;
}

#ext_section(from, upto) ⇒ Object 



766
767
768
769
770
 
# File 'ext/character_set/character_set.c', line 766

static VALUE
cs_method_ext_section(VALUE self, VALUE from, VALUE upto)
{
  return cs_from_section(self, FIX2ULONG(from), FIX2ULONG(upto));
}

#ext_section?(from, upto) ⇒ Boolean

Returns:

  • (Boolean) 


810
811
812
813
814
815
816
817
 
# File 'ext/character_set/character_set.c', line 810

static VALUE
cs_method_ext_section_p(VALUE self, VALUE from, VALUE upto)
{
  cs_ar *cps;
  cs_cp len;
  cps = cs_fetch_cps(self, &len);
  return cs_has_cp_in_section(cps, len, FIX2ULONG(from), FIX2ULONG(upto));
}

#ext_section_ratio(from, upto) ⇒ Object 



828
829
830
831
832
 
# File 'ext/character_set/character_set.c', line 828

static VALUE
cs_method_ext_section_ratio(VALUE self, VALUE from, VALUE upto)
{
  return cs_ratio_of_section(self, FIX2ULONG(from), FIX2ULONG(upto));
}

#hash ⇒ Object 



217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'ext/character_set/character_set.c', line 217

static VALUE
cs_method_hash(VALUE self)
{
  cs_cp cp, len, hash, four_byte_value;
  cs_ar *cps;
  cps = cs_fetch_cps(self, &len);
  four_byte_value = 0;

  hash = 17;
  for (cp = 0; cp < len; cp++)
  {
    if (cp % 32 == 0)
    {
      if (cp != 0)
      {
        hash = hash * 23 + four_byte_value;
      }
      four_byte_value = 0;
    }
    if (tst_cp(cps, len, cp))
    {
      four_byte_value++;
    }
  }

  return LONG2FIX(hash);
}

#include?(num) ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
362
363
364
365
366
 
# File 'ext/character_set/character_set.c', line 359

static VALUE
cs_method_include_p(VALUE self, VALUE num)
{
  cs_ar *cps;
  cs_cp len;
  cps = cs_fetch_cps(self, &len);
  return (tst_cp(cps, len, FIX2ULONG(num)) ? Qtrue : Qfalse);
}

#initialize_clone(orig) ⇒ Object 



583
584
585
586
587
588
 
# File 'ext/character_set/character_set.c', line 583

static VALUE
cs_method_initialize_copy(VALUE self, VALUE orig)
{
  cs_merge_cs(self, orig);
  return self;
}

#initialize_dup(orig) ⇒ Object 



583
584
585
586
587
588
 
# File 'ext/character_set/character_set.c', line 583

static VALUE
cs_method_initialize_copy(VALUE self, VALUE orig)
{
  cs_merge_cs(self, orig);
  return self;
}

#intersect?(other) ⇒ Boolean

Returns:

  • (Boolean) 


419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'ext/character_set/character_set.c', line 419

static VALUE
cs_method_intersect_p(VALUE self, VALUE other)
{
  cs_cp cp, alen, blen;
  cs_ar *acps, *bcps;
  acps = cs_fetch_cps(self, &alen);
  bcps = cs_fetch_cps(other, &blen);
  for (cp = 0; cp < UNICODE_CP_COUNT; cp++)
  {
    if (tst_cp(acps, alen, cp) && tst_cp(bcps, blen, cp))
    {
      return Qtrue;
    }
  }
  return Qfalse;
}

#intersection(other) ⇒ Object 



335
336
337
338
339
 
# File 'ext/character_set/character_set.c', line 335

static VALUE
cs_method_intersection(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, &&);
}

#keep_if ⇒ Object 



264
265
266
267
268
269
 
# File 'ext/character_set/character_set.c', line 264

static VALUE
cs_method_keep_if(VALUE self)
{
  RETURN_SIZED_ENUMERATOR(self, 0, 0, cs_enumerator_length);
  return cs_delete_if_block_result(self, 0);
}

#keep_in(str) ⇒ Object 



1261
1262
1263
1264
1265
 
# File 'ext/character_set/character_set.c', line 1261

static VALUE
cs_method_keep_in(VALUE self, VALUE str)
{
  return cs_apply_to_str(self, str, 0, 0);
}

#keep_in!(str) ⇒ Object 



1267
1268
1269
1270
1271
 
# File 'ext/character_set/character_set.c', line 1267

static VALUE
cs_method_keep_in_bang(VALUE self, VALUE str)
{
  return cs_apply_to_str(self, str, 0, 1);
}

#length ⇒ Object 



167
168
169
170
171
 
# File 'ext/character_set/character_set.c', line 167

static VALUE
cs_method_length(VALUE self)
{
  return LONG2FIX(cs_active_cp_count(self));
}

#max ⇒ Object 



288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
# File 'ext/character_set/character_set.c', line 288

static VALUE
cs_method_max(VALUE self)
{
  cs_cp len;
  long reverse_idx;
  cs_ar *cps;
  cps = cs_fetch_cps(self, &len);
  for (reverse_idx = len; reverse_idx >= 0; reverse_idx--)
  {
    if (tst_cp(cps, len, reverse_idx))
    {
      return LONG2FIX(reverse_idx);
    }
  }
  return Qnil;
}

#member?(num) ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
362
363
364
365
366
 
# File 'ext/character_set/character_set.c', line 359

static VALUE
cs_method_include_p(VALUE self, VALUE num)
{
  cs_ar *cps;
  cs_cp len;
  cps = cs_fetch_cps(self, &len);
  return (tst_cp(cps, len, FIX2ULONG(num)) ? Qtrue : Qfalse);
}

#member_in_plane?(plane_num) ⇒ Boolean

Returns:

  • (Boolean) 


890
891
892
893
894
895
896
897
898
899
 
# File 'ext/character_set/character_set.c', line 890

static VALUE
cs_method_member_in_plane_p(VALUE self, VALUE plane_num)
{
  cs_ar *cps;
  cs_cp len;
  unsigned int plane;
  plane = cs_valid_plane_num(plane_num);
  cps = cs_fetch_cps(self, &len);
  return cs_has_cp_in_plane(cps, len, plane);
}

#merge(other) ⇒ Object 



568
569
570
571
572
573
574
575
576
577
578
579
580
581
 
# File 'ext/character_set/character_set.c', line 568

static VALUE
cs_method_merge(VALUE self, VALUE other)
{
  rb_check_frozen(self);
  if (cs_check_type(other))
  {
    return cs_merge_cs(self, other);
  }
  if (TYPE(other) == T_ARRAY)
  {
    return cs_merge_rb_array(self, other);
  }
  return cs_merge_rb_range(self, other);
}

#min ⇒ Object 



281
282
283
284
285
286
 
# File 'ext/character_set/character_set.c', line 281

static VALUE
cs_method_min(VALUE self)
{
  FOR_EACH_ACTIVE_CODEPOINT(return LONG2FIX(cp));
  return Qnil;
}

#minmax ⇒ Object 



305
306
307
308
309
310
311
312
313
 
# File 'ext/character_set/character_set.c', line 305

static VALUE
cs_method_minmax(VALUE self)
{
  VALUE arr;
  arr = rb_ary_new2(2);
  rb_ary_push(arr, cs_method_min(self));
  rb_ary_push(arr, cs_method_max(self));
  return arr;
}

#plane(plane_num) ⇒ Object 



880
881
882
883
884
885
886
887
888
 
# File 'ext/character_set/character_set.c', line 880

static VALUE
cs_method_plane(VALUE self, VALUE plane_num)
{
  cs_cp plane, plane_beg, plane_end;
  plane = cs_valid_plane_num(plane_num);
  plane_beg = plane * UNICODE_PLANE_SIZE;
  plane_end = (plane + 1) * MAX_BMP_CP;
  return cs_from_section(self, plane_beg, plane_end);
}

#planes ⇒ Object 



848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
 
# File 'ext/character_set/character_set.c', line 848

static VALUE
cs_method_planes(VALUE self)
{
  cs_ar *cps;
  cs_cp len;
  unsigned int i;
  VALUE planes;
  cps = cs_fetch_cps(self, &len);
  planes = rb_ary_new();
  for (i = 0; i < UNICODE_PLANE_COUNT; i++)
  {
    if (cs_has_cp_in_plane(cps, len, i))
    {
      rb_ary_push(planes, INT2FIX(i));
    }
  }
  return planes;
}

#proper_subset?(other) ⇒ Boolean

Returns:

  • (Boolean) 


656
657
658
659
660
661
662
 
# File 'ext/character_set/character_set.c', line 656

static VALUE
cs_method_proper_subset_p(VALUE self, VALUE other)
{
  int is_subset, is_proper;
  is_subset = cs_a_subset_of_b(self, other, &is_proper);
  return (is_subset && is_proper) ? Qtrue : Qfalse;
}

#proper_superset?(other) ⇒ Boolean

Returns:

  • (Boolean) 


670
671
672
673
674
675
676
 
# File 'ext/character_set/character_set.c', line 670

static VALUE
cs_method_proper_superset_p(VALUE self, VALUE other)
{
  int is_superset, is_proper;
  is_superset = cs_a_subset_of_b(other, self, &is_proper);
  return (is_superset && is_proper) ? Qtrue : Qfalse;
}

#ranges ⇒ Object 



707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
 
# File 'ext/character_set/character_set.c', line 707

static VALUE
cs_method_ranges(VALUE self)
{
  VALUE ranges, cp_num, previous_cp_num, current_start, current_end;

  ranges = rb_ary_new();
  previous_cp_num = 0;
  current_start = 0;
  current_end = 0;

  FOR_EACH_ACTIVE_CODEPOINT(
      cp_num = LONG2FIX(cp);

      if (!previous_cp_num) {
        current_start = cp_num;
      } else if (previous_cp_num + 2 != cp_num) {
        // gap found, finalize previous range
        rb_ary_push(ranges, rb_range_new(current_start, current_end, 0));
        current_start = cp_num;
      } current_end = cp_num;
      previous_cp_num = cp_num;);

  // add final range
  if (current_start)
  {
    rb_ary_push(ranges, rb_range_new(current_start, current_end, 0));
  }

  return ranges;
}

#sample(*args) ⇒ Object 



738
739
740
741
742
743
744
745
 
# File 'ext/character_set/character_set.c', line 738

static VALUE
cs_method_sample(int argc, VALUE *argv, VALUE self)
{
  VALUE array, to_a_args[1] = {Qtrue};
  rb_check_arity(argc, 0, 1);
  array = cs_method_to_a(1, to_a_args, self);
  return rb_funcall(array, rb_intern("sample"), argc, argc ? argv[0] : 0);
}

#scan(str) ⇒ Object 



1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
 
# File 'ext/character_set/character_set.c', line 1130

static VALUE
cs_method_scan(VALUE self, VALUE str)
{
  VALUE memo;
  struct cs_data *data;
  raise_arg_err_unless_string(str);
  data = cs_fetch_data(self);
  memo = rb_ary_new();
  each_cp(str, add_str_cp_to_str_arr, data->cps, data->len, data, memo);
  return memo;
}

#size ⇒ Object 



167
168
169
170
171
 
# File 'ext/character_set/character_set.c', line 167

static VALUE
cs_method_length(VALUE self)
{
  return LONG2FIX(cs_active_cp_count(self));
}

#subset?(other) ⇒ Boolean

Returns:

  • (Boolean) 


650
651
652
653
654
 
# File 'ext/character_set/character_set.c', line 650

static VALUE
cs_method_subset_p(VALUE self, VALUE other)
{
  return cs_a_subset_of_b(self, other, NULL) ? Qtrue : Qfalse;
}

#subtract(other) ⇒ Object 



590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# File 'ext/character_set/character_set.c', line 590

static VALUE
cs_method_subtract(VALUE self, VALUE other)
{
  cs_cp cp, len, other_len;
  cs_ar *cps, *other_cps;
  rb_check_frozen(self);
  cps = cs_fetch_cps(self, &len);
  other_cps = cs_fetch_cps(other, &other_len);
  for (cp = 0; cp < UNICODE_CP_COUNT; cp++)
  {
    if (tst_cp(other_cps, other_len, cp))
    {
      clr_cp(cps, len, cp);
    }
  }
  return self;
}

#superset?(other) ⇒ Boolean

Returns:

  • (Boolean) 


664
665
666
667
668
 
# File 'ext/character_set/character_set.c', line 664

static VALUE
cs_method_superset_p(VALUE self, VALUE other)
{
  return cs_a_subset_of_b(other, self, NULL) ? Qtrue : Qfalse;
}

#to_a(*args) ⇒ Object

returns an Array of Strings of length 1 if passed ‘true`.



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'ext/character_set/character_set.c', line 189

static VALUE
cs_method_to_a(int argc, VALUE *argv, VALUE self)
{
  VALUE arr;
  rb_encoding *enc;
  rb_check_arity(argc, 0, 1);

  arr = rb_ary_new();
  if (!argc || NIL_P(argv[0]) || argv[0] == Qfalse)
  {
    FOR_EACH_ACTIVE_CODEPOINT(rb_ary_push(arr, LONG2FIX(cp)));
  }
  else
  {
    enc = rb_utf8_encoding();
    FOR_EACH_ACTIVE_CODEPOINT(rb_ary_push(arr, rb_enc_uint_chr((int)cp, enc)));
  }

  return arr;
}

#union(other) ⇒ Object 



347
348
349
350
351
 
# File 'ext/character_set/character_set.c', line 347

static VALUE
cs_method_union(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, ||);
}

#used_by?(str) ⇒ Boolean

Returns:

  • (Boolean) 


1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
 
# File 'ext/character_set/character_set.c', line 1148

static VALUE
cs_method_used_by_p(VALUE self, VALUE str)
{
  VALUE only_uses_other_cps;
  struct cs_data *data;
  raise_arg_err_unless_string(str);
  data = cs_fetch_data(self);
  only_uses_other_cps = each_cp(str, str_cp_not_in_arr, data->cps, data->len, data, 0);
  return only_uses_other_cps == Qfalse ? Qtrue : Qfalse;
}

#|(other) ⇒ Object 



347
348
349
350
351
 
# File 'ext/character_set/character_set.c', line 347

static VALUE
cs_method_union(VALUE self, VALUE other)
{
  RETURN_COMBINED_CS(self, other, ||);
}