Aegis: /home/archives/aegis/branch.4/branch.24/delta12472.002/libaegis/cstate.h Source File

00001 //
00002 // This file is generated by fmtgen from "libaegis/cstate.def".
00003 // If you want to change the contents of this file
00004 // you need to edit libaegis/cstate.def
00005 // or you need to enhance fmtgen.
00006 //
00007 
00008 #ifndef LIBAEGIS_CSTATE_H
00009 #define LIBAEGIS_CSTATE_H
00010 
00011 #include <common/ac/time.h>
00012 
00013 #include <common/str.h>
00014 #include <libaegis/output.h>
00015 #include <libaegis/meta_lex.h>
00016 #include <libaegis/meta_parse.h>
00017 #include <libaegis/meta_type.h>
00018 
00019 class nstring; // forward
00020 
00021 #ifndef change_cause_DEF
00022 #define change_cause_DEF
00023 enum change_cause_ty
00024 {
00025     change_cause_external_bug,
00026     change_cause_external_enhancement,
00027     change_cause_external_improvement,
00028     change_cause_internal_bug,
00029     change_cause_internal_enhancement,
00030     change_cause_internal_improvement,
00031     change_cause_chain
00032 };
00033 #define change_cause_max 7
00034 #endif // change_cause_DEF
00035 
00036 extern meta_type change_cause_type;
00037 
00038 void change_cause_write(const output::pointer &fp, const char *name, change_cause_ty value, bool show);
00039 void change_cause_write_xml(const output::pointer &fp, const char *name, change_cause_ty value, bool show);
00040 const char *change_cause_ename(change_cause_ty);
00041 
00042 #ifndef file_action_DEF
00043 #define file_action_DEF
00044 enum file_action_ty
00045 {
00046     file_action_create,
00047     file_action_modify,
00048     file_action_remove,
00049     file_action_insulate,
00050     file_action_transparent
00051 };
00052 #define file_action_max 5
00053 #endif // file_action_DEF
00054 
00055 extern meta_type file_action_type;
00056 
00057 void file_action_write(const output::pointer &fp, const char *name, file_action_ty value, bool show);
00058 void file_action_write_xml(const output::pointer &fp, const char *name, file_action_ty value, bool show);
00059 const char *file_action_ename(file_action_ty);
00060 
00061 #ifndef file_usage_DEF
00062 #define file_usage_DEF
00063 enum file_usage_ty
00064 {
00065     file_usage_source,
00066     file_usage_config,
00067     file_usage_build,
00068     file_usage_test,
00069     file_usage_manual_test
00070 };
00071 #define file_usage_max 5
00072 #endif // file_usage_DEF
00073 
00074 extern meta_type file_usage_type;
00075 
00076 void file_usage_write(const output::pointer &fp, const char *name, file_usage_ty value, bool show);
00077 void file_usage_write_xml(const output::pointer &fp, const char *name, file_usage_ty value, bool show);
00078 const char *file_usage_ename(file_usage_ty);
00079 
00080 #ifndef metric_DEF
00081 #define metric_DEF
00082 
00083 #define metric_name_mask    ((unsigned long)0)
00084 #define metric_value_mask   ((unsigned long)1 << 0)
00085 
00086 struct metric_ty
00087 {
00088     long            reference_count;
00089     unsigned long   mask;
00090     string_ty       *errpos;
00091     string_ty       *name;
00092     double          value;
00093 };
00094 #endif // metric_DEF
00095 
00096 extern meta_type metric_type;
00097 
00098 void metric_write(const output::pointer &fp, const char *name, metric_ty *value);
00099 void metric_write_xml(const output::pointer &fp, const char *name, metric_ty *value);
00100 metric_ty *metric_copy(metric_ty *);
00101 metric_ty *metric_clone(metric_ty *);
00102 #ifdef DEBUG
00103 void metric_trace_real(const char *name, const metric_ty *value);
00104 #define metric_trace(x) ((void)(trace_pretest_ && (trace_where_, metric_trace_real(trace_stringize(x), x), 0)))
00105 #else
00106 #define metric_trace(x)
00107 #endif
00108 
00109 #ifndef metric_list_DEF
00110 #define metric_list_DEF
00111 struct metric_list_ty
00112 {
00113     size_t length;
00114     size_t maximum;
00115     metric_ty       **list;
00116 };
00117 #endif // metric_list_DEF
00118 
00119 extern meta_type metric_list_type;
00120 
00121 metric_list_ty *metric_list_copy(metric_list_ty *);
00122 metric_list_ty *metric_list_clone(metric_list_ty *);
00123 void metric_list_write(const output::pointer &fp, const char *name, metric_list_ty *value);
00124 void metric_list_write_xml(const output::pointer &fp, const char *name, metric_list_ty *value);
00125 #ifdef DEBUG
00126 void metric_list_trace_real(const char *name, const metric_list_ty *value);
00127 #define metric_list_trace(x) ((void)(trace_pretest_ && (trace_where_, metric_list_trace_real(trace_stringize(x), x), 0)))
00128 #else
00129 #define metric_list_trace(x)
00130 #endif
00131 
00132 #ifndef history_version_encoding_DEF
00133 #define history_version_encoding_DEF
00134 enum history_version_encoding_ty
00135 {
00136     history_version_encoding_none,
00137     history_version_encoding_quoted_printable,
00138     history_version_encoding_base64
00139 };
00140 #define history_version_encoding_max 3
00141 #endif // history_version_encoding_DEF
00142 
00143 extern meta_type history_version_encoding_type;
00144 
00145 void history_version_encoding_write(const output::pointer &fp, const char *name, history_version_encoding_ty value, bool show);
00146 void history_version_encoding_write_xml(const output::pointer &fp, const char *name, history_version_encoding_ty value, bool show);
00147 const char *history_version_encoding_ename(history_version_encoding_ty);
00148 
00149 #ifndef history_version_DEF
00150 #define history_version_DEF
00151 
00152 #define history_version_revision_mask   ((unsigned long)0)
00153 #define history_version_encoding_mask   ((unsigned long)1 << 0)
00154 
00155 struct history_version_ty
00156 {
00157     long            reference_count;
00158     unsigned long   mask;
00159     string_ty       *errpos;
00160     string_ty       *revision;
00161     history_version_encoding_ty encoding;
00162 };
00163 #endif // history_version_DEF
00164 
00165 extern meta_type history_version_type;
00166 
00167 void history_version_write(const output::pointer &fp, const char *name, history_version_ty *value);
00168 void history_version_write_xml(const output::pointer &fp, const char *name, history_version_ty *value);
00169 history_version_ty *history_version_copy(history_version_ty *);
00170 history_version_ty *history_version_clone(history_version_ty *);
00171 #ifdef DEBUG
00172 void history_version_trace_real(const char *name, const history_version_ty *value);
00173 #define history_version_trace(x) ((void)(trace_pretest_ && (trace_where_, history_version_trace_real(trace_stringize(x), x), 0)))
00174 #else
00175 #define history_version_trace(x)
00176 #endif
00177 
00178 #ifndef attributes_DEF
00179 #define attributes_DEF
00180 
00181 #define attributes_name_mask    ((unsigned long)0)
00182 #define attributes_value_mask   ((unsigned long)0)
00183 
00184 struct attributes_ty
00185 {
00186     long            reference_count;
00187     unsigned long   mask;
00188     string_ty       *errpos;
00189     string_ty       *name;
00190     string_ty       *value;
00191 };
00192 #endif // attributes_DEF
00193 
00194 extern meta_type attributes_type;
00195 
00196 void attributes_write(const output::pointer &fp, const char *name, attributes_ty *value);
00197 void attributes_write_xml(const output::pointer &fp, const char *name, attributes_ty *value);
00198 attributes_ty *attributes_copy(attributes_ty *);
00199 attributes_ty *attributes_clone(attributes_ty *);
00200 #ifdef DEBUG
00201 void attributes_trace_real(const char *name, const attributes_ty *value);
00202 #define attributes_trace(x) ((void)(trace_pretest_ && (trace_where_, attributes_trace_real(trace_stringize(x), x), 0)))
00203 #else
00204 #define attributes_trace(x)
00205 #endif
00206 
00207 #ifndef attributes_list_DEF
00208 #define attributes_list_DEF
00209 struct attributes_list_ty
00210 {
00211     size_t length;
00212     size_t maximum;
00213     attributes_ty   **list;
00214 };
00215 #endif // attributes_list_DEF
00216 
00217 extern meta_type attributes_list_type;
00218 
00219 attributes_list_ty *attributes_list_copy(attributes_list_ty *);
00220 attributes_list_ty *attributes_list_clone(attributes_list_ty *);
00221 void attributes_list_write(const output::pointer &fp, const char *name, attributes_list_ty *value);
00222 void attributes_list_write_xml(const output::pointer &fp, const char *name, attributes_list_ty *value);
00223 #ifdef DEBUG
00224 void attributes_list_trace_real(const char *name, const attributes_list_ty *value);
00225 #define attributes_list_trace(x) ((void)(trace_pretest_ && (trace_where_, attributes_list_trace_real(trace_stringize(x), x), 0)))
00226 #else
00227 #define attributes_list_trace(x)
00228 #endif
00229 
00230 #ifndef cstate_architecture_list_DEF
00231 #define cstate_architecture_list_DEF
00232 struct cstate_architecture_list_ty
00233 {
00234     size_t length;
00235     size_t maximum;
00236     string_ty       **list;
00237 };
00238 #endif // cstate_architecture_list_DEF
00239 
00240 extern meta_type cstate_architecture_list_type;
00241 
00242 cstate_architecture_list_ty *cstate_architecture_list_copy(cstate_architecture_list_ty *);
00243 cstate_architecture_list_ty *cstate_architecture_list_clone(cstate_architecture_list_ty *);
00244 void cstate_architecture_list_write(const output::pointer &fp, const char *name, cstate_architecture_list_ty *value);
00245 void cstate_architecture_list_write_xml(const output::pointer &fp, const char *name, cstate_architecture_list_ty *value);
00246 #ifdef DEBUG
00247 void cstate_architecture_list_trace_real(const char *name, const cstate_architecture_list_ty *value);
00248 #define cstate_architecture_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_architecture_list_trace_real(trace_stringize(x), x), 0)))
00249 #else
00250 #define cstate_architecture_list_trace(x)
00251 #endif
00252 
00253 #ifndef cstate_copyright_years_list_DEF
00254 #define cstate_copyright_years_list_DEF
00255 struct cstate_copyright_years_list_ty
00256 {
00257     size_t length;
00258     size_t maximum;
00259     long            *list;
00260 };
00261 #endif // cstate_copyright_years_list_DEF
00262 
00263 extern meta_type cstate_copyright_years_list_type;
00264 
00265 cstate_copyright_years_list_ty *cstate_copyright_years_list_copy(cstate_copyright_years_list_ty *);
00266 cstate_copyright_years_list_ty *cstate_copyright_years_list_clone(cstate_copyright_years_list_ty *);
00267 void cstate_copyright_years_list_write(const output::pointer &fp, const char *name, cstate_copyright_years_list_ty *value);
00268 void cstate_copyright_years_list_write_xml(const output::pointer &fp, const char *name, cstate_copyright_years_list_ty *value);
00269 #ifdef DEBUG
00270 void cstate_copyright_years_list_trace_real(const char *name, const cstate_copyright_years_list_ty *value);
00271 #define cstate_copyright_years_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_copyright_years_list_trace_real(trace_stringize(x), x), 0)))
00272 #else
00273 #define cstate_copyright_years_list_trace(x)
00274 #endif
00275 
00276 #ifndef cstate_state_DEF
00277 #define cstate_state_DEF
00278 enum cstate_state_ty
00279 {
00280     cstate_state_awaiting_development,
00281     cstate_state_being_developed,
00282     cstate_state_awaiting_review,
00283     cstate_state_being_reviewed,
00284     cstate_state_awaiting_integration,
00285     cstate_state_being_integrated,
00286     cstate_state_completed
00287 };
00288 #define cstate_state_max 7
00289 #endif // cstate_state_DEF
00290 
00291 extern meta_type cstate_state_type;
00292 
00293 void cstate_state_write(const output::pointer &fp, const char *name, cstate_state_ty value, bool show);
00294 void cstate_state_write_xml(const output::pointer &fp, const char *name, cstate_state_ty value, bool show);
00295 const char *cstate_state_ename(cstate_state_ty);
00296 
00297 #ifndef cstate_architecture_times_DEF
00298 #define cstate_architecture_times_DEF
00299 
00300 #define cstate_architecture_times_variant_mask  ((unsigned long)0)
00301 #define cstate_architecture_times_node_mask ((unsigned long)0)
00302 #define cstate_architecture_times_build_time_mask   ((unsigned long)1 << 0)
00303 #define cstate_architecture_times_test_time_mask    ((unsigned long)1 << 1)
00304 #define cstate_architecture_times_test_baseline_time_mask   ((unsigned long)1 << 2)
00305 #define cstate_architecture_times_regression_test_time_mask ((unsigned long)1 << 3)
00306 
00307 struct cstate_architecture_times_ty
00308 {
00309     long            reference_count;
00310     unsigned long   mask;
00311     string_ty       *errpos;
00312     string_ty       *variant;
00313     string_ty       *node;
00314     time_t          build_time;
00315     time_t          test_time;
00316     time_t          test_baseline_time;
00317     time_t          regression_test_time;
00318 };
00319 #endif // cstate_architecture_times_DEF
00320 
00321 extern meta_type cstate_architecture_times_type;
00322 
00323 void cstate_architecture_times_write(const output::pointer &fp, const char *name, cstate_architecture_times_ty *value);
00324 void cstate_architecture_times_write_xml(const output::pointer &fp, const char *name, cstate_architecture_times_ty *value);
00325 cstate_architecture_times_ty *cstate_architecture_times_copy(cstate_architecture_times_ty *);
00326 cstate_architecture_times_ty *cstate_architecture_times_clone(cstate_architecture_times_ty *);
00327 #ifdef DEBUG
00328 void cstate_architecture_times_trace_real(const char *name, const cstate_architecture_times_ty *value);
00329 #define cstate_architecture_times_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_architecture_times_trace_real(trace_stringize(x), x), 0)))
00330 #else
00331 #define cstate_architecture_times_trace(x)
00332 #endif
00333 
00334 #ifndef cstate_architecture_times_list_DEF
00335 #define cstate_architecture_times_list_DEF
00336 struct cstate_architecture_times_list_ty
00337 {
00338     size_t length;
00339     size_t maximum;
00340     cstate_architecture_times_ty **list;
00341 };
00342 #endif // cstate_architecture_times_list_DEF
00343 
00344 extern meta_type cstate_architecture_times_list_type;
00345 
00346 cstate_architecture_times_list_ty *cstate_architecture_times_list_copy(cstate_architecture_times_list_ty *);
00347 cstate_architecture_times_list_ty *cstate_architecture_times_list_clone(cstate_architecture_times_list_ty *);
00348 void cstate_architecture_times_list_write(const output::pointer &fp, const char *name, cstate_architecture_times_list_ty *value);
00349 void cstate_architecture_times_list_write_xml(const output::pointer &fp, const char *name, cstate_architecture_times_list_ty *value);
00350 #ifdef DEBUG
00351 void cstate_architecture_times_list_trace_real(const char *name, const cstate_architecture_times_list_ty *value);
00352 #define cstate_architecture_times_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_architecture_times_list_trace_real(trace_stringize(x), x), 0)))
00353 #else
00354 #define cstate_architecture_times_list_trace(x)
00355 #endif
00356 
00357 #ifndef cstate_history_what_DEF
00358 #define cstate_history_what_DEF
00359 enum cstate_history_what_ty
00360 {
00361     cstate_history_what_new_change,
00362     cstate_history_what_develop_begin,
00363     cstate_history_what_develop_begin_undo,
00364     cstate_history_what_develop_end,
00365     cstate_history_what_develop_end_2ar,
00366     cstate_history_what_develop_end_2ai,
00367     cstate_history_what_develop_end_undo,
00368     cstate_history_what_review_begin,
00369     cstate_history_what_review_begin_undo,
00370     cstate_history_what_review_pass,
00371     cstate_history_what_review_pass_2ar,
00372     cstate_history_what_review_pass_2br,
00373     cstate_history_what_review_pass_undo,
00374     cstate_history_what_review_pass_undo_2ar,
00375     cstate_history_what_review_fail,
00376     cstate_history_what_integrate_begin,
00377     cstate_history_what_integrate_begin_undo,
00378     cstate_history_what_integrate_pass,
00379     cstate_history_what_integrate_fail
00380 };
00381 #define cstate_history_what_max 19
00382 #endif // cstate_history_what_DEF
00383 
00384 extern meta_type cstate_history_what_type;
00385 
00386 void cstate_history_what_write(const output::pointer &fp, const char *name, cstate_history_what_ty value, bool show);
00387 void cstate_history_what_write_xml(const output::pointer &fp, const char *name, cstate_history_what_ty value, bool show);
00388 const char *cstate_history_what_ename(cstate_history_what_ty);
00389 
00390 #ifndef cstate_history_DEF
00391 #define cstate_history_DEF
00392 
00393 #define cstate_history_when_mask    ((unsigned long)1 << 0)
00394 #define cstate_history_what_mask    ((unsigned long)1 << 1)
00395 #define cstate_history_who_mask ((unsigned long)0)
00396 #define cstate_history_why_mask ((unsigned long)0)
00397 
00398 struct cstate_history_ty
00399 {
00400     long            reference_count;
00401     unsigned long   mask;
00402     string_ty       *errpos;
00403     time_t          when;
00404     cstate_history_what_ty what;
00405     string_ty       *who;
00406     string_ty       *why;
00407 };
00408 #endif // cstate_history_DEF
00409 
00410 extern meta_type cstate_history_type;
00411 
00412 void cstate_history_write(const output::pointer &fp, const char *name, cstate_history_ty *value);
00413 void cstate_history_write_xml(const output::pointer &fp, const char *name, cstate_history_ty *value);
00414 cstate_history_ty *cstate_history_copy(cstate_history_ty *);
00415 cstate_history_ty *cstate_history_clone(cstate_history_ty *);
00416 #ifdef DEBUG
00417 void cstate_history_trace_real(const char *name, const cstate_history_ty *value);
00418 #define cstate_history_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_history_trace_real(trace_stringize(x), x), 0)))
00419 #else
00420 #define cstate_history_trace(x)
00421 #endif
00422 
00423 #ifndef cstate_history_list_DEF
00424 #define cstate_history_list_DEF
00425 struct cstate_history_list_ty
00426 {
00427     size_t length;
00428     size_t maximum;
00429     cstate_history_ty **list;
00430 };
00431 #endif // cstate_history_list_DEF
00432 
00433 extern meta_type cstate_history_list_type;
00434 
00435 cstate_history_list_ty *cstate_history_list_copy(cstate_history_list_ty *);
00436 cstate_history_list_ty *cstate_history_list_clone(cstate_history_list_ty *);
00437 void cstate_history_list_write(const output::pointer &fp, const char *name, cstate_history_list_ty *value);
00438 void cstate_history_list_write_xml(const output::pointer &fp, const char *name, cstate_history_list_ty *value);
00439 #ifdef DEBUG
00440 void cstate_history_list_trace_real(const char *name, const cstate_history_list_ty *value);
00441 #define cstate_history_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_history_list_trace_real(trace_stringize(x), x), 0)))
00442 #else
00443 #define cstate_history_list_trace(x)
00444 #endif
00445 
00446 #ifndef cstate_branch_develop_end_action_DEF
00447 #define cstate_branch_develop_end_action_DEF
00448 enum cstate_branch_develop_end_action_ty
00449 {
00450     cstate_branch_develop_end_action_goto_being_reviewed,
00451     cstate_branch_develop_end_action_goto_awaiting_review,
00452     cstate_branch_develop_end_action_goto_awaiting_integration
00453 };
00454 #define cstate_branch_develop_end_action_max 3
00455 #endif // cstate_branch_develop_end_action_DEF
00456 
00457 extern meta_type cstate_branch_develop_end_action_type;
00458 
00459 void cstate_branch_develop_end_action_write(const output::pointer &fp, const char *name, cstate_branch_develop_end_action_ty value, bool show);
00460 void cstate_branch_develop_end_action_write_xml(const output::pointer &fp, const char *name, cstate_branch_develop_end_action_ty value, bool show);
00461 const char *cstate_branch_develop_end_action_ename(cstate_branch_develop_end_action_ty);
00462 
00463 #ifndef cstate_branch_history_name_list_DEF
00464 #define cstate_branch_history_name_list_DEF
00465 struct cstate_branch_history_name_list_ty
00466 {
00467     size_t length;
00468     size_t maximum;
00469     string_ty       **list;
00470 };
00471 #endif // cstate_branch_history_name_list_DEF
00472 
00473 extern meta_type cstate_branch_history_name_list_type;
00474 
00475 cstate_branch_history_name_list_ty *cstate_branch_history_name_list_copy(cstate_branch_history_name_list_ty *);
00476 cstate_branch_history_name_list_ty *cstate_branch_history_name_list_clone(cstate_branch_history_name_list_ty *);
00477 void cstate_branch_history_name_list_write(const output::pointer &fp, const char *name, cstate_branch_history_name_list_ty *value);
00478 void cstate_branch_history_name_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_history_name_list_ty *value);
00479 #ifdef DEBUG
00480 void cstate_branch_history_name_list_trace_real(const char *name, const cstate_branch_history_name_list_ty *value);
00481 #define cstate_branch_history_name_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_history_name_list_trace_real(trace_stringize(x), x), 0)))
00482 #else
00483 #define cstate_branch_history_name_list_trace(x)
00484 #endif
00485 
00486 #ifndef cstate_branch_history_DEF
00487 #define cstate_branch_history_DEF
00488 
00489 #define cstate_branch_history_delta_number_mask ((unsigned long)1 << 0)
00490 #define cstate_branch_history_change_number_mask    ((unsigned long)1 << 1)
00491 #define cstate_branch_history_name_mask ((unsigned long)0)
00492 
00493 struct cstate_branch_history_ty
00494 {
00495     long            reference_count;
00496     unsigned long   mask;
00497     string_ty       *errpos;
00498     long            delta_number;
00499     long            change_number;
00500     cstate_branch_history_name_list_ty *name;
00501 };
00502 #endif // cstate_branch_history_DEF
00503 
00504 extern meta_type cstate_branch_history_type;
00505 
00506 void cstate_branch_history_write(const output::pointer &fp, const char *name, cstate_branch_history_ty *value);
00507 void cstate_branch_history_write_xml(const output::pointer &fp, const char *name, cstate_branch_history_ty *value);
00508 cstate_branch_history_ty *cstate_branch_history_copy(cstate_branch_history_ty *);
00509 cstate_branch_history_ty *cstate_branch_history_clone(cstate_branch_history_ty *);
00510 #ifdef DEBUG
00511 void cstate_branch_history_trace_real(const char *name, const cstate_branch_history_ty *value);
00512 #define cstate_branch_history_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_history_trace_real(trace_stringize(x), x), 0)))
00513 #else
00514 #define cstate_branch_history_trace(x)
00515 #endif
00516 
00517 #ifndef cstate_branch_history_list_DEF
00518 #define cstate_branch_history_list_DEF
00519 struct cstate_branch_history_list_ty
00520 {
00521     size_t length;
00522     size_t maximum;
00523     cstate_branch_history_ty **list;
00524 };
00525 #endif // cstate_branch_history_list_DEF
00526 
00527 extern meta_type cstate_branch_history_list_type;
00528 
00529 cstate_branch_history_list_ty *cstate_branch_history_list_copy(cstate_branch_history_list_ty *);
00530 cstate_branch_history_list_ty *cstate_branch_history_list_clone(cstate_branch_history_list_ty *);
00531 void cstate_branch_history_list_write(const output::pointer &fp, const char *name, cstate_branch_history_list_ty *value);
00532 void cstate_branch_history_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_history_list_ty *value);
00533 #ifdef DEBUG
00534 void cstate_branch_history_list_trace_real(const char *name, const cstate_branch_history_list_ty *value);
00535 #define cstate_branch_history_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_history_list_trace_real(trace_stringize(x), x), 0)))
00536 #else
00537 #define cstate_branch_history_list_trace(x)
00538 #endif
00539 
00540 #ifndef cstate_branch_change_list_DEF
00541 #define cstate_branch_change_list_DEF
00542 struct cstate_branch_change_list_ty
00543 {
00544     size_t length;
00545     size_t maximum;
00546     long            *list;
00547 };
00548 #endif // cstate_branch_change_list_DEF
00549 
00550 extern meta_type cstate_branch_change_list_type;
00551 
00552 cstate_branch_change_list_ty *cstate_branch_change_list_copy(cstate_branch_change_list_ty *);
00553 cstate_branch_change_list_ty *cstate_branch_change_list_clone(cstate_branch_change_list_ty *);
00554 void cstate_branch_change_list_write(const output::pointer &fp, const char *name, cstate_branch_change_list_ty *value);
00555 void cstate_branch_change_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_change_list_ty *value);
00556 #ifdef DEBUG
00557 void cstate_branch_change_list_trace_real(const char *name, const cstate_branch_change_list_ty *value);
00558 #define cstate_branch_change_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_change_list_trace_real(trace_stringize(x), x), 0)))
00559 #else
00560 #define cstate_branch_change_list_trace(x)
00561 #endif
00562 
00563 #ifndef cstate_branch_sub_branch_list_DEF
00564 #define cstate_branch_sub_branch_list_DEF
00565 struct cstate_branch_sub_branch_list_ty
00566 {
00567     size_t length;
00568     size_t maximum;
00569     long            *list;
00570 };
00571 #endif // cstate_branch_sub_branch_list_DEF
00572 
00573 extern meta_type cstate_branch_sub_branch_list_type;
00574 
00575 cstate_branch_sub_branch_list_ty *cstate_branch_sub_branch_list_copy(cstate_branch_sub_branch_list_ty *);
00576 cstate_branch_sub_branch_list_ty *cstate_branch_sub_branch_list_clone(cstate_branch_sub_branch_list_ty *);
00577 void cstate_branch_sub_branch_list_write(const output::pointer &fp, const char *name, cstate_branch_sub_branch_list_ty *value);
00578 void cstate_branch_sub_branch_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_sub_branch_list_ty *value);
00579 #ifdef DEBUG
00580 void cstate_branch_sub_branch_list_trace_real(const char *name, const cstate_branch_sub_branch_list_ty *value);
00581 #define cstate_branch_sub_branch_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_sub_branch_list_trace_real(trace_stringize(x), x), 0)))
00582 #else
00583 #define cstate_branch_sub_branch_list_trace(x)
00584 #endif
00585 
00586 #ifndef cstate_branch_administrator_list_DEF
00587 #define cstate_branch_administrator_list_DEF
00588 struct cstate_branch_administrator_list_ty
00589 {
00590     size_t length;
00591     size_t maximum;
00592     string_ty       **list;
00593 };
00594 #endif // cstate_branch_administrator_list_DEF
00595 
00596 extern meta_type cstate_branch_administrator_list_type;
00597 
00598 cstate_branch_administrator_list_ty *cstate_branch_administrator_list_copy(cstate_branch_administrator_list_ty *);
00599 cstate_branch_administrator_list_ty *cstate_branch_administrator_list_clone(cstate_branch_administrator_list_ty *);
00600 void cstate_branch_administrator_list_write(const output::pointer &fp, const char *name, cstate_branch_administrator_list_ty *value);
00601 void cstate_branch_administrator_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_administrator_list_ty *value);
00602 #ifdef DEBUG
00603 void cstate_branch_administrator_list_trace_real(const char *name, const cstate_branch_administrator_list_ty *value);
00604 #define cstate_branch_administrator_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_administrator_list_trace_real(trace_stringize(x), x), 0)))
00605 #else
00606 #define cstate_branch_administrator_list_trace(x)
00607 #endif
00608 
00609 #ifndef cstate_branch_developer_list_DEF
00610 #define cstate_branch_developer_list_DEF
00611 struct cstate_branch_developer_list_ty
00612 {
00613     size_t length;
00614     size_t maximum;
00615     string_ty       **list;
00616 };
00617 #endif // cstate_branch_developer_list_DEF
00618 
00619 extern meta_type cstate_branch_developer_list_type;
00620 
00621 cstate_branch_developer_list_ty *cstate_branch_developer_list_copy(cstate_branch_developer_list_ty *);
00622 cstate_branch_developer_list_ty *cstate_branch_developer_list_clone(cstate_branch_developer_list_ty *);
00623 void cstate_branch_developer_list_write(const output::pointer &fp, const char *name, cstate_branch_developer_list_ty *value);
00624 void cstate_branch_developer_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_developer_list_ty *value);
00625 #ifdef DEBUG
00626 void cstate_branch_developer_list_trace_real(const char *name, const cstate_branch_developer_list_ty *value);
00627 #define cstate_branch_developer_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_developer_list_trace_real(trace_stringize(x), x), 0)))
00628 #else
00629 #define cstate_branch_developer_list_trace(x)
00630 #endif
00631 
00632 #ifndef cstate_branch_reviewer_list_DEF
00633 #define cstate_branch_reviewer_list_DEF
00634 struct cstate_branch_reviewer_list_ty
00635 {
00636     size_t length;
00637     size_t maximum;
00638     string_ty       **list;
00639 };
00640 #endif // cstate_branch_reviewer_list_DEF
00641 
00642 extern meta_type cstate_branch_reviewer_list_type;
00643 
00644 cstate_branch_reviewer_list_ty *cstate_branch_reviewer_list_copy(cstate_branch_reviewer_list_ty *);
00645 cstate_branch_reviewer_list_ty *cstate_branch_reviewer_list_clone(cstate_branch_reviewer_list_ty *);
00646 void cstate_branch_reviewer_list_write(const output::pointer &fp, const char *name, cstate_branch_reviewer_list_ty *value);
00647 void cstate_branch_reviewer_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_reviewer_list_ty *value);
00648 #ifdef DEBUG
00649 void cstate_branch_reviewer_list_trace_real(const char *name, const cstate_branch_reviewer_list_ty *value);
00650 #define cstate_branch_reviewer_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_reviewer_list_trace_real(trace_stringize(x), x), 0)))
00651 #else
00652 #define cstate_branch_reviewer_list_trace(x)
00653 #endif