string View::formatList(list_t &list, const string d1, const string sep, const string d2) {
  string output = "";
  if(list.empty()) return output;
  FOR_l(i,list)
    output = output + (i==0 || is_dir(list[i-1]) || is_opt(list[i-1]) ? "" : sep) + list.at(i);
  return d1 + output + d2;
}

relation_data_t Query::getRelationModel(list_t values, Model * & model)
{
    relation_data_t rData;
    QList <Model *> list;
    if(!values.empty())
    {
        QStringList fields = model->getSchema()->getFields();
        int i = 0;
        while(i < values.size())
        {
            int j = i;
            Model * temp = new Model();
            temp->setSchema(model->getSchema());
            temp->setIsNew(false);
            while(values[j] != QPair <QString, QVariant> ("", ""))
            {
                if((fields.contains(values[j].first)) && (values[j].second != ""))
                {
                    temp->setField(values[j].first, values[j].second);
                }                
                j++;
            }
            list.append(temp);
            i = j + 1;
        }
    }
    rData.insert(rName, list);
    return rData;
}

handle_t *MEM_CacheLimiterCClass::insert(void *data)
{
	cclass_list.push_back(new MEM_CacheLimiterHandleCClass(data, this));
	list_t::iterator it = cclass_list.end();
	--it;
	cclass_list.back()->set_iter(it);

	return cache.insert(cclass_list.back());
}

