bool HistoryView::getLaneParentsChilds(SCRef sha, int x, SList p, SList c) {

	ListViewDelegate* lvd = static_cast<ListViewDelegate*>(itemDelegate());
	uint lane = x / lvd->laneWidth();
	int t = getLaneType(sha, lane);
	if (t == EMPTY || t == -1)
		return false;

	// first find the parents
	p.clear();
	QString root;
	if (!isFreeLane(t)) {
		p = git->revLookup(sha, fh)->parents(); // pointer cannot be NULL
		root = sha;
	} else {
		SCRef par(git->getLaneParent(sha, lane));
		if (par.isEmpty()) {
			dbs("ASSERT getLaneParentsChilds: parent not found");
			return false;
		}
		p.append(par);
		root = p.first();
	}
	// then find children
	c = git->getChilds(root);
	return true;
}

bool CheckIntersect( SList &slist1,  SList &slist2) {
   SLNode *p1 = slist1.head(), *p2 = slist2.head();
  if (!p1 || !p2) return false;
  SLNode* cross1 = CheckCircle(slist1);
  SLNode* cross2 = CheckCircle(slist2);
  // both has no circle
  if (!cross1 && !cross2) {
    // method1: check tails
    //while (p1->next) p1 = p1->next;
    //while (p2->next) p2 = p2->next;
    //return p1 == p2;
    
    //method2: connect list1 head and tail, check circle
    //         circle cross point is intersect point
    slist1.tail()->next = slist1.head();
    cross2 = CheckCircle(slist2);
    cout << "Intersect point " << cross2->val << endl;
    if (cross2) return true;
  } else if (cross1 && cross2){
    // both has circle 
    p1 = slist1.head();
    bool pass = false;
    while (p1) {
      p1 = p1->next;
      if (p1 == cross2) return true;
      if (p1 == cross1) {
        if (pass) break;
        pass = true;
      } 
    }
  }
  return false;
}

void UpwardPlanRep::initMe()
{
	m_Gamma.init(*this);
	isAugmented = false;

	FaceSinkGraph fsg(m_Gamma, s_hat);
	SList<face> extFaces;
	fsg.possibleExternalFaces(extFaces);

	OGDF_ASSERT(!extFaces.empty());

	face f_ext = nullptr;
	for(face f : extFaces) {
		if (f_ext == nullptr)
			f_ext = f;
		else {
			if (f_ext->size() < f->size())
				f_ext = f;
		}
	}
	m_Gamma.setExternalFace(f_ext);
	for(adjEntry adj : s_hat->adjEntries) {
		if (m_Gamma.rightFace(adj) == m_Gamma.externalFace()) {
			extFaceHandle = adj;
			break;
		}
	}

	computeSinkSwitches();
}

void test_pop_front(Test* test)
{
	std::string s("hello");
	SList* list =new SList("hello","world");
	std::string act = list->pop_front();	
	test->equals(act,s);
	delete list;
}

void Annotate::unify(SList dst, SCList src) {

	const QString m("Merge");
	for (int i = 0; i < dst.size(); ++i) {
		if (dst.at(i) == m)
			dst[i] = src.at(i);
	}
}

void test_push_front(Test* test)
{
	std::string s("hello");
	SList* list = new SList("hello","word");
	list->push_front(s);
	std::string act=list->get_first()->get_stringi();
	test->equals(act,s);
	delete list;
}

void test_pop_back(Test* test)
{
	std::string s("world");
	SList* list = new SList("hello","world");
	std::cout<<(*list)<<std::endl;
	std::string act = list->pop_back();
	test->equals(act,s);
	delete list;		
}

void test_iter(Test* test)
{
	SList* list = new SList("hello","wordl");
	list->push_back("hi");
	list->push_back("why");
	for(SList_iterator it = list->begin();it!=list->end();it++)
		std::cout<<(*it).get_stringi()<<endl;
	delete list;
}

