void HTMLParser :: showTree( const TNodeShared aNode, int aSpacing ) { TNodeListShared children = aNode->getChildNodes(); int length = children->getLength(); if ( length != 0 ) { for ( int i = 0; i < length; i++ ) { TNodeShared child = make_shared( children->item( i ) ); for ( int j = 0; j < aSpacing; j++ ) { cout << " "; } cout << "Child name: " << child->getNodeName().c_str() << endl; if ( child->getNodeType() == ELEMENT_NODE ) { // Check for attributes TNamedNodeMapShared attributes = child->getAttributes(); for ( unsigned int j = 0; j < attributes->getLength(); j++ ) { TNodeWeak attr = attributes->item( j ); TNodeShared tempAttr = make_shared( attr ); for ( int j = 0; j < aSpacing + 1; j++ ) { cout << " "; } cout << "Attribute " << tempAttr->getNodeName(); cout << " with value " << tempAttr->getNodeValue() << endl; } } showTree( child, aSpacing + 1 ); } } }
Expression::Ptr InstructionDecoderImpl::makeAddExpression(Expression::Ptr lhs, Expression::Ptr rhs, Result_Type resultType) { static BinaryFunction::funcT::Ptr adder(new BinaryFunction::addResult()); return make_shared(singleton_object_pool<BinaryFunction>::construct(lhs, rhs, resultType, adder)); }
std::shared_ptr<VersionForRestore> BackupSystem::compute_latest_version(version_number_t version_number){ std::shared_ptr<VersionForRestore> latest_version; std::map<version_number_t, std::shared_ptr<VersionForRestore>> versions; std::vector<version_number_t> stack; const auto &latest_version_number = version_number; { auto version = make_shared(new VersionForRestore(latest_version_number, *this, this->keypair.get())); versions[latest_version_number] = version; for (auto &object : version->get_base_objects()) this->old_objects.push_back(object); for (auto &dep : version->get_manifest()->version_dependencies) versions[dep] = make_shared(new VersionForRestore(dep, *this, this->keypair.get())); } latest_version = versions[latest_version_number]; latest_version->fill_dependencies(versions); return latest_version; }
Expression::Ptr InstructionDecoderImpl::makeRegisterExpression(MachRegister registerID) { int newID = registerID.val(); int minusArch = newID & ~(registerID.getArchitecture()); int convertedID = minusArch | m_Arch; MachRegister converted(convertedID); return make_shared(singleton_object_pool<RegisterAST>::construct(converted, 0, registerID.size() * 8)); }
static std::shared_ptr<T> get_instance() { static std::shared_ptr<T> instance; static std::mutex lock; if (instance) return instance; std::lock_guard<decltype(lock)> guard(lock); if (instance) return instance; instance = make_shared(); return instance; }
Instruction::Ptr InstructionDecoderImpl::decode(InstructionDecoder::buffer& b) { //setMode(m_Arch == Arch_x86_64); const unsigned char* start = b.start; decodeOpcode(b); unsigned int decodedSize = b.start - start; return make_shared(singleton_object_pool<Instruction>::construct( m_Operation, decodedSize, start, m_Arch)); }
std::vector<std::shared_ptr<FileSystemObject>> BackupSystem::get_old_objects(ArchiveReader &archive, version_number_t v){ boost::filesystem::ifstream file(this->get_aux_fso_path(v), std::ios::binary); if (!file) return archive.get_base_objects(); boost::iostreams::stream<LzmaInputFilter> lzma(file); std::vector<std::shared_ptr<FileSystemObject>> ret; buffer_t mem; while (simple_buffer_deserialization(mem, lzma)){ boost::iostreams::stream<MemorySource> stream(&mem); ImplementedDeserializerStream ds(stream); auto fso = make_shared(ds.begin_deserialization<FileSystemObject>(config::include_typehashes)); ret.push_back(fso); auto mbp = fso->get_unmapped_base_path(); if (!mbp) continue; auto mapped = this->map_forward(*mbp).wstring(); fso->set_mapped_base_path(make_shared(new decltype(mapped)(mapped))); } return ret; }
Immediate::Ptr Immediate::makeImmediate(const Result &val) { //static std::map<Result, Immediate::Ptr> builtImmediates; //static int cache_hits = 0; //std::map<Result, Immediate::Ptr>::const_iterator foundIt = builtImmediates.find(val); //if(foundIt == builtImmediates.end()) //{ Immediate::Ptr ret = make_shared(singleton_object_pool<Immediate>::construct(val)); //builtImmediates[val] = ret; return ret; //} //return foundIt->second; }
boost::shared_ptr<socket_core> time_socket::start_timer(size_t second) { boost::system::error_code ec; if (!timer_core) { make_shared(timer_core, core->get_io()); } timer_core->expires_from_now(boost::posix_time::seconds(second), ec); if (ec) return boost::shared_ptr<socket_core>(); timer_core->async_wait(boost::bind(&time_socket::timer_handler, shared_from_this(), _1)); return core; }
static std::shared_ptr<T> get_instance () { static std::weak_ptr<T> instance; static std::mutex lock; auto x = instance.lock(); if (x) return x; std::lock_guard<decltype(lock)> guard(lock); x = instance.lock(); if (x) return x; x = make_shared(); instance = x; return x; }
std::shared_ptr<BackupStream> BackupSystem::generate_initial_stream(FileSystemObject &fso, known_guids_t &known_guids){ if (!this->should_be_added(fso, known_guids)){ this->fix_up_stream_reference(fso, known_guids); return std::shared_ptr<BackupStream>(); } auto &filish = static_cast<FilishFso &>(fso); auto ret = make_shared(new FullStream); ret->set_unique_id(filish.get_stream_id()); ret->set_physical_size(filish.get_size()); ret->set_virtual_size(filish.get_size()); if (filish.get_file_system_guid().valid) known_guids[filish.get_file_system_guid().data] = ret; ret->add_file_system_object(&filish); return ret; }
void BackupSystem::perform_restore( const std::shared_ptr<VersionForRestore> &latest_version, const restore_vt &restore_later){ std::vector<std::shared_ptr<std::thread>> threads; threads.reserve(std::thread::hardware_concurrency()); std::mutex mutex; auto begin = restore_later.begin(); auto end = restore_later.end(); while (threads.size() < threads.capacity()) threads.push_back(make_shared(new std::thread(restore_thread, this, &begin, &end, &mutex))); while (threads.size()){ threads.back()->join(); threads.pop_back(); } }
int main() { int i; pthread_t child[NUM_CHILDREN]; Shared *shared = make_shared(); child[0] = make_thread(producer_entry, shared); child[1] = make_thread(consumer_entry, shared); for (i=0; i<NUM_CHILDREN; i++) { join_thread(child[i]); } return 0; }
int main () { int i; pthread_t child[NUM_CHILDREN]; Shared *shared = make_shared (100000000); for (i=0; i<NUM_CHILDREN; i++) { child[i] = make_thread (entry, shared); } for (i=0; i<NUM_CHILDREN; i++) { join_thread (child[i]); } check_array (shared); return 0; }
void BackupSystem::set_base_objects(){ if (this->base_objects_set) return; this->base_objects_set = true; std::shared_ptr<std::vector<std::wstring>> for_later_check(new std::vector<std::wstring>); FileSystemObject::CreationSettings settings = { this, make_shared(new SimpleErrorReporter), this->make_map(for_later_check) }; for (auto ¤t_source_location : this->get_current_source_locations()){ auto mapped = this->map_forward(current_source_location); std::shared_ptr<FileSystemObject> fso(FileSystemObject::create(mapped, current_source_location, settings)); fso->set_is_main(true); this->base_objects.push_back(fso); } while (for_later_check->size()){ auto old_for_later_check = for_later_check; for_later_check.reset(new std::vector<std::wstring>); settings.backup_mode_map = this->make_map(for_later_check); for (auto &path : *old_for_later_check){ if (this->covered(path)) continue; std::shared_ptr<FileSystemObject> fso( FileSystemObject::create( this->map_forward(path), path, settings ) ); this->base_objects.push_back(fso); } } int i = 0; for (auto &fso : this->base_objects) fso->set_entry_number(i++); this->recalculate_file_guids(); }
StoragePtr StorageSystemEvents::create(const std::string & name_) { return make_shared(name_); }
int test1() { int child = fork(); int i; data_t* smem; pid_t mypid; int cooloffs = 5; sched_param_t params = {1, 50, cooloffs}; int status; int counter = 0; if (child != 0) { smem = (data_t*)make_shared(sizeof(data_t), 1); smem->curr = 0; mypid = getpid(); ASSERT_POSITIVE(mypid); nice(1); // be nicer than child ASSERT_ZERO(sched_setscheduler(mypid, SCHED_SHORT, ¶ms)); ASSERT_EQUALS(sched_setscheduler(mypid, SCHED_SHORT, ¶ms), -1); ASSERT_EQUALS(errno, EPERM); ASSERT_EQUALS(is_SHORT(mypid), 1); smem->arr[smem->curr] = FATHER+0; // init value ASSERT_ZERO(sched_setscheduler(child, SCHED_SHORT, ¶ms)); // now we lost control until child will be overdue // child got into overdue. we gained control again. we should still be short here. smem->arr[++smem->curr] = FATHER+1; while (is_SHORT(mypid)) ; smem->arr[++smem->curr] = FATHER+(1*10)+OVERDUE_PERIOD; // got into first overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-1); for (i = 1; i <= cooloffs; ++i) { while (!is_SHORT(mypid)) ; smem->arr[++smem->curr] = FATHER+(i*10); // got out of overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-i); while (is_SHORT(mypid)) ; smem->arr[++smem->curr] = FATHER+((i+1)*10)+OVERDUE_PERIOD; // got into overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), max(cooloffs-(i+1), 0)); } // now should be overdue forever ASSERT_ZERO(remaining_cooloffs(mypid)); waitpid(child, &status, 0); // use `gcc -DVERBOSE ...` in order to print the array state if (IS_VERBOSE()) { for (i = 0; i <= 24; i++) { printf("%d:\t%d\n", i, smem->arr[i]); } } // check array ASSERT_EQUALS(smem->arr[0], FATHER+0); ASSERT_EQUALS(smem->arr[1], SON+0); ASSERT_EQUALS(smem->arr[2], FATHER+1); ASSERT_EQUALS(smem->arr[3], SON+10+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[4], SON+10); ASSERT_EQUALS(smem->arr[5], FATHER+10+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[6], FATHER+10); ASSERT_EQUALS(smem->arr[7], SON+20+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[8], SON+20); ASSERT_EQUALS(smem->arr[9], FATHER+20+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[10], FATHER+20); ASSERT_EQUALS(smem->arr[11], SON+30+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[12], SON+30); ASSERT_EQUALS(smem->arr[13], FATHER+30+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[14], FATHER+30); ASSERT_EQUALS(smem->arr[15], SON+40+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[16], SON+40); ASSERT_EQUALS(smem->arr[17], FATHER+40+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[18], FATHER+40); ASSERT_EQUALS(smem->arr[19], SON+50+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[20], SON+50); ASSERT_EQUALS(smem->arr[21], FATHER+50+OVERDUE_PERIOD); ASSERT_EQUALS(smem->arr[22], FATHER+50); ASSERT_EQUALS(smem->arr[23], SON+60+OVERDUE_PERIOD); // son finished ASSERT_EQUALS(smem->arr[24], FATHER+60+OVERDUE_PERIOD); return 1; } else { pid_t mypid = getpid(); ASSERT_POSITIVE(mypid); while (is_SHORT(mypid) != 1) ; data_t* smem = (data_t*)make_shared(sizeof(data_t), 0); smem->arr[++smem->curr] = SON+0; // this is the first SHORT time slice while (is_SHORT(mypid)) ; smem->arr[++smem->curr] = SON+(1*10)+OVERDUE_PERIOD; // got into first overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-1); for (i = 1; i <= cooloffs; ++i) { while (!is_SHORT(mypid)) ; smem->arr[++smem->curr] = SON+(i*10); // got out of overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), cooloffs-i); while (is_SHORT(mypid)) ; smem->arr[++smem->curr] = SON+((i+1)*10)+OVERDUE_PERIOD; // got into overdue period ASSERT_EQUALS(remaining_cooloffs(mypid), max(cooloffs-(i+1), 0)); } // now should be overdue forever ASSERT_ZERO(remaining_cooloffs(mypid)); exit(0); } return 0; }
boost::shared_ptr<socket_core> asio_tools::make_socket(boost::asio::io_service & io, protocal::protocal_type type) { boost::shared_ptr<socket_core> ptr; return make_shared(ptr, io, type); }
boost::shared_ptr<boost::asio::signal_set> asio_tools::make_signal(boost::asio::io_service & io) { boost::shared_ptr<boost::asio::signal_set> ptr; return make_shared(ptr, io); }
Expression::Ptr InstructionDecoderImpl::makeDereferenceExpression(Expression::Ptr addrToDereference, Result_Type resultType) { return make_shared(singleton_object_pool<Dereference>::construct(addrToDereference, resultType)); }
boost::shared_ptr<boost::asio::ip::tcp::acceptor> asio_tools::make_acceptor(boost::asio::io_service & io) { boost::shared_ptr<boost::asio::ip::tcp::acceptor> ptr; return make_shared(ptr, io); }
Instruction* InstructionDecoderImpl::makeInstruction(entryID opcode, const char* mnem, unsigned int decodedSize, const unsigned char* raw) { Operation::Ptr tmp(make_shared(singleton_object_pool<Operation>::construct(opcode, mnem, m_Arch))); return singleton_object_pool<Instruction>::construct(tmp, decodedSize, raw, m_Arch); }
time_socket::time_socket(boost::asio::io_service & io, boost::asio::ssl::context & context, bool need_extern) { make_shared(core, io, context, need_extern); }
time_socket::time_socket(boost::asio::io_service & io, protocal::protocal_type t, bool need_extern) { make_shared(core, io, t, need_extern); }
boost::shared_ptr<boost::asio::ip::tcp::resolver> asio_tools::make_resolver(boost::asio::io_service & io) { boost::shared_ptr<boost::asio::ip::tcp::resolver> ptr; return make_shared(ptr, io); }
boost::shared_ptr<boost::asio::deadline_timer> asio_tools::make_timer(boost::asio::io_service & io) { boost::shared_ptr<boost::asio::deadline_timer> ptr; return make_shared(ptr, io); }
StoragePtr StorageSystemDictionaries::create(const std::string & name) { return make_shared(name); }
int main() { shared_ptr(); shared_ptr_container(); weak_ptr(); make_shared(); }
StoragePtr StorageSystemMerges::create(const std::string & name) { return make_shared(name); }
int OOBase::Environment::get_block(const env_table_t& tabEnv, ScopedArrayPtr<wchar_t>& ptr) { if (tabEnv.empty()) return 0; // Copy and widen to UNICODE typedef SharedPtr<wchar_t> temp_wchar_t; // Sort environment block - UNICODE, no-locale, case-insensitive (from MSDN) struct env_sort { bool operator ()(const OOBase::SharedPtr<wchar_t>& s1, const OOBase::SharedPtr<wchar_t>& s2) const { return (_wcsicmp(s1.get(),s2.get()) < 0); } }; StackAllocator<1024> allocator; Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance> wenv(env_sort(),allocator); size_t total_size = 0; for (env_table_t::const_iterator i=tabEnv.begin();i;++i) { int err = Win32::utf8_to_wchar_t(i->first.c_str(),ptr); if (!err) { // Include \0 and optionally '=' length size_t len = wcslen(ptr.get()); total_size += len + 1; temp_wchar_t key = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator); if (!key) return ERROR_OUTOFMEMORY; wcscpy(key.get(),ptr.get()); err = Win32::utf8_to_wchar_t(i->second.c_str(),ptr); if (!err) { temp_wchar_t value; len = wcslen(ptr.get()); if (len) { total_size += len + 1; value = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator); if (!value) return ERROR_OUTOFMEMORY; wcscpy(value.get(),ptr.get()); } if (!wenv.insert(key,value)) return ERROR_OUTOFMEMORY; } } if (err) return err; } // And now copy into one giant block if (!ptr.resize(total_size + 2)) return ERROR_OUTOFMEMORY; wchar_t* pout = ptr.get(); for (Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance>::iterator i=wenv.begin();i;++i) { const wchar_t* p = i->first.get(); while (*p != L'\0') *pout++ = *p++; p = i->second.get(); if (p && *p != L'\0') { *pout++ = L'='; while (*p != L'\0') *pout++ = *p++; } *pout++ = L'\0'; } // Terminate with \0 *pout++ = L'\0'; *pout++ = L'\0'; return 0; }