diff options
Diffstat (limited to 'modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp')
| -rw-r--r-- | modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp | 390 |
1 files changed, 390 insertions, 0 deletions
diff --git a/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp new file mode 100644 index 00000000000..d5e39d485da --- /dev/null +++ b/modules/CIAO/tools/Config_Handlers/Package_Handlers/CID_Handler.cpp @@ -0,0 +1,390 @@ +// $Id$ +#include "tao/AnyTypeCode/AnyTypeCode_methods.h" +#include "Package_Handlers/CID_Handler.h" +#include "Package_Handlers/CPD_Handler.h" +#include "Package_Handlers/IAD_Handler.h" +#include "Package_Handlers/CAD_Handler.h" +#include "Package_Handlers/Comp_Intf_Descr_Handler.h" +#include "Package_Handlers/NIA_Handler.h" +#include "SatisfierProperty_Handler.h" +#include "Req_Handler.h" + +#include "Basic_Deployment_Data.hpp" +#include "ciao/Deployment_DataC.h" +#include "Utils/XML_Helper.h" +#include "Utils/Exceptions.h" + +#include "Deployment.hpp" +#include "Property_Handler.h" + + +namespace CIAO +{ + namespace Config_Handlers + { + namespace Packaging + { + + IDREF_Base<CORBA::ULong> CID_Handler::IDREF; + + struct Capability_Handler + { + static void handle_capability (const Capability &desc, + ::Deployment::Capability &toconfig) + { + CIAO_TRACE ("Capability_Handler::get_capability"); + + toconfig.name = desc.name ().c_str (); + + toconfig.resourceType.length (desc.count_resourceType ()); + std::for_each (desc.begin_resourceType (), + desc.end_resourceType (), + String_Seq_Functor (toconfig.resourceType)); + + toconfig.property.length (desc.count_property ()); + std::for_each (desc.begin_property (), + desc.end_property (), + SatisfierProperty_Functor (toconfig.property)); + } + + static Capability get_capability (const ::Deployment::Capability &src) + { + CIAO_TRACE ("Capability_Handler::get_capability - reverse"); + + Capability retval (src.name.in ()); + + for (CORBA::ULong i = 0; i < src.resourceType.length (); ++i) + retval.add_resourceType (src.resourceType[i]); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (SatisfierProperty_Handler::get_sat_property (src.property[i])); + + return retval; + } + }; + + typedef Sequence_Handler < Capability, + ::Deployment::Capabilities, + ::Deployment::Capability, + Capability_Handler::handle_capability > Capability_Functor; + + struct IR_Handler + { + static void handle_ir (const ImplementationRequirement &desc, + ::Deployment::ImplementationRequirement &toconfig) + { + CIAO_TRACE ("IR_Handler::get_ir"); + + if (desc.resourceUsage_p ()) + { + switch (desc.resourceUsage ().integral ()) + { + case ResourceUsageKind::None_l: + toconfig.resourceUsage = Deployment::None; + break; + + case ResourceUsageKind::InstanceUsesResource_l: + toconfig.resourceUsage = Deployment::InstanceUsesResource; + break; + + case ResourceUsageKind::ResourceUsesInstance_l: + toconfig.resourceUsage = Deployment::ResourceUsesInstance; + break; + + case ResourceUsageKind::PortUsesResource_l: + toconfig.resourceUsage = Deployment::PortUsesResource; + break; + + case ResourceUsageKind::ResourceUsesPort_l: + toconfig.resourceUsage = Deployment::ResourceUsesPort; + break; + + default: + throw Config_Error (desc.name (), + "Unknown ResourceUsageKind."); + break; + } + } + + if (desc.resourcePort_p ()) + toconfig.resourcePort = desc.resourcePort ().c_str (); + + if (desc.componentPort_p ()) + toconfig.componentPort = desc.componentPort ().c_str (); + + toconfig.resourceType = desc.resourceType ().c_str (); + toconfig.name = desc.name ().c_str (); + + std::for_each (desc.begin_property (), + desc.end_property (), + Property_Functor (toconfig.property )); + } + + static ImplementationRequirement + get_ir (const ::Deployment::ImplementationRequirement &src) + { + CIAO_TRACE ("IR_Handler::get_ir - reverse"); + + ImplementationRequirement retval (src.resourceType.in (), + src.name.in ()); + + if (src.resourceUsage.length () == 1) + switch (src.resourceUsage[0]) + { + case Deployment::None: + retval.resourceUsage (ResourceUsageKind::None); + break; + + case Deployment::InstanceUsesResource: + retval.resourceUsage (ResourceUsageKind::InstanceUsesResource); + break; + + case Deployment::ResourceUsesInstance: + retval.resourceUsage (ResourceUsageKind::ResourceUsesInstance); + break; + + case Deployment::PortUsesResource: + retval.resourceUsage (ResourceUsageKind::PortUsesResource); + break; + + case Deployment::ResourceUsesPort: + retval.resourceUsage (ResourceUsageKind::ResourceUsesPort); + break; + + default: + throw Config_Error (src.name.in (), + "Unknown ResourceUsageKind."); + break; + } + + retval.resourcePort (src.resourcePort.in ()); + + retval.componentPort (src.componentPort.in ()); + + for (CORBA::ULong i = 0; i < src.property.length (); ++i) + retval.add_property (Property_Handler::get_property (src.property[i])); + + return retval; + } + }; + + typedef Sequence_Handler < ImplementationRequirement, + ::Deployment::ImplementationRequirements, + ::Deployment::ImplementationRequirement, + IR_Handler::handle_ir > IR_Functor; + + struct MID_Handler + { + static void handle_mid (const MonolithicImplementationDescription &desc, + ::Deployment::MonolithicImplementationDescription &toconfig) + { + CIAO_TRACE ("MID_Handler::get_mid"); + + toconfig.nodeExecParameter.length (desc.count_nodeExecParameter ()); + std::for_each (desc.begin_nodeExecParameter (), + desc.end_nodeExecParameter (), + Property_Functor (toconfig.nodeExecParameter)); + + toconfig.componentExecParameter.length (desc.count_componentExecParameter ()); + std::for_each (desc.begin_componentExecParameter (), + desc.end_componentExecParameter (), + Property_Functor (toconfig.componentExecParameter)); + + toconfig.deployRequirement.length (desc.count_deployRequirement ()); + while (0) + { + IR_Handler::handle_ir (*desc.begin_deployRequirement (), + toconfig.deployRequirement[0]); + } + std::for_each (desc.begin_deployRequirement (), + desc.end_deployRequirement (), + IR_Functor (toconfig.deployRequirement)); + + toconfig.primaryArtifact.length (desc.count_primaryArtifact ()); + SEQ_HAND_GCC_BUG_WORKAROUND (NIA_Handler::handle_nia, + desc.begin_primaryArtifact (), + toconfig.primaryArtifact); + std::for_each (desc.begin_primaryArtifact (), + desc.end_primaryArtifact (), + NIA_Functor (toconfig.primaryArtifact)); + } + + static MonolithicImplementationDescription + get_mid (const ::Deployment::MonolithicImplementationDescription &src) + { + CIAO_TRACE ("MID_Handler::get_mid - reverse"); + + MonolithicImplementationDescription retval; + + for (CORBA::ULong i = 0; i < src.nodeExecParameter.length (); ++i) + retval.add_nodeExecParameter + (Property_Handler::get_property (src.nodeExecParameter[i])); + + for (CORBA::ULong i = 0; i < src.componentExecParameter.length (); ++i) + retval.add_componentExecParameter + (Property_Handler::get_property (src.componentExecParameter[i])); + + for (CORBA::ULong i = 0; i < src.deployRequirement.length (); ++i) + retval.add_deployRequirement + (IR_Handler::get_ir (src.deployRequirement[i])); + + for (CORBA::ULong i = 0; i < src.primaryArtifact.length (); ++i) + retval.add_primaryArtifact + (NIA_Handler::get_nia (src.primaryArtifact[i])); + + return retval; + } + + }; + + typedef Sequence_Handler < MonolithicImplementationDescription, + ::Deployment::MonolithicImplementationDescriptions, + ::Deployment::MonolithicImplementationDescription, + MID_Handler::handle_mid > MID_Functor; + + + + void + CID_Handler::component_impl_descr ( + const ComponentImplementationDescription &desc, + ::Deployment::ComponentImplementationDescription &toconfig) + { + CIAO_TRACE ("CID_Handler::component_impl_descr"); + + const ComponentImplementationDescription *cid = 0; + std::auto_ptr <ComponentImplementationDescription> xsc_cid; + + if (desc.href_p ()) + { + xsc_cid.reset (CID_Handler::resolve_cid (desc.href ().c_str ())); + cid = xsc_cid.get (); + } + else + cid = &desc; + + if (cid->label_p ()) + toconfig.label = cid->label ().c_str (); + + if (cid->UUID_p ()) + toconfig.UUID = cid->UUID ().c_str (); + + if (cid->implements_p ()) + { // MAJO: We should be able to assume this exists, fix broken interpeters.. + Comp_Intf_Descr_Handler::comp_intf_descr (cid->implements (), + toconfig.implements); + } + + if (cid->assemblyImpl_p ()) + { + toconfig.assemblyImpl.length (1); + CAD_Handler::component_assem_descr (cid->assemblyImpl (), + toconfig.assemblyImpl[0]); + } + else if (cid->monolithicImpl_p ()) + { + toconfig.monolithicImpl.length (1); + MID_Handler::handle_mid (cid->monolithicImpl (), + toconfig.monolithicImpl[0]); + } + else + throw Plan_Error ("ComponentImplementationDescription must have either assemblyImpl or monolithicImpl"); + + // configProperty + toconfig.configProperty.length (cid->count_configProperty ()); + std::for_each (cid->begin_configProperty (), + cid->end_configProperty (), + Property_Functor (toconfig.configProperty)); + + // capability + toconfig.capability.length (cid->count_capability ()); + SEQ_HAND_GCC_BUG_WORKAROUND (Capability_Handler::handle_capability, + cid->begin_capability (), + toconfig.capability); + std::for_each (cid->begin_capability (), + cid->end_capability (), + Capability_Functor (toconfig.capability)); + + // dependsOn + toconfig.dependsOn.length (cid->count_dependsOn ()); + CORBA::ULong pos = 0; + for (ComponentImplementationDescription::dependsOn_const_iterator i = cid->begin_dependsOn (); + i != cid->end_dependsOn (); + ++i) + toconfig.dependsOn[pos++].requiredType = i->requiredType ().c_str (); + + // infoProperty + toconfig.infoProperty.length (cid->count_infoProperty ()); + std::for_each (cid->begin_infoProperty (), + cid->end_infoProperty (), + Property_Functor (toconfig.infoProperty)); + + } + + ComponentImplementationDescription + CID_Handler::component_impl_descr (const Deployment::ComponentImplementationDescription& src) + { + CIAO_TRACE ("CID_Handler::component_impl_descr - reverse"); + + ComponentImplementationDescription retval; + + retval.label (src.label.in ()); + retval.UUID (src.UUID.in ()); + + { + retval.implements (Comp_Intf_Descr_Handler::comp_intf_descr (src.implements)); + } + + if (src.assemblyImpl.length () == 1) + { + retval.assemblyImpl (CAD_Handler::component_assem_descr (src.assemblyImpl[0])); + } + else if (src.monolithicImpl.length () == 1) + { + retval.monolithicImpl (MID_Handler::get_mid (src.monolithicImpl[0])); + } + else + ACE_DEBUG ((LM_WARNING, "Warning: ComponentImplementationDescription lacks " + "either a required assemblyImpl or monolithicImpl, or has too many")); + + for (CORBA::ULong i = 0; i < src.configProperty.length (); ++i) + { + retval.add_configProperty ( + Property_Handler::get_property (src.configProperty[i])); + } + + for (CORBA::ULong i = 0; i < src.dependsOn.length (); ++i) + { + retval.add_dependsOn (ImplementationDependency (src.dependsOn[i].requiredType.in ())); + } + + for (CORBA::ULong i = 0; i < src.infoProperty.length (); ++i) + { + retval.add_infoProperty ( + Property_Handler::get_property (src.infoProperty[i])); + } + + return retval; + } + + ComponentImplementationDescription * + CID_Handler::resolve_cid (const char *uri) + { + CIAO_TRACE ("CID_Handler::resolve_cid"); + + xercesc::DOMDocument *dom = XML_HELPER->create_dom (uri); + + if (!dom) + throw Parse_Error ("Unable to create DOM for CID"); + + try { + return new ComponentImplementationDescription + (componentImplementationDescription (dom)); + } + catch (...) { + throw Parse_Error ("Unable to create XSC structure for CID"); + } + } + } + + } +} |