/*
* Append datum to list, but only if it isn't already in the list.
*
* Whether an element is already a member of the list is determined
* via equal().
*/
List *
list_append_unique(List *list, void *datum)
{
if (list_member(list, datum))
return list;
else
return lappend(list, datum);
}
/*
* Append to list1 each member of list2 that isn't already in list1.
*
* Whether an element is already a member of the list is determined
* via equal().
*
* This is almost the same functionality as list_union(), but list1 is
* modified in-place rather than being copied. Note also that list2's cells
* are not inserted in list1, so the analogy to list_concat() isn't perfect.
*/
List *
list_concat_unique(List *list1, List *list2)
{
ListCell *cell;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
foreach(cell, list2)
{
if (!list_member(list1, lfirst(cell)))
list1 = lappend(list1, lfirst(cell));
}
check_list_invariants(list1);
return list1;
}
int main(int argc, char* argv[])
{
int ret = 0, val = -1;
// On déclare la tête de liste
struct Tlist* head = (struct Tlist*)malloc(sizeof(struct Tlist));
// Le dernier element en traitement
struct Tlist* last = head;
head->nb = 0;
head->next = 0;
// Tant qu'on entre pas 0
while (val != 0)
{
// On lit une valeur
ret = 0;
while (ret != 1)
{
printf("Entrez des nombres (0 = stop): ");
ret = scanf("%d", &val);
CLRBUF;
}
// On ajoute la valeur à la liste
last = last->next = (struct Tlist*)malloc(sizeof(struct Tlist));
last->nb = val;
last->next = 0;
}
// On recherche une valeur
ret = 0;
while (ret != 1)
{
printf("Entrez la valeur a chercher: ");
ret = scanf("%d", &val);
CLRBUF;
}
// On affiche la liste
printf("%d %s dans la liste\n", val, (list_member(head, val) ? "est" : "n'est pas"));
return 0;
}
/*
* Generate the union of two lists. This is calculated by copying
* list1 via list_copy(), then adding to it all the members of list2
* that aren't already in list1.
*
* Whether an element is already a member of the list is determined
* via equal().
*
* The returned list is newly-allocated, although the content of the
* cells is the same (i.e. any pointed-to objects are not copied).
*
* NB: this function will NOT remove any duplicates that are present
* in list1 (so it only performs a "union" if list1 is known unique to
* start with). Also, if you are about to write "x = list_union(x, y)"
* you probably want to use list_concat_unique() instead to avoid wasting
* the list cells of the old x list.
*
* This function could probably be implemented a lot faster if it is a
* performance bottleneck.
*/
List *
list_union(const List *list1, const List *list2)
{
List *result;
const ListCell *cell;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
result = list_copy(list1);
foreach(cell, list2)
{
if (!list_member(result, lfirst(cell)))
result = lappend(result, lfirst(cell));
}
check_list_invariants(result);
return result;
}
/*
* Return a list that contains all the cells in list1 that are not in
* list2. The returned list is freshly allocated via palloc(), but the
* cells themselves point to the same objects as the cells of the
* input lists.
*
* This variant works on lists of pointers, and determines list
* membership via equal()
*/
List *
list_difference(const List *list1, const List *list2)
{
const ListCell *cell;
List *result = NIL;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
if (list2 == NIL)
return list_copy(list1);
foreach(cell, list1)
{
if (!list_member(list2, lfirst(cell)))
result = lappend(result, lfirst(cell));
}
check_list_invariants(result);
return result;
}
/*
* Return a list that contains all the cells that are in both list1 and
* list2. The returned list is freshly allocated via palloc(), but the
* cells themselves point to the same objects as the cells of the
* input lists.
*
* Duplicate entries in list1 will not be suppressed, so it's only a true
* "intersection" if list1 is known unique beforehand.
*
* This variant works on lists of pointers, and determines list
* membership via equal(). Note that the list1 member will be pointed
* to in the result.
*/
List *
list_intersection(const List *list1, const List *list2)
{
List *result;
const ListCell *cell;
if (list1 == NIL || list2 == NIL)
return NIL;
Assert(IsPointerList(list1));
Assert(IsPointerList(list2));
result = NIL;
foreach(cell, list1)
{
if (list_member(list2, lfirst(cell)))
result = lappend(result, lfirst(cell));
}
check_list_invariants(result);
return result;
}
void partition(list_t numlist)
{
int i, j;
int nleft = INT_MIN;
int nright = INT_MIN;
/*检查递归终止点*/
if (!list_member(resultList, numlist, (int(*)(const void*, const void*))list_compare))
{ /*不存在于输出数组，添加进，继续递归（有一个复杂类型的强制转换）*/
list_push(resultList, numlist);
}
else
{ /*列表为降序，又已在输出数组中存在，则没有继续递归的必要，释放分配的内存，停止*/
free(numlist->elem[0]);
list_free(&numlist);
return;
}
/*循环递归部分*/
for (i = 0; i < numlist->head; ++i)
{
if (VAL(numlist, i, int*) == 1)
{ /*降序列表，如果遇到1，那么后面的也一定都是1，所以break*/
break;
}
else
{
int k = 0;
list_t newList;
int* newNumList;
if (i != 0)
{
nleft = VAL(numlist, i - 1, int*);
}
if (i + 1 != numlist->head)
{
nright = VAL(numlist, i + 1, int*);
}
/* MPP-6923: */
static
List *
AlterResqueueCapabilityEntry(
List *stmtOptIdList,
Oid queueid,
ListCell *initcell,
bool bCreate)
{
ListCell *lc;
List *elems = NIL;
List *dropelems = NIL;
List *dupcheck = NIL;
HeapTuple tuple;
cqContext *pcqCtx;
cqContext cqc;
Relation rel = NULL;
bool bWithout = false;
TupleDesc tupdesc = NULL;
#ifdef USE_ASSERT_CHECKING
{
DefElem *defel = (DefElem *) lfirst(initcell);
Assert(0 == strcmp(defel->defname, "withliststart"));
}
#endif
initcell = lnext(initcell);
/* walk the original list and build a list of valid entries */
for_each_cell(lc, initcell)
{
DefElem *defel = (DefElem *) lfirst(lc);
Oid resTypeOid = InvalidOid;
int resTypeInt = 0;
List *pentry = NIL;
Value *pKeyVal = NULL;
Value *pStrVal = NULL;
if (!bWithout && (strcmp(defel->defname, "withoutliststart") == 0))
{
bWithout = true;
rel = heap_open(ResourceTypeRelationId, RowExclusiveLock);
tupdesc = RelationGetDescr(rel);
goto L_loop_cont;
}
/* ignore the basic threshold entries -- should already be processed */
if (strcmp(defel->defname, "active_statements") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "max_cost") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "cost_overcommit") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "min_cost") == 0)
goto L_loop_cont;
if (!GetResourceTypeByName(defel->defname, &resTypeInt, &resTypeOid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("option \"%s\" is not a valid resource type",
defel->defname)));
pKeyVal = makeString(defel->defname);
/* WITHOUT clause value determined in pg_resourcetype */
if (!bWithout)
pStrVal = makeString(defGetString(defel));
else
{
pStrVal = NULL; /* if NULL, delete entry from
* pg_resqueuecapability
*/
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), rel),
cql("SELECT * FROM pg_resourcetype"
" WHERE restypid = :1 FOR UPDATE",
Int16GetDatum(resTypeInt)));
while (HeapTupleIsValid(tuple = caql_getnext(pcqCtx)))
{
text *shutoff_text = NULL;
char *shutoff_str = NULL;
Datum shutoff_datum;
bool isnull = false;
Form_pg_resourcetype rtyp =
(Form_pg_resourcetype)GETSTRUCT(tuple);
if (!rtyp->reshasdisable)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("option \"%s\" cannot be disabled",
defel->defname)));
}
/* required type must have a default value if it can
* be disabled
*/
if (!rtyp->reshasdefault)
{
if (!rtyp->resrequired)
/* optional resource without a default is
* turned off by removing entry from
* pg_resqueuecapability
*/
break;
else
{
/* XXX XXX */
Assert(0);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("required option \"%s\" cannot be disabled",
defel->defname)));
}
}
/* get the shutoff string */
shutoff_datum =
heap_getattr(tuple,
Anum_pg_resourcetype_resdisabledsetting,
tupdesc,
&isnull);
Assert(!isnull);
shutoff_text = DatumGetTextP(shutoff_datum);
shutoff_str =
DatumGetCString(
DirectFunctionCall1(
textout,
PointerGetDatum(shutoff_text)));
pStrVal = makeString(shutoff_str);
break;
} /* end while heaptuple is valid */
caql_endscan(pcqCtx);
}
/* check for duplicate key specifications */
if (list_member(dupcheck, pKeyVal))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("conflicting or redundant option for \"%s\"",
defel->defname)));
dupcheck = lappend(dupcheck, pKeyVal);
pentry = list_make2(
makeInteger(resTypeInt),
pStrVal);
/* list of lists - (resource type, resource setting) */
if (bWithout)
{
/* if the "without" entry has an "off" value, then treat
* it as a regular "with" item and update it in
* pg_resqueuecapability, else remove its entry
*/
if (!pStrVal)
dropelems = lappend(dropelems, pentry);
else
elems = lappend(elems, pentry);
}
else
elems = lappend(elems, pentry);
L_loop_cont:
resTypeInt = 0; /* make compiler happy */
}
kernel_list& erase(Type& n)
{
remove_node(list_member(&n));
return *this;
}
kernel_list& insert(Type& pos, Type& new_node)
{
auto node_member = list_member(&pos);
add_node(list_member(&new_node), node_member->prev(), node_member);
return *this;
}
kernel_list& insert(const iterator& pos, Type& new_node)
{
add_node(list_member(&new_node), pos.node()->prev(), pos.node());
return *this;
}
kernel_list& push_front(Type& new_node)
{
add_node(list_member(&new_node), &head_, head_.next());
return *this;
}
kernel_list& push_back(Type& new_node)
{
add_node(list_member(&new_node), head_.prev(), &head_);
return *this;
}
