Examples of org.openquark.cal.services.CALFeatureName

org.openquark.cal.services.CALFeatureName
A class that can be used to uniquely identify any CAL feature. This class is serializable to XML. @author Frank Worsley

                } 
            } else {
                QualifiedName oldMetadataName = QualifiedName.makeFromCompoundName(metadata.getFeatureName().getName());
                if (oldName.getModuleName().equals(oldMetadataName.getModuleName())) {
                    QualifiedName newMetadataName = QualifiedName.make(newName.getModuleName(), oldMetadataName.getUnqualifiedName());
                    return new CALFeatureName(metadata.getFeatureName().getType(), newMetadataName.getQualifiedName());
                }
            }
        // If we are not renaming a module, we only need to rename the metadata if is corresponds to the entity which we are renaming. 
        } else {
            if (metadata.getFeatureName().getType() != CALFeatureName.MODULE) {
                QualifiedName oldMetadataName = QualifiedName.makeFromCompoundName(metadata.getFeatureName().getName());
                if (oldName.equals(oldMetadataName)) {
                   return new CALFeatureName(metadata.getFeatureName().getType(), newName.getQualifiedName());
                }
            }
        }
        return metadata.getFeatureName();
    }

View Full Code Here

                    ModuleName metadataModuleName = oldMetadata.getFeatureName().toModuleName();
                    if (moduleContainer.containsModule(metadataModuleName)) {
                        continue;
                    }
                    
                    CALFeatureName newMetadataFeatureName = getNewMetadataFeatureName(oldMetadata);               
                    CALFeatureMetadata newMetadata = oldMetadata.copy(newMetadataFeatureName, metadataLocale);
                    if (!newMetadataFeatureName.equals(oldMetadata.getFeatureName())) {
                        metadataUpdated = true;
                    }
                    
                    // Try to update the examples if the metadata is for a functional agent. 
                    if (newMetadata instanceof FunctionalAgentMetadata) {

View Full Code Here

        // For now, there is nothing for it but to iterate over all the entries in the cache.
        for (Iterator<Map.Entry<LocalizedResourceName, MetadataCacheEntry>> it = dataCache.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<LocalizedResourceName, MetadataCacheEntry> mapEntry = it.next();


            LocalizedResourceName cacheEntryKey = mapEntry.getKey();
            CALFeatureName cacheEntryFeatureName = (CALFeatureName)cacheEntryKey.getFeatureName();
            if (cacheEntryFeatureName.hasModuleName() && cacheEntryFeatureName.toModuleName().equals(moduleName)) {
                it.remove();
            }
        }
    }

View Full Code Here

        
        FeatureType type = featureName.getType();
        
        if (featureName instanceof CALFeatureName) {


            CALFeatureName calFeatureName = (CALFeatureName)featureName;
            
            // Determine the path to the metadata file
            if (calFeatureName.isScopedEntityName()) {
                
                return calFeatureName.toQualifiedName().getUnqualifiedName();
                
            } else if (type == CALFeatureName.MODULE) {
                
                return featureName.getName();
                
            } else if (type == CALFeatureName.CLASS_INSTANCE) {
                
                ClassInstanceIdentifier identifier = calFeatureName.toInstanceIdentifier();
                
                return identifier.getTypeClassName().getQualifiedName() + 
                       " " + 
                       identifier.getTypeIdentifier();
                
            } else if (type == CALFeatureName.INSTANCE_METHOD) {
                
                ClassInstanceIdentifier identifier = calFeatureName.toInstanceIdentifier();
                
                return identifier.getTypeClassName().getQualifiedName() + 
                       " " + 
                       identifier.getTypeIdentifier() +
                       "@" +
                       calFeatureName.toInstanceMethodName();
                
            }
        }
        throw new IllegalArgumentException("feature type not supported: " + type);
    }

View Full Code Here

            QualifiedName typeClassName = QualifiedName.makeFromCompoundName(typeClassString);            


            return CALFeatureName.getInstanceMethodFeatureName(ClassInstanceIdentifier.make(typeClassName, typeIdentifier), moduleName, methodName);
            
        } else if (CALFeatureName.isScopedEntityFeatureType(featureType)) {
            return new CALFeatureName(featureType, QualifiedName.make(moduleName, featureString).getQualifiedName());
            
        } else {
            throw new IllegalArgumentException("feature type not supported: " + featureType);
        }
    }

