Class: DBM
Constant Summary collapse
- READER =
Indicates that dbm_open() should open the database in read-only mode
INT2FIX(O_RDONLY|RUBY_DBM_RW_BIT)
- WRITER =
Indicates that dbm_open() should open the database in read/write mode
INT2FIX(O_RDWR|RUBY_DBM_RW_BIT)
- WRCREAT =
Indicates that dbm_open() should open the database in read/write mode, and create it if it does not already exist
INT2FIX(O_RDWR|O_CREAT|RUBY_DBM_RW_BIT)
- NEWDB =
Indicates that dbm_open() should open the database in read/write mode, create it if it does not already exist, and delete all contents if it does already exist.
INT2FIX(O_RDWR|O_CREAT|O_TRUNC|RUBY_DBM_RW_BIT)
- VERSION =
since gdbm 1.9
rb_str_new2("unknown")
Class Method Summary collapse
-
.open(*args) ⇒ Object
Open a dbm database and yields it if a block is given.
Instance Method Summary collapse
-
#[](key) ⇒ nil
Return a value from the database by locating the key string provided.
-
#[]=(keystr, valstr) ⇒ Object
Stores the specified string value in the database, indexed via the string key provided.
-
#clear ⇒ Object
Deletes all data from the database.
-
#close ⇒ Object
Closes the database.
-
#closed? ⇒ Boolean
Returns true if the database is closed, false otherwise.
-
#delete(key) ⇒ Object
Deletes an entry from the database.
-
#delete_if ⇒ Object
Deletes all entries for which the code block returns true.
-
#each_pair {|key, value| ... } ⇒ self
Calls the block once for each [key, value] pair in the database.
-
#each_key {|key| ... } ⇒ self
Calls the block once for each key string in the database.
-
#each_pair {|key, value| ... } ⇒ self
Calls the block once for each [key, value] pair in the database.
-
#each_value {|value| ... } ⇒ self
Calls the block once for each value string in the database.
-
#empty? ⇒ Boolean
Returns true if the database is empty, false otherwise.
-
#fetch(key[, ifnone]) ⇒ Object
Return a value from the database by locating the key string provided.
-
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
-
#has_value?(value) ⇒ Boolean
Returns true if the database contains the specified string value, false otherwise.
-
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
-
#index(value) ⇒ Object
:nodoc:.
-
#new(filename[, mode[, flags]]) ⇒ Object
constructor
Open a dbm database with the specified name, which can include a directory path.
-
#invert ⇒ Hash
Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding key as its value.
-
#key(value) ⇒ String
Returns the key for the specified value.
-
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
-
#keys ⇒ Array
Returns an array of all the string keys in the database.
-
#length ⇒ Integer
Returns the number of entries in the database.
-
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
-
#reject {|key, value| ... } ⇒ Hash
Converts the contents of the database to an in-memory Hash, then calls Hash#reject with the specified code block, returning a new Hash.
-
#reject! ⇒ Object
Deletes all entries for which the code block returns true.
-
#replace(obj) ⇒ Object
Replaces the contents of the database with the contents of the specified object.
-
#select {|key, value| ... } ⇒ Array
Returns a new array consisting of the [key, value] pairs for which the code block returns true.
-
#shift ⇒ Array
Removes a [key, value] pair from the database, and returns it.
-
#length ⇒ Integer
Returns the number of entries in the database.
-
#store(keystr, valstr) ⇒ Object
Stores the specified string value in the database, indexed via the string key provided.
-
#to_a ⇒ Array
Converts the contents of the database to an array of [key, value] arrays, and returns it.
-
#to_hash ⇒ Hash
Converts the contents of the database to an in-memory Hash object, and returns it.
-
#update(obj) ⇒ Object
Updates the database with multiple values from the specified object.
-
#has_value?(value) ⇒ Boolean
Returns true if the database contains the specified string value, false otherwise.
-
#values ⇒ Array
Returns an array of all the string values in the database.
-
#values_at(key, ...) ⇒ Array
Returns an array containing the values associated with the given keys.
Constructor Details
#new(filename[, mode[, flags]]) ⇒ Object
Open a dbm database with the specified name, which can include a directory path. Any file extensions needed will be supplied automatically by the dbm library. For example, Berkeley DB appends ‘.db’, and GNU gdbm uses two physical files with extensions ‘.dir’ and ‘.pag’.
The mode should be an integer, as for Unix chmod.
Flags should be one of READER, WRITER, WRCREAT or NEWDB.
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 |
# File 'ext/rubysl/dbm/dbm.c', line 116
static VALUE
fdbm_initialize(int argc, VALUE *argv, VALUE obj)
{
volatile VALUE file;
VALUE vmode, vflags;
DBM *dbm;
struct dbmdata *dbmp;
int mode, flags = 0;
if (rb_scan_args(argc, argv, "12", &file, &vmode, &vflags) == 1) {
mode = 0666; /* default value */
}
else if (NIL_P(vmode)) {
mode = -1; /* return nil if DB not exist */
}
else {
mode = NUM2INT(vmode);
}
if (!NIL_P(vflags))
flags = NUM2INT(vflags);
FilePathValue(file);
if (flags & RUBY_DBM_RW_BIT) {
flags &= ~RUBY_DBM_RW_BIT;
dbm = dbm_open(RSTRING_PTR(file), flags, mode);
}
else {
dbm = 0;
if (mode >= 0) {
dbm = dbm_open(RSTRING_PTR(file), O_RDWR|O_CREAT, mode);
}
if (!dbm) {
dbm = dbm_open(RSTRING_PTR(file), O_RDWR, 0);
}
if (!dbm) {
dbm = dbm_open(RSTRING_PTR(file), O_RDONLY, 0);
}
}
if (!dbm) {
if (mode == -1) return Qnil;
rb_sys_fail(RSTRING_PTR(file));
}
dbmp = ALLOC(struct dbmdata);
DATA_PTR(obj) = dbmp;
dbmp->di_dbm = dbm;
dbmp->di_size = -1;
return obj;
}
|
Class Method Details
.open(filename[, mode[, flags]]) ⇒ Object .open(filename[, mode[, flags]]) {|dbm| ... } ⇒ Object
Open a dbm database and yields it if a block is given. See also DBM.new
.
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 |
# File 'ext/rubysl/dbm/dbm.c', line 178
static VALUE
fdbm_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE obj = Data_Wrap_Struct(klass, 0, free_dbm, 0);
if (NIL_P(fdbm_initialize(argc, argv, obj))) {
return Qnil;
}
if (rb_block_given_p()) {
return rb_ensure(rb_yield, obj, fdbm_close, obj);
}
return obj;
}
|
Instance Method Details
#[](key) ⇒ nil
Return a value from the database by locating the key string provided. If the key is not found, returns nil.
222 223 224 225 226 |
# File 'ext/rubysl/dbm/dbm.c', line 222
static VALUE
fdbm_aref(VALUE obj, VALUE keystr)
{
return fdbm_fetch(obj, keystr, Qnil);
}
|
#store(key, value) ⇒ Object #[]=(key) ⇒ Object
Stores the specified string value in the database, indexed via the string key provided.
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 |
# File 'ext/rubysl/dbm/dbm.c', line 565
static VALUE
fdbm_store(VALUE obj, VALUE keystr, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
fdbm_modify(obj);
keystr = rb_obj_as_string(keystr);
valstr = rb_obj_as_string(valstr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = (int)RSTRING_LEN(valstr);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
if (dbm_store(dbm, key, val, DBM_REPLACE)) {
#ifdef HAVE_DBM_CLEARERR
dbm_clearerr(dbm);
#endif
if (errno == EPERM) rb_sys_fail(0);
rb_raise(rb_eDBMError, "dbm_store failed");
}
return valstr;
}
|
#clear ⇒ Object
Deletes all data from the database.
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 |
# File 'ext/rubysl/dbm/dbm.c', line 467
static VALUE
fdbm_clear(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
fdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
while (key = dbm_firstkey(dbm), key.dptr) {
if (dbm_delete(dbm, key)) {
rb_raise(rb_eDBMError, "dbm_delete failed");
}
}
dbmp->di_size = 0;
return obj;
}
|
#close ⇒ Object
Closes the database.
65 66 67 68 69 70 71 72 73 74 75 |
# File 'ext/rubysl/dbm/dbm.c', line 65
static VALUE
fdbm_close(VALUE obj)
{
struct dbmdata *dbmp;
GetDBM(obj, dbmp);
dbm_close(dbmp->di_dbm);
dbmp->di_dbm = 0;
return Qnil;
}
|
#closed? ⇒ Boolean
Returns true if the database is closed, false otherwise.
83 84 85 86 87 88 89 90 91 92 93 94 95 |
# File 'ext/rubysl/dbm/dbm.c', line 83
static VALUE
fdbm_closed(VALUE obj)
{
struct dbmdata *dbmp;
Data_Get_Struct(obj, struct dbmdata, dbmp);
if (dbmp == 0)
return Qtrue;
if (dbmp->di_dbm == 0)
return Qtrue;
return Qfalse;
}
|
#delete(key) ⇒ Object
Deletes an entry from the database.
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 |
# File 'ext/rubysl/dbm/dbm.c', line 348
static VALUE
fdbm_delete(VALUE obj, VALUE keystr)
{
datum key, value;
struct dbmdata *dbmp;
DBM *dbm;
VALUE valstr;
fdbm_modify(obj);
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
GetDBM2(obj, dbmp, dbm);
value = dbm_fetch(dbm, key);
if (value.dptr == 0) {
if (rb_block_given_p()) return rb_yield(keystr);
return Qnil;
}
/* need to save value before dbm_delete() */
valstr = rb_tainted_str_new(value.dptr, value.dsize);
if (dbm_delete(dbm, key)) {
dbmp->di_size = -1;
rb_raise(rb_eDBMError, "dbm_delete failed");
}
else if (dbmp->di_size >= 0) {
dbmp->di_size--;
}
return valstr;
}
|
#reject! {|key, value| ... } ⇒ self #delete_if {|key, value| ... } ⇒ self
Deletes all entries for which the code block returns true. Returns self.
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 |
# File 'ext/rubysl/dbm/dbm.c', line 420
static VALUE
fdbm_delete_if(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE keystr, valstr;
VALUE ret, ary = rb_ary_new();
int i, status = 0;
long n;
fdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
n = dbmp->di_size;
dbmp->di_size = -1;
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
ret = rb_protect(rb_yield, rb_assoc_new(rb_str_dup(keystr), valstr), &status);
if (status != 0) break;
if (RTEST(ret)) rb_ary_push(ary, keystr);
GetDBM2(obj, dbmp, dbm);
}
for (i = 0; i < RARRAY_LEN(ary); i++) {
keystr = rb_ary_entry(ary, i);
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
if (dbm_delete(dbm, key)) {
rb_raise(rb_eDBMError, "dbm_delete failed");
}
}
if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - RARRAY_LEN(ary);
return obj;
}
|
#each_pair {|key, value| ... } ⇒ self
Calls the block once for each [key, value] pair in the database. Returns self.
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 |
# File 'ext/rubysl/dbm/dbm.c', line 703
static VALUE
fdbm_each_pair(VALUE obj)
{
datum key, val;
DBM *dbm;
struct dbmdata *dbmp;
VALUE keystr, valstr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
rb_yield(rb_assoc_new(keystr, valstr));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_key {|key| ... } ⇒ self
Calls the block once for each key string in the database. Returns self.
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 |
# File 'ext/rubysl/dbm/dbm.c', line 679
static VALUE
fdbm_each_key(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
rb_yield(rb_tainted_str_new(key.dptr, key.dsize));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_pair {|key, value| ... } ⇒ self
Calls the block once for each [key, value] pair in the database. Returns self.
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 |
# File 'ext/rubysl/dbm/dbm.c', line 703
static VALUE
fdbm_each_pair(VALUE obj)
{
datum key, val;
DBM *dbm;
struct dbmdata *dbmp;
VALUE keystr, valstr;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
rb_yield(rb_assoc_new(keystr, valstr));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#each_value {|value| ... } ⇒ self
Calls the block once for each value string in the database. Returns self.
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 |
# File 'ext/rubysl/dbm/dbm.c', line 655
static VALUE
fdbm_each_value(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
RETURN_ENUMERATOR(obj, 0, 0);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
rb_yield(rb_tainted_str_new(val.dptr, val.dsize));
GetDBM2(obj, dbmp, dbm);
}
return obj;
}
|
#empty? ⇒ Boolean
Returns true if the database is empty, false otherwise.
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 |
# File 'ext/rubysl/dbm/dbm.c', line 626
static VALUE
fdbm_empty_p(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
int i = 0;
GetDBM2(obj, dbmp, dbm);
if (dbmp->di_size < 0) {
dbm = dbmp->di_dbm;
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
i++;
}
}
else {
i = (int)dbmp->di_size;
}
if (i == 0) return Qtrue;
return Qfalse;
}
|
#fetch(key[, ifnone]) ⇒ Object
Return a value from the database by locating the key string provided. If the key is not found, returns ifnone
. If ifnone
is not given, raises IndexError.
236 237 238 239 240 241 242 243 244 245 246 247 |
# File 'ext/rubysl/dbm/dbm.c', line 236
static VALUE
fdbm_fetch_m(int argc, VALUE *argv, VALUE obj)
{
VALUE keystr, valstr, ifnone;
rb_scan_args(argc, argv, "11", &keystr, &ifnone);
valstr = fdbm_fetch(obj, keystr, ifnone);
if (argc == 1 && !rb_block_given_p() && NIL_P(valstr))
rb_raise(rb_eIndexError, "key not found");
return valstr;
}
|
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 |
# File 'ext/rubysl/dbm/dbm.c', line 780
static VALUE
fdbm_has_key(VALUE obj, VALUE keystr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
GetDBM2(obj, dbmp, dbm);
val = dbm_fetch(dbm, key);
if (val.dptr) return Qtrue;
return Qfalse;
}
|
#has_value?(value) ⇒ Boolean
Returns true if the database contains the specified string value, false otherwise.
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 |
# File 'ext/rubysl/dbm/dbm.c', line 804
static VALUE
fdbm_has_value(VALUE obj, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(valstr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = (int)RSTRING_LEN(valstr);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
if (val.dsize == (int)RSTRING_LEN(valstr) &&
memcmp(val.dptr, RSTRING_PTR(valstr), val.dsize) == 0)
return Qtrue;
}
return Qfalse;
}
|
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 |
# File 'ext/rubysl/dbm/dbm.c', line 780
static VALUE
fdbm_has_key(VALUE obj, VALUE keystr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
GetDBM2(obj, dbmp, dbm);
val = dbm_fetch(dbm, key);
if (val.dptr) return Qtrue;
return Qfalse;
}
|
#index(value) ⇒ Object
:nodoc:
278 279 280 281 282 283 |
# File 'ext/rubysl/dbm/dbm.c', line 278
static VALUE
fdbm_index(VALUE hash, VALUE value)
{
rb_warn("DBM#index is deprecated; use DBM#key");
return fdbm_key(hash, value);
}
|
#invert ⇒ Hash
Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding key as its value.
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 |
# File 'ext/rubysl/dbm/dbm.c', line 494
static VALUE
fdbm_invert(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE keystr, valstr;
VALUE hash = rb_hash_new();
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
rb_hash_aset(hash, valstr, keystr);
}
return hash;
}
|
#key(value) ⇒ String
Returns the key for the specified value.
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 |
# File 'ext/rubysl/dbm/dbm.c', line 255
static VALUE
fdbm_key(VALUE obj, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(valstr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = (int)RSTRING_LEN(valstr);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
if ((long)val.dsize == (int)RSTRING_LEN(valstr) &&
memcmp(val.dptr, RSTRING_PTR(valstr), val.dsize) == 0) {
return rb_tainted_str_new(key.dptr, key.dsize);
}
}
return Qnil;
}
|
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 |
# File 'ext/rubysl/dbm/dbm.c', line 780
static VALUE
fdbm_has_key(VALUE obj, VALUE keystr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
GetDBM2(obj, dbmp, dbm);
val = dbm_fetch(dbm, key);
if (val.dptr) return Qtrue;
return Qfalse;
}
|
#keys ⇒ Array
Returns an array of all the string keys in the database.
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 |
# File 'ext/rubysl/dbm/dbm.c', line 732
static VALUE
fdbm_keys(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
VALUE ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
rb_ary_push(ary, rb_tainted_str_new(key.dptr, key.dsize));
}
return ary;
}
|
#length ⇒ Integer
Returns the number of entries in the database.
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 |
# File 'ext/rubysl/dbm/dbm.c', line 601
static VALUE
fdbm_length(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
int i = 0;
GetDBM2(obj, dbmp, dbm);
if (dbmp->di_size > 0) return INT2FIX(dbmp->di_size);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
i++;
}
dbmp->di_size = i;
return INT2FIX(i);
}
|
#has_key?(key) ⇒ Boolean
Returns true if the database contains the specified key, false otherwise.
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 |
# File 'ext/rubysl/dbm/dbm.c', line 780
static VALUE
fdbm_has_key(VALUE obj, VALUE keystr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
GetDBM2(obj, dbmp, dbm);
val = dbm_fetch(dbm, key);
if (val.dptr) return Qtrue;
return Qfalse;
}
|
#reject {|key, value| ... } ⇒ Hash
Converts the contents of the database to an in-memory Hash, then calls Hash#reject with the specified code block, returning a new Hash.
884 885 886 887 888 |
# File 'ext/rubysl/dbm/dbm.c', line 884
static VALUE
fdbm_reject(VALUE obj)
{
return rb_hash_delete_if(fdbm_to_hash(obj));
}
|
#reject! {|key, value| ... } ⇒ self #delete_if {|key, value| ... } ⇒ self
Deletes all entries for which the code block returns true. Returns self.
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 |
# File 'ext/rubysl/dbm/dbm.c', line 420
static VALUE
fdbm_delete_if(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE keystr, valstr;
VALUE ret, ary = rb_ary_new();
int i, status = 0;
long n;
fdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
n = dbmp->di_size;
dbmp->di_size = -1;
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
ret = rb_protect(rb_yield, rb_assoc_new(rb_str_dup(keystr), valstr), &status);
if (status != 0) break;
if (RTEST(ret)) rb_ary_push(ary, keystr);
GetDBM2(obj, dbmp, dbm);
}
for (i = 0; i < RARRAY_LEN(ary); i++) {
keystr = rb_ary_entry(ary, i);
ExportStringValue(keystr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
if (dbm_delete(dbm, key)) {
rb_raise(rb_eDBMError, "dbm_delete failed");
}
}
if (status) rb_jump_tag(status);
if (n > 0) dbmp->di_size = n - RARRAY_LEN(ary);
return obj;
}
|
#replace(obj) ⇒ Object
Replaces the contents of the database with the contents of the specified object. Takes any object which implements the each_pair method, including Hash and DBM objects.
549 550 551 552 553 554 555 |
# File 'ext/rubysl/dbm/dbm.c', line 549
static VALUE
fdbm_replace(VALUE obj, VALUE other)
{
fdbm_clear(obj);
rb_block_call(other, rb_intern("each_pair"), 0, 0, update_i, obj);
return obj;
}
|
#select {|key, value| ... } ⇒ Array
Returns a new array consisting of the [key, value] pairs for which the code block returns true.
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 |
# File 'ext/rubysl/dbm/dbm.c', line 292
static VALUE
fdbm_select(VALUE obj)
{
VALUE new = rb_ary_new();
datum key, val;
DBM *dbm;
struct dbmdata *dbmp;
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
VALUE assoc, v;
val = dbm_fetch(dbm, key);
assoc = rb_assoc_new(rb_tainted_str_new(key.dptr, key.dsize),
rb_tainted_str_new(val.dptr, val.dsize));
v = rb_yield(assoc);
if (RTEST(v)) {
rb_ary_push(new, assoc);
}
GetDBM2(obj, dbmp, dbm);
}
return new;
}
|
#shift ⇒ Array
Removes a [key, value] pair from the database, and returns it. If the database is empty, returns nil. The order in which values are removed/returned is not guaranteed.
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 |
# File 'ext/rubysl/dbm/dbm.c', line 390
static VALUE
fdbm_shift(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE keystr, valstr;
fdbm_modify(obj);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
key = dbm_firstkey(dbm);
if (!key.dptr) return Qnil;
val = dbm_fetch(dbm, key);
keystr = rb_tainted_str_new(key.dptr, key.dsize);
valstr = rb_tainted_str_new(val.dptr, val.dsize);
dbm_delete(dbm, key);
return rb_assoc_new(keystr, valstr);
}
|
#length ⇒ Integer
Returns the number of entries in the database.
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 |
# File 'ext/rubysl/dbm/dbm.c', line 601
static VALUE
fdbm_length(VALUE obj)
{
datum key;
struct dbmdata *dbmp;
DBM *dbm;
int i = 0;
GetDBM2(obj, dbmp, dbm);
if (dbmp->di_size > 0) return INT2FIX(dbmp->di_size);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
i++;
}
dbmp->di_size = i;
return INT2FIX(i);
}
|
#store(key, value) ⇒ Object #[]=(key) ⇒ Object
Stores the specified string value in the database, indexed via the string key provided.
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 |
# File 'ext/rubysl/dbm/dbm.c', line 565
static VALUE
fdbm_store(VALUE obj, VALUE keystr, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
fdbm_modify(obj);
keystr = rb_obj_as_string(keystr);
valstr = rb_obj_as_string(valstr);
key.dptr = RSTRING_PTR(keystr);
key.dsize = (int)RSTRING_LEN(keystr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = (int)RSTRING_LEN(valstr);
GetDBM2(obj, dbmp, dbm);
dbmp->di_size = -1;
if (dbm_store(dbm, key, val, DBM_REPLACE)) {
#ifdef HAVE_DBM_CLEARERR
dbm_clearerr(dbm);
#endif
if (errno == EPERM) rb_sys_fail(0);
rb_raise(rb_eDBMError, "dbm_store failed");
}
return valstr;
}
|
#to_a ⇒ Array
Converts the contents of the database to an array of [key, value] arrays, and returns it.
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 |
# File 'ext/rubysl/dbm/dbm.c', line 832
static VALUE
fdbm_to_a(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
rb_ary_push(ary, rb_assoc_new(rb_tainted_str_new(key.dptr, key.dsize),
rb_tainted_str_new(val.dptr, val.dsize)));
}
return ary;
}
|
#to_hash ⇒ Hash
Converts the contents of the database to an in-memory Hash object, and returns it.
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 |
# File 'ext/rubysl/dbm/dbm.c', line 858
static VALUE
fdbm_to_hash(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE hash;
GetDBM2(obj, dbmp, dbm);
hash = rb_hash_new();
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
rb_hash_aset(hash, rb_tainted_str_new(key.dptr, key.dsize),
rb_tainted_str_new(val.dptr, val.dsize));
}
return hash;
}
|
#update(obj) ⇒ Object
Updates the database with multiple values from the specified object. Takes any object which implements the each_pair method, including Hash and DBM objects.
534 535 536 537 538 539 |
# File 'ext/rubysl/dbm/dbm.c', line 534
static VALUE
fdbm_update(VALUE obj, VALUE other)
{
rb_block_call(other, rb_intern("each_pair"), 0, 0, update_i, obj);
return obj;
}
|
#has_value?(value) ⇒ Boolean
Returns true if the database contains the specified string value, false otherwise.
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 |
# File 'ext/rubysl/dbm/dbm.c', line 804
static VALUE
fdbm_has_value(VALUE obj, VALUE valstr)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
ExportStringValue(valstr);
val.dptr = RSTRING_PTR(valstr);
val.dsize = (int)RSTRING_LEN(valstr);
GetDBM2(obj, dbmp, dbm);
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
if (val.dsize == (int)RSTRING_LEN(valstr) &&
memcmp(val.dptr, RSTRING_PTR(valstr), val.dsize) == 0)
return Qtrue;
}
return Qfalse;
}
|
#values ⇒ Array
Returns an array of all the string values in the database.
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 |
# File 'ext/rubysl/dbm/dbm.c', line 756
static VALUE
fdbm_values(VALUE obj)
{
datum key, val;
struct dbmdata *dbmp;
DBM *dbm;
VALUE ary;
GetDBM2(obj, dbmp, dbm);
ary = rb_ary_new();
for (key = dbm_firstkey(dbm); key.dptr; key = dbm_nextkey(dbm)) {
val = dbm_fetch(dbm, key);
rb_ary_push(ary, rb_tainted_str_new(val.dptr, val.dsize));
}
return ary;
}
|
#values_at(key, ...) ⇒ Array
Returns an array containing the values associated with the given keys.
322 323 324 325 326 327 328 329 330 331 332 333 |
# File 'ext/rubysl/dbm/dbm.c', line 322
static VALUE
fdbm_values_at(int argc, VALUE *argv, VALUE obj)
{
VALUE new = rb_ary_new2(argc);
int i;
for (i=0; i<argc; i++) {
rb_ary_push(new, fdbm_fetch(obj, argv[i], Qnil));
}
return new;
}
|