From a411bc1803e8f987072445600bd1b732185108e0 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Franti=C5=A1ek=20Dvo=C5=99=C3=A1k?= Date: Tue, 19 Jul 2005 08:03:41 +0000 Subject: [PATCH] Web Services and enums, stage 2: - C to soap enumeration functions - using the translate enumeration function --- org.glite.lb.server/src/ws_typeref.c.T | 399 ++++++++++----------------------- 1 file changed, 113 insertions(+), 286 deletions(-) diff --git a/org.glite.lb.server/src/ws_typeref.c.T b/org.glite.lb.server/src/ws_typeref.c.T index 6a433fe..df038b3 100644 --- a/org.glite.lb.server/src/ws_typeref.c.T +++ b/org.glite.lb.server/src/ws_typeref.c.T @@ -17,8 +17,8 @@ # if the field is optional, is ALWAYS assigned! # sub eventFieldAssign { - my ($src, $dst, $e, $f) = @_; - my ($tn, $soap_en, $soap_fn, $native_en, $native_fn); + my ($indent, $src, $dst, $e, $f, $is_common) = @_; + my ($tn, $soap_en, $soap_fn, $native_en, $native_fn, $func_name, $source, $dest); $tn = $f->{type}; $native_en = lcfirst $e; @@ -31,44 +31,47 @@ sub eventFieldAssign { while ($soap_fn =~ /([[:alpha:]]*)_([[:alpha:]_]*)/) { $soap_fn = $1.ucfirst($2); }; + $source = "$src->$native_en.$native_fn"; + $dest = "$dst->$soap_en->$soap_fn"; # print STDERR "$src, $dst, $soap_en, $soap_fn, $native_fn, $tn, $usuc\n"; - if ($tn eq 'int' || $tn eq 'port' || $tn eq 'bool' || $tn eq 'logsrc') { + if ($tn eq 'int') { + if ($f->{codes}) { + $soap_En = ucfirst $soap_en; + $soap_Fn = ucfirst $soap_fn; + $func_name = $is_common ? "edg_wll_${soap_Fn}ToSoap" : "edg_wll_${soap_En}${soap_Fn}ToSoap"; + gen $indent."$func_name(soap, $source, &$dest);\n"; + } elsif ($f->{optional}) { + gen $indent."$dest = soap_malloc(soap, sizeof(*$dest));\n"; + gen $indent."*$dest = $source;\n"; + } else { + gen $indent."$dest = $source;\n"; + } + } + elsif ($tn eq 'port' || $tn eq 'bool') { if ($f->{optional}) { -gen qq { -! $dst->$soap_en->$soap_fn = soap_malloc(soap, sizeof(*$dst->$soap_en->$soap_fn)); -! *$dst->$soap_en->$soap_fn = $src->$native_en.$native_fn; -}; + gen $indent."$dest = soap_malloc(soap, sizeof(*$dest));\n"; + gen $indent."*$dest = $source;\n"; } else { -gen qq { -! $dst->$soap_en->$soap_fn = $src->$native_en.$native_fn; -}; + gen $indent."$dest = $source;\n"; } + } elsif ($tn eq 'logsrc') { + gen $indent."edg_wll_SourceToSoap($source, &$dest);\n"; } elsif ($tn eq 'string' || $tn eq 'notifid') { -gen qq { -! $dst->$soap_en->$soap_fn = soap_strdup(soap, $src->$native_en.$native_fn); -}; + gen $indent."$dest = soap_strdup(soap, $source);\n"; } elsif ($tn eq 'jobstat') { -gen qq { -! edg_wll_StatusToSoap(soap, $src->$native_en.$native_fn, &$dst->$soap_en->$soap_fn); -}; + gen $indent."edg_wll_StatusToSoap(soap, $source, &$dest);\n"; } elsif ($tn eq 'timeval') { -gen qq { -! $dst->$soap_en->$soap_fn = soap_malloc(soap, sizeof(struct lbt__timeval)); -! $dst->$soap_en->$soap_fn->tvSec = $src->$native_en.$native_fn.tv_sec; -! $dst->$soap_en->$soap_fn->tvUsec = $src->$native_en.$native_fn.tv_usec; -}; + gen $indent."$dest = soap_malloc(soap, sizeof(struct lbt__timeval));\n"; + gen $indent."$dest->tvSec = $source.tv_sec;\n"; + gen $indent."$dest->tvUsec = $source.tv_usec;\n"; } elsif ($tn eq 'jobid') { -gen qq { -! s = edg_wlc_JobIdUnparse($src->$native_en.$native_fn); -! $dst->$soap_en->$soap_fn = soap_strdup(soap, s); -}; + gen $indent."s = edg_wlc_JobIdUnparse($source);\n"; + gen $indent."$dest = soap_strdup(soap, s);\n"; } elsif ($tn eq 'usertag') { -gen qq { -! $dst->$soap_en->$soap_fn = soap_malloc(soap, sizeof(*$dst->$soap_fn)); -! $dst->$soap_en->$soap_fn->tag = soap_strdup(soap, $src->$native_en.$native_fn.tag); -! $dst->$soap_en->$soap_fn->value = soap_strdup(soap, $src->$native_en.$native_fn.value); -}; + gen $indent."$dest = soap_malloc(soap, sizeof(*$dst->$soap_fn));\n"; + gen $indent."$dest->tag = soap_strdup(soap, $source.tag);\n"; + gen $indent."$dest->value = soap_strdup(soap, $source.value);\n"; } else { die "Unknown type $tn"; } @@ -76,8 +79,8 @@ gen qq { sub eventFieldFree { - my ($dst, $e, $f) = @_; - my ($tn, $soap_fn); + my ($indent, $dst, $e, $f) = @_; + my ($tn, $soap_fn, $dest); $tn = $f->{type}; $soap_en = $e; @@ -88,29 +91,20 @@ sub eventFieldFree { while ($soap_fn =~ /([[:alpha:]]*)_([[:alpha:]_]*)/) { $soap_fn = $1.ucfirst($2); }; + $dest = "$dst->$soap_en->$soap_fn"; if ($tn eq 'int' || $tn eq 'port' || $tn eq 'bool' || $tn eq 'logsrc') { if ($f->{optional}) { -gen qq { -! if ($dst->$soap_en->$soap_fn) soap_dealloc(soap, $dst->$soap_en->$soap_fn); -}; + gen $indent."if ($dest) soap_dealloc(soap, $dest);\n"; } - } elsif ($tn eq 'jobstat') { -gen qq { -! /* TODO: free($dst->$soap_en->$soap_fn); */ -}; } elsif ($tn eq 'string' || $tn eq 'notifid' || $tn eq 'jobid' || $tn eq 'timeval') { -gen qq { -! if ($dst->$soap_en->$soap_fn) soap_dealloc(soap, $dst->$soap_en->$soap_fn); -}; + gen $indent."if ($dest) soap_dealloc(soap, $dest);\n"; } elsif ($tn eq 'usertag') { -gen qq { -! if ($dst->$soap_en->$soap_fn) { -! if ($dst->$soap_en->$soap_fn->tag) soap_dealloc(soap, $dst->$soap_en->$soap_fn->tag); -! if ($dst->$soap_en->$soap_fn->value) soap_dealloc(soap, $dst->$soap_en->$soap_fn->value); -! soap_dealloc(soap, $dst->$soap_en->$soap_fn); -! } -}; + gen $indent."if ($dest) {\n"; + gen $indent." if ($dest->tag) soap_dealloc(soap, $dest->tag);\n"; + gen $indent." if ($dest->value) soap_dealloc(soap, $dest->value);\n"; + gen $indent." soap_dealloc(soap, $dest);\n"; + gen $indent."}\n"; } else { die "Unknown type $tn"; } @@ -758,6 +752,10 @@ static void edg_wll_SoapToSource(enum lbt__eventSource in, edg_wll_Source *out) } +/* + * Soap to C and C to Soap enumeration translate functions. + */ + @@@{ foreach ('_common_', sort { $event->{order}->{$a} <=> $event->{order}->{$b} } getTypes $event) { my ($e, $upper_en, $soap_en, $en); @@ -779,7 +777,7 @@ foreach ('_common_', sort { $event->{order}->{$a} <=> $event->{order}->{$b} } ge my $f = selectField $event $_; if ($f->{codes}) { - my ($fn, $enum_name, $func_name); + my ($fn, $enum_name, $enum_value_prefix, $func2C_name, $func2S_name); $fn = ucfirst $f->{name}; $upper_fn = uc $f->{name}; @@ -787,139 +785,73 @@ foreach ('_common_', sort { $event->{order}->{$a} <=> $event->{order}->{$b} } ge $soap_fn = $1.ucfirst $2 while $soap_fn =~ /([[:alpha:]]*)_([[:alpha:]_]*)/; $enum_name = $e eq '_common_' && $fn eq 'Level' ? "int": "enum edg_wll_${en}${fn}"; - $soap_enum_name = "lbt__$soap_en$soap_fn"; - $func_name = "edg_wll_SoapTo$soap_en$soap_fn"; - gen "static void $func_name(const enum $soap_enum_name in, $enum_name *out) {\n"; - gen "\tswitch(in) {\n"; + $enum_value_prefix = $e eq '_common_' ? "EDG_WLL_${upper_fn}_" : "EDG_WLL_${upper_en}_"; + $soap_enum_name = "enum lbt__$soap_en$soap_fn "; + if ($f->{optional}) {$soap_enum_name .= "*";} + + # Soap to C function + $func2C_name = "edg_wll_SoapTo$soap_en$soap_fn"; + gen "\n"; + gen "static void $func2C_name(const ${soap_enum_name}in, $enum_name *out) {\n"; + if ($f->{optional}) { + gen "\tif (in == NULL) {\n"; + gen "\t\t*out = ${enum_value_prefix}UNDEFINED;\n"; + gen "\t\treturn;\n"; + gen "\t}\n"; + gen "\n"; + gen "\tswitch(*in) {\n"; + } else { + gen "\tswitch(in) {\n"; + } foreach $code (@{$f->{codes}}) { - my ($enum_value, $soap_enum_name); + my ($enum_value, $soap_enum_value); $upper_cn = $code->{name}; - - if ($e eq '_common_') { - $enum_value = "EDG_WLL_${upper_fn}_${upper_cn}"; - } else { - $enum_value = "EDG_WLL_${upper_en}_${upper_cn}"; - } - $soap_enum_name = "lbt__${soap_en}${soap_fn}__${upper_cn}"; - gen "\tcase $soap_enum_name: *out = $enum_value; break;\n" + $enum_value = "${enum_value_prefix}${upper_cn}"; + $soap_enum_value = "lbt__${soap_en}${soap_fn}__${upper_cn}"; + gen "\tcase $soap_enum_value: *out = $enum_value; break;\n" } gen "\tdefault: assert(0);\n"; gen "\t};\n"; gen "}\n"; gen "\n"; + + # C to Soap function + my $target; + + $func2S_name = "edg_wll_${soap_en}${soap_fn}ToSoap"; gen "\n"; + gen "static void $func2S_name(struct soap *soap, const $enum_name in, ${soap_enum_name}*out) {\n"; + if ($f->{optional}) { + gen "\tif (in == ${enum_value_prefix}UNDEFINED) {\n"; + gen "\t\t*out = NULL;\n"; + gen "\t\treturn;\n"; + gen "\t}\n"; + gen "\n"; + gen "\t*out = soap_malloc(soap, sizeof(**out));\n"; + $target = "**out"; + } else { + $target = "*out"; + } + gen "\tswitch(in) {\n"; + foreach $code (@{$f->{codes}}) { + my ($enum_value, $soap_enum_value); + + $upper_cn = $code->{name}; + $enum_value = "${enum_value_prefix}${upper_cn}"; + $soap_enum_value = "lbt__${soap_en}${soap_fn}__${upper_cn}"; + gen "\tcase $enum_value: $target = $soap_enum_value; break;\n" + } + gen "\tdefault: assert(0);\n"; + gen "\t};\n"; + gen "}\n"; + gen "\n"; + } # if code } # fields } # _common_, types @@@} - -/* -static void edg_wll_SoapToTransferResult(enum in, edg_wll_TransferResult *out) -{ - switch ( in ) { - case : *out = EDG_WLL_TRANSFER_UNDEFINED,; break; - case : *out = EDG_WLL_TRANSFER_START,; break; - case : *out = EDG_WLL_TRANSFER_OK,; break; - case : *out = EDG_WLL_TRANSFER_REFUSED,; break; - case : *out = EDG_WLL_TRANSFER_FAIL,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToEnQueuedResult(enum in, edg_wll_EnQueuedResult *out) -{ - switch ( in ) { - case : *out = EDG_WLL_ENQUEUED_UNDEFINED,; break; - case : *out = EDG_WLL_ENQUEUED_START,; break; - case : *out = EDG_WLL_ENQUEUED_OK,; break; - case : *out = EDG_WLL_ENQUEUED_REFUSED,; break; - case : *out = EDG_WLL_ENQUEUED_FAIL,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToHelperCallSrcRole(enum in, edg_wll_HelperCallSrc_role *out) -{ - switch ( in ) { - case : *out = EDG_WLL_HELPERCALL_UNDEFINED,; break; - case : *out = EDG_WLL_HELPERCALL_CALLING,; break; - case : *out = EDG_WLL_HELPERCALL_CALLED,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToHelperReturnSrcRole(enum in, edg_wll_HelperReturnSrc_role *out) -{ - switch ( in ) { - case : *out = EDG_WLL_HELPERRETURN_UNDEFINED,; break; - case : *out = EDG_WLL_HELPERRETURN_CALLING,; break; - case : *out = EDG_WLL_HELPERRETURN_CALLED,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToResubmissionResult(enum in, edg_wll_ResubmissionResult *out) -{ - switch ( in ) { - case : *out = EDG_WLL_RESUBMISSION_UNDEFINED,; break; - case : *out = EDG_WLL_RESUBMISSION_WILLRESUB,; break; - case : *out = EDG_WLL_RESUBMISSION_WONTRESUB,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToDoneStatusCode(enum in, edg_wll_DoneStatus_code *out) -{ - switch ( in ) { - case : *out = EDG_WLL_DONE_UNDEFINED,; break; - case : *out = EDG_WLL_DONE_OK,; break; - case : *out = EDG_WLL_DONE_FAILED,; break; - case : *out = EDG_WLL_DONE_CANCELLED,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToCancelStatusCode(enum in, edg_wll_CancelStatus_code *out) -{ - switch ( in ) { - case : *out = EDG_WLL_CANCEL_UNDEFINED,; break; - case : *out = EDG_WLL_CANCEL_REQ,; break; - case : *out = EDG_WLL_CANCEL_REFUSE,; break; - case : *out = EDG_WLL_CANCEL_DONE,; break; - case : *out = EDG_WLL_CANCEL_ABORT,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToClearReason(enum in, edg_wll_ClearReason *out) -{ - switch ( in ) { - case : *out = EDG_WLL_CLEAR_UNDEFINED,; break; - case : *out = EDG_WLL_CLEAR_USER,; break; - case : *out = EDG_WLL_CLEAR_TIMEOUT,; break; - case : *out = EDG_WLL_CLEAR_NOOUTPUT,; break; - default: assert(0); break; - } -} - -static void edg_wll_SoapToRegJobJobtype(enum in, edg_wll_RegJobJobtype *out) -{ - switch ( in ) { - case : *out = EDG_WLL_REGJOB_UNDEFINED,; break; - case : *out = EDG_WLL_REGJOB_SIMPLE,; break; - case : *out = EDG_WLL_REGJOB_DAG,; break; - case : *out = EDG_WLL_REGJOB_PARTITIONABLE,; break; - case : *out = EDG_WLL_REGJOB_PARTITIONED,; break; - default: assert(0); break; - } -} - -*/ - - - static void edg_wll_SourceToSoap(edg_wll_Source in, enum lbt__eventSource *out) { assert(EDG_WLL_SOURCE_APPLICATION + 1 == EDG_WLL_SOURCE__LAST); @@ -938,110 +870,6 @@ static void edg_wll_SourceToSoap(edg_wll_Source in, enum lbt__eventSource *out) } -/* -static void edg_wll_TransferResultToSoap(edg_wll_TransferResult in, enum *out) -{ - switch ( in ) { - case EDG_WLL_TRANSFER_UNDEFINED,: *out = ; break; - case EDG_WLL_TRANSFER_START,: *out = ; break; - case EDG_WLL_TRANSFER_OK,: *out = ; break; - case EDG_WLL_TRANSFER_REFUSED,: *out = ; break; - case EDG_WLL_TRANSFER_FAIL,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_EnQueuedResultToSoap(edg_wll_EnQueuedResult in, enum *out) -{ - switch ( in ) { - case EDG_WLL_ENQUEUED_UNDEFINED,: *out = ; break; - case EDG_WLL_ENQUEUED_START,: *out = ; break; - case EDG_WLL_ENQUEUED_OK,: *out = ; break; - case EDG_WLL_ENQUEUED_REFUSED,: *out = ; break; - case EDG_WLL_ENQUEUED_FAIL,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_HelperCallSrcRoleToSoap(edg_wll_HelperCallSrc_role in, enum *out) -{ - switch ( in ) { - case EDG_WLL_HELPERCALL_UNDEFINED,: *out = ; break; - case EDG_WLL_HELPERCALL_CALLING,: *out = ; break; - case EDG_WLL_HELPERCALL_CALLED,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_HelperReturnSrcRoleToSoap(edg_wll_HelperReturnSrc_role in, enum *out) -{ - switch ( in ) { - case EDG_WLL_HELPERRETURN_UNDEFINED,: *out = ; break; - case EDG_WLL_HELPERRETURN_CALLING,: *out = ; break; - case EDG_WLL_HELPERRETURN_CALLED,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_ResubmissionResultToSoap(edg_wll_ResubmissionResult in, enum *out) -{ - switch ( in ) { - case EDG_WLL_RESUBMISSION_UNDEFINED,: *out = ; break; - case EDG_WLL_RESUBMISSION_WILLRESUB,: *out = ; break; - case EDG_WLL_RESUBMISSION_WONTRESUB,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_DoneStatusCodeToSoap(edg_wll_DoneStatus_code in, enum *out) -{ - switch ( in ) { - case EDG_WLL_DONE_UNDEFINED,: *out = ; break; - case EDG_WLL_DONE_OK,: *out = ; break; - case EDG_WLL_DONE_FAILED,: *out = ; break; - case EDG_WLL_DONE_CANCELLED,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_CancelStatusCodeToSoap(edg_wll_CancelStatus_code in, enum *out) -{ - switch ( in ) { - case EDG_WLL_CANCEL_UNDEFINED,: *out = ; break; - case EDG_WLL_CANCEL_REQ,: *out = ; break; - case EDG_WLL_CANCEL_REFUSE,: *out = ; break; - case EDG_WLL_CANCEL_DONE,: *out = ; break; - case EDG_WLL_CANCEL_ABORT,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_ClearReasonToSoap(edg_wll_ClearReason in, enum *out) -{ - switch ( in ) { - case EDG_WLL_CLEAR_UNDEFINED,: *out = ; break; - case EDG_WLL_CLEAR_USER,: *out = ; break; - case EDG_WLL_CLEAR_TIMEOUT,: *out = ; break; - case EDG_WLL_CLEAR_NOOUTPUT,: *out = ; break; - default: assert(0); break; - } -} - -static void edg_wll_RegJobtypeToSoap(edg_wll_RegJobJobtype in, enum *out) -{ - switch ( in ) { - case EDG_WLL_REGJOB_UNDEFINED,: *out = ; break; - case EDG_WLL_REGJOB_SIMPLE,: *out = ; break; - case EDG_WLL_REGJOB_DAG,: *out = ; break; - case EDG_WLL_REGJOB_PARTITIONABLE,: *out = ; break; - case EDG_WLL_REGJOB_PARTITIONED,: *out = ; break; - default: assert(0); break; - } -} - - -*/ - /** * TODO: not tested * Translate event structure to Soap event. @@ -1079,7 +907,7 @@ gen qq { my ($f); $f = selectField $event $_; - eventFieldAssign("event", "(*sevent)", $e, $f); + eventFieldAssign("\t\t\t", "event", "(*sevent)", $e, $f, 1); } gen "\n"; @@ -1089,7 +917,7 @@ gen qq { my ($f); $f = selectField $event $_; - eventFieldAssign("event", "(*sevent)", $e, $f); + eventFieldAssign("\t\t\t", "event", "(*sevent)", $e, $f, 0); } gen qq { ! break; @@ -1127,7 +955,7 @@ void edg_wll_FreeSoapEvent(struct soap *soap, struct lbt__event *sevent) { my ($f); $f = selectField $event $_; - eventFieldFree("sevent", $e, $f); + eventFieldFree("\t\t", "sevent", $e, $f); } selectType $event $e; @@ -1135,7 +963,7 @@ void edg_wll_FreeSoapEvent(struct soap *soap, struct lbt__event *sevent) { my ($f); $f = selectField $event $_; - eventFieldFree("sevent", $e, $f); + eventFieldFree("\t\t", "sevent", $e, $f); } gen qq "\t\tsoap_dealloc(soap, sevent->$soap_en);\n"; gen qq "\t}\n"; @@ -1250,15 +1078,14 @@ static int edg_wll_SoapToEvent( if ($f->{optional}) { gen "\t\t\tout->$act.$fn = *in->$name->$usuc;\n"; } -# XXX: comment out when tranform functions ready... -# elsif ($f->{codes}) { -# if ($type eq '_common_') { -# gen "\t\t\tedg_wll_SoapTo$fuc(in->$name->$usuc,&(out->$act.$fn));\n"; -# } -# else { -# gen "\t\t\tedg_wll_SoapTo$name$fuc(in->$name->$usuc,&(out->$act.$fn));\n"; -# } -# } + elsif ($f->{codes}) { + if ($type eq '_common_') { + gen "\t\t\tedg_wll_SoapTo$fuc(in->$name->$usuc,&(out->$act.$fn));\n"; + } + else { + gen "\t\t\tedg_wll_SoapTo$name$fuc(in->$name->$usuc,&(out->$act.$fn));\n"; + } + } else { gen "\t\t\tout->$act.$fn = in->$name->$usuc;\n"; } -- 1.8.2.3