View Full Code Here

                buffer.append(getAdditionalMetadataHtml(owner, metadata, null));
            }
            
        } else {
            // add the basic metadata, then the metadata specific sections, and finally put the additional sections at the bottom
            CALFeatureName featureName = url.toFeatureName();
            
            // in the following if-else checks, if the metadata is null, it will fail all the instanceof checks
            // and simply fall off the end with no additional HTML generated, which is what is intended in such cases.
            
            if (metadata instanceof FunctionalAgentMetadata) {
                QualifiedName qualifiedName = featureName.toQualifiedName();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(qualifiedName.getModuleName()).getTypeInfo();
                FunctionalAgent envEntity = moduleTypeInfoForFeature.getFunctionalAgent(qualifiedName.getUnqualifiedName());
                
                boolean isRequiredClassMethod = false;
                if (envEntity instanceof ClassMethod) {
                    ClassMethod method = (ClassMethod)envEntity;
                    isRequiredClassMethod = (method.getDefaultClassMethodName() == null); // no default -> required
                }
                
                CALDocComment caldoc = envEntity.getCALDocComment();
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getFunctionalAgentMetadataHtml(owner, (FunctionalAgentMetadata) metadata, url, caldoc, isRequiredClassMethod));
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
                
            } else if (metadata instanceof ModuleMetadata) {
                ModuleName moduleName = featureName.toModuleName();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(moduleName).getTypeInfo();
                
                CALDocComment caldoc = moduleTypeInfoForFeature.getCALDocComment();
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getModuleMetadataHtml(owner, (ModuleMetadata) metadata)); 
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
                
            } else if (metadata instanceof TypeClassMetadata) {
                QualifiedName qualifiedName = featureName.toQualifiedName();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(qualifiedName.getModuleName()).getTypeInfo();
                TypeClass typeClass = moduleTypeInfoForFeature.getTypeClass(qualifiedName.getUnqualifiedName());
                
                CALDocComment caldoc = typeClass.getCALDocComment();
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getTypeClassMetadataHtml(owner, (TypeClassMetadata) metadata));
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
                
            } else if (metadata instanceof TypeConstructorMetadata) {
                QualifiedName qualifiedName = featureName.toQualifiedName();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(qualifiedName.getModuleName()).getTypeInfo();
                TypeConstructor typeCons = moduleTypeInfoForFeature.getTypeConstructor(qualifiedName.getUnqualifiedName());
                
                CALDocComment caldoc = typeCons.getCALDocComment();
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getTypeConstructorMetadataHtml(owner, (TypeConstructorMetadata) metadata));
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
                
            } else if (metadata instanceof ClassInstanceMetadata) {
                ClassInstanceIdentifier classInstanceID = featureName.toInstanceIdentifier();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(featureName.toModuleName()).getTypeInfo();
                ClassInstance instance = moduleTypeInfoForFeature.getClassInstance(classInstanceID);
                
                CALDocComment caldoc = instance.getCALDocComment();
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getClassInstanceMetadataHtml(owner, (ClassInstanceMetadata) metadata));
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
                
            } else if (metadata instanceof InstanceMethodMetadata) {
                ClassInstanceIdentifier classInstanceID = featureName.toInstanceIdentifier();
                ModuleTypeInfo moduleTypeInfoForFeature = owner.getPerspective().getMetaModule(featureName.toModuleName()).getTypeInfo();
                ClassInstance instance = moduleTypeInfoForFeature.getClassInstance(classInstanceID);
                
                CALDocComment caldoc = instance.getMethodCALDocComment(featureName.toInstanceMethodName());
                buffer.append(getBasicMetadataHtml(owner, metadata, caldoc));
                buffer.append(getInstanceMethodMetadataHtml(owner, (InstanceMethodMetadata) metadata, url, caldoc));
                buffer.append(getAdditionalMetadataHtml(owner, metadata, caldoc));
            }
        }

