Fix other modern compiler warnings for fdb.
[fstitch] / fscore / patchgroup.h
1 /* This file is part of Featherstitch. Featherstitch is copyright 2005-2008 The
2  * Regents of the University of California. It is distributed under the terms of
3  * version 2 of the GNU GPL. See the file LICENSE for details. */
4
5 #ifndef __FSTITCH_FSCORE_PATCHGROUP_H
6 #define __FSTITCH_FSCORE_PATCHGROUP_H
7
8 #ifdef FSTITCHD
9 #include <fscore/patch.h>
10 #endif
11
12 /* The following operations change the state of patchgroups:
13  * A) Add afters    W) Write data (i.e. engage)
14  * R) Release       B) Add befores
15  * 
16  * The following table shows the possible states and what operations are valid.
17  * Notice that each of A, R, W, and B above sets a bit in the state of a
18  * patchgroup. Adding a before means that the patchgroup now has before,
19  * releasing a patchgroup means it is now released, etc.
20  * 
21  * A R W B  Can do: [ (W) means we do not allow this now, but plan to when we
22  * -------            work out how to hide changes from other clients. ]
23  * 0 0 0 0   A   R  (W)  B
24  * 0 0 0 1   A   R  (W)  B
25  * 0 0 1 0   A   R   W   B  <--- initially, these states cannot exist due to (W)
26  * 0 0 1 1   A   R   W   B  <-/
27  * 0 1 0 0   A   R   W
28  * 0 1 0 1   A   R   W
29  * 0 1 1 0   A   R   W
30  * 0 1 1 1   A   R   W
31  * 1 0 0 0   A   R          <--- these are "empty" patchgroups. B is disallowed to easily prevent cycles.
32  * 1 0 0 1   A   R          <-/
33  * 1 0 1 0   A   R       B  <--- initially, these states cannot exist due to (W)
34  * 1 0 1 1   A   R       B  <-/
35  * 1 1 0 0   A   R          <--- these are "empty" patchgroups (the first is "dead")
36  * 1 1 0 1   A   R          <-/
37  * 1 1 1 0   A   R
38  * 1 1 1 1   A   R
39  *
40  *
41  * Valid operations for atomic patchgroups:
42  * - Add after always
43  * - Add before iff !released
44  * - Engage iff !released
45  * - Release iff !engaged
46  * - Abandon iff released (abandon without release requires a hidden patchgroup)
47  * */
48
49 typedef int patchgroup_id_t;
50
51 #define PATCHGROUP_FLAG_HIDDEN 0x2
52 #define PATCHGROUP_FLAG_ATOMIC 0x6
53
54 #ifdef FSTITCHD
55
56 struct patchgroup;
57 typedef struct patchgroup patchgroup_t;
58
59 struct patchgroup_scope;
60 typedef struct patchgroup_scope patchgroup_scope_t;
61
62 patchgroup_scope_t * patchgroup_scope_create(void);
63 patchgroup_scope_t * patchgroup_scope_copy(patchgroup_scope_t * scope);
64 size_t patchgroup_scope_size(patchgroup_scope_t * scope);
65 void patchgroup_scope_destroy(patchgroup_scope_t * scope);
66
67 void patchgroup_scope_set_current(patchgroup_scope_t * scope);
68
69 /* normal patchgroup operations are relative to the current scope */
70
71 patchgroup_t * patchgroup_create(int flags);
72 int patchgroup_sync(patchgroup_t * patchgroup);
73 int patchgroup_add_depend(patchgroup_t * after, patchgroup_t * before);
74
75 int patchgroup_engage(patchgroup_t * patchgroup);
76 int patchgroup_disengage(patchgroup_t * patchgroup);
77
78 int patchgroup_release(patchgroup_t * patchgroup);
79 int patchgroup_abandon(patchgroup_t ** patchgroup);
80
81 patchgroup_t * patchgroup_lookup(patchgroup_id_t id);
82 patchgroup_id_t patchgroup_id(const patchgroup_t * patchgroup);
83
84 int patchgroup_engaged(void);
85 void patchgroup_masquerade(void);
86 void patchgroup_demasquerade(void);
87
88 /* add patches to the engaged patchgroups in the current scope */
89 int patchgroup_prepare_head(patch_t ** head);
90 int patchgroup_finish_head(patch_t * head);
91
92 int patchgroup_label(patchgroup_t * patchgroup, const char * label);
93
94 #else /* FSTITCHD */
95
96 patchgroup_id_t patchgroup_create(int flags);
97 int patchgroup_sync(patchgroup_id_t patchgroup);
98 int patchgroup_add_depend(patchgroup_id_t after, patchgroup_id_t before);
99
100 int patchgroup_engage(patchgroup_id_t patchgroup);
101 int patchgroup_disengage(patchgroup_id_t patchgroup);
102
103 int patchgroup_release(patchgroup_id_t patchgroup);
104 int patchgroup_abandon(patchgroup_id_t patchgroup);
105
106 int patchgroup_label(patchgroup_id_t patchgroup, const char * label);
107
108
109 /* Create, release, and engage a new patchgroup.
110  * Make the new patchgroup depend on previous... until <0.
111  * Each previous must be disengaged. Does not abandon previous. */
112 patchgroup_id_t patchgroup_create_engage(patchgroup_id_t previous, ...);
113
114 /* Create a linear dependency chain:
115  * Create, release, and engage a new patchgroup.
116  * If 'previous >= 0' then the new patchgroup will depend on previous
117  * and previous will be disengaged and abandoned. */
118 patchgroup_id_t patchgroup_linear(patchgroup_id_t previous);
119
120 #endif /* FSTITCHD */
121
122 #endif /* __FSTITCH_FSCORE_PATCHGROUP_H */