list_t View::chopList(list_t list, const string prefix) {
  if(list.empty()) return list;
  FOR_l(i,list) {
    string item = list[i];
    // normal chop
    if(!item.compare(0,prefix.length(),prefix))
      list.at(i) = item.substr(prefix.length());
    else
      list.at(i) = "["+item+"]";
  }

static void remove_even(list_t &l) {
    bool even = false;
    for (auto it = l.begin(); it != l.end();) {
        if (even)
            it = l.erase(it);
        else
            ++it;

        even = !even;
    }
}

/*@[email protected]*/ static node_t list_get_node_by_value(list_t inst, void* val) {
	node_t n = inst->head;
	int ctr = 0;
	while ((n != NULL) && (inst->cmp(node_get_value(n), val))) {
		ctr++;
		n = n->next;
	}
	return n;
}

int list_find(list_t list, void *data){
    struct list_node *p = list->head;
    int i = 0;
    while (p != NULL) {
        if (list->eq(p->data, data))
            return i;
        i++;
        p = p->next;
    }
    return -1;
}

int list_index_of(list_t inst, void* val) {
	node_t n = inst->head;
	int rval = 0;
	while ((n != NULL) && (inst->cmp(node_get_value(n), val))) {
		rval++;
		n = n->next;
	}
	if (n == NULL) {
		rval = -1;
	}
	return rval;
}

string_t
generate(const string_t& method, const list_t& arguments)
{
	std::string call("H\x02\x00""C"s);

	generator::value_visitor visitor(call);
	visitor(method);
	visitor(static_cast<int_t>(arguments.size()));
	for (const auto& argument : arguments)
		boost::apply_visitor(visitor, argument);

	return std::move(call);
}

int walk2(list_t::iterator it, int s, int t)
{
    if(s==t) return 0;
    for(int i=0;i<30;i++)
    {
        if(links[s][i].size())
        {
            output.insert(it, mp(links[s][i].back(),s));
            links[s][i].pop_back();
            return walk2(it, i,t);
        }
    }
    return -1;
}

int pump(list_t::iterator it)
{
    int pos = it->second;
redo:
    for(int i=0;i<30;i++)
    {
        if(links[pos][i].size())
        {
            output.insert(it, mp(links[pos][i].back(), pos));
            links[pos][i].pop_back();
            if(walk2(it, i, pos) == -1) return -1;
            goto redo;
        }
    }
    return 0;
}

void list_clear(list_t inst) {
	void* val;
	node_t n = inst->head;
	node_t m;
	while (n != NULL) {
		m = n->next;
		val = node_exit(n);
		//printf("exit [email protected]%p\n", inst->val);
if (inst->lfree != NULL) {
		inst->lfree(val);
}
		n = m;
	}
	inst->head = NULL;
	inst->tail = NULL;
}

void solve(int dataId)
{
    int s = -1, t= -1, use = -1;
    for(int i=0;i<26;i++)
    {
        int outd = 0, ind=0;
        for(int j=0;j<26;j++)
        {
            outd += links[i][j].size();
            ind += links[j][i].size();
        }
        if(outd || ind) use = i;
        if(outd > ind+1 || ind > outd+1)
        {
            cout << "IMPOSSIBLE" << endl;
            return;
        }
        if(outd > ind)
        {
            if(s != -1)
            {
                cout << "IMPOSSIBLE" << endl;
                return;
            }
            s = i;
        }
        if(ind > outd)
        {
            if(t != -1)
            {
                cout << "IMPOSSIBLE" << endl;
                return;
            }
            t = i;
        }
    }
    if(s == -1) s = t = use;

    if(walk2(output.end(), s, t) == -1)
    {
        cout << "IMPOSSIBLE" << endl;
        return;
    }
    output.pb(mp("", t));
    foreach(it, output)
    {
        if(pump(it) == -1)
        {
            cout << "IMPOSSIBLE" << endl;
            return;
        }
    }

    for(int i=0;i<30;i++) for(int j=0;j<30;j++) if(links[i][j].size())
    {
        cout << "IMPOSSIBLE" << endl;
        return;
    }

    output.pop_back();
    list_t::iterator it = output.begin();
    do
    {
        cout << it->first;
        ++it;
        if(it == output.end()) break;
        cout << " ";
    } while(true);
    cout << endl;
}

void MEM_CacheLimiterCClass::destruct(void *data, list_t::iterator it)
{
	data_destructor(data);
	cclass_list.erase(it);
}

gboolean
post_parse()
{
    if (file_ != 0)
    {
    	if (tofile_ == 0 && todir_ == 0)
	{
	    log::errorf("One of \"tofile\" or \"todir\" must be specified with \"file\"\n");
	    return FALSE;
	}
    }
    else if (filesets_.first() != 0)
    {
    	if (tofile_ != 0)
	{
	    log::errorf("Only \"todir\" is allowed with \"filesets\"\n");
	    return FALSE;
	}
    	if (todir_ == 0)
	{
	    log::errorf("Must use \"todir\" is \"filesets\"\n");
	    return FALSE;
	}
    }
    else if (file_ == 0 && filesets_.first() == 0)
    {
    	log::errorf("At least one of \"file\" or \"<fileset>\" must be present\n");
	return FALSE;
    }

    if (mapper_ == 0)
    	mapper_ = mapper_t::create("identity", 0, 0);

    return TRUE;
}

 /** Mark an element as recently used. */
 void touch (const key_type& k)
 {
     auto found (map_.find(k));
     assert(found != map_.end());
     if (found != map_.end())
         list_.splice(list_.begin(), list_, found->second);
 }

    boost::optional<mapped_type&> try_get (const key_type& k)
    {
        auto found (map_.find(k));
        if (found == map_.end())
            return boost::optional<mapped_type&>();

        list_.splice(list_.begin(), list_, found->second);
        return found->second->second;
    }

 /** Prune the cache back to a given size.
  *  If the cache is larger than the maximum, the oldest entries
  *  will be deleted.
  * @post size() <= max_size
  * @param max_size  The maximum cache size */
 void prune (size_t max_size)
 {
     while (size_ > max_size)
     {
         map_.erase(list_.back().first);
         list_.pop_back();
         --size_;
     }
 }

gboolean
exec()
{
    list_iterator_t<fileset_t> iter;
    
    result_ = TRUE;
    ncopied_ = 0;
    
    exp_todir_ = expand(todir_);

    if (file_ != 0)
    {
    	string_var expfile = expand(file_);
    	copy_one(expfile, this);
    }

    /* execute for <fileset> children */
    
    for (iter = filesets_.first() ; iter != 0 ; ++iter)
	(*iter)->apply(project_->properties(), copy_one, this);
    
    exp_todir_ = (char*)0;

    return result_;
}

~copy_task_t()
{
    if (mapper_ != 0)
	delete mapper_;
    
    /* delete filesets */
    // TODO: void unref(refcounted_t*)
    filesets_.apply_remove(unref);
}