void test_reverse(Test* test)
{
	SList* list = new SList("hello","wordl");
	list->push_back("hi");
	list->push_back("why");
	
	(*list).reverse();
	delete list;
}

 void SList::reverse() {
   SList tmp;
   Elem *tmp_elem = front;
   while(tmp_elem) {
     tmp.push_front(tmp_elem->get_contents());
     tmp_elem = tmp_elem->next;
   }
   tmp.swap(*this);
 }

int main() {
  SList ls;
  ls.Insert(8);
  ls.Insert(5);
  ls.Insert(4);
  ls.Insert(1);

  ls.Traversal();
  ls.ReverseTraversal();
}

void FrontIsEmpty::run()
{
    SList newList;
    try {
        string str = newList.front();
        fail();
    } catch (logic_error&) {
        pass();
    }
}

std::size_t Processer::StealHalf(Processer & other)
{
    std::size_t runnable_task_count = runnable_list_.size();
    SList<Task> tasks = runnable_list_.pop_back((runnable_task_count + 1) / 2);
    std::size_t c = tasks.size();
    DebugPrint(dbg_scheduler, "proc[%u] steal proc[%u] work returns %d.",
            other.id_, id_, (int)c);
    if (!c) return 0;
    other.runnable_list_.push(std::move(tasks));
    return c;
}

void test_swap(Test* test)
{
	SList *list = new SList("hello","world");
	SList *list_ = new SList("hei","maailma");
	
	list->swap((*list_));
	std::cout<<(*list)<<std::endl;
	std::cout<<(*list_)<<std::endl;
	delete list;
	delete list_;
}

int main(void){
	SList<int> mylist;
	mylist.pushFront(10);
	mylist.pushFront(20);
	mylist.pushBack(30);

	for(auto it=mylist.begin();it!=mylist.end();++it){
		cout << *it << endl;
	}
	return 0;

}

SList *PCCTS_AST::
to_slist()
{
	SList *list = new SList;
	PCCTS_AST *p;

	for (p=this; p!=NULL; p=p->right())
	{
		list->add(p);
	}
	return list;
}

void SwndContainerImpl::OnNextFrame()
{
    if(!IsVisible(TRUE)) return;
    
    SList<ITimelineHandler*> lstCopy;
    CopyList(m_lstTimelineHandler,lstCopy);
    SPOSITION pos=lstCopy.GetHeadPosition();
    while(pos)
    {
        ITimelineHandler * pHandler=lstCopy.GetNext(pos);
        pHandler->OnNextFrame();
    }
}

bool CommitImpl::getFiles(SList selFiles) {

	// check for files to commit
	selFiles.clear();
	QTreeWidgetItemIterator it(treeWidgetFiles);
	while (*it) {
		if ((*it)->checkState(0) == Qt::Checked)
			selFiles.append((*it)->text(0));
		++it;
	}

	return !selFiles.isEmpty();
}

void test7()
{
	SList list;
	list.PushBack(1);
	list.PushBack(2);
	list.PushBack(3);
	list.PushBack(4);
	list.PushBack(5);
	list.PushBack(6);
	list.Circle();
	cout << (list.CheckCycle())->_data << endl;
	cout << (list.GetCycleEntryNode(list.CheckCycle()))->_data << endl;
	cout << (list.GetCircleLength(list.CheckCycle())) << endl;
}

int main()
{
	SList sList;

	sList.PrintList();

	int count = 10;
	while(count--)
	{
		AddElement(sList);
	}

	std::cout << "insert a elelment at pos 8" << std::endl;
	Node pos(8);
	Node node(101);

	sList.InsertElement(&node, &pos);
	sList.PrintList();
	std::cout << std::endl << "The Size : " << sList.GetListSize() << std::endl;

	std::cout << std::endl;
	std::cout << "delete a element node 8" << std::endl;
	Node del(8);
	sList.DeleteElement(&node);

	sList.PrintList();
	std::cout << std::endl << "The Size : " << sList.GetListSize() << std::endl;
	return 0;
}