bool element_block_func_base::equal_block(const base_element_block& left, const base_element_block& right)
{
element_t block_type = get_block_type(left);
if (block_type != get_block_type(right))
return false;
switch (block_type)
{
case element_type_numeric:
return numeric_element_block::get(left) == numeric_element_block::get(right);
case element_type_string:
return string_element_block::get(left) == string_element_block::get(right);
case element_type_short:
return short_element_block::get(left) == short_element_block::get(right);
case element_type_ushort:
return ushort_element_block::get(left) == ushort_element_block::get(right);
case element_type_int:
return int_element_block::get(left) == int_element_block::get(right);
case element_type_uint:
return uint_element_block::get(left) == uint_element_block::get(right);
case element_type_long:
return long_element_block::get(left) == long_element_block::get(right);
case element_type_ulong:
return ulong_element_block::get(left) == ulong_element_block::get(right);
case element_type_boolean:
return boolean_element_block::get(left) == boolean_element_block::get(right);
case element_type_char:
return char_element_block::get(left) == char_element_block::get(right);
case element_type_uchar:
return uchar_element_block::get(left) == uchar_element_block::get(right);
default:
;
}
return false;
}
//virtual
std::istream &csv_selector::input(std::istream &iss) {
// reuse the input from csv_tool
if (!iss) {
return iss;
}
csv_data->buffer.clear();
while (iss) {
std::string tmp = read_block(iss);
// std::cerr << "tmp:" << std::endl << tmp << std::endl;
if (tmp.size() < 1) {
break;
}
std::string block_type = get_block_type(tmp);
if (block_type == "csv_analyzer_header") {
csv_data->mcolumns = parse_csv_header(tmp);
this->update_selector();
} else if (block_type == "line_t" ) {
line_t line = parse_csv_line(tmp);
csv_data->buffer.push_back(line);
} else {
throw std::runtime_error("unknown block type in csv_selector::input: \"" + block_type + "\". block = \"" + tmp + "\".");
}
}
return iss;
}
base_element_block* element_block_func_base::clone_block(const base_element_block& block)
{
switch (get_block_type(block))
{
case element_type_numeric:
return numeric_element_block::clone_block(block);
case element_type_string:
return string_element_block::clone_block(block);
case element_type_short:
return short_element_block::clone_block(block);
case element_type_ushort:
return ushort_element_block::clone_block(block);
case element_type_int:
return int_element_block::clone_block(block);
case element_type_uint:
return uint_element_block::clone_block(block);
case element_type_long:
return long_element_block::clone_block(block);
case element_type_ulong:
return ulong_element_block::clone_block(block);
case element_type_boolean:
return boolean_element_block::clone_block(block);
case element_type_char:
return char_element_block::clone_block(block);
case element_type_uchar:
return uchar_element_block::clone_block(block);
default:
throw general_error("clone_block: failed to clone a block of unknown type.");
}
}
void *realloc_small_tiny(t_page_list *lst, void *ptr, size_t len)
{
size_t i;
void *addr;
if (len <= get_block_size(lst->page.type))
{
MALLOC_UNLOCK();
return (return_enomem(ptr));
}
if (!(addr = create_new_block(get_block_type(len), len)))
{
MALLOC_UNLOCK();
return (return_enomem(NULL));
}
i = 0;
while (i < len && i < lst->page.len - sizeof(*lst))
{
((unsigned char*)addr)[i] = ((unsigned char*)ptr)[i];
i++;
}
free(ptr);
MALLOC_UNLOCK();
return (return_enomem(addr));
}
int64_t GWriteHDFFile::WriteBlock(std::string BlockName, int type, void *data, int partlen, uint32_t np_write, uint32_t begin)
{
herr_t herr;
hid_t handle = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
hid_t group = H5Gopen2(handle, g_name[type], H5P_DEFAULT);
if(group < 0)
return group;
hsize_t size[2];
int rank=1;
//Get type
char b_type = get_block_type(BlockName);
hid_t dtype;
if(b_type == 'f') {
size[1] = partlen/sizeof(float);
dtype=H5T_NATIVE_FLOAT;
}else if (b_type == 'i') {
size[1] = partlen/sizeof(int64_t);
//Hopefully this is 64 bits; the HDF5 manual is not clear.
dtype = H5T_NATIVE_LLONG;
}
else{
return -1000;
}
if (size[1] > 1) {
rank = 2;
}
/* I don't totally understand why the below works (it is not clear to me from the documentation).
* I gleaned it from a posting to the HDF5 mailing list and a related stack overflow thread here:
* http://stackoverflow.com/questions/24883461/hdf5-updating-a-cell-in-a-table-of-integers
* http://lists.hdfgroup.org/pipermail/hdf-forum_lists.hdfgroup.org/2014-July/007966.html
* The important thing seems to be that we have a dataspace for the whole array and create a hyperslab on that dataspace.
* Then we need another dataspace with the size of the stuff we want to write.*/
//Make space in memory for the whole array
//Create a hyperslab that we will write to
size[0] = npart[type];
hid_t full_space_id = H5Screate_simple(rank, size, NULL);
//If this is the first write, create the dataset
if (begin==0) {
H5Dcreate2(group,BlockName.c_str(),dtype, full_space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
}
hid_t dset = H5Dopen2(group,BlockName.c_str(),H5P_DEFAULT);
if (dset < 0)
return dset;
size[0] = np_write;
hid_t space_id = H5Screate_simple(rank, size, NULL);
hsize_t begins[2]={begin,0};
//Select the hyperslab of elements we are about to write to
H5Sselect_hyperslab(full_space_id, H5S_SELECT_SET, begins, NULL, size, NULL);
/* Write to the dataset */
herr = H5Dwrite(dset, dtype, space_id, full_space_id, H5P_DEFAULT, data);
H5Dclose(dset);
H5Sclose(space_id);
H5Sclose(full_space_id);
H5Gclose(group);
H5Fclose(handle);
if (herr < 0)
return herr;
return np_write;
}
void element_block_func_base::swap_values(
base_element_block& blk1, base_element_block& blk2, size_t pos1, size_t pos2, size_t len)
{
element_t blk1_type = get_block_type(blk1);
assert(blk1_type == get_block_type(blk2));
switch (blk1_type)
{
case element_type_numeric:
numeric_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_string:
string_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_short:
short_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_ushort:
ushort_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_int:
int_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_uint:
uint_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_long:
long_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_ulong:
ulong_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_boolean:
boolean_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_char:
char_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
case element_type_uchar:
uchar_element_block::swap_values(blk1, blk2, pos1, pos2, len);
break;
default:
throw general_error("swap_values: block of unknown type.");
}
}
BlockType World::get_block_type(int block_x, int block_y, int block_z) const
{
auto chunk = get_block_chunk(block_x, block_y, block_z);
if (!chunk)
{
return BLOCK_AIR;
}
return chunk->get_block_type(static_cast<int>(block_x - chunk->get_x() * WorldConstants::CHUNK_SIZE), static_cast<int>(block_y - chunk->get_y() * WorldConstants::CHUNK_SIZE), static_cast<int>(block_z - chunk->get_z() * WorldConstants::CHUNK_SIZE));
}
static int init_face(cube_face_t *face, char color){
int i;
int j;
for(i = 0; i < CUBE_ORDER; ++i){
for(j = 0; j < CUBE_ORDER; ++j){
face->block[i][j].color = color;
face->block[i][j].row = 'A' + i;
face->block[i][j].col = 'a' + j;
face->block[i][j].type = get_block_type(i, j);
}
}
return 0;
}
void element_block_func_base::delete_block(const base_element_block* p)
{
if (!p)
return;
switch (get_block_type(*p))
{
case element_type_numeric:
numeric_element_block::delete_block(p);
break;
case element_type_string:
string_element_block::delete_block(p);
break;
case element_type_short:
short_element_block::delete_block(p);
break;
case element_type_ushort:
ushort_element_block::delete_block(p);
break;
case element_type_int:
int_element_block::delete_block(p);
break;
case element_type_uint:
uint_element_block::delete_block(p);
break;
case element_type_long:
long_element_block::delete_block(p);
break;
case element_type_ulong:
ulong_element_block::delete_block(p);
break;
case element_type_boolean:
boolean_element_block::delete_block(p);
break;
case element_type_char:
char_element_block::delete_block(p);
break;
case element_type_uchar:
uchar_element_block::delete_block(p);
break;
default:
throw general_error("delete_block: failed to delete a block of unknown type.");
}
}
void element_block_func_base::prepend_values_from_block(
base_element_block& dest, const base_element_block& src, size_t begin_pos, size_t len)
{
switch (get_block_type(dest))
{
case element_type_numeric:
numeric_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_string:
string_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_short:
short_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_ushort:
ushort_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_int:
int_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_uint:
uint_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_long:
long_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_ulong:
ulong_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_boolean:
boolean_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_char:
char_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
case element_type_uchar:
uchar_element_block::prepend_values_from_block(dest, src, begin_pos, len);
break;
default:
throw general_error("prepend_values_from_block: failed to prepend values to a block of unknown type.");
}
}
void element_block_func_base::shrink_to_fit(base_element_block& block)
{
switch (get_block_type(block))
{
case element_type_numeric:
numeric_element_block::shrink_to_fit(block);
break;
case element_type_string:
string_element_block::shrink_to_fit(block);
break;
case element_type_short:
short_element_block::shrink_to_fit(block);
break;
case element_type_ushort:
ushort_element_block::shrink_to_fit(block);
break;
case element_type_int:
int_element_block::shrink_to_fit(block);
break;
case element_type_uint:
uint_element_block::shrink_to_fit(block);
break;
case element_type_long:
long_element_block::shrink_to_fit(block);
break;
case element_type_ulong:
ulong_element_block::shrink_to_fit(block);
break;
case element_type_boolean:
boolean_element_block::shrink_to_fit(block);
break;
case element_type_char:
char_element_block::shrink_to_fit(block);
break;
case element_type_uchar:
uchar_element_block::shrink_to_fit(block);
break;
default:
throw general_error("shrink_to_fit: failed to print a block of unknown type.");
}
}
void element_block_func_base::erase(base_element_block& block, size_t pos, size_t size)
{
switch (get_block_type(block))
{
case element_type_numeric:
numeric_element_block::erase_block(block, pos, size);
break;
case element_type_string:
string_element_block::erase_block(block, pos, size);
break;
case element_type_short:
short_element_block::erase_block(block, pos, size);
break;
case element_type_ushort:
ushort_element_block::erase_block(block, pos, size);
break;
case element_type_int:
int_element_block::erase_block(block, pos, size);
break;
case element_type_uint:
uint_element_block::erase_block(block, pos, size);
break;
case element_type_long:
long_element_block::erase_block(block, pos, size);
break;
case element_type_ulong:
ulong_element_block::erase_block(block, pos, size);
break;
case element_type_boolean:
boolean_element_block::erase_block(block, pos, size);
break;
case element_type_char:
char_element_block::erase_block(block, pos, size);
break;
case element_type_uchar:
uchar_element_block::erase_block(block, pos, size);
break;
default:
throw general_error("erase: failed to erase elements from a block of unknown type.");
}
}
static int is_wrap_pt(char *buf, uint64_t *highest_seq)
{
struct gfs2_buffer_head tbh = { .b_data = buf };
if (get_block_type(&tbh, NULL) == GFS2_METATYPE_LH) {
uint64_t seq;
if (sbd.gfs1) {
struct gfs_log_header lh;
gfs_log_header_in(&lh, &tbh);
seq = lh.lh_sequence;
} else {
struct gfs2_log_header lh;
gfs2_log_header_in(&lh, &tbh);
seq = lh.lh_sequence;
}
if (seq < *highest_seq)
return 1;
*highest_seq = seq;
}
return 0;
}
/**
* meta_has_ref - check if a metadata block references a given block
*/
static int meta_has_ref(uint64_t abs_block, int tblk)
{
struct gfs2_buffer_head *mbh;
int structlen, ty, has_ref = 0;
uint64_t *b;
struct gfs2_dinode *dinode;
mbh = bread(&sbd, abs_block);
ty = get_block_type(mbh, &structlen);
if (ty == GFS2_METATYPE_DI) {
dinode = (struct gfs2_dinode *)mbh->b_data;
if (be64_to_cpu(dinode->di_eattr) == tblk)
has_ref = 1;
}
b = (uint64_t *)(mbh->b_data + structlen);
while (!has_ref && ty && (char *)b < mbh->b_data + sbd.bsize) {
if (be64_to_cpu(*b) == tblk)
has_ref = 1;
b++;
}
brelse(mbh);
return has_ref;
}
Type const*
Parser::on_block_type(Type const* t)
{
return get_block_type(t);
}
/**
* dump_journal - dump a journal file's contents.
* @journal: name of the journal to dump
* @tblk: block number to trace in the journals
*
* This function dumps the contents of a journal. If a trace block is specified
* then only information printed is: (1) log descriptors that reference that
* block, (2) metadata in the journal that references the block, or (3)
* rgrp bitmaps that reference that block's allocation bit status.
*/
void dump_journal(const char *journal, int tblk)
{
struct gfs2_buffer_head *j_bh = NULL, dummy_bh;
uint64_t jblock, j_size, jb, abs_block, saveblk, wrappt = 0;
int start_line, journal_num;
struct gfs2_inode *j_inode = NULL;
int ld_blocks = 0, offset_from_ld = 0;
uint64_t tblk_off = 0, bblk_off = 0, bitblk = 0;
uint64_t highest_seq = 0;
char *jbuf = NULL;
struct rgrp_tree *rgd = NULL;
uint64_t abs_ld = 0;
start_line = line;
lines_per_row[dmode] = 1;
journal_num = atoi(journal + 7);
print_gfs2("Dumping journal #%d.", journal_num);
if (tblk) {
dmode = HEX_MODE;
print_gfs2(" Tracing block 0x%llx", (unsigned long long)tblk);
}
eol(0);
jblock = find_journal_block(journal, &j_size);
if (!jblock)
return;
if (!sbd.gfs1) {
j_bh = bread(&sbd, jblock);
j_inode = lgfs2_inode_get(&sbd, j_bh);
if (j_inode == NULL) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
jbuf = malloc(sbd.bsize);
if (jbuf == NULL) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
}
if (tblk) {
uint64_t wp;
rgd = gfs2_blk2rgrpd(&sbd, tblk);
if (!rgd) {
print_gfs2("Can't locate the rgrp for block 0x%x",
tblk);
eol(0);
} else {
uint64_t o;
int bmap = 0;
print_gfs2("rgd: 0x%llx for 0x%x, ", rgd->ri.ri_addr,
rgd->ri.ri_length);
o = tblk - rgd->ri.ri_data0;
if (o >= (rgd->bits->bi_start +
rgd->bits->bi_len) * GFS2_NBBY)
o += (sizeof(struct gfs2_rgrp) -
sizeof(struct gfs2_meta_header))
* GFS2_NBBY;
bmap = o / sbd.sd_blocks_per_bitmap;
bitblk = rgd->ri.ri_addr + bmap;
print_gfs2("bitmap: %d, bitblk: 0x%llx", bmap,
(unsigned long long)bitblk);
eol(0);
}
wrappt = find_wrap_pt(j_inode, jbuf, jblock, j_size);
wp = wrappt / (sbd.gfs1 ? 1 : sbd.bsize);
print_gfs2("Starting at journal wrap block: 0x%llx "
"(j + 0x%llx)",
(unsigned long long)jblock + wp,
(unsigned long long)wp);
eol(0);
}
for (jb = 0; jb < j_size; jb += (sbd.gfs1 ? 1 : sbd.bsize)) {
int is_pertinent = 1;
uint32_t block_type = 0;
if (sbd.gfs1) {
if (j_bh)
brelse(j_bh);
abs_block = jblock + ((jb + wrappt) % j_size);
j_bh = bread(&sbd, abs_block);
dummy_bh.b_data = j_bh->b_data;
} else {
int error = fsck_readi(j_inode, (void *)jbuf,
((jb + wrappt) % j_size),
sbd.bsize, &abs_block);
if (!error) /* end of file */
break;
dummy_bh.b_data = jbuf;
}
offset_from_ld++;
block_type = get_block_type(&dummy_bh, NULL);
if (block_type == GFS2_METATYPE_LD) {
ld_blocks = process_ld(abs_block, wrappt, j_size, jb,
&dummy_bh, tblk, &tblk_off,
bitblk, rgd, &is_pertinent,
&bblk_off);
offset_from_ld = 0;
abs_ld = abs_block;
} else if (!tblk && block_type == GFS2_METATYPE_LH) {
struct gfs2_log_header lh;
struct gfs_log_header lh1;
if (sbd.gfs1) {
gfs_log_header_in(&lh1, &dummy_bh);
check_journal_wrap(lh1.lh_sequence,
&highest_seq);
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: "
"Flags:%x, Seq: 0x%llx, 1st: 0x%llx, "
"tail: 0x%llx, last: 0x%llx",
abs_block, jb + wrappt,
lh1.lh_flags, lh1.lh_sequence,
lh1.lh_first, lh1.lh_tail,
lh1.lh_last_dump);
} else {
gfs2_log_header_in(&lh, &dummy_bh);
check_journal_wrap(lh.lh_sequence,
&highest_seq);
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log header: Seq"
": 0x%llx, tail: 0x%x, blk: 0x%x%s",
abs_block, ((jb + wrappt) % j_size)
/ sbd.bsize, lh.lh_sequence,
lh.lh_tail, lh.lh_blkno,
lh.lh_flags ==
GFS2_LOG_HEAD_UNMOUNT ?
" [UNMOUNTED]" : "");
}
eol(0);
} else if ((ld_blocks > 0) &&
(sbd.gfs1 || block_type == GFS2_METATYPE_LB)) {
print_gfs2("0x%"PRIx64" (j+%4"PRIx64"): Log descriptor"
" continuation block", abs_block,
((jb + wrappt) % j_size) / sbd.bsize);
eol(0);
print_gfs2(" ");
ld_blocks -= print_ld_blks((uint64_t *)dummy_bh.b_data +
(sbd.gfs1 ? 0 :
sizeof(struct gfs2_meta_header)),
(dummy_bh.b_data +
sbd.bsize), start_line,
tblk, &tblk_off, 0, rgd,
0, 1, NULL, 0);
} else if (block_type == 0) {
continue;
}
/* Check if this metadata block references the block we're
trying to trace. */
if (details || (tblk && ((is_pertinent &&
((tblk_off && offset_from_ld == tblk_off) ||
(bblk_off && offset_from_ld == bblk_off))) ||
meta_has_ref(abs_block, tblk)))) {
uint64_t ref_blk = 0;
saveblk = block;
block = abs_block;
if (tblk && !details) {
ref_blk = get_ldref(abs_ld, offset_from_ld);
display(0, 1, tblk, ref_blk);
} else {
display(0, 0, 0, 0);
}
block = saveblk;
}
}
inode_put(&j_inode);
brelse(j_bh);
blockhist = -1; /* So we don't print anything else */
free(jbuf);
if (!termlines)
fflush(stdout);
}
