async def create_resolved_entity_async(self, new_ent_name: str, res_opt: Optional['ResolveOptions'] = None, folder: 'CdmFolderDefinition' = None,
new_doc_name: str = None) -> 'CdmEntityDefinition':
"""Create a resolved copy of the entity."""
if not res_opt:
res_opt = ResolveOptions(self, self.ctx.corpus.default_resolution_directives)
if not res_opt.wrt_doc:
logger.error(self._TAG, self.ctx, 'No WRT document was supplied.', self.create_resolved_entity_async.__name__)
return None
if not new_ent_name:
logger.error(self._TAG, self.ctx, 'No Entity Name provided.', self.create_resolved_entity_async.__name__)
return None
folder = folder or self.in_document.folder
file_name = new_doc_name or new_ent_name + PersistenceLayer.CDM_EXTENSION
orig_doc = self.in_document.at_corpus_path
# Don't overwite the source document.
target_at_corpus_path = self.ctx.corpus.storage.create_absolute_corpus_path(folder.at_corpus_path, folder) + file_name
if StringUtils.equals_with_ignore_case(target_at_corpus_path, orig_doc):
logger.error(self._TAG, self.ctx, 'Attempting to replace source entity\'s document \'{}\''.format(
target_at_corpus_path), self.create_resolved_entity_async.__name__)
return None
if not await res_opt.wrt_doc._index_if_needed(res_opt, True):
logger.error(self._TAG, self.ctx, 'Couldn\'t index source document.', self.create_resolved_entity_async.__name__)
return None
# Make the top level attribute context for this entity.
# for this whole section where we generate the attribute context tree and get resolved attributes
# set the flag that keeps all of the parent changes and document dirty from from happening
was_resolving = self.ctx.corpus._is_currently_resolving
self.ctx.corpus._is_currently_resolving = True
ent_name = new_ent_name
ctx = self.ctx
att_ctx_ent = ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_CONTEXT_DEF, ent_name, True) # type: CdmAttributeContext
att_ctx_ent.ctx = ctx
att_ctx_ent.in_document = self.in_document
# Cheating a bit to put the paths in the right place.
acp = AttributeContextParameters()
acp._under = att_ctx_ent
acp._type = CdmAttributeContextType.ATTRIBUTE_GROUP
acp._name = 'attributeContext'
att_ctx_ac = CdmAttributeContext._create_child_under(res_opt, acp)
acp_ent = AttributeContextParameters()
acp_ent._under = att_ctx_ac
acp_ent._type = CdmAttributeContextType.ENTITY
acp_ent._name = ent_name
acp_ent._regarding = ctx.corpus.make_ref(CdmObjectType.ENTITY_REF, self.get_name(), True)
# Use this whenever we need to keep references pointing at things that were already found.
# Used when 'fixing' references by localizing to a new document.
res_opt_copy = CdmObject._copy_resolve_options(res_opt)
res_opt_copy._save_resolutions_on_copy = True
# Resolve attributes with this context. the end result is that each resolved attribute points to the level of
# the context where it was created.
ras = self._fetch_resolved_attributes(res_opt_copy, acp_ent)
if ras is None:
self._resolving_attributes = False
return None
# Create a new copy of the attribute context for this entity.
# TODO: all_att_ctx type ideally should be ordered set
all_att_ctx = [] # type: List[CdmAttributeContext]
new_node = cast('CdmAttributeContext', att_ctx_ent.copy_node(res_opt))
att_ctx_ent = att_ctx_ent._copy_attribute_context_tree(res_opt, new_node, ras, all_att_ctx, 'resolvedFrom')
att_ctx = cast('CdmAttributeContext', cast('CdmAttributeContext', att_ctx_ent.contents[0]).contents[0])
self.ctx.corpus._is_currently_resolving = was_resolving
# make a new document in given folder if provided or the same folder as the source entity
folder.documents.remove(file_name)
doc_res = folder.documents.append(file_name)
# add a import of the source document
orig_doc = self.ctx.corpus.storage.create_relative_corpus_path(orig_doc, doc_res) # just in case we missed the prefix
doc_res.imports.append(orig_doc, "resolvedFrom")
# make the empty entity
ent_resolved = doc_res.definitions.append(ent_name)
# set the context to the copy of the tree. fix the docs on the context nodes
ent_resolved.attribute_context = att_ctx
def visit_callback(obj: 'CdmObject', path: str) -> bool:
obj.in_document = doc_res
return False
att_ctx.visit('{}/attributeContext/'.format(ent_name), visit_callback, None)
# add the traits of the entity
rts_ent = self._fetch_resolved_traits(res_opt)
for rt in rts_ent.rt_set:
trait_ref = CdmObject._resolved_trait_to_trait_ref(res_opt_copy, rt)
ent_resolved.exhibits_traits.append(trait_ref)
# The attributes have been named, shaped, etc. for this entity so now it is safe to go and make each attribute
# context level point at these final versions of attributes.
att_path_to_order = {} # type: Dict[str, int]
def point_context_at_resolved_atts(ras_sub: 'ResolvedAttributeSet', path: str) -> None:
for ra in ras_sub._set:
ra_ctx_in_ent = [] # type: List[CdmAttributeContext]
ra_ctx_set = ras_sub.rattr_to_attctxset.get(ra)
# find the correct attctx for this copy, intersect these two sets
# (interate over the shortest list)
if len(all_att_ctx) < len(ra_ctx_set):
for curr_att_ctx in all_att_ctx:
if curr_att_ctx in ra_ctx_set:
ra_ctx_in_ent.append(curr_att_ctx)
else:
for curr_att_ctx in ra_ctx_set:
if curr_att_ctx in all_att_ctx:
ra_ctx_in_ent.append(curr_att_ctx)
for ra_ctx in ra_ctx_in_ent:
refs = ra_ctx.contents
# there might be more than one explanation for where and attribute came from when things get merges as they do
# This won't work when I add the structured attributes to avoid name collisions.
att_ref_path = path + ra.resolved_name
if isinstance(ra.target, CdmObject):
if not att_ref_path in att_path_to_order:
att_ref = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_REF, att_ref_path, True) # type: CdmObjectReference
# only need one explanation for this path to the insert order
att_path_to_order[att_ref.named_reference] = ra.insert_order
refs.append(att_ref)
else:
att_ref_path += '/members/'
point_context_at_resolved_atts(cast('ResolvedAttributeSet', ra.target), att_ref_path)
point_context_at_resolved_atts(ras, ent_name + '/hasAttributes/')
# generated attribute structures may end up with 0 attributes after that. prune them
def clean_sub_group(sub_item, under_generated) -> bool:
if sub_item.object_type == CdmObjectType.ATTRIBUTE_REF:
return True # not empty
ac = sub_item # type: CdmAttributeContext
if ac.type == CdmAttributeContextType.GENERATED_SET:
under_generated = True
if not ac.contents:
return False # empty
# look at all children, make a set to remove
to_remove = [] # type: List[CdmAttributeContext]
for sub_sub in ac.contents:
if not clean_sub_group(sub_sub, under_generated):
potential_target = under_generated
if not potential_target:
# cast is safe because we returned false meaning empty and not a attribute ref
# so is this the set holder itself?
potential_target = sub_sub.type == CdmAttributeContextType.GENERATED_SET
if potential_target:
to_remove.append(sub_sub)
for to_die in to_remove:
ac.contents.remove(to_die)
return bool(ac.contents)
clean_sub_group(att_ctx, False)
# Create an all-up ordering of attributes at the leaves of this tree based on insert order. Sort the attributes
# in each context by their creation order and mix that with the other sub-contexts that have been sorted.
def get_order_num(item: 'CdmObject') -> int:
if item.object_type == CdmObjectType.ATTRIBUTE_CONTEXT_DEF:
return order_contents(item)
if item.object_type == CdmObjectType.ATTRIBUTE_REF:
return att_path_to_order[item.named_reference]
# put the mystery item on top.
return -1
def order_contents(under: 'CdmAttributeContext') -> int:
if under._lowest_order is None:
under._lowest_order = -1
if len(under.contents) == 1:
under._lowest_order = get_order_num(under.contents[0])
else:
def get_and_update_order(item1: 'CdmObject', item2: 'CdmObject'):
left_order = get_order_num(item1)
right_order = get_order_num(item2)
if left_order != -1 and (under._lowest_order == -1 or left_order < under._lowest_order):
under._lowest_order = left_order
if right_order != -1 and (under._lowest_order == -1 or right_order < under._lowest_order):
under._lowest_order = right_order
return left_order - right_order
under.contents.sort(key=functools.cmp_to_key(get_and_update_order))
return under._lowest_order
order_contents(att_ctx)
# Resolved attributes can gain traits that are applied to an entity when referenced since these traits are
# described in the context, it is redundant and messy to list them in the attribute. So, remove them. Create and
# cache a set of names to look for per context. There is actually a hierarchy to this. All attributes from the
# base entity should have all traits applied independently of the sub-context they come from. Same is true of
# attribute entities. So do this recursively top down.
ctx_to_trait_names = {} # type: Dict[CdmAttributeContext, Set[str]]
def collect_context_traits(sub_att_ctx: 'CdmAttributeContext', inherited_trait_names: Set[str]) -> None:
trait_names_here = set(inherited_trait_names)
traits_here = sub_att_ctx.exhibits_traits
if traits_here:
for tat in traits_here:
trait_names_here.add(tat.named_reference)
ctx_to_trait_names[sub_att_ctx] = trait_names_here
for cr in sub_att_ctx.contents:
if cr.object_type == CdmObjectType.ATTRIBUTE_CONTEXT_DEF:
# do this for all types?
collect_context_traits(cast('CdmAttributeContext', cr), trait_names_here)
collect_context_traits(att_ctx, set())
# add the attributes, put them in attribute groups if structure needed.
res_att_to_ref_path = {} # type: Dict[ResolvedAttribute, str]
def add_attributes(ras_sub: 'ResolvedAttributeSet', container: 'Union[CdmEntityDefinition, CdmAttributeGroupDefinition]', path: str) -> None:
for ra in ras_sub._set:
att_path = path + ra.resolved_name
# use the path of the context associated with this attribute to find the new context that matches on path.
ra_ctx_set = ras_sub.rattr_to_attctxset[ra]
# find the correct att_ctx for this copy.
# ra_ctx = next((ac for ac in all_att_ctx if ac in ra_ctx_set), None) # type: CdmAttributeContext
if len(all_att_ctx) < len(ra_ctx_set):
for curr_att_ctx in all_att_ctx:
if curr_att_ctx in ra_ctx_set:
ra_ctx = curr_att_ctx
break
else:
for curr_att_ctx in ra_ctx_set:
if curr_att_ctx in all_att_ctx:
ra_ctx = curr_att_ctx
break
if isinstance(ra.target, ResolvedAttributeSet) and cast('ResolvedAttributeSet', ra.target)._set:
# this is a set of attributes. Make an attribute group to hold them.
att_grp = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_GROUP_DEF, ra.resolved_name) # type: CdmAttributeGroupDefinition
att_grp.attribute_context = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_CONTEXT_REF, ra_ctx.at_corpus_path, True)
# take any traits from the set and make them look like traits exhibited by the group.
avoid_set = ctx_to_trait_names[ra_ctx]
rts_att = ra.resolved_traits
for rt in rts_att.rt_set:
if not rt.trait.ugly: # Don't mention your ugly traits.
if not avoid_set or rt.trait_name not in avoid_set: # Avoid the ones from the context.
trait_ref = CdmObject._resolved_trait_to_trait_ref(res_opt_copy, rt)
cast('CdmObjectDefinition', att_grp).exhibits_traits.append(trait_ref, isinstance(trait_ref, str))
# wrap it in a reference and then recurse with this as the new container.
att_grp_ref = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_GROUP_REF, None) # type: CdmAttributeGroupReference
att_grp_ref.explicit_reference = att_grp
container._add_attribute_def(att_grp_ref)
# isn't this where ...
add_attributes(cast('ResolvedAttributeSet', ra.target), att_grp, att_path + '/(object)/members/')
else:
att = self.ctx.corpus.make_object(CdmObjectType.TYPE_ATTRIBUTE_DEF, ra.resolved_name) # type: CdmTypeAttributeDefinition
att.attribute_context = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_CONTEXT_REF, ra_ctx.at_corpus_path, True)
avoid_set = ctx_to_trait_names[ra_ctx]
rts_att = ra.resolved_traits
for rt in rts_att.rt_set:
if not rt.trait.ugly: # Don't mention your ugly traits.
if not avoid_set or rt.trait_name not in avoid_set: # Avoid the ones from the context.
trait_ref = CdmObject._resolved_trait_to_trait_ref(res_opt_copy, rt)
cast('CdmTypeAttributeDefinition', att).applied_traits.append(trait_ref, isinstance(trait_ref, str))
# none of the dataformat traits have the bit set that will make them turn into a property
# this is intentional so that the format traits make it into the resolved object
# but, we still want a guess as the data format, so get it and set it.
implied_data_format = att.data_format
if implied_data_format:
att.data_format = implied_data_format
container._add_attribute_def(att)
res_att_to_ref_path[ra] = att_path
add_attributes(ras, ent_resolved, ent_name + '/hasAttributes/')
# Any resolved traits that hold arguments with attribute refs should get 'fixed' here.
def replace_trait_att_ref(tr: 'CdmTraitReference', entity_hint: str) -> None:
if tr.arguments:
for arg in tr.arguments:
v = arg._unresolved_value or arg.value
# Is this an attribute reference?
if v and isinstance(v, CdmObject) and cast('CdmObject', v).object_type == CdmObjectType.ATTRIBUTE_REF:
# Only try this if the reference has no path to it (only happens with intra-entity att refs).
att_ref = cast('CdmAttributeReference', v)
if att_ref.named_reference and att_ref.named_reference.find('/') == -1:
if not arg._unresolved_value:
arg._unresolved_value = arg.value
# Give a promise that can be worked out later.
# Assumption is that the attribute must come from this entity.
new_att_ref = self.ctx.corpus.make_object(CdmObjectType.ATTRIBUTE_REF, entity_hint +
'/(resolvedAttributes)/' + att_ref.named_reference, True)
# inDocument is not propagated during resolution, so set it here
new_att_ref.in_document = arg.in_document
arg.set_value(new_att_ref)
# Fix entity traits.
if ent_resolved.exhibits_traits:
for et in ent_resolved.exhibits_traits:
replace_trait_att_ref(et, new_ent_name)
# Fix context traits.
def fix_context_traits(sub_att_ctx: 'CdmAttributeContext', entity_hint: str) -> None:
traits_here = sub_att_ctx.exhibits_traits
if traits_here:
for tr in traits_here:
replace_trait_att_ref(tr, entity_hint)
for cr in sub_att_ctx.contents:
if cr.object_type == CdmObjectType.ATTRIBUTE_CONTEXT_DEF:
# If this is a new entity context, get the name to pass along.
sub_sub_att_ctx = cast('CdmAttributeContext', cr)
sub_entity_hint = entity_hint
if sub_sub_att_ctx.type == CdmAttributeContextType.ENTITY:
sub_entity_hint = sub_sub_att_ctx.definition.named_reference
# Do this for all types.
fix_context_traits(sub_sub_att_ctx, sub_entity_hint)
fix_context_traits(att_ctx, new_ent_name)
# And the attribute traits.
ent_atts = ent_resolved.attributes
if ent_atts:
for attribute in ent_atts:
att_traits = attribute.applied_traits
if att_traits:
for tr in att_traits:
replace_trait_att_ref(tr, new_ent_name)
# We are about to put this content created in the context of various documents (like references to attributes
# from base entities, etc.) into one specific document. All of the borrowed refs need to work. so, re-write all
# string references to work from this new document. The catch-22 is that the new document needs these fixes done
# before it can be used to make these fixes. The fix needs to happen in the middle of the refresh trigger the
# document to refresh current content into the resolved OM.
cast('CdmAttributeContext', att_ctx).parent = None # Remove the fake parent that made the paths work.
res_opt_new = CdmObject._copy_resolve_options(res_opt)
res_opt_new.wrt_doc = doc_res
res_opt_new._localize_references_for = doc_res
if not await doc_res.refresh_async(res_opt_new):
logger.error(self._TAG, self.ctx, 'Failed to index the resolved document.', self.create_resolved_entity_async.__name__)
return None
# Get a fresh ref.
ent_resolved = cast('CdmEntityDefinition', doc_res._fetch_object_from_document_path(ent_name, res_opt_new))
self.ctx.corpus._res_ent_map[self.at_corpus_path] = ent_resolved.at_corpus_path
return ent_resolved
def _construct_projection_context(
self,
proj_directive: 'ProjectionDirective',
attr_ctx: 'CdmAttributeContext',
ras: Optional['ResolvedAttributeSet'] = None
) -> 'ProjectionContext':
"""
A function to construct projection context and populate the resolved attribute set that ExtractResolvedAttributes method can then extract
This function is the entry point for projection resolution.
This function is expected to do the following 3 things:
- Create an condition expression tree & default if appropriate
- Create and initialize Projection Context
- Process operations
"""
if not attr_ctx:
return None
proj_context = None
# Add projection to context tree
acp_proj = AttributeContextParameters()
acp_proj._under = attr_ctx
acp_proj._type = CdmAttributeContextType.PROJECTION
acp_proj._name = self.fetch_object_definition_name()
acp_proj._regarding = proj_directive._owner_ref
acp_proj._include_traits = False
ac_proj = CdmAttributeContext._create_child_under(
proj_directive._res_opt, acp_proj)
acp_source = AttributeContextParameters()
acp_source._under = ac_proj
acp_source._type = CdmAttributeContextType.SOURCE
acp_source._name = 'source'
acp_source._regarding = None
acp_source._include_traits = False
ac_source = CdmAttributeContext._create_child_under(
proj_directive._res_opt, acp_source)
# Initialize the projection context
ctx = proj_directive._owner.ctx if proj_directive._owner else None
if self.source:
source = self.source.fetch_object_definition(
proj_directive._res_opt)
if source.object_type == CdmObjectType.PROJECTION_DEF:
# A Projection
proj_context = source._construct_projection_context(
proj_directive, ac_source, ras)
else:
# An Entity Reference
acp_source_projection = AttributeContextParameters()
acp_source_projection._under = ac_source
acp_source_projection._type = CdmAttributeContextType.ENTITY
acp_source_projection._name = self.source.named_reference if self.source.named_reference else self.source.explicit_reference.get_name(
)
acp_source_projection._regarding = self.source
acp_source_projection._include_traits = False
ras = self.source._fetch_resolved_attributes(
proj_directive._res_opt,
acp_source_projection) # type: ResolvedAttributeSet
# clean up the context tree, it was left in a bad state on purpose in this call
ras.attribute_context._finalize_attribute_context(
proj_directive._res_opt, ac_source.at_corpus_path,
self.in_document, self.in_document, None, False)
# if polymorphic keep original source as previous state
poly_source_set = None
if proj_directive._is_source_polymorphic:
poly_source_set = ProjectionResolutionCommonUtil._get_polymorphic_source_set(
proj_directive, ctx, self.source, ras)
# Now initialize projection attribute state
pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set(
proj_directive, ctx, ras,
proj_directive._is_source_polymorphic, poly_source_set)
proj_context = ProjectionContext(proj_directive,
ras.attribute_context)
proj_context._current_attribute_state_set = pas_set
else:
# A type attribute
# Initialize projection attribute state
pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set(
proj_directive,
ctx,
ras,
is_source_polymorphic=False,
polymorphic_set=None)
proj_context = ProjectionContext(proj_directive,
ras.attribute_context)
proj_context._current_attribute_state_set = pas_set
is_condition_valid = False
input_values = InputValues(proj_directive)
is_condition_valid = ExpressionTree._evaluate_condition(
self.condition, input_values)
if is_condition_valid and self.operations and len(self.operations) > 0:
# Just in case operations were added programmatically, reindex operations
for i in range(len(self.operations)):
self.operations[i]._index = i + 1
# Operation
acp_gen_attr_set = AttributeContextParameters()
acp_gen_attr_set._under = attr_ctx
acp_gen_attr_set._type = CdmAttributeContextType.GENERATED_SET
acp_gen_attr_set._name = '_generatedAttributeSet'
ac_gen_attr_set = CdmAttributeContext._create_child_under(
proj_directive._res_opt, acp_gen_attr_set)
# Start with an empty list for each projection
pas_operations = ProjectionAttributeStateSet(
proj_context._current_attribute_state_set._ctx)
# The attribute set that the operation will execute on
operation_working_attribute_set = None # type: ProjectionAttributeStateSet
# The attribute set containing the attributes from the source
source_attribute_set = proj_context._current_attribute_state_set # type: ProjectionAttributeStateSet
# Specifies if the operation is the first on the list to run
first_operation_to_run = True
for operation in self.operations:
operation_condition = ExpressionTree._evaluate_condition(
operation.condition, input_values)
if not operation_condition:
# Skip this operation if the condition does not evaluate to true
continue
# If run_sequentially is not true then all the operations will receive the source input
# Unless the operation overwrites this behavior using the source_input property
source_input = operation.source_input if operation.source_input is not None else not self.run_sequentially
# If this is the first operation to run it will get the source attribute set since the operations attribute set starts empty
if source_input or first_operation_to_run:
proj_context._current_attribute_state_set = source_attribute_set
operation_working_attribute_set = pas_operations
else:
# Needs to create a copy since this set can be modified by the operation
proj_context._current_attribute_state_set = pas_operations._copy(
)
operation_working_attribute_set = ProjectionAttributeStateSet(
proj_context._current_attribute_state_set._ctx)
# Evaluate projections and apply to empty state
new_pas_operations = operation._append_projection_attribute_state(
proj_context, operation_working_attribute_set,
ac_gen_attr_set)
# If the operations fails or it is not implemented the projection cannot be evaluated so keep previous valid state.
if new_pas_operations is not None:
first_operation_to_run = False
pas_operations = new_pas_operations
# If no operation ran successfully pas_operations will be empty
if not first_operation_to_run:
# Finally update the current state to the projection context
proj_context._current_attribute_state_set = pas_operations
return proj_context
def _construct_projection_context(self, proj_directive: 'ProjectionDirective', attr_ctx: 'CdmAttributeContext', ras: Optional['ResolvedAttributeSet'] = None) -> 'ProjectionContext':
"""
A function to construct projection context and populate the resolved attribute set that ExtractResolvedAttributes method can then extract
This function is the entry point for projection resolution.
This function is expected to do the following 3 things:
- Create an condition expression tree & default if appropriate
- Create and initialize Projection Context
- Process operations
"""
proj_context = None
condition = self.condition if self.condition else "(true)"
# create an expression tree based on the condition
tree = ExpressionTree()
self._condition_expression_tree_root = tree._construct_expression_tree(condition)
if attr_ctx:
# Add projection to context tree
acp_proj = AttributeContextParameters()
acp_proj._under = attr_ctx
acp_proj._type = CdmAttributeContextType.PROJECTION
acp_proj._name = self.fetch_object_definition_name()
acp_proj._regarding = proj_directive._owner_ref
acp_proj._include_traits = False
ac_proj = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_proj)
acp_source = AttributeContextParameters()
acp_source._under = ac_proj
acp_source._type = CdmAttributeContextType.SOURCE
acp_source._name = 'source'
acp_source._regarding = None
acp_source._include_traits = False
ac_source = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_source)
# Initialize the projection context
ctx = proj_directive._owner.ctx if proj_directive._owner else None
if self.source:
source = self.source.fetch_object_definition(proj_directive._res_opt)
if source.object_type == CdmObjectType.PROJECTION_DEF:
# A Projection
proj_context = self.source.explicit_reference._construct_projection_context(proj_directive, ac_source, ras)
else:
# An Entity Reference
acp_source_projection = AttributeContextParameters()
acp_source_projection._under = ac_source
acp_source_projection._type = CdmAttributeContextType.ENTITY
acp_source_projection._name = self.source.named_reference if self.source.named_reference else self.source.explicit_reference.get_name()
acp_source_projection._regarding = self.source
acp_source_projection._include_traits = False
ras = self.source._fetch_resolved_attributes(proj_directive._res_opt, acp_source_projection)
# If polymorphic keep original source as previous state
poly_source_set = None
if proj_directive._is_source_polymorphic:
poly_source_set = ProjectionResolutionCommonUtil._get_polymorphic_source_set(proj_directive, ctx, self.source, acp_source_projection)
# Now initialize projection attribute state
pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set(
proj_directive,
ctx,
ras,
proj_directive._is_source_polymorphic,
poly_source_set
)
proj_context = ProjectionContext(proj_directive, ras.attribute_context)
proj_context._current_attribute_state_set = pas_set
else:
# A type attribute
# Initialize projection attribute state
pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set(
proj_directive,
ctx,
ras,
is_source_polymorphic=False,
polymorphic_set=None
)
proj_context = ProjectionContext(proj_directive, ras.attribute_context)
proj_context._current_attribute_state_set = pas_set
is_condition_valid = False
if self._condition_expression_tree_root:
input = InputValues()
input.no_max_depth = proj_directive._has_no_maximum_depth
input.is_array = proj_directive._is_array
input.reference_only = proj_directive._is_reference_only
input.normalized = proj_directive._is_normalized
input.structured = proj_directive._is_structured
input.is_virtual = proj_directive._is_virtual
current_depth = proj_directive._current_depth
current_depth += 1
input.next_depth = current_depth
proj_directive._current_depth = current_depth
input.max_depth = proj_directive._maximum_depth
input.min_cardinality = proj_directive._cardinality._minimum_number if proj_directive._cardinality else None
input.max_cardinality = proj_directive._cardinality._maximum_number if proj_directive._cardinality else None
is_condition_valid = ExpressionTree._evaluate_expression_tree(self._condition_expression_tree_root, input)
if is_condition_valid and self.operations and len(self.operations) > 0:
# Just in case operations were added programmatically, reindex operations
for i in range(len(self.operations)):
self.operations[i]._index = i + 1
# Operation
acp_gen_attr_set = AttributeContextParameters()
acp_gen_attr_set._under = attr_ctx
acp_gen_attr_set._type = CdmAttributeContextType.GENERATED_SET
acp_gen_attr_set._name = '_generatedAttributeSet'
ac_gen_attr_set = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_gen_attr_set)
# Start with an empty list for each projection
pas_operations = ProjectionAttributeStateSet(proj_context._current_attribute_state_set._ctx)
for operation in self.operations:
# Evaluate projections and apply to empty state
new_pas_operations = operation._append_projection_attribute_state(proj_context, pas_operations, ac_gen_attr_set)
# If the operations fails or it is not implemented the projection cannot be evaluated so keep previous valid state.
if new_pas_operations is not None:
pas_operations = new_pas_operations
# Finally update the current state to the projection context
proj_context._current_attribute_state_set = pas_operations
return proj_context