00001
00002
00003
00004
00005
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;
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
00654
00655 #ifndef cstate_branch_integrator_list_DEF
00656 #define cstate_branch_integrator_list_DEF
00657 struct cstate_branch_integrator_list_ty
00658 {
00659 size_t length;
00660 size_t maximum;
00661 string_ty **list;
00662 };
00663 #endif // cstate_branch_integrator_list_DEF
00664
00665 extern meta_type cstate_branch_integrator_list_type;
00666
00667 cstate_branch_integrator_list_ty *cstate_branch_integrator_list_copy(cstate_branch_integrator_list_ty *);
00668 cstate_branch_integrator_list_ty *cstate_branch_integrator_list_clone(cstate_branch_integrator_list_ty *);
00669 void cstate_branch_integrator_list_write(const output::pointer &fp, const char *name, cstate_branch_integrator_list_ty *value);
00670 void cstate_branch_integrator_list_write_xml(const output::pointer &fp, const char *name, cstate_branch_integrator_list_ty *value);
00671 #ifdef DEBUG
00672 void cstate_branch_integrator_list_trace_real(const char *name, const cstate_branch_integrator_list_ty *value);
00673 #define cstate_branch_integrator_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_integrator_list_trace_real(trace_stringize(x), x), 0)))
00674 #else
00675 #define cstate_branch_integrator_list_trace(x)
00676 #endif
00677
00678 #ifndef cstate_branch_DEF
00679 #define cstate_branch_DEF
00680
00681 #define cstate_branch_umask_mask ((unsigned long)1 << 0)
00682 #define cstate_branch_developer_may_review_mask ((unsigned long)1 << 1)
00683 #define cstate_branch_developer_may_integrate_mask ((unsigned long)1 << 2)
00684 #define cstate_branch_reviewer_may_integrate_mask ((unsigned long)1 << 3)
00685 #define cstate_branch_developers_may_create_changes_mask ((unsigned long)1 << 4)
00686 #define cstate_branch_forced_develop_begin_notify_command_mask ((unsigned long)0)
00687 #define cstate_branch_develop_end_notify_command_mask ((unsigned long)0)
00688 #define cstate_branch_develop_end_undo_notify_command_mask ((unsigned long)0)
00689 #define cstate_branch_review_begin_notify_command_mask ((unsigned long)0)
00690 #define cstate_branch_review_begin_undo_notify_command_mask ((unsigned long)0)
00691 #define cstate_branch_review_pass_notify_command_mask ((unsigned long)0)
00692 #define cstate_branch_review_pass_undo_notify_command_mask ((unsigned long)0)
00693 #define cstate_branch_review_fail_notify_command_mask ((unsigned long)0)
00694 #define cstate_branch_integrate_pass_notify_command_mask ((unsigned long)0)
00695 #define cstate_branch_integrate_fail_notify_command_mask ((unsigned long)0)
00696 #define cstate_branch_default_test_exemption_mask ((unsigned long)1 << 5)
00697 #define cstate_branch_default_test_regression_exemption_mask ((unsigned long)1 << 6)
00698 #define cstate_branch_skip_unlucky_mask ((unsigned long)1 << 7)
00699 #define cstate_branch_compress_database_mask ((unsigned long)1 << 8)
00700 #define cstate_branch_develop_end_action_mask ((unsigned long)1 << 9)
00701 #define cstate_branch_history_mask ((unsigned long)0)
00702 #define cstate_branch_change_mask ((unsigned long)0)
00703 #define cstate_branch_sub_branch_mask ((unsigned long)0)
00704 #define cstate_branch_administrator_mask ((unsigned long)0)
00705 #define cstate_branch_developer_mask ((unsigned long)0)
00706 #define cstate_branch_reviewer_mask ((unsigned long)0)
00707 #define cstate_branch_integrator_mask ((unsigned long)0)
00708 #define cstate_branch_currently_integrating_change_mask ((unsigned long)1 << 10)
00709 #define cstate_branch_default_development_directory_mask ((unsigned long)0)
00710 #define cstate_branch_minimum_change_number_mask ((unsigned long)1 << 11)
00711 #define cstate_branch_reuse_change_numbers_mask ((unsigned long)1 << 12)
00712 #define cstate_branch_minimum_branch_number_mask ((unsigned long)1 << 13)
00713 #define cstate_branch_protect_development_directory_mask ((unsigned long)1 << 14)
00714
00715 struct cstate_branch_ty
00716 {
00717 long reference_count;
00718 unsigned long mask;
00719 string_ty *errpos;
00720 long umask;
00721 bool developer_may_review;
00722 bool developer_may_integrate;
00723 bool reviewer_may_integrate;
00724 bool developers_may_create_changes;
00725 string_ty *forced_develop_begin_notify_command;
00726 string_ty *develop_end_notify_command;
00727 string_ty *develop_end_undo_notify_command;
00728 string_ty *review_begin_notify_command;
00729 string_ty *review_begin_undo_notify_command;
00730 string_ty *review_pass_notify_command;
00731 string_ty *review_pass_undo_notify_command;
00732 string_ty *review_fail_notify_command;
00733 string_ty *integrate_pass_notify_command;
00734 string_ty *integrate_fail_notify_command;
00735 bool default_test_exemption;
00736 bool default_test_regression_exemption;
00737 bool skip_unlucky;
00738 bool compress_database;
00739 cstate_branch_develop_end_action_ty develop_end_action;
00740 cstate_branch_history_list_ty *history;
00741 cstate_branch_change_list_ty *change;
00742 cstate_branch_sub_branch_list_ty *sub_branch;
00743 cstate_branch_administrator_list_ty *administrator;
00744 cstate_branch_developer_list_ty *developer;
00745 cstate_branch_reviewer_list_ty *reviewer;
00746 cstate_branch_integrator_list_ty *integrator;
00747 long currently_integrating_change;
00748 string_ty *default_development_directory;
00749 long minimum_change_number;
00750 bool reuse_change_numbers;
00751 long minimum_branch_number;
00752 bool protect_development_directory;
00753 };
00754 #endif // cstate_branch_DEF
00755
00756 extern meta_type cstate_branch_type;
00757
00758 void cstate_branch_write(const output::pointer &fp, const char *name, cstate_branch_ty *value);
00759 void cstate_branch_write_xml(const output::pointer &fp, const char *name, cstate_branch_ty *value);
00760 cstate_branch_ty *cstate_branch_copy(cstate_branch_ty *);
00761 cstate_branch_ty *cstate_branch_clone(cstate_branch_ty *);
00762 #ifdef DEBUG
00763 void cstate_branch_trace_real(const char *name, const cstate_branch_ty *value);
00764 #define cstate_branch_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_branch_trace_real(trace_stringize(x), x), 0)))
00765 #else
00766 #define cstate_branch_trace(x)
00767 #endif
00768
00769 #ifndef cstate_src_DEF
00770 #define cstate_src_DEF
00771
00772 #define cstate_src_file_name_mask ((unsigned long)0)
00773 #define cstate_src_uuid_mask ((unsigned long)0)
00774 #define cstate_src_action_mask ((unsigned long)1 << 0)
00775 #define cstate_src_edit_number_mask ((unsigned long)0)
00776 #define cstate_src_usage_mask ((unsigned long)1 << 1)
00777 #define cstate_src_diff_time_mask ((unsigned long)1 << 2)
00778 #define cstate_src_diff_file_time_mask ((unsigned long)1 << 3)
00779 #define cstate_src_move_mask ((unsigned long)0)
00780 #define cstate_src_executable_mask ((unsigned long)1 << 4)
00781 #define cstate_src_attribute_mask ((unsigned long)0)
00782
00783 struct cstate_src_ty
00784 {
00785 long reference_count;
00786 unsigned long mask;
00787 string_ty *errpos;
00788 string_ty *file_name;
00789 string_ty *uuid;
00790 file_action_ty action;
00791 string_ty *edit_number;
00792 file_usage_ty usage;
00793 time_t diff_time;
00794 time_t diff_file_time;
00795 string_ty *move;
00796 bool executable;
00797 attributes_list_ty *attribute;
00798 };
00799 #endif // cstate_src_DEF
00800
00801 extern meta_type cstate_src_type;
00802
00803 void cstate_src_write(const output::pointer &fp, const char *name, cstate_src_ty *value);
00804 void cstate_src_write_xml(const output::pointer &fp, const char *name, cstate_src_ty *value);
00805 cstate_src_ty *cstate_src_copy(cstate_src_ty *);
00806 cstate_src_ty *cstate_src_clone(cstate_src_ty *);
00807 #ifdef DEBUG
00808 void cstate_src_trace_real(const char *name, const cstate_src_ty *value);
00809 #define cstate_src_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_src_trace_real(trace_stringize(x), x), 0)))
00810 #else
00811 #define cstate_src_trace(x)
00812 #endif
00813
00814 #ifndef cstate_src_list_DEF
00815 #define cstate_src_list_DEF
00816 struct cstate_src_list_ty
00817 {
00818 size_t length;
00819 size_t maximum;
00820 cstate_src_ty **list;
00821 };
00822 #endif // cstate_src_list_DEF
00823
00824 extern meta_type cstate_src_list_type;
00825
00826 cstate_src_list_ty *cstate_src_list_copy(cstate_src_list_ty *);
00827 cstate_src_list_ty *cstate_src_list_clone(cstate_src_list_ty *);
00828 void cstate_src_list_write(const output::pointer &fp, const char *name, cstate_src_list_ty *value);
00829 void cstate_src_list_write_xml(const output::pointer &fp, const char *name, cstate_src_list_ty *value);
00830 #ifdef DEBUG
00831 void cstate_src_list_trace_real(const char *name, const cstate_src_list_ty *value);
00832 #define cstate_src_list_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_src_list_trace_real(trace_stringize(x), x), 0)))
00833 #else
00834 #define cstate_src_list_trace(x)
00835 #endif
00836
00837 #ifndef cstate_DEF
00838 #define cstate_DEF
00839
00840 #define cstate_brief_description_mask ((unsigned long)0)
00841 #define cstate_description_mask ((unsigned long)0)
00842 #define cstate_cause_mask ((unsigned long)1 << 0)
00843 #define cstate_test_exempt_mask ((unsigned long)1 << 1)
00844 #define cstate_test_baseline_exempt_mask ((unsigned long)1 << 2)
00845 #define cstate_regression_test_exempt_mask ((unsigned long)1 << 3)
00846 #define cstate_architecture_mask ((unsigned long)0)
00847 #define cstate_copyright_years_mask ((unsigned long)0)
00848 #define cstate_version_previous_mask ((unsigned long)0)
00849 #define cstate_attribute_mask ((unsigned long)0)
00850 #define cstate_state_mask ((unsigned long)1 << 4)
00851 #define cstate_given_test_exemption_mask ((unsigned long)1 << 5)
00852 #define cstate_given_regression_test_exemption_mask ((unsigned long)1 << 6)
00853 #define cstate_delta_number_mask ((unsigned long)1 << 7)
00854 #define cstate_delta_uuid_mask ((unsigned long)0)
00855 #define cstate_minimum_integration_mask ((unsigned long)1 << 8)
00856 #define cstate_project_file_command_sync_mask ((unsigned long)1 << 9)
00857 #define cstate_build_time_mask ((unsigned long)1 << 10)
00858 #define cstate_test_time_mask ((unsigned long)1 << 11)
00859 #define cstate_test_baseline_time_mask ((unsigned long)1 << 12)
00860 #define cstate_regression_test_time_mask ((unsigned long)1 << 13)
00861 #define cstate_architecture_times_mask ((unsigned long)0)
00862 #define cstate_development_directory_mask ((unsigned long)0)
00863 #define cstate_integration_directory_mask ((unsigned long)0)
00864 #define cstate_history_mask ((unsigned long)0)
00865 #define cstate_uuid_mask ((unsigned long)0)
00866 #define cstate_branch_mask ((unsigned long)0)
00867 #define cstate_src_mask ((unsigned long)0)
00868
00869 struct cstate_ty
00870 {
00871 long reference_count;
00872 unsigned long mask;
00873 string_ty *errpos;
00874 string_ty *brief_description;
00875 string_ty *description;
00876 change_cause_ty cause;
00877 bool test_exempt;
00878 bool test_baseline_exempt;
00879 bool regression_test_exempt;
00880 cstate_architecture_list_ty *architecture;
00881 cstate_copyright_years_list_ty *copyright_years;
00882 string_ty *version_previous;
00883 attributes_list_ty *attribute;
00884 cstate_state_ty state;
00885 bool given_test_exemption;
00886 bool given_regression_test_exemption;
00887 long delta_number;
00888 string_ty *delta_uuid;
00889 bool minimum_integration;
00890 long project_file_command_sync;
00891 time_t build_time;
00892 time_t test_time;
00893 time_t test_baseline_time;
00894 time_t regression_test_time;
00895 cstate_architecture_times_list_ty *architecture_times;
00896 string_ty *development_directory;
00897 string_ty *integration_directory;
00898 cstate_history_list_ty *history;
00899 string_ty *uuid;
00900 cstate_branch_ty *branch;
00901 cstate_src_list_ty *src;
00902 };
00903 #endif // cstate_DEF
00904
00905 extern meta_type cstate_type;
00906
00907 void cstate_write(const output::pointer &fp, cstate_ty *value);
00908 void cstate_write_xml(const output::pointer &fp, cstate_ty *value);
00909 cstate_ty *cstate_copy(cstate_ty *);
00910 cstate_ty *cstate_clone(cstate_ty *);
00911 #ifdef DEBUG
00912 void cstate_trace_real(const char *name, const cstate_ty *value);
00913 #define cstate_trace(x) ((void)(trace_pretest_ && (trace_where_, cstate_trace_real(trace_stringize(x), x), 0)))
00914 #else
00915 #define cstate_trace(x)
00916 #endif
00917
00934 void cstate_write_file(string_ty *filename, cstate_ty *value, int comp);
00935
00952 void cstate_write_file(const nstring &filnam, cstate_ty *value, bool comp);
00953
00970 cstate_ty *cstate_read_file(string_ty *filename);
00971
00988 cstate_ty *cstate_read_file(const nstring &filename);
00989 void cstate__rpt_init(void);
00990
00991 #endif // LIBAEGIS_CSTATE_H
