From f760dce745948f65d00a557cd1cbc03a9d35200f Mon Sep 17 00:00:00 2001 From: jedmondson Date: Mon, 21 Mar 2011 11:25:22 +0000 Subject: Mon Mar 21 11:07:19 UTC 2011 James Edmondson - Applied formatting for 80 columns where possible - Added DANCE_TRACE to all functions so we have the option to turn them off and on. - Applied macros from dance\Logger\Log_Macros.h to replace numbers with appropriate log levels * tools/Artifact_Installation/Artifact_Installation_exec.cpp * tools/Artifact_Installation/Artifact_Installation_Impl.cpp * tools/Artifact_Installation/Installation_Repository_Manager.cpp * tools/Config_Handlers/ADD_Handler.cpp * tools/Config_Handlers/Any_Handler.cpp * tools/Config_Handlers/CPD_Handler.cpp * tools/Config_Handlers/DataType_Handler.cpp * tools/Config_Handlers/DnC_Dump.cpp * tools/Config_Handlers/DnC_Dump_T.cpp * tools/Config_Handlers/DP_Handler.cpp * tools/Config_Handlers/Dump_Obj.cpp * tools/Config_Handlers/DynAny_Handler/DataType_Handler.cpp * tools/Config_Handlers/DynAny_Handler/DynAlias_Handler.cpp * tools/Config_Handlers/DynAny_Handler/DynAny_Handler.cpp * tools/Config_Handlers/DynAny_Handler/DynEnum_Handler.cpp * tools/Config_Handlers/DynAny_Handler/DynSequence_Handler.cpp * tools/Config_Handlers/DynAny_Handler/DynStruct_Handler.cpp * tools/Config_Handlers/IDD_Handler.cpp * tools/Config_Handlers/MDD_Handler.cpp * tools/Config_Handlers/Package_Handlers/CAD_Handler.cpp * tools/Config_Handlers/Package_Handlers/CID_Handler.cpp * tools/Config_Handlers/Package_Handlers/CPD_Handler.cpp * tools/Config_Handlers/Package_Handlers/SID_Handler.cpp * tools/Config_Handlers/PSPE_Handler.cpp * tools/Config_Handlers/SatisfierProperty_Handler.cpp * tools/Config_Handlers/XML_File_Intf.cpp * tools/Convert_Plan/Convert_Plan.cpp * tools/Convert_Plan/Convert_Plan_Impl.cpp * tools/Split_Plan/Locality_Splitter.cpp * tools/Split_Plan/Split_Plan.cpp * tools/Split_Plan/Split_Plan_exec.cpp * tools/System_Health/Daemon/SHS_Daemon.cpp * tools/System_Health/Daemon/SHS_Daemon_Impl.cpp * tools/System_Health/Interceptors/SHS_CORBA_Transport.cpp --- DAnCE/tools/Config_Handlers/DnC_Dump.cpp | 498 ++++++++++++++++++++++--------- 1 file changed, 362 insertions(+), 136 deletions(-) (limited to 'DAnCE/tools/Config_Handlers/DnC_Dump.cpp') diff --git a/DAnCE/tools/Config_Handlers/DnC_Dump.cpp b/DAnCE/tools/Config_Handlers/DnC_Dump.cpp index add026aeedd..9735583e2c7 100644 --- a/DAnCE/tools/Config_Handlers/DnC_Dump.cpp +++ b/DAnCE/tools/Config_Handlers/DnC_Dump.cpp @@ -7,12 +7,22 @@ #include "DnC_Dump_T.h" #include +// James Edmondson note: +// All of the dumps in this file had log levels of 1, which in our Log_Macros +// indicates a terminal error. Ideally, I would think these should take +// a parameter to indicate the log level to assume, rather than assuming +// the worst. Although dumps tend to happen when a fatal error has +// occurred, it can also be a debugging tool. Not sure if I agree with +// them being terminal error prints, but perhaps this is something +// we can discuss + using namespace ::Deployment::DnC_Dump_T; namespace Deployment { void DnC_Dump::dump (const char* caption, const ::CORBA::StringSeq &str_seq) { + DANCE_TRACE("DnC_Dump::dump"); CORBA::ULong size = str_seq.length (); if (size != 0) @@ -21,9 +31,9 @@ namespace Deployment for (CORBA::ULong i = 0; i < size; ++i) { - DANCE_DEBUG (1, (LM_DEBUG, "%s%s %d:\n", + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "%s%s %d:\n", Dump_Obj::indent(), caption, i)); - DANCE_DEBUG (1, (LM_DEBUG, "%s %s:\n", + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "%s %s:\n", Dump_Obj::indent(), str_seq[i].in ())); } } @@ -32,15 +42,19 @@ namespace Deployment // Dumps a string void DnC_Dump::dump (const char* caption, const TAO::String_Manager& str) { - DANCE_DEBUG (1, (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), - caption, str.in())); + DANCE_TRACE("DnC_Dump::dump"); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), + caption, str.in())); } // Dumps a boolean void DnC_Dump::dump (const char* caption, const CORBA::Boolean& val) { - DANCE_DEBUG (1, (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), - caption, val ? "true" : "false")); + DANCE_TRACE("DnC_Dump::dump"); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%s%s: %s\n", Dump_Obj::indent(), + caption, val ? "true" : "false")); } /* @@ -50,26 +64,43 @@ namespace Deployment // SatisfierProperty void DnC_Dump::dump (const Deployment::SatisfierProperty& sp) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("SatisfierProperty"); dump ("name", sp.name); - DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%skind: ", Dump_Obj::indent())); + switch (sp.kind) { - case Quantity: DANCE_DEBUG (1, (LM_DEBUG, "Quantity\n")); break; - case Capacity: DANCE_DEBUG (1, (LM_DEBUG, "Capacity\n")); break; - case Minimum: DANCE_DEBUG (1, (LM_DEBUG, "Minimum\n")); break; - case Maximum: DANCE_DEBUG (1, (LM_DEBUG, "Maximum\n")); break; - case Attribute: DANCE_DEBUG (1, (LM_DEBUG, "Attribute\n")); break; - case Selection: DANCE_DEBUG (1, (LM_DEBUG, "Selection\n")); break; + case Quantity: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Quantity\n")); + break; + case Capacity: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Capacity\n")); + break; + case Minimum: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Minimum\n")); + break; + case Maximum: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Maximum\n")); + break; + case Attribute: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Attribute\n")); + break; + case Selection: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "Selection\n")); + break; } - DANCE_DEBUG (1, (LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); dump (sp.value); } // SharedResource void DnC_Dump::dump (const Deployment::SharedResource& sr) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("SharedResource"); dump ("name", sr.name); dump ("resourceType", sr.resourceType); @@ -86,6 +117,7 @@ namespace Deployment // Resource void DnC_Dump::dump (const Deployment::Resource& resource) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("Resource"); dump ("name", resource.name); dump ("resourceType", resource.resourceType); @@ -96,6 +128,7 @@ namespace Deployment // Node void DnC_Dump::dump (const Deployment::Node& node) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("Node"); dump ("name", node.name); dump ("label", node.label); @@ -124,6 +157,7 @@ namespace Deployment // Interconnect void DnC_Dump::dump (const Deployment::Interconnect& conn) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("Interconnect"); dump ("name", conn.name); dump ("label", conn.label); @@ -150,6 +184,7 @@ namespace Deployment void DnC_Dump::dump (const Deployment::Bridge& bridge) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("Bridge"); dump ("name", bridge.name); dump ("label", bridge.label); @@ -167,6 +202,7 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::Domain &domain) { + DANCE_TRACE("DnC_Dump::dump"); CORBA::Any val; val <<= domain; @@ -196,6 +232,7 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::ComponentPortDescription &compportdesc) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("ComponentPortDescription"); dump ("name", compportdesc.name); @@ -206,15 +243,37 @@ namespace Deployment dump ("exclusiveUser", compportdesc.exclusiveUser); dump ("optional", compportdesc.optional); - DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%skind: ", Dump_Obj::indent())); switch (compportdesc.kind) { - case Facet: DANCE_DEBUG (1, (LM_DEBUG, "Facet\n")); break; - case SimplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "SimplexReceptacle\n")); break; - case MultiplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "MultiplexReceptacle\n")); break; - case EventEmitter: DANCE_DEBUG (1, (LM_DEBUG, "EventEmitter\n")); break; - case EventPublisher: DANCE_DEBUG (1, (LM_DEBUG, "EventPublisher\n")); break; - case EventConsumer: DANCE_DEBUG (1, (LM_DEBUG, "EventConsumer\n")); break; - default: DANCE_DEBUG (1, (LM_DEBUG, "Unknown port kind\n")); break; + case Facet: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Facet\n")); + break; + case SimplexReceptacle: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "SimplexReceptacle\n")); + break; + case MultiplexReceptacle: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "MultiplexReceptacle\n")); + break; + case EventEmitter: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventEmitter\n")); + break; + case EventPublisher: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventPublisher\n")); + break; + case EventConsumer: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventConsumer\n")); + break; + default: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Unknown port kind\n")); + break; } } @@ -222,49 +281,125 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::ComponentPropertyDescription &comppropdesc) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("ComponentPropertyDescription"); dump ("name", comppropdesc.name); - DANCE_DEBUG (1, (LM_DEBUG, "%stype: ", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%stype: ", Dump_Obj::indent())); switch (comppropdesc.type.in()->kind()) { - case ::CORBA::tk_null: DANCE_DEBUG (1, (LM_DEBUG, "tk_null\n")); break; - case ::CORBA::tk_void: DANCE_DEBUG (1, (LM_DEBUG, "tk_void\n")); break; - case ::CORBA::tk_short: DANCE_DEBUG (1, (LM_DEBUG, "tk_short\n")); break; - case ::CORBA::tk_long: DANCE_DEBUG (1, (LM_DEBUG, "tk_long\n")); break; - case ::CORBA::tk_ushort: DANCE_DEBUG (1, (LM_DEBUG, "tk_ushort\n")); break; - case ::CORBA::tk_ulong: DANCE_DEBUG (1, (LM_DEBUG, "tk_ulong\n")); break; - case ::CORBA::tk_float: DANCE_DEBUG (1, (LM_DEBUG, "tk_float\n")); break; - case ::CORBA::tk_double: DANCE_DEBUG (1, (LM_DEBUG, "tk_double\n")); break; - case ::CORBA::tk_boolean: DANCE_DEBUG (1, (LM_DEBUG, "tk_boolean\n")); break; - case ::CORBA::tk_char: DANCE_DEBUG (1, (LM_DEBUG, "tk_char\n")); break; - case ::CORBA::tk_octet: DANCE_DEBUG (1, (LM_DEBUG, "tk_octet\n")); break; - case ::CORBA::tk_any: DANCE_DEBUG (1, (LM_DEBUG, "tk_any\n")); break; - case ::CORBA::tk_TypeCode: DANCE_DEBUG (1, (LM_DEBUG, "tk_TypeCode\n")); break; - case ::CORBA::tk_Principal: DANCE_DEBUG (1, (LM_DEBUG, "tk_Principal\n")); break; - case ::CORBA::tk_objref: DANCE_DEBUG (1, (LM_DEBUG, "tk_objref\n")); break; - case ::CORBA::tk_struct: DANCE_DEBUG (1, (LM_DEBUG, "tk_struct\n")); break; - case ::CORBA::tk_union: DANCE_DEBUG (1, (LM_DEBUG, "tk_union\n")); break; - case ::CORBA::tk_enum: DANCE_DEBUG (1, (LM_DEBUG, "tk_enum\n")); break; - case ::CORBA::tk_string: DANCE_DEBUG (1, (LM_DEBUG, "tk_string\n")); break; - case ::CORBA::tk_sequence: DANCE_DEBUG (1, (LM_DEBUG, "tk_sequence\n")); break; - case ::CORBA::tk_array: DANCE_DEBUG (1, (LM_DEBUG, "tk_array\n")); break; - case ::CORBA::tk_alias: DANCE_DEBUG (1, (LM_DEBUG, "tk_alias\n")); break; - case ::CORBA::tk_except: DANCE_DEBUG (1, (LM_DEBUG, "tk_except\n")); break; - case ::CORBA::tk_longlong: DANCE_DEBUG (1, (LM_DEBUG, "tk_longlong\n")); break; - case ::CORBA::tk_ulonglong: DANCE_DEBUG (1, (LM_DEBUG, "tk_ulonglong\n")); break; - case ::CORBA::tk_longdouble: DANCE_DEBUG (1, (LM_DEBUG, "tk_longdouble\n")); break; - case ::CORBA::tk_wchar: DANCE_DEBUG (1, (LM_DEBUG, "tk_wchar\n")); break; - case ::CORBA::tk_wstring: DANCE_DEBUG (1, (LM_DEBUG, "tk_wstring\n")); break; - case ::CORBA::tk_fixed: DANCE_DEBUG (1, (LM_DEBUG, "tk_fixed\n")); break; - case ::CORBA::tk_value: DANCE_DEBUG (1, (LM_DEBUG, "tk_value\n")); break; - case ::CORBA::tk_value_box: DANCE_DEBUG (1, (LM_DEBUG, "tk_value_box\n")); break; - case ::CORBA::tk_native: DANCE_DEBUG (1, (LM_DEBUG, "tk_native\n")); break; - case ::CORBA::tk_abstract_interface: DANCE_DEBUG (1, (LM_DEBUG, "tk_abstract_interface\n")); break; - case ::CORBA::tk_local_interface: DANCE_DEBUG (1, (LM_DEBUG, "tk_local_interface\n")); break; - case ::CORBA::tk_component: DANCE_DEBUG (1, (LM_DEBUG, "tk_component\n")); break; - case ::CORBA::tk_home: DANCE_DEBUG (1, (LM_DEBUG, "tk_home\n")); break; - case ::CORBA::tk_event: DANCE_DEBUG (1, (LM_DEBUG, "tk_event\n")); break; + case ::CORBA::tk_null: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_null\n")); + break; + case ::CORBA::tk_void: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_void\n")); + break; + case ::CORBA::tk_short: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_short\n")); + break; + case ::CORBA::tk_long: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_long\n")); + break; + case ::CORBA::tk_ushort: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ushort\n")); + break; + case ::CORBA::tk_ulong: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ulong\n")); + break; + case ::CORBA::tk_float: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_float\n")); + break; + case ::CORBA::tk_double: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_double\n")); + break; + case ::CORBA::tk_boolean: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_boolean\n")); + break; + case ::CORBA::tk_char: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_char\n")); + break; + case ::CORBA::tk_octet: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_octet\n")); + break; + case ::CORBA::tk_any: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_any\n")); + break; + case ::CORBA::tk_TypeCode: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_TypeCode\n")); + break; + case ::CORBA::tk_Principal: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_Principal\n")); + break; + case ::CORBA::tk_objref: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_objref\n")); + break; + case ::CORBA::tk_struct: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_struct\n")); + break; + case ::CORBA::tk_union: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_union\n")); + break; + case ::CORBA::tk_enum: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_enum\n")); + break; + case ::CORBA::tk_string: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_string\n")); + break; + case ::CORBA::tk_sequence: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_sequence\n")); + break; + case ::CORBA::tk_array: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_array\n")); + break; + case ::CORBA::tk_alias: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_alias\n")); + break; + case ::CORBA::tk_except: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_except\n")); + break; + case ::CORBA::tk_longlong: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_longlong\n")); + break; + case ::CORBA::tk_ulonglong: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_ulonglong\n")); + break; + case ::CORBA::tk_longdouble: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_longdouble\n")); + break; + case ::CORBA::tk_wchar: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_wchar\n")); + break; + case ::CORBA::tk_wstring: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_wstring\n")); + break; + case ::CORBA::tk_fixed: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_fixed\n")); + break; + case ::CORBA::tk_value: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_value\n")); + break; + case ::CORBA::tk_value_box: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_value_box\n")); + break; + case ::CORBA::tk_native: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_native\n")); + break; + case ::CORBA::tk_abstract_interface: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_abstract_interface\n")); + break; + case ::CORBA::tk_local_interface: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_local_interface\n")); + break; + case ::CORBA::tk_component: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_component\n")); + break; + case ::CORBA::tk_home: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_home\n")); + break; + case ::CORBA::tk_event: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "tk_event\n")); + break; default: break; }; @@ -274,6 +409,7 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::ComponentInterfaceDescription &cid) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("ComponentInterfaceDescription"); dump ("label", cid.label); dump ("UUID", cid.UUID); @@ -290,6 +426,7 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::Requirement &req) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("Requirement"); dump ("resourceType", req.resourceType); @@ -301,6 +438,7 @@ namespace Deployment void DnC_Dump::dump(const Deployment::MonolithicDeploymentDescription &mdd) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("MonolithicDeploymentDescription"); dump ("name", mdd.name); @@ -319,26 +457,46 @@ namespace Deployment void DnC_Dump::dump(const Deployment::ResourceUsageKind &ruk) { - DANCE_DEBUG (1, (LM_DEBUG, "%sresourceUsage: ", Dump_Obj::indent())); + DANCE_TRACE("DnC_Dump::dump"); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sresourceUsage: ", Dump_Obj::indent())); switch (ruk) { - case None: DANCE_DEBUG (1, (LM_DEBUG, "None\n")); break; - case InstanceUsesResource: DANCE_DEBUG (1, (LM_DEBUG, "InstanceUsesResource\n")); break; - case ResourceUsesInstance: DANCE_DEBUG (1, (LM_DEBUG, "ResourceUsesInstance\n")); break; - case PortUsesResource: DANCE_DEBUG (1, (LM_DEBUG, "PortUsesResource\n")); break; - case ResourceUsesPort: DANCE_DEBUG (1, (LM_DEBUG, "ResourceUsesPort\n")); break; + case None: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "None\n")); + break; + case InstanceUsesResource: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "InstanceUsesResource\n")); + break; + case ResourceUsesInstance: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "ResourceUsesInstance\n")); + break; + case PortUsesResource: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "PortUsesResource\n")); + break; + case ResourceUsesPort: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "ResourceUsesPort\n")); + break; } } // InstanceResourceDeploymentDescription - void DnC_Dump::dump(const Deployment::InstanceResourceDeploymentDescription &irdd) + void DnC_Dump::dump( + const Deployment::InstanceResourceDeploymentDescription &irdd) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("InstanceResourceDeploymentDescription"); dump (irdd.resourceUsage); dump ("requirementName", irdd.requirementName); dump ("resourceName", irdd.resourceName); - DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, + "%sresourceValue:\n", Dump_Obj::indent())); dump_sequence ("property", irdd.property); } @@ -346,6 +504,7 @@ namespace Deployment void DnC_Dump::dump(const Deployment::InstanceDeploymentDescription &idd) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("InstanceDeploymentDescription"); dump ("name", idd.name); @@ -367,6 +526,7 @@ namespace Deployment void DnC_Dump::dump (const ::Deployment::ComponentExternalPortEndpoint &cepe) { + DANCE_TRACE("DnC_Dump::dump"); Dump_Obj dump_obj("ComponentExternalPortEndpoint"); dump ("portName", cepe.portName); @@ -380,15 +540,37 @@ namespace Deployment dump ("portName", pspe.portName); dump ("provider", pspe.provider); - DANCE_DEBUG (1, (LM_DEBUG, "%skind: ", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%skind: ", Dump_Obj::indent())); switch (pspe.kind) { - case Facet: DANCE_DEBUG (1, (LM_DEBUG, "Facet\n")); break; - case SimplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "SimplexReceptacle\n")); break; - case MultiplexReceptacle: DANCE_DEBUG (1, (LM_DEBUG, "MultiplexReceptacle\n")); break; - case EventEmitter: DANCE_DEBUG (1, (LM_DEBUG, "EventEmitter\n")); break; - case EventPublisher: DANCE_DEBUG (1, (LM_DEBUG, "EventPublisher\n")); break; - case EventConsumer: DANCE_DEBUG (1, (LM_DEBUG, "EventConsumer\n")); break; - default: DANCE_DEBUG (1, (LM_DEBUG, "Unknown port kind\n")); break; + case Facet: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Facet\n")); + break; + case SimplexReceptacle: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "SimplexReceptacle\n")); + break; + case MultiplexReceptacle: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "MultiplexReceptacle\n")); + break; + case EventEmitter: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventEmitter\n")); + break; + case EventPublisher: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventPublisher\n")); + break; + case EventConsumer: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "EventConsumer\n")); + break; + default: + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Unknown port kind\n")); + break; } #if (_MSC_VER) dump_ref ("instanceRef", pspe.instanceRef, @@ -415,7 +597,8 @@ namespace Deployment dump ("targetName", crdd.targetName); dump ("requirementName", crdd.requirementName); dump ("resourceName", crdd.resourceName); - DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); dump_sequence ("properties", crdd.property); } @@ -478,7 +661,8 @@ namespace Deployment dump ("requirementName", rdd.requirementName); dump ("resourceName", rdd.resourceName); - DANCE_DEBUG (1, (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sresourceValue:\n", Dump_Obj::indent())); dump_sequence ("properties", rdd.property); } @@ -530,7 +714,8 @@ namespace Deployment // SubcomponentInstantiationDescription - void DnC_Dump::dump (const ::Deployment::SubcomponentInstantiationDescription &sid) + void DnC_Dump::dump ( + const ::Deployment::SubcomponentInstantiationDescription &sid) { Dump_Obj dump_obj("SubcomponentInstantiationDescription"); @@ -555,8 +740,9 @@ namespace Deployment a >>= v; - DANCE_DEBUG (1, (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), - v->instance[value].name.in ())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), + v->instance[value].name.in ())); } // AssemblyConnectionDescription @@ -588,8 +774,9 @@ namespace Deployment a >>= v; - DANCE_DEBUG (1, (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), - v->instance[value].name.in ())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sinstance: %s\n", Dump_Obj::indent (), + v->instance[value].name.in ())); } void @@ -619,7 +806,8 @@ namespace Deployment // ImplementationArtifactDescription - void DnC_Dump::dump (const ::Deployment::ImplementationArtifactDescription &iad) + void DnC_Dump::dump ( + const ::Deployment::ImplementationArtifactDescription &iad) { Dump_Obj dump_obj("ImplementationArtifactDescription"); @@ -682,13 +870,14 @@ namespace Deployment // ComponentImplementationDescription void DnC_Dump::dump ( - const ::Deployment::ComponentImplementationDescription &cid) + const ::Deployment::ComponentImplementationDescription &cid) { Dump_Obj dump_obj("ComponentImplementationDescription"); dump ("label", cid.label); dump ("UUID", cid.UUID); - DANCE_DEBUG (1, (LM_DEBUG, "%sImplements:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sImplements:\n", Dump_Obj::indent())); dump (cid.implements); dump_sequence ("assemblyImpl", cid.assemblyImpl); dump_sequence ("monolithicImpl", cid.monolithicImpl); @@ -700,12 +889,13 @@ namespace Deployment // PackagedComponentImplementation - void DnC_Dump::dump (const ::Deployment::PackagedComponentImplementation &pci) + void DnC_Dump::dump ( + const ::Deployment::PackagedComponentImplementation &pci) { Dump_Obj dump_obj("PackagedComponentImplementation"); dump ("Name", pci.name); - DANCE_DEBUG (1, (LM_DEBUG, + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, "%sreferencedImplementation:\n", Dump_Obj::indent())); DnC_Dump::dump (pci.referencedImplementation); } @@ -719,7 +909,8 @@ namespace Deployment dump ("label", comppkgdesc.label); dump ("UUID", comppkgdesc.UUID); - DANCE_DEBUG (1, (LM_DEBUG, "%srealizes:\n", Dump_Obj::indent ())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%srealizes:\n", Dump_Obj::indent ())); DnC_Dump::dump (comppkgdesc.realizes); // ComponentInterfaceDescription dump_sequence ("configProperty", comppkgdesc.configProperty); dump_sequence ("implementation", comppkgdesc.implementation); @@ -746,7 +937,8 @@ namespace Deployment { Dump_Obj dump_obj("Property"); dump ("name", property.name); - DANCE_DEBUG (1, (LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%svalue:\n", Dump_Obj::indent())); dump (property.value); } @@ -762,33 +954,39 @@ namespace Deployment CORBA::Short temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC_Dump::dump (CORBA::Any), expected short\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC_Dump::dump (CORBA::Any), expected short\ encoded different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); } break; case CORBA::tk_null: - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: null value encoded\n", - Dump_Obj::indent ())); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: null value encoded\n", + Dump_Obj::indent ())); break; case CORBA::tk_void: - DANCE_DEBUG (1, (LM_DEBUG, "Any value: void type encoded\n")); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Any value: void type encoded\n")); break; case CORBA::tk_long: { CORBA::Long temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected long\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected long\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), temp)); } break; @@ -798,12 +996,14 @@ encoded with different type")); CORBA::UShort temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected u short\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected u short\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), + temp)); } break; @@ -812,11 +1012,13 @@ encoded with different type")); CORBA::ULong temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected ulong\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected ulong\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %u\n", Dump_Obj::indent (), temp)); } break; @@ -826,12 +1028,14 @@ encoded with different type")); CORBA::Float temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected float\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected float\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), + temp)); } break; case CORBA::tk_double: @@ -839,12 +1043,14 @@ encoded with different type")); CORBA::Double temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected double\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected double\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %f\n", Dump_Obj::indent (), + temp)); } break; case CORBA::tk_boolean: @@ -852,15 +1058,18 @@ encoded with different type")); CORBA::Boolean temp; if (! (any >>= CORBA::Any::to_boolean (temp))) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected bool\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected bool\ encoded with different type")); throw CORBA::INTERNAL (); } if (temp) - DANCE_DEBUG (1, (LM_DEBUG, "Any value: True\n")); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Any value: True\n")); else - DANCE_DEBUG (1, (LM_DEBUG, "Any value: False\n")); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Any value: False\n")); } break; @@ -869,12 +1078,14 @@ encoded with different type")); CORBA::Char temp; if (! (any >>= CORBA::Any::to_char (temp))) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected char\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected char\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), + temp)); } break; @@ -883,12 +1094,14 @@ encoded with different type")); CORBA::Octet temp; if (! (any >>= CORBA::Any::to_octet (temp))) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected octet\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected octet\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, + "%sAny value: %d\n", Dump_Obj::indent (), + temp)); } break; @@ -897,12 +1110,14 @@ encoded with different type")); const char * temp = 0; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected string\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected string\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (), + temp)); } break; case CORBA::tk_longlong: @@ -910,12 +1125,14 @@ encoded with different type")); CORBA::LongLong temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected longlong\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected longlong\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %l\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %l\n", Dump_Obj::indent (), + temp)); } break; @@ -924,12 +1141,14 @@ encoded with different type")); CORBA::LongDouble temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected longdouble\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected longdouble\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %d\n", Dump_Obj::indent (), + temp)); } break; @@ -938,12 +1157,14 @@ encoded with different type")); CORBA::WChar temp; if (! (any >>= CORBA::Any::to_wchar (temp))) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected wchar\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected wchar\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: %c\n", Dump_Obj::indent (), + temp)); } break; @@ -952,12 +1173,14 @@ encoded with different type")); const CORBA::WChar * temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected wstring\ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "DnC::dump (CORBA::Any) expected wstring\ encoded with different type")); throw CORBA::INTERNAL (); } - DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: %s\n", Dump_Obj::indent (), - temp)); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, + "%sAny value: %s\n", Dump_Obj::indent (), + temp)); } break; @@ -966,16 +1189,19 @@ encoded with different type")); /* CORBA::Enum temp; if (! (any >>= temp)) { - DANCE_DEBUG (1, (LM_DEBUG, "DnC::dump (CORBA::Any) expected enum \ + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, (LM_DEBUG, + "DnC::dump (CORBA::Any) expected enum \ encoded with different type")); throw CORBA::INTERNAL (); } -*/ DANCE_DEBUG (1, (LM_DEBUG, "%sAny value: some enum\n", Dump_Obj::indent ())); +*/ DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "%sAny value: some enum\n", Dump_Obj::indent ())); } break; default: - DANCE_DEBUG (1, (LM_DEBUG, "Unknown type encoded in Any\n")); + DANCE_DEBUG (DANCE_LOG_TERMINAL_ERROR, + (LM_DEBUG, "Unknown type encoded in Any\n")); throw CORBA::INTERNAL (); } } -- cgit v1.2.1