int getChildIndex(List* list,void* childData, compareFunc* compareFunc){
Iterator* iterator = getIterator(list);
TreeNode *ptNode;
int result;
while(iterator->hasNext(iterator)){
ptNode = iterator->next(iterator);
result = compareFunc(ptNode->data, childData);
if(result) return iterator->currentPosition;
}
return -1;
};
bool ObjectOrderBase::erase(IddObjectType type) {
if (!m_iddOrder) {
return false;
}
IddObjectTypeVector::iterator it = getIterator(type);
if (it == m_iddOrder->end()) {
return false;
}
m_iddOrder->erase(it);
return true;
}
void DisposeTree(List *list){
TreeNode* temp;
Iterator it = getIterator(list);
while(it.hasNext(&it)){
temp = it.next(&it);
if(NULL != temp->children->head){
DisposeTree(temp->children);
}
dispose(temp->children);
}
}
size_t CompositeResourceProvider::getResourceGroupFileNames(std::vector<String>& out_vec,
const String& file_pattern,const String& resource_group)
{
size_t entries = 0;
ProviderIterator it=getIterator();
for(it.toStart(); !it.isAtEnd(); ++it)
{
entries += it.getCurrentValue()->getResourceGroupFileNames(out_vec,file_pattern,resource_group);
}
return entries;
}
void test_gives_the_data_of_first_node(){
DoubleList dList = create();
Iterator it;
int number1 = 5,number2 = 9;
insert(&dList, 0, &number1);
insert(&dList, 1, &number2);
it = getIterator(&dList);
ASSERT(5 == *(int*)it.next(&it));
ASSERT(9 == *(int*)it.next(&it));
ASSERT(NULL == it.next(&it));
}
bool fme::RessourceManager::freeSpecificSprite(std::string const& key, unsigned int id)
{
ressourceArrayIndex = getIterator(key);
if (ressourceArrayIndex != ressources.end()) {
if (ressourceArrayIndex->second.size() >= id)
{
ressourceArrayIndex->second[id].isUsed = false;
return true;
}
}
return false;
}
bool fme::RessourceManager::createKey(std::string const& key)
{
// check if the key exists
ressourceArrayIndex = getIterator(key);
if (ressourceArrayIndex != ressources.end()) {
return true;
}
// create a new array from the new key
ressources.emplace(key, std::vector <fme::Ressource>());
return false;
}
bool ObjectOrderBase::move(IddObjectType type, unsigned index) {
if (!m_iddOrder) { return false; }
// find type in order
auto it = getIterator(type);
if (it == m_iddOrder->end()) { return false; }
// handle degenerate case
if ((it - m_iddOrder->begin()) == static_cast<int>(index)) { return true; }
// erase type
m_iddOrder->erase(it);
// reinsert at given index
return insert(type,index);
}
int getIndex(List* list,void* data,compareFunc cmp){
int i = 0;
TreeNode *tn;
Iterator it = getIterator(list);
while(it.hasNext(&it)){
i = i + 1;
tn = (TreeNode*)it.next(&it);
if(0 == cmp(tn->data,data))
return i;
}
return i;
};
Iterator getChildren(Tree* tree, void *parent){
TreeNode *tNode;
TreeNode *root = (TreeNode*)tree->root;
Iterator it;
if(0 == tree->cmp(root->data,parent))
tNode = root;
else
tNode = getTreeNode(root->children, parent, tree->cmp);
it = getIterator(&tNode->children);
it.next = &treeNext;
return it;
}
int findIndex(Tree* tree,TreeNode* treenode,void* data){
Iterator it = getIterator(treenode->children);
int count = 0;
void* elements;
while(it.hasNext(&it)){
elements = ((TreeNode*)it.next(&it))->data;
if(tree->compare(elements,data))
return count;
count++;
}
return -1;
}
TreeNode* getTreeNode(DoubleList list,void *dataToFind,Compare cmp){
Iterator it = getIterator(&list);
TreeNode *tNode;
while(it.hasNext(&it)){
tNode = (TreeNode*)it.next(&it);
if(0 == cmp(tNode->data,dataToFind))
return tNode;
if(tNode->children.head)
return getTreeNode(tNode->children, dataToFind, cmp);
}
return NULL;
}
Status RocksRecordStore::truncate( OperationContext* txn ) {
// XXX once we have readable WriteBatch, also delete outstanding writes to
// this collection in the WriteBatch
//AFB add Clear(ColumnFamilyHandle*)
boost::scoped_ptr<RecordIterator> iter( getIterator( txn ) );
while( !iter->isEOF() ) {
DiskLoc loc = iter->getNext();
deleteRecord( txn, loc );
}
return Status::OK();
}
bool ObjectOrderBase::inOrder(const IddObjectType& type) const {
if (m_orderByIddEnum) {
return true;
}
if (m_iddOrder) {
IddObjectTypeVector::const_iterator it = getIterator(type);
if (it != m_iddOrder->end()) {
return true;
}
}
return false;
}
bool ObjectOrderBase::move(IddObjectType type, IddObjectType insertBeforeType) {
if (!m_iddOrder) { return false; }
// find type in order
auto it = getIterator(type);
if (it == m_iddOrder->end()) { return false; }
// handle degenerate case
if (type == insertBeforeType) { return true; }
// erase type
m_iddOrder->erase(it);
// reinsert at given location
return insert(type,insertBeforeType);
}
bool WorkspaceObjectOrder_Impl::move(const Handle& handle, unsigned index) {
if (!m_directOrder) { return false; }
// find type in order
auto it = getIterator(handle);
if (it == m_directOrder->end()) { return false; }
// handle degenerate case
if ((it - m_directOrder->begin()) == static_cast<int>(index)) { return true; }
// erase handle
m_directOrder->erase(it);
// reinsert at given location
return insert(handle,index);
}
bool WorkspaceObjectOrder_Impl::move(const Handle& handle, const Handle& insertBeforeHandle) {
if (!m_directOrder) { return false; }
// find type in order
auto it = getIterator(handle);
if (it == m_directOrder->end()) { return false; }
// handle degenerate case
if (handle == insertBeforeHandle) { return true; }
// erase handle
m_directOrder->erase(it);
// reinsert at given location
return insert(handle,insertBeforeHandle);
}
TreeNode* getTreeNode(List* list,void* parentData,compareFunc cmp){
TreeNode *tn;
Iterator it = getIterator(list);
while(it.hasNext(&it)){
tn = it.next(&it);
if(0 == cmp(tn->data,parentData))
return tn;
if(tn->list)
return getTreeNode(tn->list,parentData,cmp);
}
return NULL;
};
void Container::moveShapeToEnd(Shape*& s) {
if (s == nullptr) {
cout << "Error: No such shape!\n";
return;
}
item1 = getIterator(s);
if (item1 != lst.end())
lst.splice(lst.end(), lst, item1);
}
void test_deletes_and_shifts_elements_left(){
Intern tanbirka = {43343, "Tanbir Ka"};
int result;
Intern *res;
Iterator it = getIterator(internsPtr);
insert(internsPtr, 0, &prateek);
insert(internsPtr, 1, &ji);
insert(internsPtr, 2, &tanbirka);
res = remove(internsPtr, 0);
ASSERT(res == &prateek);
ASSERT(0 == compareInterns(&tanbirka, get(internsPtr, 1)));
ASSERT(0 == compareInterns(&ji, get(internsPtr, 0)));
}
void reHash(HashMap *map){
Object *object;
Iterator it = keys(map);
ArrayList listOfBuckets;
Iterator dllIterator = getIterator(it.list);
disposeHashMap(map);
map->capacity = map->capacity * 2;
createLinkedListInBuckets(map);
while(dllIterator.hasNext(&dllIterator)){
object = dllIterator.next(&dllIterator);
put(map,object->key,object->values);
}
};
java::lang::String* rice::pastry::IdSet::toString()
{
auto it = getIterator();
Id* key;
auto s = u"[ IdSet: "_j;
while (npc(it)->hasNext()) {
key = java_cast< Id* >(java_cast< ::java::lang::Object* >(npc(it)->next()));
s = ::java::lang::StringBuilder().append(s)->append(static_cast< ::java::lang::Object* >(key))
->append(u","_j)->toString();
}
s = ::java::lang::StringBuilder().append(s)->append(u" ]"_j)->toString();
return s;
}
fme::Sprite* fme::RessourceManager::getFreeSprite(std::string const& key)
{
// check if the key exists
ressourceArrayIndex = getIterator(key);
if (ressourceArrayIndex == ressources.end()) {
return NULL;
}
// check if there is a non used sprite
for (unsigned int i = 0; i < ressourceArrayIndex->second.size(); i++)
{
// return the adress of the free sprite
if (!ressourceArrayIndex->second[i].isUsed)
{
// set the variable isUsed to show that this object is busy
ressourceArrayIndex->second[i].isUsed = true;
return ressources[key][i].sprite;
}
}
// create a sprite if all sprites are busy
// check if there is an another element to copy it
if (ressourceArrayIndex->second.size() == 0)
{
return NULL;
}
fme::Sprite* newSprite = NULL;
// check if we need construct a fme::Sprite or an fme::Animation
if (ressourceArrayIndex->second[0].sprite->isSprite())
{
// create a copy fme::Sprite from the first element
newSprite = new fme::Sprite(*ressourceArrayIndex->second[0].sprite);
}
else
{
// create an fme::Animation by casting the first element in fme::Animation
newSprite = new fme::Animation(*(fme::Animation*)ressourceArrayIndex->second[0].sprite);
}
// add the new objet to the map
ressources[key].push_back(fme::Ressource(newSprite));
// set the variable isUsed to show that this object is busy
ressourceArrayIndex->second[ressourceArrayIndex->second.size()-1].isUsed = true;
// return the address of the object
return newSprite;
}
void test_10_to_check_iterator() {
int* temp;
int count=0;
int data=2,data2 =3;
int expected[] = {2,3};
Iterator it = getIterator(start);
insert(start, 0, &data);
insert(start, 1, &data2);
while(it.hasNext(&it)) {
temp = it.next(&it);
ASSERT(expected[count] = *(int*)temp);
count++;
}
}
TreeNode* Traverse(List *list, void* parentData,int (*compare)(void*,void*)){
TreeNode* temp;
Iterator it = getIterator(list);
while(it.hasNext(&it)){
temp = it.next(&it);
if (1 == compare(temp->data,parentData)){
return temp;
}
if(NULL != temp->children->head){
return Traverse(temp->children, parentData, compare);
}
}
return NULL;
}
int64_t Collection::countTableScan( const MatchExpression* expression ) {
scoped_ptr<RecordIterator> iterator( getIterator( DiskLoc(),
false,
CollectionScanParams::FORWARD ) );
int64_t count = 0;
while ( !iterator->isEOF() ) {
DiskLoc loc = iterator->getNext();
BSONObj obj = docFor( loc );
if ( expression->matchesBSON( obj ) )
count++;
}
return count;
}
static btSIter *createIterator(bt *btr, iter_single *itl, iter_single *itn) {
btSIter *siter = getIterator();
siter->dofree = 1;
siter->missed = 0;
siter->nim = 0;
siter->empty = 1;
siter->scan = 0;
siter->ktype = btr->s.ktype;
init_ai_obj(&siter->key);
siter->be.key = &(siter->key);
siter->be.val = NULL;
init_iter(&siter->x, btr, itl, itn);
return siter;
}
void test_getIterator_should_create_an_iterator_and_point_to_the_LinkedList()
{
LinkedList *testList = malloc(sizeof(LinkedList));
Iterator *iter;
iter = getIterator(testList);
TEST_ASSERT_NOT_NULL(iter);
//Make sure Iterator refer to the same linked list.
TEST_ASSERT_EQUAL(testList,iter->list);
//And it is points to the head.
TEST_ASSERT_EQUAL(testList->head,iter->current);
//Make sure the function pointer point to the function that refer the next element.
TEST_ASSERT_EQUAL(&getNext,iter->next);
List_DestroyList(testList);
destroyIterator(iter);
}
void Container::deleteShape(Shape*& s) {
if (s == nullptr) {
cout << "Error: No such shape!\n";
return;
}
item1 = getIterator(s);
if (item1 != lst.end()) {
delete *item1;
lst.erase(item1);
}
}
boost::optional<RecordId> KVRecordStoreCapped::oplogStartHack(OperationContext* txn,
const RecordId& startingPosition) const {
if (!_isOplog) {
return boost::none;
}
RecordId lowestInvisible = _idTracker->lowestInvisible();
for (boost::scoped_ptr<RecordIterator> iter(getIterator(txn, startingPosition, CollectionScanParams::BACKWARD));
!iter->isEOF(); iter->getNext()) {
if (iter->curr() <= startingPosition && iter->curr() < lowestInvisible) {
return iter->curr();
}
}
return boost::none;
}
