bool AssocArrayElem::convertKey(block& blk, AssocArrayType& aaType, Variable* keyVar, bool needSwap)
{
bool result = false; //conversion generated?
if (keyVar && aaType.keyTYPE().isStringType())
{
block* keyBlock = needSwap ? blk.addNewBlock() : &blk;
//do not convert if the key is explicitly of the System.String type
if (aaType.keyType().isString())
{
#if 0
keyVar->store(*keyBlock);
loadArray(*keyBlock, *keyVar);
#else
Variable* v = savePartialResult(*keyBlock, keyVar->getDecl(), keyVar->getType(), false);
keyBlock->add(*new UTF8Encoding);
loadArray(*keyBlock, *v);
#endif
keyBlock->add(*new EncodingGetString);
result = true;
}
if (needSwap)
{
blk.swapTail();
}
}
return result;
}
void block_file::write_block(int position, const block &b) {
ASSERTION(position < get_block_count());
ASSERTION(b.get_size() == block_size);
file.seekp(position * block_size);
file.write(b.raw_char_pointer(), block_size);
}
// as copy
block::block(const block& original)
:
BlockDef(original.blockDef()),
Vertices(original.points()),
Cells(original.cells()),
BoundaryPatches(original.boundaryPatches())
{}
void abstract_block_model::ok(block& blk) {
if (currentblockiteator != end()) currentblockiteator->set_ok();
currentblockiteator++;
parcel_iterator endit = blk.end();
endit++;
for (parcel_iterator it = blk.begin(); it != endit; ++it) {
if (it->first->isvalue()) {
if (!it->first->error()) {
switch (SUPER_TYPE(it->first->type())) {
case TYPE_EVENT:
{
executr->write_val_event(it->second, it->first->value_event());
break;
}
case TYPE_REPORT:
{
executr->write_val_report(it->second, it->first->value_report());
break;
}
default:
{
executr->write_val(it->second, it->first->value());
}
}
}
}
if (it->first->error()) {
executr->error(it->second, it->first->error());
}
}
}
// Return the neighbour face point from the mapped indices
inline label facePointN
(
const int facei,
const block& block,
const label i,
const label j
)
{
switch (facei)
{
case 0:
return facePointN(block, 0, i, j);
case 1:
return facePointN(block, block.meshDensity().x(), i, j);
case 2:
return facePointN(block, i, 0, j);
case 3:
return facePointN(block, i, block.meshDensity().y(), j);
case 4:
return facePointN(block, i, j, 0);
case 5:
return facePointN(block, i, j, block.meshDensity().z());
default:
return -1;
}
}
block::block(const block&right){
//delete []this->data;
allocData();
this->b_type=right.getType();
this->b_pos=right.getPos();
this->setType(this->b_type);
this->setState(right.getState());
}
std::size_t block_hasher::hash(const block& v) {
std::size_t seed(0);
combine(seed, v.type());
combine(seed, v.content());
return seed;
}
void block::addInside(block & check, block grab, int i)
{
int pos=0;
if(check.cond&&(pos=check.blockIsInside(grab))){
check.addInside(check.blocksIn[pos-1],grab,pos-1);
}
else {
addIn(grab, i);
}
}
void bGroup::resetUsed(block & t)
{
//-------- resets the log of what blocks have been used in the last print stage
used[""]=false;
used[t.title]=false;
for (unsigned int i=0; i<t.numInside(); i++) {
resetUsed(t.blocksIn[i]);
}
for (unsigned int i=0; i<t.size(); i++) {
resetUsed(t.blocksOn[i]);
}
}
void resetList(block & t, map<string,bool> & used)
{
//-------- resets the log of what blocks have been used in the last print stage
used[""]=false;
used[t.title]=false;
for (unsigned int i=0; i<t.numInside(); i++) {
resetList(t.blocksIn[i],used);
}
for (unsigned int i=0; i<t.size(); i++) {
resetList(t.blocksOn[i],used);
}
}
code data_base::verify_push(const block& block, size_t height)
{
if (block.transactions().empty())
return error::empty_block;
if (get_next_height(blocks()) != height)
return error::store_block_invalid_height;
if (block.header().previous_block_hash() !=
get_previous_hash(blocks(), height))
return error::store_block_missing_parent;
return error::success;
}
// Return the neighbour face point from the signed indices
inline label facePointN
(
const block& block,
const label i,
const label j,
const label k
)
{
return block.vtxLabel
(
unsignIndex(i, block.meshDensity().x()),
unsignIndex(j, block.meshDensity().y()),
unsignIndex(k, block.meshDensity().z())
);
}
//---------------------------------------------------------------
bool generate_genesis_block(
block& bl
, std::string const & genesis_tx
, uint32_t nonce
)
{
//genesis block
bl = boost::value_initialized<block>();
account_public_address ac = boost::value_initialized<account_public_address>();
std::vector<size_t> sz;
construct_miner_tx(0, 0, 0, 0, 0, ac, bl.miner_tx); // zero fee in genesis
blobdata txb = tx_to_blob(bl.miner_tx);
std::string hex_tx_represent = string_tools::buff_to_hex_nodelimer(txb);
std::string genesis_coinbase_tx_hex = config::GENESIS_TX;
blobdata tx_bl;
string_tools::parse_hexstr_to_binbuff(genesis_coinbase_tx_hex, tx_bl);
bool r = parse_and_validate_tx_from_blob(tx_bl, bl.miner_tx);
CHECK_AND_ASSERT_MES(r, false, "failed to parse coinbase tx from hard coded blob");
bl.major_version = CURRENT_BLOCK_MAJOR_VERSION;
bl.minor_version = CURRENT_BLOCK_MINOR_VERSION;
bl.timestamp = 0;
bl.nonce = nonce;
miner::find_nonce_for_given_block(bl, 1, 0);
bl.invalidate_hashes();
return true;
}
void bGroup::addFromClick(block & t, int _x, int _y)
{
for (unsigned int j=0; j<t.blocksIn.size(); j++) {
if (!inHand&&!ddopen&&!t.ddSelected){
int blk=0;
if(blk=t.blocksIn[j].onBlockIn(_x, _y)){
addFromClick(t.blocksIn[j].blocksIn[blk-1], _x, _y);
}
else if(t.blocksIn[j].clickDown(_x,_y)) {
int cur=add(t.passBlocks(OF_BLOCK_IN,j));
inHand=true;
dispx = blocks[cur].x-_x;
dispy = blocks[cur].y-_y;
}
}
}
for (unsigned int j=0; j<t.blocksOn.size(); j++) {
if (!inHand&&!ddopen&&!t.ddSelected){
int blk=0;
if(blk=t.blocksOn[j].onBlockIn(_x, _y)){
addFromClick(t.blocksOn[j].blocksIn[blk-1], _x, _y);
}
}
}
}
bool Game::can_place(block b, Point p)
{
bool onAbsCorner = false;
bool onRelCorner = false;
int N = dimension - 1;
Point corners[4] = { Point(0,0), Point(N, 0), Point(0, N), Point(N, N) };
Point corner = corners[my_number];
for(int i = 0; i < b.size(); i++){
Point q = b[i].add(p);
int x = q.x;
int y = q.y;
if (x > N || x < 0 || y < 0 || y > N || grid[x][y] >= 0
|| grid[x][y] == -2
|| (x > 0 && grid[x-1][y] == my_number)
|| (y > 0 && grid[x][y-1] == my_number)
|| (x < N && grid[x+1][y] == my_number)
|| (y < N && grid[x][y+1] == my_number)) {
return false;
}
onAbsCorner = onAbsCorner || q.eq(corner);
onRelCorner = onRelCorner
|| (x > 0 && y > 0 && grid[x-1][y-1] == my_number)
|| (x < N && y > 0 && grid[x+1][y-1] == my_number)
|| (x > 0 && y < N && grid[x-1][y+1] == my_number)
|| (x < N && y < N && grid[x+1][y+1] == my_number);
}
return grid[corner.x][corner.y] < 0 ? onAbsCorner : onRelCorner;
}
/**
* Frees the given block and resets it.
* \param b Block to be freed.
*/
void deallocate(block &b)
{
if (b) {
::free(b.ptr);
b.reset();
}
}
block Game::rotate_block(block b, int num_rotations)
{
block newBlock;
for(int i = 0; i < b.size(); i++){
newBlock.push_back(b[i].rotate(num_rotations));
}
return newBlock;
}
block calc_c22(block A, block B, block C) {
block tempC = C.block22();
tempC.add_scratch();
future<block> A21B12 = async(rec_mult, A.block21(), B.block12(), C.block22());
future<block> A22B22 = async(rec_mult, A.block22(), B.block22(), tempC);
return add_blocks(A21B12.get(), A22B22.get(), C.block22());
}
block calc_c11(block A, block B, block C) {
block tempC = C.block11();//scratch space
tempC.add_scratch();
future<block> A11B11 = async(rec_mult, A.block11(), B.block11(), C.block11());
future<block> A12B21 = async(rec_mult, A.block12(), B.block21(), tempC);
return add_blocks(A11B11.get(), A12B21.get(), C.block11());
}
code data_base::verify_insert(const block& block, size_t height)
{
if (block.transactions().empty())
return error::empty_block;
if (blocks_->exists(height))
return error::store_block_duplicate;
return error::success;
}
void draw_game::draw_Block(int x, int y, const block& object, bool is_connect) const
{
int cn = object.get_connect_dir();
//ブロックの中央座標
util::pos<int> center(x + block_size_.x / 2, y + block_size_.y / 2 ) ;
switch (object.get_block_type())
{
case BLOCK_TYPE::BLANK:
//DrawGraph(x, y, *res[RES::WALL], true);
//DrawBox(x, y, x + block_size_.x, y + block_size_.y, BlockDefaultColor, true);
break;
case BLOCK_TYPE::WALL:
DrawGraph(x, y, *res[RES::WALL], true);
//DrawBox(x, y, x + block_size_.x, y + block_size_.y, GetColor(128, 128, 128), true);
break;
case BLOCK_TYPE::BLOCK:
{
int color = is_connect ? LineColor : DarkLineColor;
//仮でDrawBox
//DrawBox(x, y, x + block_size_.x, y + block_size_.y, BlockDefaultColor, true);
//DrawGraph(x, y, *res[RES::BLOCK], true);
//線の方向にLineを描画する
if (cn & DIR::UP)
{
DrawLine(center.x, center.y, center.x, center.y - block_size_.y / 2, color, blockline_tickness);
}
if (cn & DIR::LEFT)
{
DrawLine(center.x, center.y, center.x - block_size_.x / 2, center.y, color, blockline_tickness);
}
if (cn & DIR::DOWN)
{
DrawLine(center.x, center.y, center.x, center.y + block_size_.y / 2, color, blockline_tickness);
}
if (cn & DIR::RIGHT)
{
DrawLine(center.x, center.y, center.x + block_size_.x / 2, center.y, color, blockline_tickness);
}
}
break;
}
}
int bGroup::heightUpdate(block & grab, block & comp)
{
int ret=0;
for (unsigned int i=0; i<comp.numInside(); i++) {
heightUpdate(grab, comp.blocksIn[i]);
}
for (unsigned int i=0; i<comp.size(); i++) {
heightUpdate(grab, comp.blocksOn[i]);
}
if(comp.blockIsInside(grab)&&!comp.bSeq&&!grab.numBlock){
if(!comp.inBlockIn(grab.x,grab.y)) comp.h=grab.heightOnlyOn(true)+comp.heightInside()+grab.h+65-((!comp.numInside())?40:0);
else comp.h=comp.heightInside()+65-((!comp.numInside())?40:0);
comp.updatePositions(grab);
}
return ret;
}
void show_block(uint8_t x, uint8_t y, const block& fig, const color::rgb& rgb)
{
for(uint8_t i = 0; i != fig.height; ++i)
{
for(uint8_t j = 0; j != fig.width; ++j)
{
if(fig.at(j, i))
ws2812_matrix::set_pixel_color(x + j, y - i, rgb);
}
}
}
void hide_block(uint8_t x, uint8_t y, const block& fig)
{
for(uint8_t i = 0; i != fig.height; ++i)
{
for(uint8_t j = 0; j != fig.width; ++j)
{
if(fig.at(j, i))
ws2812_matrix::clear_pixel(x + j, y - i);
}
}
}
/**
* Frees the given block back to the system. The block gets nulled.
* \param b The block, describing what memory shall be freed.
*/
void deallocate(block &b) noexcept
{
if (b) {
#ifdef _MSC_VER
_aligned_free(b.ptr);
#else
::free(b.ptr);
#endif
b.reset();
}
}
bool block::inside(block & drop)
{
bool ret=0;
if(type==BLK_BRACKET){
int inLine=y+ttlSize.y/2;
//int bottomSpace=orig.height-(interior.y+interior.height);
int inH=h-((inLine-y)+bottomBar/2);
if(drop.inBounds(x+interior.x, inLine, fullWidth()-interior.x, inH))
ret=true;
}
return ret;
}
bool intersects(const block& b, uint8_t x, uint8_t y)
{
for(uint8_t i = 0; i != b.height; ++i)
{
for(uint8_t j = 0; j != b.width; ++j)
{
if(b.at(j, i) && ws2812_matrix::is_on(x + j, y - i))
return true;
}
}
return false;
}
bool abstract_block_model::check_block_active(block& blk, parcel_iterator& bgn, parcel_iterator& ed) {
parcel_iterator strt = blk.begin();
parcel_iterator stpit = blk.end();
if (IN_SMPLSET(intf->type(strt->second)))
return true;
if (blk.begin() == stpit) {
return check_parcel_active(strt);
}
++stpit;
for (parcel_iterator it = blk.begin(); it != stpit; ++it) {
if (!check_parcel_active(it)) ++bgn;
else {
if (it != ed) {
for (it = ed; it != bgn; --it) {
if (!check_parcel_active(it)) ed--;
else return true;
}
}
return true;
}
}
return false;
}
void block::updatePositions(block & t){
if(blocksIn.size()&&!bSeq&&blockIsInside(t)==1&&!blocksIn[0].onInside(t.x, t.y)) blocksIn[0].move(x+20,y+40+t.h+t.heightOnlyOn()),blocksIn[0].updatePositions(t);
else if(blocksIn.size()) blocksIn[0].move(x+20,y+40),blocksIn[0].updatePositions(t);
for (unsigned int i=1; i<blocksIn.size()&&blocksIn.size()>1; i++) {
if(blockIsInside(t)-2==i-1&&!bSeq&&!blocksIn[i-1].onInside(t.x, t.y)&&!blocksIn[i].cond)
blocksIn[i].move(blocksIn[i-1].x,blocksIn[i-1].y+blocksIn[i-1].h+t.h+t.heightOnlyOn()-5);
else blocksIn[i].move(blocksIn[i-1].x,blocksIn[i-1].y+blocksIn[i-1].h-5);
blocksIn[i].updatePositions(t);
}
if(blocksOn.size()&&!bSeq&&blockIsBelow(t)==1) blocksOn[0].move(x,y+h-5),blocksOn[0].updatePositions(t);
else if(blocksOn.size()) blocksOn[0].move(x,y+h-5),blocksOn[0].updatePositions(t);
for (unsigned int i=1; i<blocksOn.size()&&blocksOn.size()>1; i++) {
if(blocksOn[i-1].blockIsBelow(t)==1&&!bSeq&&!blocksOn[i-1].onInside(t.x, t.y)&&!blocksOn[i].cond) {
blocksOn[i].move(blocksOn[i-1].x,blocksOn[i-1].y+blocksOn[i-1].h+t.h+t.heightOnlyOn()-5);
}
else blocksOn[i].move(blocksOn[i-1].x,blocksOn[i-1].y+blocksOn[i-1].h-5);
blocksOn[i].updatePositions(t);
}
for (unsigned int i=0; i<numBlocks.size(); i++) {
numBlocks[i].move(x+numBlocks[i].xo+1,y+(40-numBlocks[i].h)/2);
}
}
bool block::beneath(block & chk,signed int blw)
{
if(blw<ttlSize.y/2-5){
blw=ttlSize.y;
}
else blw+=ttlSize.y;
int midLine=y+h-ttlSize.y/2;
if(type==BLK_BRACKET){
midLine=y+(interior.y+interior.height+bottomBar/2);
blw=blw+(y+h)-midLine;
}
return (chk.inBounds(x, midLine, fullWidth(), blw));
}