/*
* bc_close() is not thread safe, should stop other threads before call it.
* */
void bc_close(Bitcask *bc)
{
char datapath[255], hintpath[255];
if (bc->optimize_flag > 0)
{
bc->optimize_flag = 2;
while (bc->optimize_flag > 0)
{
sleep(1);
}
}
pthread_mutex_lock(&bc->write_lock);
bc_flush(bc, 0, 0);
if (NULL != bc->curr_tree)
{
if (bc->curr_bytes > 0)
{
build_hint(bc->curr_tree, new_path(hintpath, bc->mgr, HINT_FILE, bc->curr));
}
else
{
ht_destroy(bc->curr_tree);
}
bc->curr_tree = NULL;
}
if (bc->curr_bytes == 0) bc->curr --;
if (bc->curr - bc->last_snapshot >= SAVE_HTREE_LIMIT)
{
if (ht_save(bc->tree, new_path(datapath, bc->mgr, HTREE_FILE, bc->curr)) == 0)
{
mgr_unlink(gen_path(datapath, mgr_base(bc->mgr), HTREE_FILE, bc->last_snapshot));
}
else
{
fprintf(stderr, "save HTree to %s failed\n", datapath);
}
}
ht_destroy(bc->tree);
mgr_destroy(bc->mgr);
free(bc->write_buffer);
free(bc);
}
int main() {
{
TimeCheck time;
auto surface = create_surface(CAIRO_FORMAT_ARGB32, SURFACE_SIZE{ 256, 256 });
auto cr = create(surface);
arc(cr, POINT{ 128.0, 128.0 }, 76.8, DEGRESS{ 0 }, DEGRESS{ 360 });
clip(cr);
new_path(cr); /* current path is not consumed by cairo_clip() */
rectangle(cr, POINT{ 0, 0 }, SIZE{ 255, 255 });
fill(cr);
source(cr, RGB{ 0, 1, 0 });
move_to(cr, POINT{ 0, 0 });
line_to(cr, POINT{ 256, 256 });
move_to(cr, POINT{ 256, 0 });
line_to(cr, POINT{ 0, 256 });
line_width(cr, 10.0);
stroke(cr);
write_to_png(surface, "image.png");
}
return 0;
}
// MemoryManager::_build_context_maps
void MemoryManager::_build_context_maps( const ContextConfig & i_context, const NamePath & i_context_path )
{
// setup the entry
ContextEntry entry;
entry.m_config = &i_context;
IAllocator * allocator = nullptr;
if( i_context.allocator_config() != nullptr )
{
allocator = i_context.allocator_config()->create_allocator();
}
entry.m_allocator = allocator;
// insert it in the map
if( !m_contexts_map.insert( std::make_pair( i_context_path, entry ) ).second )
{
memo_externals::output_message( "hash collision in the context map: " );
memo_externals::output_message( i_context.name().name() );
memo_externals::output_message( "\n" );
memo_externals::debug_break();
}
const ContextConfig::ContextVector & inner_contexts = i_context.inner_contexts();
for( size_t index = 0; index < inner_contexts.size(); index++ )
{
const ContextConfig & child_config = *inner_contexts[ index ];
NamePath new_path( i_context_path );
new_path.append_context( child_config.name() );
_build_context_maps( child_config, new_path );
}
}
std::string path::expandvars(const std::string &path) {
std::string new_path(path);
if(new_path.find('$') == std::string::npos) {
return new_path;
}
pcrecpp::StringPiece path_re(new_path);
pcrecpp::RE expandvars_re(".*\\$(\\w+|\\{[^}]*\\})");
int offset = 0;
std::string _;
std::string varname;
while(expandvars_re.Consume(&path_re, &varname)) {
int varname_size = varname.size();
if(varname.find('{') == 0 && varname.find('}') == varname.size() - 1) {
varname = varname.substr(1, varname.length() - 2);
}
char *_varval = getenv(varname.c_str());
if(_varval != NULL) {
std::string varval(_varval);
offset = new_path.size() - path_re.size();
std::string tail(new_path.substr(offset));
new_path = new_path.substr(0, offset - varname_size - 1) + varval;
offset = new_path.size();
new_path += tail;
} else {
offset = new_path.size() - path_re.size();
}
}
return new_path;
}
void PHPWorkspace::Rename(const wxString& newname)
{
wxFileName new_path(GetFilename());
new_path.SetName(newname);
if(!::wxRenameFile(m_workspaceFile.GetFullPath(), new_path.GetFullPath())) {
wxString msg;
msg << _("Failed to rename workspace file:\n'") << m_workspaceFile.GetFullName() << _("'\nto:\n'")
<< new_path.GetFullName() << "'\n" << strerror(errno);
::wxMessageBox(msg, "CodeLite", wxOK | wxCENTER | wxICON_ERROR, EventNotifier::Get()->TopFrame());
return;
}
PHPEvent evt(wxEVT_PHP_WORKSPACE_RENAMED);
evt.SetOldFilename(m_workspaceFile.GetFullPath());
evt.SetFileName(new_path.GetFullPath());
EventNotifier::Get()->AddPendingEvent(evt);
// and now rename the actual file
m_workspaceFile = new_path;
// trigger a workspace parsing
wxCommandEvent evtRetag(wxEVT_CMD_RETAG_WORKSPACE_FULL);
EventNotifier::Get()->AddPendingEvent(evtRetag);
}
int Lua_Monster_Move_By_Path(lua_State *L)
{
int monster_index = Lua_Monster::Index(L, 1);
int polygon_index = 0;
if (lua_isnumber(L, 2))
{
polygon_index = static_cast<int>(lua_tonumber(L, 2));
if (!Lua_Polygon::Valid(polygon_index))
return luaL_error(L, "move_by_path: invalid polygon index");
}
else if (Lua_Polygon::Is(L, 2))
{
polygon_index = Lua_Polygon::Index(L, 2);
}
else
return luaL_error(L, "move_by_path: incorrect argument type");
monster_data *monster = get_monster_data(monster_index);
if (MONSTER_IS_PLAYER(monster))
return luaL_error(L, "move_by_path: monster is player");
monster_definition *definition = get_monster_definition_external(monster->type);
object_data *object = get_object_data(monster->object_index);
monster_pathfinding_data path;
world_point2d destination;
if (!MONSTER_IS_ACTIVE(monster))
activate_monster(monster_index);
if (monster->path != NONE)
{
delete_path(monster->path);
monster->path = NONE;
}
SET_MONSTER_NEEDS_PATH_STATUS(monster, false);
path.definition = definition;
path.monster = monster;
path.cross_zone_boundaries = true;
destination = get_polygon_data(polygon_index)->center;
monster->path = new_path((world_point2d *) &object->location, object->polygon, &destination, polygon_index, 3 * definition->radius, monster_pathfinding_cost_function, &path);
if (monster->path == NONE)
{
if (monster->action != _monster_is_being_hit || MONSTER_IS_DYING(monster))
{
set_monster_action(monster_index, _monster_is_stationary);
}
set_monster_mode(monster_index, _monster_unlocked, NONE);
return 0;
}
advance_monster_path(monster_index);
return 0;
}
void Environment::addToFrontEnvironmentVariable(const std::string& variable, const std::string& value) {
std::string new_path(variable + "=");
const char* path_env = getenv(variable.c_str());
new_path += value;
new_path += ";";
if (path_env) {
new_path += path_env;
}
_putenv(new_path.c_str());
}
// Take a path and convert to the conforming definition, back-slashes converted to forward slashes
// and no trailing slash.
std::string make_conformal_path(const std::string& path)
{
std::string new_path(path);
std::replace(new_path.begin(), new_path.end(),'\\','/');
new_path = boost::regex_replace(new_path, boost::regex("//"), "/", boost::match_default | boost::format_all);
if(new_path[new_path.length()-1] == '/') {
new_path.erase(new_path.length()-1);
}
return new_path;
}
struct path *find_shortest_ (int **weights, struct path **cache, struct node **graph, int id1, int id2) {
printf ("id1: %d, id2: %d\n", id1, id2);
if (id1 == id2) {
struct path *stub = new_path (id1);
cache[id1] = stub;
return stub;
}
// If the path passed to us is a cycl
//struct node *start = get_node (graph, id1);
struct node *end = get_node (graph, id2);
// Get all of the shortest paths for the predecessors
// Also, the shortest path to us is us plus the shortest of the paths to our
// predecessors
int i;
int min = 65535;
int minpath = 0;
for (i = 0; i < end->num_back; i++) {
struct path *cur = cache[end->back[i]];
// Only do work if we have to
if (cur == NULL) {
cur = find_shortest_ (weights, cache, graph, id1, end->back[i]);
}
// Now we definitely have a value
if (cur->numelems > 0 && cur->length + weights[end->back[i]][id2] < min) {
min = cur->length + weights[end->back[i]][id2];
minpath = end->back[i];
}
}
// If there's no path, return that
// We also get here if there's nobody behind us
if (min == 65535)
return no_path ();
// Add us to the cache and return
struct path *our_shortest = add_stop (weights, cache[minpath], minpath, id2);
// If we've cycled (only happens if there's a negative cycle) then print out
// that we have a negative cycle and the path that has it
// Might not terminate if we do... Hmm...
if (has_cycle (our_shortest)) {
printf ("======== We have a cycle =======\n");
print_path (our_shortest);
printf("================\n");
}
// Add us to the cache
cache[id2] = our_shortest;
return our_shortest;
}
void generate_alt_paths(PathConsVector& paths, const std::string& base, const std::vector<std::string>& alts,
const uint32_t k)
{
// Generate alternatives
for(uint32_t ai = 0; ai < alts.size(); ++ai) {
const std::string& alt = alts[ai];
if(alt.size() < k)
continue;
kLCSResult result = kLCS(base, alt, k);
#ifdef DEBUG_ALT_GENERATION
printf("Match to alt %s\n", alt.c_str());
for(size_t mi = 0; mi < result.size(); ++mi) {
std::string extend = "";
if(mi < result.size() - 1 && result[mi].j + 1 != result[mi + 1].j) {
extend = alt.substr(result[mi].j, result[mi + 1].j - result[mi].j + k);
}
printf("\t%zu %zu %s %s\n", result[mi].i, result[mi].j, base.substr(result[mi].i, k).c_str(), extend.c_str());
}
#endif
uint32_t match_idx = 0;
while(match_idx < result.size()) {
uint32_t last_idx = result.size() - 1;
// advance the match to the next point of divergence
while(match_idx != last_idx &&
result[match_idx].i == result[match_idx + 1].i - 1 &&
result[match_idx].j == result[match_idx + 1].j - 1) {
match_idx++;
}
// no more divergences to process
if(match_idx == last_idx)
break;
uint32_t bl = result[match_idx + 1].i - result[match_idx].i;
uint32_t rl = result[match_idx + 1].j - result[match_idx].j;
std::string base_subseq = base.substr(result[match_idx].i, bl);
std::string alt_subseq = alt.substr(result[match_idx].j, rl);
// Perform the splice
PathCons new_path(base);
new_path.path.replace(result[match_idx].i, bl, alt_subseq);
paths.push_back(new_path);
match_idx += 1;
}
}
}
bool TreeIterator::Reset(const std::wstring &path, bool ignore_err)
{
Path new_path(path);
if(new_path.GetPathType() == INVALID_PATH)
{
return false;
}else
{
m_root = new_path;//Reset(path);
m_ignore_error = ignore_err;
clear();
return true;
}
}
void Environment::addToEnvironmentVariable(const std::string& variable, const std::string& value) {
std::string new_path(variable + "=");
const char* path_env = getenv(variable.c_str());
if (path_env) {
new_path += path_env;
}
if (new_path.length() > 0) {
if (!(new_path.back() == '=' || new_path.back() == ';')) {
new_path += ";";
}
}
new_path += value;
_putenv(new_path.c_str());
}
void bc_rotate(Bitcask *bc)
{
// build in new thread
char hintpath[255];
new_path(hintpath, bc->mgr, HINT_FILE, bc->curr);
struct build_thread_args *args = (struct build_thread_args*)malloc(
sizeof(struct build_thread_args));
args->tree = bc->curr_tree;
args->path = strdup(hintpath);
pthread_t build_ptid;
pthread_create(&build_ptid, NULL, build_thread, args);
// next bucket
bc->curr ++;
bc->curr_tree = ht_new(bc->depth, bc->pos);
bc->wbuf_start_pos = 0;
}
EDGE *add_n_gon_inverse(int n, EDGE *start)
/* Like add_n_gon, but in counterclockwise direction */
{
EDGE *run, *last;
int length, i;
last=start->prev->invers->prev;
for (length=n-2; last->end!=outside; last=last->invers->prev) length--;
if (length<=0)
{ if (length<0)
{ fprintf(stderr,"Error -- %d-gon does not fit in %d-hole \n",n,n-length);
exit(42); }
if (length==0)
{ fprintf(stderr,"Didn't expect to add a polygon without a new vertex.\n");
fprintf(stderr,"small changes necessary.\n");
exit(52); }
}
/* The path must be glued in the opposite direction: */
run=new_path_last(nv+1,length);
start->invers=run; run->invers=start;
start->end=nv+length; run->end=start->start;
for (i=length; i>=1; i--, run=run->next->invers) firstedge[nv+i]=run;
run=new_path(nv+1,length);
last->invers=run; run->invers=last;
last->end=nv+1; run->end=last->start;
nv += length;
if (n==5) { for ( start=start->invers ; n ; n--, start=start->invers->prev)
{ pentagons[pentagonedges]=start; pentagonedges++;
start->pentagon_right=1; }
pentagoncounter++; }
return(run->next);
}
static PyObject* path_concat(PyObject* py_self, PyObject* py_other) {
if (!is_PathObject(py_other)) {
PyErr_SetString(PyExc_TypeError, "Paths can only be concatenated with other path objects");
return 0;
}
boost::shared_ptr<Path> self = ((PathObject*)py_self)->m_x;
boost::shared_ptr<Path> other = ((PathObject*)py_other)->m_x;
boost::shared_ptr<Path> new_path(new Path());
new_path->reserve(self->size() + other->size());
try {
new_path->insert(new_path->begin(), self->begin(), self->end());
new_path->insert(new_path->end(), other->begin(), other->end());
} catch (path_exception e) {
// delete new_path; Should be implicit by boost::shared_ptr
PyErr_SetString(PyExc_PathException, e.what());
return 0;
}
return create_PathObject(new_path);
}
void myGraph::findAllPathesBetweenTwoNodes(int source, int target, int totalnode, int totaledge, vector<vector<int>> GRAPH, vector<vector<int>> &pathVector)
{ //sort the path from smallest length to longest
set<vector<int>> pathInfoSet;
vector<vector<int>> pathVector_t;
vector<int>path;
path.push_back(source);
queue<vector<int> >q;
q.push(path);
int count=0;
while(!q.empty())
{
path=q.front();
q.pop();
int last_nodeof_path=path[path.size()-1];
if(last_nodeof_path==target)
{
vector<int> pathInfo;
pathInfo.push_back(path.size());
pathInfo.push_back(count);
pathInfoSet.insert(pathInfo);
pathVector_t.push_back(path); //a valid path
count++;
}
for(int i=0;i<GRAPH[last_nodeof_path].size();++i)
{
if(isadjacency_node_not_present_in_current_path(GRAPH[last_nodeof_path][i],path))
{
vector<int>new_path(path.begin(),path.end());
new_path.push_back(GRAPH[last_nodeof_path][i]);
q.push(new_path);
}
}
}
for(set<vector<int>>::iterator it=pathInfoSet.begin(); it!=pathInfoSet.end(); it++)
{
vector<int> item = *it;
pathVector.push_back(pathVector_t[item[1]]);
}
}
static int update_filter_files(update_t *update)
{
unsigned char digest[SHA256_DIGEST_LENGTH];
char* filename;
update_item_t **prev = &(update->items);
update_item_t *item = update->items;
int excluded = 0;
while (item)
{
filename = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,NULL);
if (sha256sum(filename,digest)!=0)
{
if (memcmp(digest,bytestring_get_data(&item->digest),SHA256_DIGEST_LENGTH)!=0)
{
log_printf(LOG_INFO,"File %s needs to be updated.",filename);
prev = &(item->next);
item = item->next;
}
else
{
/* log_printf(LOG_DEBUG,"No update needed for %s",filename); */
*prev = item->next;
update_item_free(item);
excluded++;
item = *prev;
update->item_count--;
}
}
else
{
log_printf(LOG_INFO,"File %s is proposed for creation in current script updates.",filename);
prev = &(item->next);
item = item->next;
}
g_free(filename);
}
return excluded;
}
bool copyFile(std::string old_path, std::string new_root, std::string &filename)
{
//get just the filename part of the original file
size_t slash_position = old_path.find_last_of('/');
if (slash_position == std::string::npos)
{
//no slash
filename = old_path;
}
else if (slash_position >= old_path.size() - 1)
{
//slash is the last character
std::cerr << "Failed to parse input filename: " << old_path << "\n";
return false;
}
else
{
//skip the last slash
filename = old_path.substr(slash_position+1, std::string::npos);
}
std::string new_path(new_root);
if (new_path.at(new_path.size() - 1) != '/')
{
new_path.append("//");
}
new_path.append(filename);
if ( boost::filesystem::exists(new_path) )
{
std::cerr << "File " << new_path << " already exists; skipping copy.\n";
return true;
}
boost::filesystem::copy_file(old_path, new_path);
if ( !boost::filesystem::exists(new_path) )
{
std::cerr << "Failed to copy file " << filename << " to " << new_path << "\n";
return false;
}
return true;
}
int cardpeek_update_perform(void)
{
const char* cardpeek_update_file = path_config_get_string(PATH_CONFIG_FILE_CARDPEEK_UPDATE);
a_string_t *contents;
update_t *update;
int remove;
update_item_t *item;
time_t now = time(NULL);
int updated = 0;
char *url = NULL;
char *local_file;
char *local_dnld;
unsigned char digest[SHA256_DIGEST_LENGTH];
a_string_t *url_request;
unsigned first_update;
first_update = (unsigned)luax_variable_get_integer("cardpeek.updates.first_update");
/* STEP 1: get cardpeek.update file */
url=luax_variable_get_strdup("cardpeek.updates.url");
if (url==NULL)
url = g_strdup(DEFAULT_UPDATE_URL);
log_printf(LOG_INFO,"Fetching '%s'",url);
url_request = a_strnew(NULL);
a_sprintf(url_request,"%s?u=%x&v=%s",url,first_update,VERSION);
if (http_download(a_strval(url_request),cardpeek_update_file)==0)
{
g_free(url);
return 0;
}
g_free(url);
a_strfree(url_request);
/* STEP 2: parse file */
if ((contents=file_get_contents(cardpeek_update_file))==NULL)
{
log_printf(LOG_ERROR,"failed to read update file information.");
unlink(cardpeek_update_file);
return 0;
}
update = update_new();
if ((update_load(update,a_strval(contents),a_strlen(contents)))==0)
{
unlink(cardpeek_update_file);
a_strfree(contents);
update_free(update);
return 0;
}
a_strfree(contents);
/* log_printf(LOG_DEBUG,"Updates correctly loaded from '%s'",cardpeek_update_file); */
if ((remove = update_filter_version(update,VERSION))>0)
log_printf(LOG_WARNING,"%d updates will not be installed because they require a newer version of Cardpeek.");
remove = update_filter_files(update);
if (update->item_count)
log_printf(LOG_INFO,"A total of %d files will be updated, %d files are kept unchanged.",update->item_count,remove);
else
log_printf(LOG_INFO,"No files will be updated, %d files are kept unchanged.",remove);
item = update->items;
while (item)
{
local_dnld = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,".download");
local_file = new_path(PATH_CONFIG_FOLDER_CARDPEEK,item->file,NULL);
if (http_download(item->url,local_dnld)!=0)
{
if (sha256sum(local_dnld,digest))
{
if (memcmp(digest,bytestring_get_data(&item->digest),SHA256_DIGEST_LENGTH)==0)
{
unlink(local_file);
if (rename(local_dnld,local_file)==0)
{
log_printf(LOG_INFO,"Successfuly updated %s", local_file);
updated++;
}
else
{
log_printf(LOG_ERROR,"Failed to copy %s to %s: %s",
local_dnld,
local_file,
strerror(errno));
}
}
else
{
log_printf(LOG_WARNING,"File %s was not updated: authentication failed.",local_file);
}
}
unlink(local_dnld);
}
g_free(local_dnld);
g_free(local_file);
item = item->next;
}
if (updated == update->item_count)
{
luax_variable_set_integer("cardpeek.updates.next_update",(int)(now+7*(24*3600)));
luax_config_table_save();
}
unlink(cardpeek_update_file);
update_free(update);
/* STEP 3: finish */
return 1;
}
static bool strip_manual_mounts()
{
autoclose::dir dir(autoclose::opendir("/"));
if (!dir) {
return true;
}
struct dirent *ent;
while ((ent = readdir(dir.get()))) {
// Look for *.rc files
if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0
|| !util::ends_with(ent->d_name, ".rc")) {
continue;
}
std::string path("/");
path += ent->d_name;
autoclose::file fp(autoclose::fopen(path.c_str(), "r"));
if (!fp) {
LOGE("Failed to open %s for reading: %s",
path.c_str(), strerror(errno));
continue;
}
char *line = nullptr;
size_t len = 0;
ssize_t read = 0;
auto free_line = util::finally([&] {
free(line);
});
std::size_t count = 0;
std::unordered_set<std::size_t> comment_out;
// Find out which lines need to be commented out
while ((read = getline(&line, &len, fp.get())) >= 0) {
if (strstr(line, "mount")
&& (strstr(line, "/system")
|| strstr(line, "/cache")
|| strstr(line, "/data"))) {
std::vector<std::string> tokens = util::tokenize(line, " \t\n");
if (tokens.size() >= 4 && tokens[0] == "mount"
&& (tokens[3] == "/system"
|| tokens[3] == "/cache"
|| tokens[3] == "/data")) {
comment_out.insert(count);
}
}
++count;
}
if (comment_out.empty()) {
continue;
}
// Go back to beginning of file for reread
rewind(fp.get());
count = 0;
std::string new_path(path);
new_path += ".new";
autoclose::file fp_new(autoclose::fopen(new_path.c_str(), "w"));
if (!fp_new) {
LOGE("Failed to open %s for writing: %s",
new_path.c_str(), strerror(errno));
continue;
}
// Actually comment out the lines
while ((read = getline(&line, &len, fp.get())) >= 0) {
if (comment_out.find(count) != comment_out.end()) {
fputs("#", fp_new.get());
}
fputs(line, fp_new.get());
++count;
}
replace_file(path.c_str(), new_path.c_str());
}
return true;
}
void spc_new_path_perhaps(snap_path_closure_t &spc) {
if (!spc.first) return;
new_path(spc.cr);
spc.first = 0;
}
void bc_scan(Bitcask* bc)
{
char datapath[255], hintpath[255];
int i=0;
struct stat st, hst;
skip_empty_file(bc);
const char* base = mgr_base(bc->mgr);
// load snapshot of htree
for (i=MAX_BUCKET_COUNT-1; i>=0; i--)
{
if (stat(gen_path(datapath, base, HTREE_FILE, i), &st) == 0
&& stat(gen_path(hintpath, base, HINT_FILE, i), &hst) == 0
&& st.st_mtime >= hst.st_mtime
&& (bc->before == 0 || st.st_mtime < bc->before))
{
bc->tree = ht_open(bc->depth, bc->pos, datapath);
if (bc->tree != NULL)
{
bc->last_snapshot = i;
break;
}
else
{
fprintf(stderr, "open HTree from %s failed\n", datapath);
mgr_unlink(datapath);
}
}
}
if (bc->tree == NULL)
{
bc->tree = ht_new(bc->depth, bc->pos);
}
for (i=0; i<MAX_BUCKET_COUNT; i++)
{
if (stat(gen_path(datapath, base, DATA_FILE, i), &st) != 0)
{
break;
}
bc->bytes += st.st_size;
if (i <= bc->last_snapshot) continue;
gen_path(hintpath, base, HINT_FILE, i);
if (bc->before == 0)
{
if (0 == stat(hintpath, &st))
{
scanHintFile(bc->tree, i, hintpath, NULL);
}
else
{
scanDataFile(bc->tree, i, datapath,
new_path(hintpath, bc->mgr, HINT_FILE, i));
}
}
else
{
if (0 == stat(hintpath, &st) &&
(st.st_mtime < bc->before || 0 == stat(datapath, &st) && st.st_mtime < bc->before))
{
scanHintFile(bc->tree, i, hintpath, NULL);
}
else
{
scanDataFileBefore(bc->tree, i, datapath, bc->before);
}
}
}
if (i - bc->last_snapshot > SAVE_HTREE_LIMIT)
{
if (ht_save(bc->tree, new_path(datapath, bc->mgr, HTREE_FILE, i-1)) == 0)
{
mgr_unlink(gen_path(NULL, base, HTREE_FILE, bc->last_snapshot));
bc->last_snapshot = i-1;
}
else
{
fprintf(stderr, "save HTree to %s failed\n", datapath);
}
}
bc->curr = i;
}
int RT_BFS_1(Graph &G, int source, std::ofstream & outputfile2, int * cost) {
std::vector<int> path;
path.push_back(source);
std::queue<std::vector<int> >q;
q.push(path);
std::map <int, unsigned int> flag1, vertex_to_index;
std::map <int, bool> flag2;
int ii = 0;
// for each vertex in the graph
for (auto aa : G.graphVector)
{
// set source to vertex distance to infinity
flag1.insert(std::make_pair(aa.ID, 9999));
// set vertex as not visited
flag2.insert(std::make_pair(aa.ID, false));
vertex_to_index.insert(std::make_pair(aa.ID, ii++));
}
int deepness = 1;
// loop until queue is empty
while (!q.empty())
{
// get a path from the queue
path = q.front();
q.pop();
// get the last node in the path
int last_nodeof_path = path[path.size() - 1];
// print out the current path to the file
//print_path(path, outputfile2);
int grp_pos = last_nodeof_path;
// loop through all the vertex's edges
for (auto it : G.graphVector[grp_pos].edges)
{
// get the connected vertex id
int v_id = std::get<2>(it).get_Vertex_ID();
// get the index of the vertex
int index_id = vertex_to_index.find(v_id)->second;
// if the vertex distance is greater than the path size
if (flag1.find(v_id)->second >= path.size())
{
// if the vertex is not in the current path and has not been visited then add to queue
if (isadjacency_node_not_present_in_current_path(index_id, path) && flag2.find(v_id)->second == false)
{
// copy the current path vector into a new one
std::vector<int> new_path(path.begin(), path.end());
// add the new vertex
new_path.push_back(index_id);
// push the new path on the queue
q.push(new_path);
// set the distance to the vertex to the path size
flag1[v_id] = path.size();
cost[v_id] = path.size();
}
}
}
flag2.find(G.graphVector[grp_pos].ID)->second = true;
deepness++;
}
//std::cout << "\nRT_BFS finished Process \n ------------";
return 1;
}
void init_new_paths(int maxnv_cap)
/* Initialises the new_path entries. Must be called before the construction starts.
The parameter maxnv_cap must be the maximum number of vertices a cap might have */
{
int nv,length,i;
EDGE *edges;
edges=(EDGE *) malloc(3*(1+2+3+4)*maxnv_cap*sizeof(EDGE));
if (edges==NULL) { fprintf(stderr,"Can not get enough space for the cap edges \n");
exit(1); }
{ int marki;
EDGE *markrun;
for (marki=0; (marki<MAX_EDGE_ARRAYS) && (edge_array_start[marki]!=0); marki++);
if (marki==MAX_EDGE_ARRAYS)
{ fprintf(stderr,"Constant MAX_EDGE_ARRAYS too small (1) -- increase.\n");
exit(1); }
edge_array_start[marki]=edges;
how_many_edges[marki]=3*(1+2+3+4)*maxnv_cap;
for (marki=3*(1+2+3+4)*maxnv_cap, markrun=edges; marki>0; marki--, markrun++) markrun->mark__=0;
}
new__path=(EDGE **)malloc(sizeof(EDGE *)*(maxnv_cap+1)*4);
if (new__path==NULL) { fprintf(stderr,"Can not get enough space for the new__path entries \n");
exit(1); }
new__path_last=(EDGE **)malloc(sizeof(EDGE *)*(maxnv_cap+1)*4);
if (new__path_last==NULL)
{ fprintf(stderr,"Can not get enough space for the new__path_last entries \n");
exit(1); }
for (nv=1; nv<=maxnv_cap; nv++)
for (length=1; length<=4; length++,edges++)
{ /* first the edge that is glued to the existing patch: */
new_path(nv,length)=edges;
edges->start=nv;
edges->pentagon_right=0;
edges->prev=edges+2; edges->next=edges+1;
edges++;
edges->start=nv; edges->end=outside;
edges->pentagon_right=0;
edges->prev=edges-1; edges->next=edges+1;
edges++;
edges->start=nv; edges->pentagon_right=0;
edges->prev=edges-1; edges->next=edges-2;
for (i=1; i<length; i++)
{
edges++;
edges->start=nv+i; edges->end=nv+(i-1);
edges->pentagon_right=0;
edges->prev=edges+2; edges->next=edges+1;
edges->invers=edges-1;
(edges-1)->invers=edges; (edges-1)->end=nv+i;
edges++;
edges->start=nv+i; edges->end=outside;
edges->pentagon_right=0;
edges->prev=edges-1; edges->next=edges+1;
edges++;
edges->start=nv+i;
edges->pentagon_right=0;
edges->prev=edges-1; edges->next=edges-2;
}
new_path_last(nv,length)=edges;
}
}
EDGE *add_n_gon(int n, EDGE *start)
/* Adds an n-gon starting at "start" in clockwise direction. Returns the last
edge of this polygon pointing to the outside, if such an edge exists.
Otherwise (that is: if no new vertices are inserted, but just a gap
closed) the routine exits, since this is not expected to be necessary in this
program.
The firstedge, nv entries are updated.
In case construct_ipr==1 and n==5, it is checked whether this penatgon neighbours
another. In case it does not, the global variable is_ipr is set to 0;
*/
{
EDGE *run, *last;
int length, i;
if (construct_ipr && (n==5))
{
last=start->next;
if (last->pentagon_right) is_ipr=0;
last=last->invers->next;
for (length=n-2; last->end!=outside; last=last->invers->next)
{ if (last->pentagon_right) is_ipr=0;
length--;
}
}
else
{
last=start->next->invers->next;
for (length=n-2; last->end!=outside; last=last->invers->next) length--;
}
/* length counts, how many new vertices are needed. */
if (length<=0)
{ if (length<0)
{ fprintf(stderr,"Error -- %d-gon does not fit in %d-hole \n",n,n-length);
exit(4); }
if (length==0)
{ fprintf(stderr,"Didn't expect to add a polygon without a new vertex.\n");
fprintf(stderr,"small changes necessary.\n");
exit(5); }
}
run=new_path(nv+1,length);
start->invers=run; run->invers=start;
start->end=nv+1; run->end=start->start;
for (i=1; i<=length; i++, run=run->prev->invers) firstedge[nv+i]=run;
run=new_path_last(nv+1,length);
last->invers=run; run->invers=last;
last->end=nv+length; run->end=last->start;
nv += length;
if (n==5) { for ( ; n ; n--, start=start->invers->prev)
{ pentagons[pentagonedges]=start; pentagonedges++;
start->pentagon_right=1; }
pentagoncounter++; }
return(run->prev);
}
static int
add_disk2controller(disk_t *diskp, struct search_args *args)
{
di_node_t pnode;
controller_t *cp;
di_minor_t minor;
di_node_t node;
int i;
node = args->node;
pnode = di_parent_node(node);
if (pnode == DI_NODE_NIL) {
return (0);
}
minor = di_minor_next(pnode, NULL);
if (minor == NULL) {
return (0);
}
if ((cp = add_controller(args, pnode, minor)) == NULL) {
return (ENOMEM);
}
/* check if the disk <-> ctrl assoc is already there */
for (i = 0; diskp->controllers[i]; i++) {
if (cp == diskp->controllers[i]) {
return (0);
}
}
/* this is a new controller for this disk */
/* add the disk to the controller */
if (add_ptr2array(diskp, (void ***)&cp->disks) != 0) {
return (ENOMEM);
}
/* add the controller to the disk */
if (add_ptr2array(cp, (void ***)&diskp->controllers) != 0) {
return (ENOMEM);
}
/*
* Set up paths for mpxio controlled drives.
*/
if (libdiskmgt_str_eq(di_node_name(pnode), "scsi_vhci")) {
/* note: mpxio di_path stuff is all consolidation private */
di_path_t pi = DI_PATH_NIL;
while (
(pi = di_path_client_next_path(node, pi)) != DI_PATH_NIL) {
int cnt;
uchar_t *bytes;
char str[MAXPATHLEN];
char *wwn;
di_node_t phci_node = di_path_phci_node(pi);
/* get the node wwn */
cnt = di_path_prop_lookup_bytes(pi, WWN_PROP, &bytes);
wwn = NULL;
if (cnt > 0) {
int i;
str[0] = 0;
for (i = 0; i < cnt; i++) {
/*
* A byte is only 2 hex chars + null.
*/
char bstr[8];
(void) snprintf(bstr,
sizeof (bstr), "%.2x", bytes[i]);
(void) strlcat(str, bstr, sizeof (str));
}
wwn = str;
}
if (new_path(cp, diskp, phci_node,
di_path_state(pi), wwn) == NULL) {
return (ENOMEM);
}
}
}
return (0);
}
void bc_optimize(Bitcask *bc, int limit)
{
int i, total, last = -1;
bc->optimize_flag = 1;
const char *base = mgr_base(bc->mgr);
// remove htree
for (i=0; i < bc->curr; i++)
{
mgr_unlink(gen_path(NULL, base, HTREE_FILE, i));
}
bc->last_snapshot = -1;
time_t limit_time = 0;
if (limit > 3600 * 24 * 365 * 10) // more than 10 years
{
limit_time = limit; // absolute time
}
else
{
limit_time = time(NULL) - limit; // relative time
}
struct stat st;
bool skipped = false;
for (i=0; i < bc->curr && bc->optimize_flag == 1; i++)
{
char datapath[255], hintpath[255];
gen_path(datapath, base, DATA_FILE, i);
gen_path(hintpath, base, HINT_FILE, i);
if (stat(datapath, &st) != 0)
{
continue; // skip empty file
}
// skip recent modified file
if (st.st_mtime > limit_time)
{
skipped = true;
last ++;
if (last != i) // rotate data file
{
char npath[255];
gen_path(npath, base, DATA_FILE, last);
if (symlink(datapath, npath) != 0)
{
fprintf(stderr, "symlink failed: %s -> %s\n", datapath, npath);
last = i;
continue;
}
// update HTree to use new index
if (stat(hintpath, &st) != 0)
{
fprintf(stderr, "no hint file: %s, skip it\n", hintpath);
last = i;
continue;
}
HTree *tree = ht_new(bc->depth, bc->pos);
scanHintFile(tree, i, hintpath, NULL);
struct update_args args;
args.tree = bc->tree;
args.index = last;
ht_visit(tree, update_item_pos, &args);
ht_destroy(tree);
unlink(npath);
mgr_rename(datapath, npath);
mgr_rename(hintpath, gen_path(npath, base, HINT_FILE, last));
}
continue;
}
int deleted = count_deleted_record(bc->tree, i, hintpath, &total);
uint64_t curr_size = data_file_size(bc, i) * (total - deleted/2) / (total+1); // guess
uint64_t last_size = last >= 0 ? data_file_size(bc, last) : -1;
// last data file size
uint32_t recoverd = 0;
if (last == -1 || last_size + curr_size > MAX_BUCKET_SIZE)
{
last ++;
}
while (last < i)
{
char ldpath[255], lhpath[255];
new_path(ldpath, bc->mgr, DATA_FILE, last);
new_path(lhpath, bc->mgr, HINT_FILE, last);
recoverd = optimizeDataFile(bc->tree, i, datapath, hintpath,
skipped, MAX_BUCKET_SIZE, last, ldpath, lhpath);
if (recoverd == 0)
{
last ++;
}
else
{
break;
}
}
if (recoverd == 0)
{
// last == i
recoverd = optimizeDataFile(bc->tree, i, datapath, hintpath,
skipped, MAX_BUCKET_SIZE, last, NULL, NULL);
}
if (recoverd < 0) break; // failed
pthread_mutex_lock(&bc->buffer_lock);
bc->bytes -= recoverd;
pthread_mutex_unlock(&bc->buffer_lock);
}
// update pos of items in curr_tree
pthread_mutex_lock(&bc->write_lock);
pthread_mutex_lock(&bc->flush_lock);
if (i == bc->curr && ++last < bc->curr)
{
char opath[255], npath[255];
gen_path(opath, base, DATA_FILE, bc->curr);
if (file_exists(opath))
{
gen_path(npath, base, DATA_FILE, last);
if (symlink(opath, npath) != 0)
fprintf(stderr, "symlink failed: %s -> %s\n", opath, npath);
struct update_args args;
args.tree = bc->tree;
args.index = last;
ht_visit(bc->curr_tree, update_item_pos, &args);
unlink(npath);
mgr_rename(opath, npath);
}
bc->curr = last;
}
pthread_mutex_unlock(&bc->flush_lock);
pthread_mutex_unlock(&bc->write_lock);
bc->optimize_flag = 0;
}
void bc_flush(Bitcask *bc, int limit, int flush_period)
{
if (bc->curr >= MAX_BUCKET_COUNT)
{
fprintf(stderr, "reach max bucket count\n");
exit(1);
}
pthread_mutex_lock(&bc->flush_lock);
pthread_mutex_lock(&bc->buffer_lock);
time_t now = time(NULL);
if (bc->wbuf_curr_pos > limit * 1024 ||
now > bc->last_flush_time + flush_period && bc->wbuf_curr_pos > 0)
{
uint32_t size = bc->wbuf_curr_pos;
char * tmp = (char*) malloc(size);
memcpy(tmp, bc->write_buffer, size);
pthread_mutex_unlock(&bc->buffer_lock);
char buf[255];
new_path(buf, bc->mgr, DATA_FILE, bc->curr);
FILE *f = fopen(buf, "ab");
if (f == NULL)
{
fprintf(stderr, "open file %s for flushing failed.\n", buf);
exit(1);
}
// check file size
uint64_t last_pos = ftello(f);
if (last_pos > 0 && last_pos != bc->wbuf_start_pos)
{
fprintf(stderr, "last pos not match: %"PRIu64" != %d in %s\n", last_pos, bc->wbuf_start_pos, buf);
exit(1);
}
int n = fwrite(tmp, 1, size, f);
if (n < size)
{
fprintf(stderr, "write failed: return %d\n", n);
exit(1);
}
free(tmp);
fclose(f);
bc->last_flush_time = now;
pthread_mutex_lock(&bc->buffer_lock);
bc->bytes += n;
bc->curr_bytes += n;
if (n < bc->wbuf_curr_pos)
{
memmove(bc->write_buffer, bc->write_buffer + n, bc->wbuf_curr_pos - n);
}
bc->wbuf_start_pos += n;
bc->wbuf_curr_pos -= n;
if (bc->wbuf_curr_pos == 0)
{
if (bc->wbuf_size < WRITE_BUFFER_SIZE)
{
bc->wbuf_size *= 2;
free(bc->write_buffer);
bc->write_buffer = (char*)malloc(bc->wbuf_size);
}
else if (bc->wbuf_size > WRITE_BUFFER_SIZE * 2)
{
bc->wbuf_size = WRITE_BUFFER_SIZE;
free(bc->write_buffer);
bc->write_buffer = (char*)malloc(bc->wbuf_size);
}
}
if (bc->wbuf_start_pos + bc->wbuf_size > MAX_BUCKET_SIZE)
{
bc_rotate(bc);
}
}
pthread_mutex_unlock(&bc->buffer_lock);
pthread_mutex_unlock(&bc->flush_lock);
}
void move::execute(bool& success, bool& complete)
{
if (!valid_) {
success = false;
//Setting complete to true signifies to side_actions to delete the planned action.
complete = true;
return;
}
if (get_source_hex() == get_dest_hex()) {
//zero-hex move, used by attack subclass
success = complete = true;
return;
}
LOG_WB << "Executing: " << shared_from_this() << "\n";
set_arrow_brightness(ARROW_BRIGHTNESS_HIGHLIGHTED);
hide_fake_unit();
events::mouse_handler& mouse_handler = resources::controller->get_mouse_handler_base();
std::set<map_location> adj_enemies = mouse_handler.get_adj_enemies(get_dest_hex(), side_number());
map_location final_location;
bool steps_finished;
bool enemy_sighted;
{
team const& owner_team = resources::teams->at(team_index());
try {
steps_finished = mouse_handler.move_unit_along_route(*route_, &final_location, owner_team.auto_shroud_updates(), &enemy_sighted);
} catch (end_turn_exception&) {
set_arrow_brightness(ARROW_BRIGHTNESS_STANDARD);
throw; // we rely on the caller to delete this action
}
// final_location now contains the final unit location
// if that isn't needed, pass NULL rather than &final_location
// Also, enemy_sighted now tells whether a unit was sighted during the move
}
if(mouse_handler.get_adj_enemies(final_location,side_number()) != adj_enemies)
enemy_sighted = true; //< "ambushed" on last hex
unit_map::const_iterator unit_it;
if (final_location == route_->steps.front())
{
LOG_WB << "Move execution resulted in zero movement.\n";
success = false;
complete = true;
}
else if (final_location.valid() &&
(unit_it = resources::units->find(final_location)) != resources::units->end()
&& unit_it->id() == unit_id_)
{
if (steps_finished && route_->steps.back() == final_location) //reached destination
{
complete = true;
//check if new enemies are now visible
if(enemy_sighted)
{
LOG_WB << "Move completed, but interrupted on final hex. Halting.\n";
//reset to a single-hex path, just in case *this is a wb::attack
arrow_.reset();
route_->steps = std::vector<map_location>(1,route_->steps.back());
success = false;
}
else // Everything went smoothly
success = true;
}
else // Move was interrupted, probably by enemy unit sighted
{
success = false;
LOG_WB << "Move finished at (" << final_location << ") instead of at (" << get_dest_hex() << "), analyzing\n";
std::vector<map_location>::iterator start_new_path;
bool found = false;
for (start_new_path = route_->steps.begin(); ((start_new_path != route_->steps.end()) && !found); ++start_new_path)
{
if (*start_new_path == final_location)
{
found = true;
}
}
if (found)
{
--start_new_path; //since the for loop incremented the iterator once after we found the right one.
std::vector<map_location> new_path(start_new_path, route_->steps.end());
LOG_WB << "Setting new path for this move from (" << new_path.front()
<< ") to (" << new_path.back() << ").\n";
//FIXME: probably better to use the new calculate_new_route instead of doing this
route_->steps = new_path;
arrow_->set_path(new_path);
complete = false;
}
else //Unit ended up in location outside path, likely due to a WML event
{
WRN_WB << "Unit ended up in location outside path during move execution.\n";
complete = true;
}
}
}
else //Unit disappeared from the map, likely due to a WML event
{
WRN_WB << "Unit disappeared from map during move execution.\n";
success = false;
complete = true;
}
if(!complete)
{
set_arrow_brightness(ARROW_BRIGHTNESS_STANDARD);
show_fake_unit();
}
}
const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern)
{
filetype_t type;
if(pattern == 0)
{
pattern = "*";
}
FileTypeList typelist;
GlobalFiletypes().getTypeList(pattern, &typelist);
GTKMasks masks(typelist);
if (title == 0)
title = open ? "Open File" : "Save File";
GtkWidget* dialog;
if (open)
{
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
}
else
{
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "unnamed");
}
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
// we expect an actual path below, if the path is 0 we might crash
if (path != 0 && !string_empty(path))
{
ASSERT_MESSAGE(path_is_absolute(path), "file_dialog_show: path not absolute: " << makeQuoted(path));
Array<char> new_path(strlen(path)+1);
// copy path, replacing dir separators as appropriate
Array<char>::iterator w = new_path.begin();
for(const char* r = path; *r != '\0'; ++r)
{
*w++ = (*r == '/') ? G_DIR_SEPARATOR : *r;
}
// remove separator from end of path if required
if(*(w-1) == G_DIR_SEPARATOR)
{
--w;
}
// terminate string
*w = '\0';
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), new_path.data());
}
// we should add all important paths as shortcut folder...
// gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog), "/tmp/", NULL);
for(std::size_t i = 0; i < masks.m_filters.size(); ++i)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, masks.m_filters[i].c_str());
gtk_file_filter_set_name(filter, masks.m_masks[i].c_str());
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
}
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
strcpy(g_file_dialog_file, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
if(!string_equal(pattern, "*"))
{
GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
if(filter != 0) // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files'
{
type = masks.GetTypeForGTKMask(gtk_file_filter_get_name(filter)).m_type;
// last ext separator
const char* extension = path_get_extension(g_file_dialog_file);
// no extension
if(string_empty(extension))
{
strcat(g_file_dialog_file, type.pattern+1);
}
else
{
strcpy(g_file_dialog_file + (extension - g_file_dialog_file), type.pattern+2);
}
}
}
// convert back to unix format
for(char* w = g_file_dialog_file; *w!='\0'; w++)
{
if(*w=='\\')
{
*w = '/';
}
}
}
else
{
g_file_dialog_file[0] = '\0';
}
gtk_widget_destroy(dialog);
// don't return an empty filename
if(g_file_dialog_file[0] == '\0') return NULL;
return g_file_dialog_file;
}
