int Collator::collate(StringView a, StringView b) const
{
UCharIterator iteratorA = createIterator(a);
UCharIterator iteratorB = createIterator(b);
UErrorCode status = U_ZERO_ERROR;
int result = ucol_strcollIter(m_collator, &iteratorA, &iteratorB, &status);
ASSERT(U_SUCCESS(status));
return result;
}
extern LSQ_IteratorT LSQ_GetFrontElement(LSQ_HandleT handle)
{
AVLTreeT * tree = (AVLTreeT *)handle;
if IS_HANDLE_INVALID(handle)
return LSQ_HandleInvalid;
return createIterator(handle, treeMinimum(tree->root));
}
IndexIterator* IndexABase::createFilteredIterator(FSFilter const * cpFilter) const {
IndexIterator* pit = createIterator();
assert( EXISTS(pit) );
IndexIterator* result = new FilterIndexIterator(cpFilter, pit);
assert( EXISTS(result) );
return result;
}
/* add data to the list */
void SortDoubleLinkedList::add(int &value)
{
Iterator *it = createIterator();
CircleNode *nNode = new CircleNode();
dynamic_cast<CircleNode*>(locAddPosition(*it,value).current())->addBefore(*nNode,value);
delete it;
}
extern LSQ_IteratorT LSQ_GetElementByIndex(LSQ_HandleT handle, LSQ_IntegerIndexT index)
{
ArrayIteratorPointerT iterator = createIterator(handle);
if(iterator == NULL) return NULL;
iterator->index = index;
if(index < 0)
{
iterator->type = BEFOREFIRST;
index = -1;
}
else
{
if(index >= ((ArrayPointerT)handle)->count)
{
iterator->type = PASTREAR;
index = ((ArrayPointerT)handle)->count;
}
else
{
iterator->type = DEREFERENCABLE;
}
}
iterator->index = index;
return iterator;
}
Iterator List::erase(Iterator i)
{
Iterator iter = createIterator();
iter = i;
bool iAmHead;
// if(iter.isHead())
//{ cout <<iter.isHead()<<"---bool iter is head"<<endl;
// iAmHead=true;}
// return iter;
//iter.position->getNext().setPrev(iter.position->getPrev());
//iter.position->getPrev().setNext(iter.position->getNext());
iter.position->del(*iter.position);
Iterator tmp= iter;
iter.position= iter.next().position;
cout <<tmp.get()<< "iter been deleted"<<endl;
if(!iAmHead)
delete tmp.position;
/* Node* remove = iter.position;
Node* before = & (remove ->getPrev());
Node* after =& (remove ->getNext());
before -> setNext(*after);
after -> setPrev(*before);
iter.position = after;
cout <<iter.get()<< "iter been delected"<<endl;
if(!iAmHead)
delete remove;
// }
*/
return iter;
}
vector<unsigned int> HashTable::statBuckets()
{
vector<unsigned int> ret;
HashTable::Iterator it = createIterator();
for (unsigned int i=0; i<getNumberOfBuckets(); ++i)
{
placeIterator(it, i);
unsigned int count = 0;
while (it.next())
{
++count;
}
if (count >= ret.size())
{
ret.resize(count+1, 0);
}
++ret.at(count);
}
return ret;
}
entity_t *closest(scene_t *scene, point_t base, vector_t unitDir,
entity_t *self, hitinfo_t *hit) {
// set up iterator for sobjList and create sentinel value for
// min distance
iterator_t *iter = createIterator(scene->sobjList);
entity_t *temp = list_getnext(iter);
// set sentinel value
hit->distance = 9999;
sobj_t *sobj = NULL;
entity_t *closest = NULL;
// temporary hit info
hitinfo_t tempHit;
// loop through the entire sobjList
while (temp != NULL) {
sobj = ((sobj_t*)temp->entDerived);
/* if we have a hit, check the min distance
* if the mindistance previously calculated is
* greater, then set the new min distance
* and set the entity to the closest entity
*/
if (sobj->hits(temp, base, unitDir, &tempHit) == 1) {
if (hit->distance > tempHit.distance
|| hit->distance == 9999) {
hit->distance = tempHit.distance;
closest = temp;
}
}
temp = list_getnext(iter);
}
return closest;
}
void UnitCollection::cleanup()
{
//NOTE: advance() will be cleaning up the list by itself
un_iter ui = createIterator();
while ( !ui.isDone() )
ui.advance();
}
/**
* Renames all inserts with name 'oldName' to 'newName'. This is
* called after a block was rename to update the inserts.
*/
void RS_EntityContainer::renameInserts(const RS_String& oldName,
const RS_String& newName) {
RS_DEBUG->print("RS_EntityContainer::renameInserts()");
//for (RS_Entity* e=firstEntity(RS2::ResolveNone);
// e!=NULL;
// e=nextEntity(RS2::ResolveNone)) {
RS_PtrListIterator<RS_Entity> it = createIterator();
RS_Entity* e;
while ( (e = it.current()) != NULL ) {
++it;
if (e->rtti()==RS2::EntityInsert) {
RS_Insert* i = ((RS_Insert*)e);
if (i->getName()==oldName) {
i->setName(newName);
}
} else if (e->isContainer()) {
((RS_EntityContainer*)e)->renameInserts(oldName, newName);
}
}
RS_DEBUG->print("RS_EntityContainer::renameInserts() OK");
}
extern LSQ_IteratorT LSQ_GetPastRearElement(LSQ_HandleT handle)
{
ArrayIteratorPointerT iterator = createIterator(handle);
if(iterator == NULL) return NULL;
iterator->index = ((ArrayPointerT)handle)->count;
iterator->type = PASTREAR;
return iterator;
}
JSValue IntlCollator::compareStrings(ExecState& state, StringView x, StringView y)
{
// 10.3.4 CompareStrings abstract operation (ECMA-402 2.0)
if (!m_collator) {
createCollator(state);
if (!m_collator)
return state.vm().throwException(&state, createError(&state, ASCIILiteral("Failed to compare strings.")));
}
UErrorCode status = U_ZERO_ERROR;
UCharIterator iteratorX = createIterator(x);
UCharIterator iteratorY = createIterator(y);
auto result = ucol_strcollIter(m_collator, &iteratorX, &iteratorY, &status);
if (U_FAILURE(status))
return state.vm().throwException(&state, createError(&state, ASCIILiteral("Failed to compare strings.")));
return jsNumber(result);
}
virtual PlanIter_t codegen(
CompilerCB* cb,
static_context* sctx,
const QueryLoc& loc,
std::vector<PlanIter_t>& argv,
expr &ann) const
{
return createIterator(sctx, loc, argv);
}
TagElement::~TagElement()
{
TagElementIterator iter = createIterator();
while(iter.hasNext()) {
ISaveToXml *ele = iter.next();
delete ele;
}
m_childs.clear();
}
DocxParagraph::~DocxParagraph()
{
ParagraphTagIterator iter = createIterator();
while(iter.hasNext()) {
ISaveToXml *ele = iter.next();
delete ele;
}
m_childs.clear();
}
extern LSQ_IteratorT LSQ_GetElementByIndex(LSQ_HandleT handle, LSQ_IntegerIndexT index)
{
AVLTreeT * tree = (AVLTreeT *)handle;
TreeNodeT * node = tree->root;
if IS_HANDLE_INVALID(handle)
return LSQ_HandleInvalid;
while ((node != NULL) && (node->key != index))
node = (index > node->key) ? node->r_child : node->l_child;
return createIterator(handle, node);
}
void print() {
std::cout << "\n" << getName();
std::cout << ", " << getDescription() << std::endl;
std::cout << "---------------------" << std::endl;
Iterator* iterator = createIterator();
while (iterator->hasNext()) {
MenuComponent* menuComponent = iterator->next();
menuComponent->print();
}
delete iterator;
}
void List:: show()
{
Iterator iter = createIterator();
iter.goHead();
while(iter.hasNext())
{
cout<< iter.get() << " ->";
iter.next();
}
// delete &iter;
}
/**
* generic implementation of find().
*/
TyFS IndexABase::find(TyFS fs) const {
auto_ptr<IndexIterator> it(createIterator());
assert( EXISTS(it.get()) );
for (it->moveToFirst(); it->isValid(); it->moveToNext() ) {
TyFS nextFS = it->get();
if (nextFS == fs) {
return fs;
}
}
return uima::lowlevel::FSHeap::INVALID_FS;
}
List::~List() {
Iterator iter = createIterator();
iter.goHead();
while(!iter.isHead())
{
Node *tmp =iter.position;
iter = iter.next();
delete tmp;
}
}
/**
* Updates the sub entities of this container.
*/
void RS_EntityContainer::update() {
//for (RS_Entity* e=firstEntity(RS2::ResolveNone);
// e!=NULL;
// e=nextEntity(RS2::ResolveNone)) {
RS_PtrListIterator<RS_Entity> it = createIterator();
RS_Entity* e;
while ( (e = it.current()) != NULL ) {
++it;
e->update();
}
}
void customTestAssertValue(void *value, ListElement *actual, int lineNo){
Iterator *iter;
if (value==NULL || actual==NULL){
CUSTOM_TEST_FAIL("ERROR:The value or actual cannot be NULL.");
}
else{
OperatorToken *opTokActual=((OperatorToken *)(actual->value));
char *strValue=((StringToken *)(value))->name;
int intValue=((IntegerToken *)(value))->value;
double floatValue=((FloatToken *)(value))->value;
char *charRightToken=((StringToken *)(opTokActual->token[1]))->name;
int intRightToken=((IntegerToken *)(opTokActual->token[1]))->value;
double floatRightToken=((FloatToken *)(opTokActual->token[1]))->value;
iter=createIterator((LinkedList *)(opTokActual->token[1]));
UNITY_TEST_ASSERT_EQUAL_STRING(":", opTokActual->symbol, lineNo, NULL);
//test for VALUE token
if(opTokActual->token[1]->type==TOKEN_STRING_TYPE){
if(((Token *)(value))->type==TOKEN_STRING_TYPE){
UNITY_TEST_ASSERT_EQUAL_STRING(strValue,charRightToken,lineNo, NULL);
}
else{
CUSTOM_TEST_FAIL("ERROR:Actual value for VALUE was %s",charRightToken);
}
}
else if(opTokActual->token[1]->type==TOKEN_INTEGER_TYPE){
if(((Token *)(value))->type==TOKEN_INTEGER_TYPE){
UNITY_TEST_ASSERT_EQUAL_INT(intValue,intRightToken, lineNo, NULL);
}
else{
CUSTOM_TEST_FAIL("ERROR:Actual value for VALUE was %d",intRightToken);
}
}
else if(opTokActual->token[1]->type==TOKEN_FLOAT_TYPE){
if(((Token *)(value))->type==TOKEN_FLOAT_TYPE){
UNITY_TEST_ASSERT_EQUAL_FLOAT(floatValue,floatRightToken, lineNo, NULL);
}
else{
CUSTOM_TEST_FAIL("ERROR:Actual value for VALUE was %d",floatRightToken);
}
}
else{
CUSTOM_TEST_FAIL("ERROR:Unexpected VALUE Token type.Expected String,Integer or a Float Token.");
}
}
}
IntEnumeration *ihtab_getKeys(IntHashtable *p){
IntHashtableIterator *ihi;
IntEnumeration *e;
ihi = createIterator(p);
e = ienum_create(
(void *)ihi,
(int (*)(void *))next_key_fn,
(char(*)(void *))has_more_keys_fn
);
return e;
}
UnitCollection::UnitCollection( const UnitCollection &uc ) : u( NULL )
{
init();
un_iter ui = createIterator();
const UnitListNode *n = uc.u;
while (n) {
if (n->unit) {
ui.postinsert( n->unit );
++ui;
}
n = n->next;
}
}
Enumeration *ihtab_getValues(IntHashtable *p){
IntHashtableIterator *ihi;
Enumeration *e;
ihi = createIterator(p);
e = enum_create(
(void *)ihi,
(void *(*)(void *))next_value_fn,
(char(*)(void *))has_more_values_fn
);
return e;
}
Enumeration *hset_elements(HashSet *p){
HashSetIterator *hi;
Enumeration *e;
hi = createIterator(p);
e = enum_create(
(void *)hi,
(void *(*)(void *))next_hash_key_fn,
(char(*)(void *))has_more_hash_keys_fn
);
return e;
}
void iteration(size_t orderIndex, ScTemplateSearchResult & result)
{
size_t const constrIndex = mTemplate.mSearchCachedOrder[orderIndex];
check_expr(constrIndex < mTemplate.mConstructions.size());
size_t const finishIdx = mTemplate.mConstructions.size() - 1;
size_t resultIdx = constrIndex * 3;
/// TODO: prevent recursive search and make test for that case
ScTemplateConstr3 const & constr = mTemplate.mConstructions[constrIndex];
ScTemplateItemValue const * values = constr.getValues();
ScIterator3Ptr const it3 = createIterator(constr);
while (it3->next())
{
/// check if search in structure
if (mScStruct.isValid())
{
if (!checkInStruct(it3->value(0)) ||
!checkInStruct(it3->value(1)) ||
!checkInStruct(it3->value(2)))
{
continue;
}
}
// do not make cycle for optimization issues (remove comparsion expresion)
mResultAddrs[resultIdx] = it3->value(0);
mResultAddrs[resultIdx + 1] = it3->value(1);
mResultAddrs[resultIdx + 2] = it3->value(2);
refReplacement(values[0], it3->value(0));
refReplacement(values[1], it3->value(1));
refReplacement(values[2], it3->value(2));
if (orderIndex == finishIdx)
{
result.mResults.push_back(mResultAddrs);
}
else
{
iteration(orderIndex + 1, result);
}
unrefReplacement(values[0]);
unrefReplacement(values[1]);
unrefReplacement(values[2]);
}
}
void TagElement::saveToXmlElement(QXmlStreamWriter *writer) const
{
writer->writeStartElement(m_tagName);
if (m_properties.count() > 0)
for (pairValue att : m_properties) {
writer->writeAttribute(att.first, att.second);
}
TagElementIterator iter = createIterator();
while(iter.hasNext()) {
ISaveToXml *element = iter.next();
element->saveToXmlElement(writer);
}
if (!m_charaters.isEmpty())
writer->writeCharacters(QString::fromUtf8(m_charaters.toUtf8()));
writer->writeEndElement();
}
const UnitCollection& UnitCollection::operator=( const UnitCollection &uc )
{
#ifdef _DEBUG
printf( "warning could cause problems with concurrent lists. Make sure no one is traversing gotten list" );
#endif
destr();
init();
un_iter ui = createIterator();
const UnitListNode *n = uc.u;
while (n) {
if (n->unit) {
ui.postinsert( n->unit );
++ui;
}
n = n->next;
}
return uc;
}
bool List:: locate(Data key)
{
bool found;
Iterator iter = createIterator();
iter.goHead();
while(iter.hasNext())
{
if(key.get() == iter.get())
{ found = true;
cout<<"found key"<< iter.get() << " ->";
return true;
} else
iter.next();
}
if(found == false)
cout<< " cant locate key"<<key.get()<<endl;
return false;
}
