stress_data::stress_data(string &i_sdata): files_w_data(i_sdata) {
    ifstream stream_data(files_w_data);
    int ct = 0; int tn_points = 0;
    while(!stream_data.eof() && !is_file_empty(stream_data))
    {
        string tmp_string;
        stream_data >> tmp_string;
        data_points<data_point_with_stress> tmp_data(tmp_string, ct++);
        data_points_collection.insert({tmp_string, tmp_data});
        tn_points += tmp_data.number_of_points;
    }
    num_of_zones = ct;
    total_num_of_points = tn_points;
}
/**
 * update node and data
 * \param node indicate key
 * \param data indicate value
 * \param flag =ZOO_EPHEMERAL
*/ 
bool ZKOP::zkUpdateNodeData(const std::string& node, const std::string& data, int flag) 
{/*{{{*/
	if (!zkCreateNodePath(node, flag)) {
		return false;
	}
	std::string tmp_data(data, 0, 256);

	int rc = 0;
	if ((rc = zoo_set(zkhandle, node.data(), tmp_data.data(), data.size(), -1)) != ZOK) {
		LOG(ERROR) << "update node data failed, node = [" << node << "], data = [" << tmp_data << "], error = [" << zerror(rc) << "]";
		return false;
	}

/*
#ifndef NDEBUG
	LOG(INFO) << "update node data successful, node = [" << node << "], data = [" << data << "]";
#endif
*/

	return true;
}/*}}}*/
std::string encode_base58(const data_chunk& unencoded_data)
{                                                                                
    std::string encoded_data;
    // Expected size increase from base58 conversion is approximately 137%
    // use 138% to be safe
    encoded_data.reserve((unencoded_data.size() - 1) * 138 / 100 + 1);

    // Convert big endian data to little endian
    // Extra zero at the end make sure bignum will interpret
    // as a positive number
    data_chunk tmp_data(unencoded_data.size() + 1, 0);
    std::reverse_copy(unencoded_data.begin(), unencoded_data.end(),
        tmp_data.begin());

    big_number long_value;
    long_value.set_data(tmp_data);
    while (long_value > 0)
    {                                                                            
        auto result = divmod(long_value, 58);
        long_value = result.first;
        size_t remainder = result.second.uint32();
        encoded_data += base58_chars[remainder];
    }                                                                            
                                                                                 
    // Leading zeroes encoded as base58 zeros                                    
    for (const uint8_t unencoded_byte: unencoded_data)
    {
        if (unencoded_byte != 0)
            break;
        encoded_data += base58_chars[0];
    }

    // Convert little endian std::string to big endian
    reverse(encoded_data.begin(), encoded_data.end());
    return encoded_data;
}