View Full Code Here

        } else {
            buffer.append(version);
        }
        
        if (metadata instanceof ScopedEntityMetadata) {
            CALFeatureName featureName = ((ScopedEntityMetadata) metadata).getFeatureName();
            ScopedEntity entity = owner.getPerspective().getWorkspace().getScopedEntity(featureName);
            
            if (entity != null) {
                buffer.append("</td></tr><tr><td valign='top'>" + NavigatorMessages.getString("NAV_Visibility") + "</td><td>");
                buffer.append(entity.getScope().toString());
            }
        }
        
        if (metadata instanceof FunctionalAgentMetadata) {
    
            buffer.append("</td></tr><tr><td valign='top'>" + NavigatorMessages.getString("NAV_Categories") + "</td><td>");
            String[] categories = ((FunctionalAgentMetadata) metadata).getCategories();
            if (categories.length == 0) {
                buffer.append(NavigatorMessages.getString("NAV_NoValue"));
            
            } else {
                
                for (final String category : categories) {
                    buffer.append(category);
                    buffer.append(", ");
                }
                    
                // remove trailing comma
                buffer.delete(buffer.length() - 2, buffer.length());
            }
        }
        
        buffer.append("</td></tr></table>");
        
        // Put in a section for the related features.
        buffer.append("<h2>" + getAnchorHtml(RELATED_ANCHOR, NavigatorMessages.getString("NAV_RelatedFeatures_Header")) + "</h2>");
        
        int featureCount = metadata.getNRelatedFeatures();
        if (featureCount == 0) {
            if (caldoc != null) {
                // add the CALDoc @see references if the metadata specifies no related features
                
                boolean seenSeeBlock = false;
                
                for (int i = 0, nModuleRefs = caldoc.getNModuleReferences(); i < nModuleRefs; i++) {
                    seenSeeBlock = true;
                    
                    ModuleName name = caldoc.getNthModuleReference(i).getName();
                    CALFeatureName featureName = CALFeatureName.getModuleFeatureName(name);
                    buffer.append(getRelatedFeatureLinkHtml(owner, featureName)).append("<br>");
                }
                
                for (int i = 0, nFuncRefs = caldoc.getNFunctionOrClassMethodReferences(); i < nFuncRefs; i++) {
                    seenSeeBlock = true;
                    
                    QualifiedName name = caldoc.getNthFunctionOrClassMethodReference(i).getName();
                    CALFeatureName featureName;
                    if (isNameForClassMethod(owner, name)) {
                        featureName = CALFeatureName.getClassMethodFeatureName(name);
                    } else {
                        featureName = CALFeatureName.getFunctionFeatureName(name);
                    }
                    buffer.append(getRelatedFeatureLinkHtml(owner, featureName)).append("<br>");
                }
                
                for (int i = 0, nTypeConsRefs = caldoc.getNTypeConstructorReferences(); i < nTypeConsRefs; i++) {
                    seenSeeBlock = true;
                    
                    QualifiedName name = caldoc.getNthTypeConstructorReference(i).getName();
                    CALFeatureName featureName = CALFeatureName.getTypeConstructorFeatureName(name);
                    buffer.append(getRelatedFeatureLinkHtml(owner, featureName)).append("<br>");
                }
                
                for (int i = 0, nDataConsRefs = caldoc.getNDataConstructorReferences(); i < nDataConsRefs; i++) {
                    seenSeeBlock = true;
                    
                    QualifiedName name = caldoc.getNthDataConstructorReference(i).getName();
                    CALFeatureName featureName = CALFeatureName.getDataConstructorFeatureName(name);
                    buffer.append(getRelatedFeatureLinkHtml(owner, featureName)).append("<br>");
                }
                
                for (int i = 0, nTypeClassRefs = caldoc.getNTypeClassReferences(); i < nTypeClassRefs; i++) {
                    seenSeeBlock = true;
                    
                    QualifiedName name = caldoc.getNthTypeClassReference(i).getName();
                    CALFeatureName featureName = CALFeatureName.getTypeClassFeatureName(name);
                    buffer.append(getRelatedFeatureLinkHtml(owner, featureName)).append("<br>");
                }
                
                if (seenSeeBlock) {
                    // remove trailing <br>

View Full Code Here

        StringBuilder buffer = new StringBuilder();


        ScopedEntityNamingPolicy namingPolicy = new UnqualifiedUnlessAmbiguous(owner.getPerspective().getWorkingModuleTypeInfo());        
        ClassInstanceIdentifier identifier = metadata.getFeatureName().toInstanceIdentifier();
                
        CALFeatureName className = CALFeatureName.getTypeClassFeatureName(identifier.getTypeClassName());        
        TypeClass typeClass = (TypeClass) owner.getPerspective().getWorkspace().getScopedEntity(className);
        
        // list the instance class and type        
        buffer.append("<h2>" + getAnchorHtml(INSTANCE_CLASS_ANCHOR, NavigatorMessages.getString("NAV_InstanceClass_Header")) + "</h2>");
        buffer.append(getLinkHtml(NavAddress.getAddress(typeClass), typeClass.getAdaptedName(namingPolicy)));
        
        if (identifier instanceof ClassInstanceIdentifier.TypeConstructorInstance) {               
            CALFeatureName typeName = CALFeatureName.getTypeConstructorFeatureName(((ClassInstanceIdentifier.TypeConstructorInstance)identifier).getTypeConsName());
            TypeConstructor typeCons = (TypeConstructor) owner.getPerspective().getWorkspace().getScopedEntity(typeName);
            buffer.append("<h2>" + getAnchorHtml(INSTANCE_TYPE_ANCHOR, NavigatorMessages.getString("NAV_InstanceType_Header")) + "</h2>");
            buffer.append(getLinkHtml(NavAddress.getAddress(typeCons), typeCons.getAdaptedName(namingPolicy)));
        }

View Full Code Here

            }
        
        } else if (metadata instanceof ScopedEntityMetadata || metadata instanceof ClassInstanceMetadata || metadata instanceof InstanceMethodMetadata) {
                
            String typeString = null;
            CALFeatureName featureName = metadata.getFeatureName();
            
            // add link to module
            ModuleName moduleName = featureName.toModuleName();
            MetaModule module = owner.getPerspective().getMetaModule(moduleName);
            NavAddress moduleUrl = NavAddress.getAddress(module);
            buffer.append(getLinkHtml(NavAddress.getAddress(module), moduleName.toSourceText()));
            buffer.append(separator);


            // add link to parent or vault
            if (metadata instanceof FunctionMetadata) {
                NavAddress vaultUrl = moduleUrl.withParameter(NavAddress.VAULT_PARAMETER, NavAddress.FUNCTION_VAULT_VALUE);
                buffer.append(getLinkHtml(vaultUrl, NavigatorMessages.getString("NAV_FunctionVault_Location")));
                typeString = NavigatorMessages.getString("NAV_Function_Location");


            } else if (metadata instanceof TypeConstructorMetadata) {
                NavAddress vaultUrl = moduleUrl.withParameter(NavAddress.VAULT_PARAMETER, NavAddress.TYPE_VAULT_VALUE);
                buffer.append(getLinkHtml(vaultUrl, NavigatorMessages.getString("NAV_TypeVault_Location")));
                typeString = NavigatorMessages.getString("NAV_Type_Location");
                
            } else if (metadata instanceof TypeClassMetadata) {
                NavAddress vaultUrl = moduleUrl.withParameter(NavAddress.VAULT_PARAMETER, NavAddress.CLASS_VAULT_VALUE);
                buffer.append(getLinkHtml(vaultUrl, NavigatorMessages.getString("NAV_ClassVault_Location")));
                typeString = NavigatorMessages.getString("NAV_Class_Location");
                
            } else if (metadata instanceof ClassInstanceMetadata) {
                NavAddress vaultUrl = moduleUrl.withParameter(NavAddress.VAULT_PARAMETER, NavAddress.INSTANCE_VAULT_VALUE);
                buffer.append(getLinkHtml(vaultUrl, NavigatorMessages.getString("NAV_InstanceVault_Location")));
                typeString = NavigatorMessages.getString("NAV_Instance_Location");                    
            
            } else if (metadata instanceof InstanceMethodMetadata) {
                CALFeatureName methodFeatureName = metadata.getFeatureName();
                NavAddress parentUrl = NavAddress.getAddress(CALFeatureName.getClassInstanceFeatureName(
                    methodFeatureName.toInstanceIdentifier(), methodFeatureName.toModuleName()));
                
                buffer.append(getLinkHtml(parentUrl, NavAddressHelper.getDisplayText(owner, parentUrl, ScopedEntityNamingPolicy.UNQUALIFIED)));
                typeString = NavigatorMessages.getString("NAV_InstanceMethod_Location");                    
            
            } else if (metadata instanceof ClassMethodMetadata) {


                typeString = NavigatorMessages.getString("NAV_ClassMethod_Location");


                // figure out the type class this method belongs to
                TypeClass parentClass = null;
                CALFeatureName methodFeatureName = ((ClassMethodMetadata) metadata).getFeatureName();
                QualifiedName methodName = methodFeatureName.toQualifiedName();
                int classCount = module.getTypeInfo().getNTypeClasses();
                
                for (int i = 0; i < classCount; i++) {
                    TypeClass typeClass = module.getTypeInfo().getNthTypeClass(i);
                    
                    int methodCount = typeClass.getNClassMethods();
                    for (int n = 0; n < methodCount; n++) {
                        if (typeClass.getNthClassMethod(n).getName().equals(methodName)) {
                            parentClass = typeClass;
                            break;
                        }
                    }
                    
                    if (parentClass != null) {
                        break;
                    }
                }
                
                if (parentClass != null) {
                    NavAddress parentUrl = NavAddress.getAddress(parentClass);
                    buffer.append(getLinkHtml(parentUrl, NavAddressHelper.getDisplayText(owner, parentUrl, ScopedEntityNamingPolicy.UNQUALIFIED)));
                } else {
                    buffer.append("<font color='red'>" + NavigatorMessages.getString("NAV_ClassNotFound_Location") + "</font>");
                }
                
            } else if (metadata instanceof DataConstructorMetadata) {
                
                typeString = NavigatorMessages.getString("NAV_Constructor_Location");
                
                // figure out the type constructor this data constructor is for
                CALFeatureName dataConsFeatureName = ((DataConstructorMetadata) metadata).getFeatureName();
                QualifiedName dataConsName = dataConsFeatureName.toQualifiedName();
                TypeConstructor parentCons = null;
                int typeConsCount = module.getTypeInfo().getNTypeConstructors();
                
                for (int i = 0; i < typeConsCount; i++) {
                    TypeConstructor typeCons = module.getTypeInfo().getNthTypeConstructor(i);

View Full Code Here

                    MetadataStore metadataStore = (MetadataStore)metadataResourceManager.getResourceStore();
                    if (metadataStore.isWriteable()) {
                        for (Iterator<WorkspaceResource> it = metadataStore.getResourceIterator(moduleName); it.hasNext(); ) {
                            WorkspaceResource metadataResource = it.next();
                            ResourceIdentifier identifier = metadataResource.getIdentifier();
                            CALFeatureName featureName = (CALFeatureName)identifier.getFeatureName();
                            Locale locale = LocalizedResourceName.localeOf(identifier.getResourceName());
                            if (getWorkspace().getMetaModule(featureName.toModuleName()) != null) {
                                CALFeatureMetadata metadata = getWorkspace().getMetadata(featureName, locale);
                                if (!getWorkspace().saveMetadata(metadata)) {
                                    System.out.println("Error saving metadata for " + featureName + " for " + (locale == null ? "default" : locale.toString()) + " locale.");
                                } 
                            }

View Full Code Here

0 1 2

TOP

Related Classes of org.openquark.cal.services.CALFeatureName

org.openquark.cal.caldoc.CALDocToHTMLUtilities$CALFeatureCrossReferenceGenerator

org.openquark.cal.compiler.CALRenaming_DeepTest

org.openquark.cal.compiler.QualifiedName

org.openquark.cal.compiler.Refactorer$Rename

org.openquark.cal.filter.ExcludeTestModulesFilter

org.openquark.cal.ICE

org.openquark.cal.metadata.CALFeatureMetadata

org.openquark.cal.metadata.MetadataCache

org.openquark.cal.metadata.MetadataPathMapper

org.openquark.cal.metadata.MetadataRenameUpdater

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.