Пример #1
0
def copy_identifier_ref(obj_ref: CdmObjectReference, res_opt: ResolveOptions, options: CopyOptions) -> Union[str, 'IdentifierRef']:
    identifier = obj_ref.named_reference

    if options is None or not options.string_refs:
        return identifier

    resolved = obj_ref.fetch_object_definition(res_opt)

    if resolved is None:
        return identifier

    ident_ref = IdentifierRef()
    ident_ref.corpus_path = resolved.at_corpus_path
    ident_ref.identifier = identifier

    return ident_ref
Пример #2
0
    def _const_type_check(self, res_opt: 'ResolveOptions', wrt_doc: 'CdmDocumentDefinition', argument_value: Any) -> 'CdmArgumentValue':
        ctx = self.ctx
        replacement = argument_value
        # if parameter type is entity, then the value should be an entity or ref to one
        # same is true of 'dataType' dataType
        ref = self.data_type_ref
        if not ref:
            return replacement

        dt = ref.fetch_object_definition(res_opt)
        if not dt:
            logger.error(self.ctx, self._TAG, '_const_type_check', self.at_corpus_path, CdmLogCode.ERR_UNRECOGNIZED_DATA_TYPE, self.name)
            return None

        # compare with passed in value or default for parameter
        p_value = argument_value
        if p_value is None:
            p_value = self.default_value
            replacement = p_value

        if p_value is not None:
            if dt.is_derived_from('cdmObject', res_opt):
                expected_types = []
                expected = None
                if dt.is_derived_from('entity', res_opt):
                    expected_types.append(CdmObjectType.CONSTANT_ENTITY_DEF)
                    expected_types.append(CdmObjectType.ENTITY_REF)
                    expected_types.append(CdmObjectType.ENTITY_DEF)
                    expected_types.append(CdmObjectType.PROJECTION_DEF)
                    expected = 'entity'
                elif dt.is_derived_from('attribute', res_opt):
                    expected_types.append(CdmObjectType.ATTRIBUTE_REF)
                    expected_types.append(CdmObjectType.TYPE_ATTRIBUTE_DEF)
                    expected_types.append(CdmObjectType.ENTITY_ATTRIBUTE_DEF)
                    expected = 'attribute'
                elif dt.is_derived_from('dataType', res_opt):
                    expected_types.append(CdmObjectType.DATA_TYPE_REF)
                    expected_types.append(CdmObjectType.DATA_TYPE_DEF)
                    expected = 'dataType'
                elif dt.is_derived_from('purpose', res_opt):
                    expected_types.append(CdmObjectType.PURPOSE_REF)
                    expected_types.append(CdmObjectType.PURPOSE_DEF)
                    expected = 'purpose'
                elif dt.is_derived_from('trait', res_opt):
                    expected_types.append(CdmObjectType.TRAIT_REF)
                    expected_types.append(CdmObjectType.TRAIT_DEF)
                    expected = 'trait'
                elif dt.is_derived_from('traitGroup', res_opt):
                    expected_types.append(CdmObjectType.TRAIT_GROUP_REF)
                    expected_types.append(CdmObjectType.TRAIT_GROUP_DEF)
                    expected = 'traitGroup'
                elif dt.is_derived_from('attributeGroup', res_opt):
                    expected_types.append(CdmObjectType.ATTRIBUTE_GROUP_REF)
                    expected_types.append(CdmObjectType.ATTRIBUTE_GROUP_DEF)
                    expected = 'attributeGroup'

                if not expected_types:
                    logger.error(self.ctx, self._TAG, '_const_type_check', wrt_doc.at_corpus_path, CdmLogCode.ERR_UNEXPECTED_DATA_TYPE,
                                 self.name)

                # if a string constant, resolve to an object ref.
                found_type = CdmObjectType.ERROR
                if isinstance(p_value, CdmObject):
                    found_type = p_value.object_type

                found_desc = ctx._relative_path
                if isinstance(p_value, str):
                    if p_value == 'this.attribute' and expected == 'attribute':
                        # will get sorted out later when resolving traits
                        found_type = CdmObjectType.ATTRIBUTE_REF
                    else:
                        found_desc = p_value
                        from cdm.objectmodel import CdmObjectReference
                        seek_res_att = CdmObjectReference._offset_attribute_promise(p_value)
                        if seek_res_att >= 0:
                            # get an object there that will get resolved later after resolved attributes
                            replacement = CdmAttributeReference(self.ctx, p_value, True)
                            replacement.in_document = wrt_doc
                            found_type = CdmObjectType.ATTRIBUTE_REF
                        else:
                            lu = ctx.corpus._resolve_symbol_reference(res_opt, wrt_doc, p_value,
                                                                      CdmObjectType.ERROR, True)
                            if lu:
                                if expected == 'attribute':
                                    replacement = CdmAttributeReference(self.ctx, p_value, True)
                                    replacement.in_document = wrt_doc
                                    found_type = CdmObjectType.ATTRIBUTE_REF
                                else:
                                    replacement = lu
                                    if isinstance(replacement, CdmObject):
                                        found_type = replacement.object_type

                if expected_types.index(found_type) == -1:
                    logger.error(self.ctx, self._TAG, wrt_doc.at_corpus_path,
                                 CdmLogCode.ERR_RESOLUTION_FAILURE,
                                 self.get_name(), expected, found_desc)
                else:
                    logger.info(self.ctx, self._TAG, self._const_type_check.__name__,
                                wrt_doc.at_corpus_path, 'resolved \'{}\''.format(found_desc))

        return replacement