/* config_set_string; Sets a value in the config, possibly overriding * an existing value */ void config_set_string(const char *directive, const char* s) { stringmap S; S = stringmap_find(config, directive); if (S) { xfree(S->d.v); S->d = item_ptr(xstrdup(s)); } else { stringmap_insert(config, directive, item_ptr(xstrdup(s))); } }
item_ptr fork_database::fetch_block( const block_id_type& id )const { auto itr = _index.get<block_id>().find(id); if( itr != _index.get<block_id>().end() ) return *itr; return item_ptr(); }
void wsplayer_t::delegate_step() { incer_t<int> hld_thinking(thinking); field=game().field(); root=item_ptr(new item_t(*this,field.back())); ObjectProgress::log_generator lg(true); init_states(); try { root->process_deep_common(); } catch(e_cancel&) { lg<<"canceled"; hld_thinking.reset(); throw; } if(!root->get_wins().empty()) { unsigned int depth=root->get_chain_depth()-1; std::string chain=print_chain(root->get_wins().get_best()); lg<<"wsplayer_t::delegate_step(): find win chain_depth="<<depth<<": "<<chain; } if(!root->get_fails().empty() && root->get_neitrals().empty())lg<<"wsplayer_t::delegate_step(): find fail chain_depth="<<(root->get_chain_depth()-1) <<": "<<print_chain(root->get_fails().get_best()); point p=*root->get_next_step(); game().OnNextStep(*this,p); }
// C++ allocator interface T* allocate(size_t n) { assert(n == 1); if( next_free == -1 ) { throw std::bad_alloc(); } const int current = next_free; next_free = indicator(next_free); return item_ptr(current); }
void wsplayer_t::solve() { field=game().field(); wide_item_t* wr=new wide_item_t(*this,field.back()); root=item_ptr(wr); init_states(); wr->process_deep_common(); }
item_ptr fork_database::fetch_block(const block_id_type& id)const { auto& index = _index.get<block_id>(); auto itr = index.find(id); if( itr != index.end() ) return *itr; auto& unlinked_index = _unlinked_index.get<block_id>(); auto unlinked_itr = unlinked_index.find(id); if( unlinked_itr != unlinked_index.end() ) return *unlinked_itr; return item_ptr(); }
/** * Updates or creates (as appropriate) the menu item with the given @a id. */ void wmi_container::set_item(const std::string& id, const vconfig& menu_item) { // Try to insert a dummy value. This combines looking for an existing // entry with insertion. map_t::iterator add_it = wml_menu_items_.insert(map_t::value_type(id, item_ptr())).first; if ( add_it->second ) // Create a new menu item based on the old. This leaves the old item // alone in case someone else is holding on to (and processing) it. add_it->second.reset(new wml_menu_item(id, menu_item, *add_it->second)); else // This is a new menu item. add_it->second.reset(new wml_menu_item(id, menu_item)); }
void load_activity::load_item(unsigned int count, outputer::shared_ptr outer) {/*{{{*/ try { log_item::shared_ptr item_ptr(new log_item); log_item& item=*item_ptr; _analyser_ptr->analyse(*_stream_in,item); if(_filter_rule_ptr && ! _filter_rule_ptr->is_true(item_ptr)) { if(_logger.isDebugEnabled()) _logger.debugStream()<<" filter it : "<< *item_ptr; } else { outer->output(item_ptr); } if(_stream_in->bad()) _stream_in->clear(); if(_stream_in->fail()) _stream_in->clear(); } catch(data_error& e) { if(_stream_in->bad()) throw; if(_stream_in->eof()) return; _stream_in->clear(); _stream_in->ignore(1024,'\n'); if(_logger.isErrorEnabled()) _logger.errorStream()<<e.what()<<"line:"<<count; } catch(exception& ex) { _stream_in->ignore(1024,'\n'); _logger.errorStream()<<ex.what()<<"line:"<<count; } }/*}}}*/
// C++-like allocator interface T* allocate() { unsigned long allocated_item_coded = next_free.load(); int allocated_item; //tprintf(tinfra::err, "T[%i]: allocate first try with allocated_item %i\n", get_thread_string(), idx_decode(allocated_item_coded)); while( true ) { allocated_item = idx_decode(allocated_item_coded); if( allocated_item == -1 ) { throw std::bad_alloc(); } const int new_next_free = item_next_free_idx(allocated_item); // so here is the race // 1 (allocated_item AI, new_next_free NNF) pair is "read" // 2. (tries to commit, but ... in meantime) // 3. (other thread allocates AI as a race) // 3.1 (NNF is allocates by other thread) ... // 4. (other thread deallocates AI and it appears again as NF but now points to NNF2) // 5. (commit succedds with NNF because AI is same as in 1) // BUG, NF points at NNF, which is not necessarily allocated // should point at NNF2 (!?) impossible // or TXN this kind of race should be detected and whole TXN shall be retried assert(new_next_free != allocated_item); //if(rand() % 2 ) my_nanosleep(1); const unsigned long new_next_free_coded = idx_encode(new_next_free); const bool change_succeded = next_free.compare_exchange_strong(allocated_item_coded, new_next_free_coded); if( !change_succeded ) { allocated_item = idx_decode(allocated_item_coded); //tprintf(tinfra::err, "T[%i]: allocate, retrying with allocated_item %i\n", get_thread_string(), allocated_item); continue; } else { //tprintf(tinfra::err, "T[%i]: allocated %i, next_free = %i\n", get_thread_string(), allocated_item, new_next_free); } break; } my_assert(_check_allocated(allocated_item)); ++n_allocated; return item_ptr(allocated_item); }
/* read_config_file: * Read a configuration file consisting of key: value tuples, returning a * stringmap of the results. Prints errors to stderr, rather than using * syslog, since this file is called at program startup. Returns 1 on success * or 0 on failure. */ int read_config_file(const char *f, int whinge) { int ret = 0; FILE *fp; char *line; int i = 1; line = xmalloc(MAX_CONFIG_LINE); fp = fopen(f, "rt"); if (!fp) { if(whinge) fprintf(stderr, "%s: %s\n", f, strerror(errno)); goto fail; } while (fgets(line, MAX_CONFIG_LINE, fp)) { char *key, *value, *r; for (r = line + strlen(line) - 1; r > line && *r == '\n'; *(r--) = 0); /* Get continuation lines. Ugly. */ while (*(line + strlen(line) - 1) == '\\') { if (!fgets(line + strlen(line) - 1, MAX_CONFIG_LINE - strlen(line), fp)) break; for (r = line + strlen(line) - 1; r > line && *r == '\n'; *(r--) = 0); } /* Strip comment. */ key = strpbrk(line, "#\n"); if (key) *key = 0; /* foo : bar baz quux * key^ ^value */ key = line + strspn(line, " \t"); value = strchr(line, ':'); if (value) { /* foo : bar baz quux * key^ ^r ^value */ ++value; r = key + strcspn(key, " \t:"); if (r != key) { item *I; *r = 0; /* foo\0: bar baz quux * key^ ^value ^r */ value += strspn(value, " \t"); r = value + strlen(value) - 1; while (strchr(" \t", *r) && r > value) --r; *(r + 1) = 0; /* (Removed check for zero length value.) */ /* Check that this is a valid key. */ if (!is_cfgdirective_valid(key)) fprintf(stderr, "%s:%d: warning: unknown directive \"%s\"\n", f, i, key); else if ((I = stringmap_insert(config, key, item_ptr(xstrdup(value))))) /* Don't warn of repeated directives, because they * may have been specified via the command line * Previous option takes precedence. */ fprintf(stderr, "%s:%d: warning: repeated directive \"%s\"\n", f, i, key); } } memset(line, 0, MAX_CONFIG_LINE); /* security paranoia */ ++i; } ret = 1; fail: if (fp) fclose(fp); if (line) xfree(line); return ret; }
void row::append( Item * item ) { std::unique_ptr<Item> item_ptr(item); Items.push_back( std::move(item_ptr) ); }