def merge_requirement_assignment(context, relationship_property_definitions,
relationship_interface_definitions,
requirement, our_requirement):
our_capability = our_requirement.capability
if our_capability is not None:
requirement._raw['capability'] = deepcopy_with_locators(our_capability)
our_node = our_requirement.node
if our_node is not None:
requirement._raw['node'] = deepcopy_with_locators(our_node)
our_node_filter = our_requirement.node_filter
if our_node_filter is not None:
requirement._raw['node_filter'] = deepcopy_with_locators(
our_node_filter._raw)
our_relationship = our_requirement.relationship # RelationshipAssignment
if our_relationship is not None:
# Make sure we have a dict
if 'relationship' not in requirement._raw:
requirement._raw['relationship'] = OrderedDict()
elif not isinstance(requirement._raw['relationship'], dict):
# Convert existing short form to long form
the_type = requirement._raw['relationship']
requirement._raw['relationship'] = OrderedDict()
requirement._raw['relationship']['type'] = deepcopy_with_locators(
the_type)
merge_requirement_assignment_relationship(
context, our_relationship, relationship_property_definitions,
relationship_interface_definitions, requirement, our_relationship)
def merge_raw_operation_definition(context, raw_operation, our_operation,
interface_name, presentation, type_name):
if not isinstance(our_operation._raw, dict):
# Convert short form to long form
raw_operation['implementation'] = deepcopy_with_locators(
our_operation._raw)
return
# Add/merge inputs
our_operation_inputs = our_operation.inputs
if our_operation_inputs:
# Make sure we have the dict
if ('inputs'
not in raw_operation) or (raw_operation.get('inputs') is None):
raw_operation['inputs'] = OrderedDict()
merge_raw_input_definitions(context, raw_operation['inputs'],
our_operation_inputs, interface_name,
our_operation._name, presentation,
type_name)
# Override the description
if our_operation._raw.get('description') is not None:
raw_operation['description'] = deepcopy_with_locators(
our_operation._raw['description'])
# Add/merge implementation
if our_operation._raw.get('implementation') is not None:
if raw_operation.get('implementation') is not None:
merge(raw_operation['implementation'],
deepcopy_with_locators(our_operation._raw['implementation']))
else:
raw_operation['implementation'] = \
deepcopy_with_locators(our_operation._raw['implementation'])
def convert_interface_definition_from_type_to_raw_template(context, presentation): # pylint: disable=invalid-name
raw = OrderedDict()
# Copy default values for inputs
interface_inputs = presentation._get_inputs(context)
if interface_inputs is not None:
raw['inputs'] = convert_parameter_definitions_to_values(context, interface_inputs)
# Copy operations
operations = presentation._get_operations(context)
if operations:
for operation_name, operation in operations.iteritems():
raw[operation_name] = OrderedDict()
description = operation.description
if description is not None:
raw[operation_name]['description'] = deepcopy_with_locators(description._raw)
implementation = operation.implementation
if implementation is not None:
raw[operation_name]['implementation'] = deepcopy_with_locators(implementation._raw)
inputs = operation.inputs
if inputs is not None:
raw[operation_name]['inputs'] = convert_parameter_definitions_to_values(context,
inputs)
return raw
def merge_requirement_assignment(context, relationship_property_definitions,
relationship_interface_definitions,
requirement, our_requirement):
our_capability = our_requirement.capability
if our_capability is not None:
requirement._raw['capability'] = deepcopy_with_locators(our_capability)
our_node = our_requirement.node
if our_node is not None:
requirement._raw['node'] = deepcopy_with_locators(our_node)
our_node_filter = our_requirement.node_filter
if our_node_filter is not None:
requirement._raw['node_filter'] = deepcopy_with_locators(
our_node_filter._raw)
our_relationship = our_requirement.relationship # RelationshipAssignment
if (our_relationship is not None) and (our_relationship.type is None):
# Make sure we have a dict
if 'relationship' not in requirement._raw:
requirement._raw['relationship'] = OrderedDict()
merge_requirement_assignment_relationship(
context, our_relationship, relationship_property_definitions,
relationship_interface_definitions, requirement, our_relationship)
def merge_capability_definition_from_type(context, presentation, capability_definition):
"""
Merge ``properties`` and ``valid_source_types`` from the node type's capability definition
over those taken from the parent node type.
"""
raw_properties = OrderedDict()
# Merge properties from parent
the_type = capability_definition._get_type(context)
type_property_defintions = the_type._get_properties(context)
merge_raw_parameter_definitions(context, presentation, raw_properties, type_property_defintions,
'properties')
# Merge our properties (might override definitions in parent)
merge_raw_parameter_definitions(context, presentation, raw_properties,
capability_definition.properties, 'properties')
if raw_properties:
capability_definition._raw['properties'] = raw_properties
# Override valid_source_types
if capability_definition._raw.get('valid_source_types') is None:
valid_source_types = the_type._get_valid_source_types(context)
if valid_source_types is not None:
capability_definition._raw['valid_source_types'] = \
deepcopy_with_locators(valid_source_types)
def merge_raw_input_definitions(context, raw_inputs, our_inputs,
interface_name, operation_name, presentation,
type_name):
for input_name, our_input in our_inputs.iteritems():
if input_name in raw_inputs:
merge_raw_input_definition(context, raw_inputs[input_name],
our_input, interface_name,
operation_name, presentation, type_name)
else:
raw_inputs[input_name] = deepcopy_with_locators(our_input._raw)
def merge_interface(context, presentation, interface_assignment,
our_interface_assignment, interface_definition,
interface_name):
# Assign/merge interface inputs
assign_raw_inputs(context, interface_assignment._raw,
our_interface_assignment.inputs,
interface_definition._get_inputs(context),
interface_name, None, presentation)
our_operation_templates = our_interface_assignment.operations # OperationAssignment
if our_operation_templates is None:
our_operation_templates = {}
# OperationDefinition or OperationAssignment:
operation_definitions = interface_definition._get_operations(context) \
if hasattr(interface_definition, '_get_operations') else interface_definition.operations
if operation_definitions is None:
operation_definitions = {}
# OperationAssignment:
for operation_name, our_operation_template in our_operation_templates.iteritems(
):
operation_definition = operation_definitions.get(
operation_name) # OperationDefinition
our_input_assignments = our_operation_template.inputs
our_implementation = our_operation_template.implementation
if operation_definition is None:
context.validation.report(
u'interface definition "{0}" refers to an unknown operation "{1}" in "{2}"'
.format(interface_name, operation_name,
presentation._fullname),
locator=our_operation_template._locator,
level=Issue.BETWEEN_TYPES)
# Make sure we have the dict
if (operation_name not in interface_assignment._raw) \
or (interface_assignment._raw[operation_name] is None):
interface_assignment._raw[operation_name] = OrderedDict()
if our_implementation is not None:
interface_assignment._raw[operation_name]['implementation'] = \
deepcopy_with_locators(our_implementation._raw)
# Assign/merge operation inputs
input_definitions = operation_definition.inputs \
if operation_definition is not None else None
assign_raw_inputs(context, interface_assignment._raw[operation_name],
our_input_assignments, input_definitions,
interface_name, operation_name, presentation)
def merge_raw_operation_definitions(context, raw_operations, our_operations,
interface_name, presentation, type_name):
for operation_name, our_operation in our_operations.iteritems():
if operation_name in raw_operations:
raw_operation = raw_operations[operation_name]
if isinstance(raw_operation, basestring):
# Convert short form to long form
raw_operations[operation_name] = OrderedDict(
(('implementation', raw_operation), ))
raw_operation = raw_operations[operation_name]
merge_raw_operation_definition(context, raw_operation,
our_operation, interface_name,
presentation, type_name)
else:
raw_operations[operation_name] = deepcopy_with_locators(
our_operation._raw)
def merge_raw_parameter_definitions(context, presentation,
raw_property_definitions,
our_property_definitions, field_name):
if not our_property_definitions:
return
for property_name, our_property_definition in our_property_definitions.iteritems(
):
if property_name in raw_property_definitions:
raw_property_definition = raw_property_definitions[property_name]
merge_raw_parameter_definition(context, presentation,
raw_property_definition,
our_property_definition, field_name,
property_name)
else:
raw_property_definitions[property_name] = \
deepcopy_with_locators(our_property_definition._raw)
def merge_capability_definition(context, presentation, capability_definition,
from_capability_definition):
capability_definition._raw['type'] = from_capability_definition.type
raw_properties = OrderedDict()
raw_attributes = OrderedDict()
# Merge parameters from type
merge_raw_parameter_definitions(context, presentation, raw_properties,
capability_definition.properties,
'properties')
merge_raw_parameter_definitions(context, presentation, raw_attributes,
capability_definition.attributes,
'attributes')
# Merge our parameters
merge_raw_parameter_definitions(context, presentation, raw_properties,
from_capability_definition.properties,
'properties')
merge_raw_parameter_definitions(context, presentation, raw_attributes,
from_capability_definition.attributes,
'attributes')
if raw_properties:
capability_definition._raw['properties'] = raw_properties
capability_definition._reset_method_cache()
if raw_attributes:
capability_definition._raw['attributes'] = raw_attributes
capability_definition._reset_method_cache()
# Merge occurrences
occurrences = from_capability_definition._raw.get('occurrences')
if (occurrences is not None) and (
capability_definition._raw.get('occurrences') is None):
capability_definition._raw['occurrences'] = \
deepcopy_with_locators(occurrences)
def merge_capability_definition_from_type(context, presentation,
capability_definition):
raw_properties = OrderedDict()
# Merge properties from type
the_type = capability_definition._get_type(context)
type_property_defintions = the_type._get_properties(context)
merge_raw_parameter_definitions(context, presentation, raw_properties,
type_property_defintions, 'properties')
# Merge our properties
merge_raw_parameter_definitions(context, presentation, raw_properties,
capability_definition.properties,
'properties')
if raw_properties:
capability_definition._raw['properties'] = raw_properties
# Override valid_source_types
if capability_definition._raw.get('valid_source_types') is None:
valid_source_types = the_type._get_valid_source_types(context)
if valid_source_types is not None:
capability_definition._raw['valid_source_types'] = \
deepcopy_with_locators(valid_source_types)
def merge_requirement_assignment_relationship(context, presentation,
property_definitions,
interface_definitions,
requirement, our_relationship):
the_type = our_relationship.type
if the_type is not None:
# Could be a type or a template:
requirement._raw['relationship']['type'] = deepcopy_with_locators(
the_type)
our_relationship_properties = our_relationship._raw.get('properties')
if our_relationship_properties:
# Make sure we have a dict
if 'properties' not in requirement._raw['relationship']:
requirement._raw['relationship']['properties'] = OrderedDict()
# Merge our properties
for property_name, prop in our_relationship_properties.iteritems():
if property_name in property_definitions:
definition = property_definitions[property_name]
requirement._raw['relationship']['properties'][property_name] = \
coerce_property_value(context, presentation, definition, prop)
else:
context.validation.report(
'relationship property "%s" not declared at definition of requirement "%s"'
' in "%s"' %
(property_name, presentation._fullname,
presentation._container._container._fullname),
locator=our_relationship._get_child_locator(
'properties', property_name),
level=Issue.BETWEEN_TYPES)
our_interfaces = our_relationship.interfaces
if our_interfaces:
# Make sure we have a dict
if 'interfaces' not in requirement._raw['relationship']:
requirement._raw['relationship']['interfaces'] = OrderedDict()
# Merge interfaces
for interface_name, our_interface in our_interfaces.iteritems():
if interface_name not in requirement._raw['relationship'][
'interfaces']:
requirement._raw['relationship']['interfaces'][
interface_name] = OrderedDict()
if (interface_definitions
is not None) and (interface_name in interface_definitions):
interface_definition = interface_definitions[interface_name]
interface_assignment = requirement.relationship.interfaces[
interface_name]
merge_interface(context, presentation, interface_assignment,
our_interface, interface_definition,
interface_name)
else:
context.validation.report(
'interface definition "%s" not declared at definition of requirement "%s"'
' in "%s"' %
(interface_name, presentation._fullname,
presentation._container._container._fullname),
locator=our_relationship._locator,
level=Issue.BETWEEN_TYPES)
def convert_requirement_from_definition_to_assignment(
context,
requirement_definition, # pylint: disable=too-many-branches
our_requirement_assignment,
container):
from ..assignments import RequirementAssignment
raw = OrderedDict()
# Capability type name:
raw['capability'] = deepcopy_with_locators(
requirement_definition.capability)
node_type = requirement_definition._get_node_type(context)
if node_type is not None:
raw['node'] = deepcopy_with_locators(node_type._name)
relationship_type = None
relationship_template = None
relationship_property_definitions = None
relationship_interface_definitions = None
# First try to find the relationship if we declared it
# RelationshipAssignment:
our_relationship = our_requirement_assignment.relationship \
if our_requirement_assignment is not None else None
if our_relationship is not None:
relationship_type, relationship_type_variant = our_relationship._get_type(
context)
if relationship_type_variant == 'relationship_template':
relationship_template = relationship_type
relationship_type = relationship_template._get_type(context)
definition_relationship_type = None
relationship_definition = requirement_definition.relationship # RelationshipDefinition
if relationship_definition is not None:
definition_relationship_type = relationship_definition._get_type(
context)
# If not exists, try at the node type
if relationship_type is None:
relationship_type = definition_relationship_type
else:
# Make sure the type is derived
if not definition_relationship_type._is_descendant(
context, relationship_type):
context.validation.report(
'assigned relationship type "%s" is not a descendant of declared relationship type "%s"'
%
(relationship_type._name, definition_relationship_type._name),
locator=container._locator,
level=Issue.BETWEEN_TYPES)
if relationship_type is not None:
raw['relationship'] = OrderedDict()
type_name = our_relationship.type if our_relationship is not None else None
if type_name is None:
type_name = relationship_type._name
raw['relationship']['type'] = deepcopy_with_locators(type_name)
# These are our property definitions
relationship_property_definitions = relationship_type._get_properties(
context)
if relationship_template is not None:
# Property values from template
raw['properties'] = relationship_template._get_property_values(
context)
else:
if relationship_property_definitions:
# Convert property definitions to values
raw['properties'] = \
convert_property_definitions_to_values(context,
relationship_property_definitions)
# These are our interface definitions
# InterfaceDefinition:
relationship_interface_definitions = OrderedDict(
relationship_type._get_interfaces(context))
# Convert interface definitions to templates
convert_requirement_interface_definitions_from_type_to_raw_template(
context, raw['relationship'], relationship_interface_definitions)
if relationship_definition:
# Merge extra interface definitions
# InterfaceDefinition:
relationship_interface_definitions = relationship_definition.interfaces
merge_interface_definitions(context,
relationship_interface_definitions,
relationship_interface_definitions,
requirement_definition, container)
if relationship_template is not None:
# Interfaces from template
interfaces = relationship_template._get_interfaces(context)
if interfaces:
raw['relationship']['interfaces'] = OrderedDict()
for interface_name, interface in interfaces.iteritems():
raw['relationship']['interfaces'][
interface_name] = interface._raw
return \
RequirementAssignment(name=requirement_definition._name, raw=raw, container=container), \
relationship_property_definitions, \
relationship_interface_definitions
