Class: CharacterSet
- Inherits:
-
Object
- Object
- CharacterSet
- 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
-
.from_ranges(ranges) ⇒ Object
******************************.
- .of_string(string) ⇒ Object
Instance Method Summary collapse
- #&(other) ⇒ Object
- #+(other) ⇒ Object
- #-(other) ⇒ Object
- #<(other) ⇒ Object
- #<<(cp_num) ⇒ Object
- #<=(other) ⇒ Object
- #<=>(other) ⇒ Object
- #==(other) ⇒ Object
- #===(num) ⇒ Object
- #>(other) ⇒ Object
- #>=(other) ⇒ Object
- #^(other) ⇒ Object
- #add(cp_num) ⇒ Object
- #add?(cp_num) ⇒ Boolean
- #allocated_length ⇒ Object
- #case_insensitive ⇒ Object
- #clear ⇒ Object
- #count_in(str) ⇒ Object
- #cover?(str) ⇒ Boolean
- #delete(cp_num) ⇒ Object
- #delete?(cp_num) ⇒ Boolean
- #delete_if ⇒ Object
- #delete_in(str) ⇒ Object
- #delete_in!(str) ⇒ Object
- #difference(other) ⇒ Object
- #disjoint?(other) ⇒ Boolean
-
#each ⇒ Object
‘Set` compatibility methods.
- #empty? ⇒ Boolean
- #eql?(other) ⇒ Boolean
- #ext_count_in_section(from, upto) ⇒ Object
- #ext_inversion(*args) ⇒ Object
- #ext_section(from, upto) ⇒ Object
- #ext_section?(from, upto) ⇒ Boolean
- #ext_section_ratio(from, upto) ⇒ Object
- #hash ⇒ Object
- #include?(num) ⇒ Boolean
- #initialize_clone(orig) ⇒ Object
- #initialize_dup(orig) ⇒ Object
- #intersect?(other) ⇒ Boolean
- #intersection(other) ⇒ Object
- #keep_if ⇒ Object
- #keep_in(str) ⇒ Object
- #keep_in!(str) ⇒ Object
- #length ⇒ Object
- #max ⇒ Object
- #member?(num) ⇒ Boolean
- #member_in_plane?(plane_num) ⇒ Boolean
- #merge(other) ⇒ Object
- #min ⇒ Object
- #minmax ⇒ Object
- #plane(plane_num) ⇒ Object
- #planes ⇒ Object
- #proper_subset?(other) ⇒ Boolean
- #proper_superset?(other) ⇒ Boolean
- #ranges ⇒ Object
- #sample(*args) ⇒ Object
- #scan(str) ⇒ Object
- #size ⇒ Object
- #subset?(other) ⇒ Boolean
- #subtract(other) ⇒ Object
- #superset?(other) ⇒ Boolean
-
#to_a(*args) ⇒ Object
returns an Array of Strings of length 1 if passed ‘true`.
- #union(other) ⇒ Object
- #used_by?(str) ⇒ Boolean
- #|(other) ⇒ Object
Methods included from PredefinedSets
Methods included from SharedMethods
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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, ||);
}
|