def fetch_resolved_entity_references(self, res_opt: Optional['ResolveOptions'] = None) -> 'ResolvedEntityReferenceSet': res_opt = res_opt if res_opt is not None else ResolveOptions(wrt_doc=self) from cdm.resolvedmodel import ResolvedEntityReferenceSet rers = ResolvedEntityReferenceSet(res_opt) for member in self.members: rers.add(member.fetch_resolved_entity_references(res_opt)) return rers
def fetch_resolved_entity_references( self, res_opt: 'ResolveOptions') -> 'ResolvedEntityReferenceSet': # this whole resolved entity ref goo will go away when resolved documents are done. # for now, it breaks if structured att sets get made. from cdm.resolvedmodel import ResolvedEntityReferenceSet from cdm.utilities import AttributeResolutionDirectiveSet from .cdm_object import CdmObject was_previously_resolving = self.ctx.corpus._is_currently_resolving self.ctx.corpus._is_currently_resolving = True if not res_opt: res_opt = ResolveOptions( self, self.ctx.corpus.default_resolution_directives) res_opt = CdmObject._copy_resolve_options(res_opt) res_opt.directives = AttributeResolutionDirectiveSet( set(['normalized', 'referenceOnly'])) ctx = self.ctx ent_ref_set_cache = ctx.fetch_cache(self, res_opt, 'entRefSet') if not ent_ref_set_cache: ent_ref_set_cache = ResolvedEntityReferenceSet(res_opt) if not self._resolving_entity_references: self._resolving_entity_references = True # get from any base class and then 'fix' those to point here instead. ext_ref = self.extends_entity if ext_ref: ext_def = cast('CdmEntityDefinition', ext_ref.fetch_object_definition(res_opt)) if ext_def: inherited = ext_def.fetch_resolved_entity_references( res_opt) if inherited: for res in inherited.rer_set: res = res.copy() res.referencing.entity = self ent_ref_set_cache.rer_set.append(res) if self.attributes: for attribute in self.attributes: # if any refs come back from attributes, they don't know who we are, so they don't set the entity sub = attribute.fetch_resolved_entity_references( res_opt) if sub: for res in sub.rer_set: res.referencing.entity = self ent_ref_set_cache.add(sub) ctx.update_cache(self, res_opt, 'entRefSet', ent_ref_set_cache) self._resolving_entity_references = False self.ctx.corpus._is_currently_resolving = was_previously_resolving return ent_ref_set_cache
def fetch_resolved_entity_references( self, res_opt: Optional['ResolveOptions'] = None ) -> 'ResolvedEntityReferenceSet': res_opt = res_opt if res_opt is not None else ResolveOptions( wrt_doc=self) from cdm.resolvedmodel import AttributeResolutionContext, ResolvedEntityReference, ResolvedEntityReferenceSide, ResolvedEntityReferenceSet from cdm.utilities import ResolveOptions from .cdm_object import CdmObject rts_this_att = self._fetch_resolved_traits(res_opt) res_guide = self.resolution_guidance # this context object holds all of the info about what needs to happen to resolve these attributes arc = AttributeResolutionContext(res_opt, res_guide, rts_this_att) rel_info = self._get_relationship_info(res_opt, arc) if not rel_info.is_by_ref or rel_info.is_array: return None # only place this is used, so logic here instead of encapsulated. # make a set and the one ref it will hold rers = ResolvedEntityReferenceSet(res_opt) rer = ResolvedEntityReference() # referencing attribute(s) come from this attribute rer.referencing._rasb.merge_attributes( self._fetch_resolved_attributes(res_opt)) def resolve_side( ent_ref: 'CdmEntityReference') -> ResolvedEntityReferenceSide: side_other = ResolvedEntityReferenceSide() if ent_ref: # reference to the other entity, hard part is the attribue name. # by convention, this is held in a trait that identifies the key side_other.entity = ent_ref.fetch_object_definition(res_opt) if side_other.entity: other_attribute = None other_opts = ResolveOptions(wrt_doc=res_opt.wrt_doc, directives=res_opt.directives) trait = ent_ref._fetch_resolved_traits(other_opts).find( other_opts, 'is.identifiedBy') if trait and trait.parameter_values and trait.parameter_values.length: other_ref = trait.parameter_values.fetch_parameter_value( 'attribute').value if isinstance(other_ref, CdmObject): other_attribute = other_ref.fetch_object_definition( other_opts) if other_attribute: side_other._rasb.own_one( side_other.entity. _fetch_resolved_attributes(other_opts).get( other_attribute.get_name()).copy()) return side_other # either several or one entity # for now, a sub for the 'select one' idea if self.entity.explicit_reference: ent_pick_from = self.entity.fetch_object_definition(res_opt) atts_pick = ent_pick_from.attributes if ent_pick_from and atts_pick: for attribute in atts_pick: if attribute.object_type == CdmObjectType.ENTITY_ATTRIBUTE_DEF: entity = attribute.entity rer.referenced.append(resolve_side(entity)) else: rer.referenced.append(resolve_side(self.entity)) rers.rer_set.append(rer) return rers