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