struct ZSTLIterator *ZSTLMapEnum(struct ZSTLMap *pm) { ZSTLIterator_t *iterator; pthread_mutex_lock(&(pm->enum_mutex)); do_lock(&(pm->mutex)); iterator = get_iterator(pm); zstlmap_assert(iterator); #ifdef SANDISK_PRINTSTUFF fprintf(stderr, "ZSTLMapEnum: pm=%p, iterator=%p, ", pm, iterator); #endif iterator->enum_entry = pm->lru_head; #ifdef SANDISK_PRINTSTUFF fprintf(stderr, "pme=%p, enum_entry=%p\n", pm, iterator->enum_entry); #endif do_unlock(&(pm->mutex)); return(iterator); }
void list_traverse(const list_t* list, int direction, void (*func)(node_t*)) { node_t *node; list_iterator_t *it = get_iterator(list, direction); while ((node = iterator_next(it)) != NULL) { func(node); } free_iterator(it); }
/* Linked List Open */ void list_free(List* list) { Iterator* it = get_iterator(list); while (1) { Iterator* old_it = it; if (it == NULL) break; free(it->element); it = it->next; free(old_it); } }
void STLMetaClass::copy_over( Address target, GenericList* source ) const { int instanceSize = _element_meta_class->get_size_of_instance(); int i = source->count; Address space = source->space; Iterator* iterator = get_iterator( target ); while (i--) { iterator->add( (Byte*)space ); space = ((Byte*)space) + instanceSize; } delete iterator; delete (char*)(source->space); // delete source; }
void tuple_connect::insert( const tuple_ptr in, const tuple_ptr out) { in_to_out_t::iterator it = get_iterator(in, m_data); if ( it == m_data.end()) { //input tuple seen for the first time it = m_data.insert(in_to_out_t::value_type(in, outs_t())); } it->second.push_back(out); m_published.insert(published_t::value_type(out, false)); }
tuple_connect::outs_t tuple_connect::remove( const tuple_ptr in) { in_to_out_t::iterator in_it = get_iterator(in, m_data); if (in_it == m_data.end()) return outs_t(); outs_t& outs = in_it->second; outs_t result; published_t::iterator pub_it; for (outs_t::iterator out_it = outs.begin(); out_it != outs.end(); ++out_it) { pub_it = get_iterator(*out_it, m_published); if (pub_it != m_published.end()) { if (pub_it->second) result.push_back(*out_it); m_published.erase(pub_it); } } m_data.erase(in_it); return result; }
BackupSystem::stream_dict_t BackupSystem::generate_streams(generate_archive_fp generator){ known_guids_t known_guids; stream_dict_t stream_dict; for (stream_index_t i = 0; i < this->base_objects.size(); i++){ auto fso = this->base_objects[i]; std::vector<std::shared_ptr<BackupStream>> streams; for (auto &child : fso->get_iterator()){ auto stream = (this->*generator)(*child, known_guids); if (!stream || !stream->has_data()) continue; child->set_unique_ids(*this); stream->set_unique_id(child->get_stream_id()); streams.push_back(stream); this->streams.push_back(stream); } stream_dict[i] = std::move(streams); } return stream_dict; }
void BackupSystem::archive_process_files(stream_dict_t &stream_dict, std::set<version_number_t> &version_dependencies, ArchiveWriter &archive){ std::vector<ArchiveWriter::FileQueueElement> file_queue; for (auto &kv : stream_dict){ auto base_object = this->base_objects[kv.first]; for (auto &stream : kv.second) for (auto &fso : stream->get_file_system_objects()) fso->set_backup_stream(stream.get()); for (auto &i : base_object->get_iterator()) this->get_dependencies(version_dependencies, *i); for (auto &backup_stream : kv.second){ auto fso = backup_stream->get_file_system_objects()[0]; auto id = backup_stream->get_unique_id(); file_queue.push_back({ fso, id }); } } reorder_file_streams(file_queue); archive.add_files(file_queue); }
/** * \brief Get an iterator on the placement of a given mark. * \param m The mark for which we want the iterator. */ bf::snapshot::placement_list::iterator bf::snapshot::get_iterator( const mark* m ) { return get_iterator(m->get_label()); } // snapshot::get_iterator()
/** * \brief Remove a mark from the snapshot. * \param m The identifief of the mark to remove. * \pre has_mark(m) == true */ void bf::snapshot::remove_mark( mark* m ) { CLAW_PRECOND( has_mark(m) ); m_placement.erase( get_iterator(m) ); } // snapshot::remove_mark()
/** * \brief Get the placement of a given mark. * \param m The mark for which we want the placement. * \pre There is such a mark \a m in the snapshot. */ bf::mark_placement& bf::snapshot::get_placement( const mark* m ) { CLAW_PRECOND( has_mark(m) ); return *get_iterator(m); } // snapshot::get_placement()
void tuple_connect::mark_as_published(const tuple_ptr out) { published_t::iterator out_it = get_iterator(out, m_published); if (out_it != m_published.end()) out_it->second = true; }
table& operator[] (unsigned resultID) throw (result_exception&) {return *get_iterator(resultID)->second.result_table;}
/* La funzione executed() permette di verificare il termine dell'esecuzione di una query */ bool executed (unsigned long resultID) const throw (result_exception&) {return get_iterator(resultID)->second.completed;}