public void refreshFromDB(String newName) {
    if (_mainObject.getName().equals(newName)) {
      if (_mainObject instanceof ICatalogObject) {
        if (_mainObject instanceof SybaseASABaseUserDefinedType) {
          Schema schema = ((UserDefinedType) _mainObject).getSchema();
          // schema may lost
          if (schema == null) {
            _mainObject = null;
            return;
          }
        }
        ((ICatalogObject) _mainObject).refresh();
        return;
      }
    }

    if (!isModelExist()) {
      _mainObject = null;
      return;
    }

    boolean isFound = false;
    if (_mainObject instanceof SybaseASABaseUserDefinedType) {
      Schema schema = ((SybaseASABaseUserDefinedType) _mainObject).getSchema();
      // schema may lost
      if (schema != null) {
        //                DSEUtil.refreshObjectBySchema(schema, _mainObject);

        EList udds = schema.getUserDefinedTypes();
        for (Iterator iter = udds.iterator(); iter.hasNext(); ) {
          SybaseASABaseUserDefinedType asaUDD = (SybaseASABaseUserDefinedType) iter.next();
          if (asaUDD.getName().equals(_mainObject.getName())) {
            _mainObject = asaUDD;
            isFound = true;
            break;
          }
        }

        if (!isFound) {
          for (Iterator iter = udds.iterator(); iter.hasNext(); ) {
            SybaseASABaseUserDefinedType asaUDD = (SybaseASABaseUserDefinedType) iter.next();
            if (asaUDD.getName().equals(newName)) {
              _mainObject = asaUDD;
              isFound = true;
              break;
            }
          }
        }
      }
    }
    if (!isFound) {
      _mainObject = null;
    }
  }
  /*
   * (non-Javadoc)
   *
   * @see org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
   */
  public Object execute(ExecutionEvent event) throws ExecutionException {
    Project p = MovieUtil.getActiveProject();
    if (p != null) {
      EList<Movie> movies =
          p.getAllModelElementsbyClass(MoviesPackage.eINSTANCE.getMovie(), new BasicEList<Movie>());
      for (Iterator<Movie> iter = movies.iterator(); iter.hasNext(); ) {
        if (iter.next().getOverallRating() == "ZERO"
            || iter.next().getOverallRating() == "ONE"
            || iter.next().getOverallRating() == "TWO") {
          iter.remove();
        }
      }

      // Open Movies View and set input
      try {
        IViewPart view =
            PlatformUI.getWorkbench()
                .getActiveWorkbenchWindow()
                .getActivePage()
                .showView(MoviesView.ID);
        if (view instanceof MoviesView) {
          MoviesView moviesView = (MoviesView) view;
          moviesView.setInput(movies);
        }
      } catch (PartInitException e) {
        // showView() can throw an exception if view cannot be shown
        e.printStackTrace();
      }
    }
    return null;
  }
Esempio n. 3
0
 public static Preference getPreferenceByID(
     DefaultProfile defaultProfile, String categoryId, String prefId) {
   Category cat = getCategoryByID(defaultProfile, categoryId);
   if (cat != null) { // if found category
     EList groups = cat.getGroup();
     for (Iterator grpIt = groups.iterator(); grpIt.hasNext(); ) {
       Group group = (Group) grpIt.next();
       EList prefs = group.getPref();
       for (Iterator it = prefs.iterator(); it.hasNext(); ) {
         Preference pref = (Preference) it.next();
         if (prefId.equals(pref.getId())) return pref;
       }
     }
   }
   return null;
 }
Esempio n. 4
0
 private static Category getCategoryByID(DefaultProfile defaultProfile, String categoryId) {
   EList cats = defaultProfile.getCategory();
   for (Iterator it = cats.iterator(); it.hasNext(); ) {
     Category cat = (Category) it.next();
     if (categoryId.equals(cat.getId())) return cat;
   }
   return null;
 }
Esempio n. 5
0
 private static void getAllSuperClasses(EClass eClass, Set<EClass> result) {
   EList superTypes = eClass.getESuperTypes();
   for (Iterator it = superTypes.iterator(); it.hasNext(); ) {
     EClass element = (EClass) it.next();
     result.add(element);
     getAllSuperClasses(element, result);
   }
 }
Esempio n. 6
0
 private int[] initDomainValues(DiscreteDomain domain) {
   EList<DomainValue> values = domain.getValues();
   int[] valueArray = new int[values.size()];
   Iterator<DomainValue> iterator = values.iterator();
   for (int i = 0; i < valueArray.length; i++) {
     valueArray[i] = iterator.next().getInt();
   }
   return valueArray;
 }
Esempio n. 7
0
 public static List getProfilesWhoseBaseIs(String baseName, FormatProfiles profilesroot) {
   List results = new ArrayList();
   EList profiles = profilesroot.getProfile();
   for (Iterator it = profiles.iterator(); it.hasNext(); ) {
     Profile profile = (Profile) it.next();
     String profileBase = profile.getBase();
     if (profileBase != null && profileBase.equals(baseName)) results.add(profile);
   }
   return results;
 }
Esempio n. 8
0
 private static Control getControlByName(DefaultProfile defaultProfile, String controlName) {
   Controls controls = defaultProfile.getControls();
   EList cntrls = controls.getControl();
   for (Iterator it = cntrls.iterator(); it.hasNext(); ) {
     Control control = (Control) it.next();
     String controlElemName = control.getName();
     if (controlElemName != null && controlElemName.equals(controlName)) return control;
   }
   return null;
 }
Esempio n. 9
0
 /**
  * try to find the profile node within <egl:format_profiles>, whose name is profileName
  *
  * @param profileName
  * @param formatprofiles
  * @return - null if not found
  */
 public static Profile findProfileByName(String profileName, FormatProfiles formatprofiles) {
   EList profiles = formatprofiles.getProfile();
   for (Iterator it = profiles.iterator(); it.hasNext(); ) {
     Profile profile = (Profile) it.next();
     if (profileName.equals(profile.getName())) {
       return profile;
     }
   }
   return null;
 }
 /**
  * check for transitions from initstate
  *
  * @param initState
  * @return
  */
 private boolean isLoneTransition(EObject initState) {
   Pageflow pageflow = (Pageflow) initState.eContainer();
   EList transitions = pageflow.getTransitions();
   for (Iterator iter = transitions.iterator(); iter.hasNext(); ) {
     Transition transition = (Transition) iter.next();
     if (transition.getFromState().equals(initState)) {
       return false;
     }
   }
   return true;
 }
 /**
  * Gets the top level navexpression model.
  *
  * @return
  */
 public CCM getModel() {
   if (null == ccm) {
     EList l = resource.getContents();
     Iterator i = l.iterator();
     while (i.hasNext()) {
       Object o = i.next();
       if (o instanceof CCM) ccm = (CCM) o;
     }
   }
   return ccm;
 }
Esempio n. 12
0
 public static Setting getPreferenceSettingByID(
     Profile profile, String categoryId, String prefId) {
   EList settings = profile.getSetting();
   if (settings != null) {
     for (Iterator it = settings.iterator(); it.hasNext(); ) {
       Setting setting = (Setting) it.next();
       if (categoryId.equals(setting.getCategory()) && prefId.equals(setting.getPref()))
         return setting;
     }
   }
   return null;
 }
Esempio n. 13
0
 protected static void filterMPEForLib(EList<MindPathEntry> list) {
   for (Iterator iterator = list.iterator(); iterator.hasNext(); ) {
     MindPathEntry mpe = (MindPathEntry) iterator.next();
     if (mpe.getEntryKind() == MindPathKind.SOURCE) {
       iterator.remove();
     }
   }
   MindPathEntryCustomImpl mpe = new MindPathEntryCustomImpl();
   mpe.setEntryKind(MindPathKind.SOURCE);
   mpe.setName(".");
   list.add(mpe);
 }
Esempio n. 14
0
  @SuppressWarnings("unchecked")
  @Before
  public void setUp() throws Exception {
    ProjectRegistry registry = ProjectPlugin.getPlugin().getProjectRegistry();
    List<Project> projects = registry.getProjects();
    registry.getProjects().removeAll(projects);

    EList list = registry.eResource().getResourceSet().getResources();
    Set<Resource> toRemove = new HashSet<Resource>();
    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
      Resource element = (Resource) iter.next();
      if (element != registry.eResource()) {
        element.unload();
        toRemove.add(element);
      }
    }

    project = registry.getDefaultProject();
    file = new File(project.eResource().getURI().toFileString());
    if (file.exists()) {
      if (file.isFile()) {
        file.delete();
        File parent = file.getParentFile();
        File[] files = parent.listFiles();
        for (File file : files) {
          file.delete();
        }
        parent.delete();
      }
      file.delete();
    }

    registry.eResource().getResourceSet().getResources().removeAll(toRemove);

    project =
        registry.getProject(
            FileLocator.toFileURL(Platform.getInstanceLocation().getURL()).getFile());

    resource1 =
        MapTests.createGeoResource(UDIGTestUtil.createDefaultTestFeatures(type1Name, 4), false);
    Map map = MapTests.createNonDynamicMapAndRenderer(resource1, new Dimension(512, 512));
    map.setName(firstMapName);
    map.getLayersInternal().get(0).setName(firstMapLayerName);

    resource2 =
        MapTests.createGeoResource(UDIGTestUtil.createDefaultTestFeatures(type2Name, 6), false);
    map = MapTests.createNonDynamicMapAndRenderer(resource2, new Dimension(512, 512));
    map.setName(secondMapName);
    map.getLayersInternal().get(0).setName(secondMapLayerName);
  }
 protected double sumMemoryActuals(ComponentInstance ci, boolean isROM) {
   try {
     double total =
         isROM ? GetProperties.getROMActualInKB(ci, 0.0) : GetProperties.getRAMActualInKB(ci, 0.0);
     EList subcis = ci.getComponentInstances();
     for (Iterator it = subcis.iterator(); it.hasNext(); ) {
       ComponentInstance subci = (ComponentInstance) it.next();
       total += sumMemoryActuals(subci, isROM);
     }
     return total;
   } catch (PropertyDoesNotApplyToHolderException e) {
     /*
      * Callers are allowed to be sloppy and not care if the property
      * actually applies to the category of the component instance 'ci'
      */
     return 0.0;
   }
 }
Esempio n. 16
0
 @Override
 public void pruneDependencies() {
   final Iterator<java.util.Map.Entry<EObject, EList<IScriptDependency>>> eIterator =
       getDependencies().entrySet().iterator();
   while (eIterator.hasNext()) {
     final java.util.Map.Entry<EObject, EList<IScriptDependency>> e = eIterator.next();
     final EList<IScriptDependency> dList = e.getValue();
     final Iterator<IScriptDependency> dIterator = dList.iterator();
     while (dIterator.hasNext()) {
       final IScriptDependency d = dIterator.next();
       if (!d.eIsSet(IScriptEnginePackage.Literals.SCRIPT_DEPENDENCY__EXPRESSIONS)) {
         dIterator.remove();
       }
     }
     if (dList.isEmpty()) {
       e.getKey().eAdapters().remove(myDependencyAdapter);
       eIterator.remove();
     }
   }
 }
  /**
   * Builds the dependency for a method element.
   *
   * @param element A method element.
   */
  private void buildDependency(MethodElement element) {
    if (element == null) {
      return;
    }

    try {
      PackageDependency dependency = buildDependencyFor(element);
      boolean isProcess = element instanceof ProcessComponent;

      EList elements = element.eContents();
      if (elements != null) {
        for (Iterator it = elements.iterator(); it.hasNext(); ) {
          Object obj = it.next();
          if (!(obj instanceof MethodElement)) {
            continue;
          }
          MethodElement methodElement = (MethodElement) obj;
          if (methodElement != null && !LibraryUtil.selectable(methodElement)) {
            buildDependencyFor(methodElement);
          } else if (isProcess && methodElement instanceof ProcessPackage) {
            for (Iterator itt = methodElement.eAllContents(); itt.hasNext(); ) {
              Object objj = itt.next();
              if (objj instanceof MethodElement) {
                MethodElement m = (MethodElement) objj;
                if (!LibraryUtil.selectable(m)) {
                  buildDependencyFor(m);
                }
              }
            }
          }
        }
      }

      dependency.setLoaded(true);
    } catch (Exception e) {
      if (debug) {
        e.printStackTrace();
      }
    }
  }
 @Override
 public String toString() {
   /*
    * Don't return a string with spaces in it becase this is used to
    * create a name for the object, and we cannot have spaces in our
    * name, or else it messes up the XML/XMI processing.
    */
   final StringBuffer name = new StringBuffer();
   EList ml = getCurrentModes();
   for (Iterator it = ml.iterator(); it.hasNext(); ) {
     final ModeInstance mi = (ModeInstance) it.next();
     final ComponentInstance ci = (ComponentInstance) mi.eContainer();
     name.append(ci.getComponentInstancePath());
     if (name.length() > 0) {
       name.append(".");
     }
     name.append(mi.getName());
     if (it.hasNext()) {
       name.append("#");
     }
   }
   return name.toString();
 }
  /**
   * Calculate bandwidth demand from rate & data size
   *
   * @param pci Port connection instance
   * @return
   */
  protected double calcBandwidthKBytesps(ConnectionInstanceEnd cie) {
    double res = 0;

    // TODO-LW add other cases
    if (cie instanceof FeatureInstance) {
      FeatureInstance fi = (FeatureInstance) cie;
      double datasize = GetProperties.getSourceDataSize(fi, GetProperties.getKBUnitLiteral(fi));
      double srcRate = getDataRate(fi, 0.0);
      if (srcRate == 0) {
        double period = GetProperties.getPeriodInSeconds(fi.getContainingComponentInstance(), 0);
        if (period == 0) return res;
        srcRate = 1 / GetProperties.getPeriodInSeconds(fi.getContainingComponentInstance(), 1);
      }
      res = datasize * srcRate;
      EList fil = fi.getFeatureInstances();
      if (fil.size() > 0) {
        double subres = 0;
        for (Iterator it = fil.iterator(); it.hasNext(); ) {
          FeatureInstance sfi = (FeatureInstance) it.next();
          subres = subres + calcBandwidthKBytesps(sfi);
        }
        if (subres > res) {
          if (res > 0) {
            errManager.warningSummary(
                fi,
                null,
                "Bandwidth of feature group ports "
                    + subres
                    + " exceeds feature group bandwidth "
                    + res);
          }
          res = subres;
        }
      }
    }
    return res;
  }
Esempio n. 20
0
  @Ignore
  @Test
  public void testSaveAndLoad() throws Exception {
    EList list = project.eResource().getResourceSet().getResources();

    for (Iterator iter = list.iterator(); iter.hasNext(); ) {
      Resource element = (Resource) iter.next();
      try {
        element.save(null);
      } catch (Exception e) {
      }
      if (!element.getContents().contains(ProjectPlugin.getPlugin().getProjectRegistry()))
        element.unload();
    }

    ResourceSet set = new ResourceSetImpl();
    Project project =
        (Project)
            set.getResource(URI.createURI("file://" + file.getAbsolutePath()), true)
                .getAllContents()
                .next(); //$NON-NLS-1$
    assertFalse(project.eIsProxy());
    assertNotNull(project);
    int maps = 0;
    boolean foundFirstMap = false;
    boolean foundSecondMap = false;

    List resources = project.getElements();
    for (Iterator iter = resources.iterator(); iter.hasNext(); ) {
      Map map = (Map) iter.next();

      assertFalse(map.eIsProxy());
      assertEquals(1, map.getLayersInternal().size());
      assertNotNull(map.getLayersInternal().get(0).getGeoResources().get(0));
      assertNotNull(
          map.getLayersInternal()
              .get(0)
              .getResource(FeatureSource.class, new NullProgressMonitor()));

      if (map.getName().equals(firstMapName)) {
        foundFirstMap = true;
        assertEquals(firstMapLayerName, map.getLayersInternal().get(0).getName());
        FeatureSource<SimpleFeatureType, SimpleFeature> source =
            map.getLayersInternal().get(0).getResource(FeatureSource.class, null);
        assertEquals(4, source.getCount(Query.ALL));
        assertEquals(firstMapLayerName, map.getLayersInternal().get(0).getName());
      }
      if (map.getName().equals(secondMapName)) {
        foundSecondMap = true;
        assertEquals(secondMapLayerName, map.getLayersInternal().get(0).getName());
        FeatureSource<SimpleFeatureType, SimpleFeature> source =
            map.getLayersInternal().get(0).getResource(FeatureSource.class, null);
        assertEquals(6, source.getCount(Query.ALL));
        assertEquals(secondMapLayerName, map.getLayersInternal().get(0).getName());
      }
      maps++;
    }
    assertEquals(2, maps);
    assertTrue(foundFirstMap);
    assertTrue(foundSecondMap);
  }
  public CharSequence apply(ImportManager importManager) {
    JvmOperation cacheMethod =
        (JvmOperation)
            logicalContainerProvider.getLogicalContainer(createExtensionInfo.getCreateExpression());
    StringBuilderBasedAppendable appendable = new StringBuilderBasedAppendable(importManager);
    JvmDeclaredType containerType = cacheMethod.getDeclaringType();
    JvmTypeReference listType = typeReferences.getTypeForName(ArrayList.class, containerType);
    JvmTypeReference collectonLiterals =
        typeReferences.getTypeForName(CollectionLiterals.class, containerType);
    String cacheVarName = cacheField.getSimpleName();
    String cacheKeyVarName = appendable.declareVariable("CacheKey", "_cacheKey");
    appendable.append("final ");
    typeReferenceSerializer.serialize(listType, containerType, appendable);
    appendable.append(cacheKeyVarName).append(" = ");
    typeReferenceSerializer.serialize(collectonLiterals, containerType, appendable);
    appendable.append(".newArrayList(");
    EList<JvmFormalParameter> list = cacheMethod.getParameters();
    for (Iterator<JvmFormalParameter> iterator = list.iterator(); iterator.hasNext(); ) {
      JvmFormalParameter jvmFormalParameter = iterator.next();
      appendable.append(getVarName(jvmFormalParameter));
      if (iterator.hasNext()) {
        appendable.append(", ");
      }
    }
    appendable.append(");");
    // declare result variable
    JvmTypeReference returnType = typeProvider.getType(createExtensionInfo.getCreateExpression());
    appendable.append("\nfinal ");
    typeReferenceSerializer.serialize(returnType, containerType, appendable);
    String resultVarName = "_result";
    appendable.append(" ").append(resultVarName).append(";");
    // open synchronize block
    appendable.append("\nsynchronized (").append(cacheVarName).append(") {");
    appendable.increaseIndentation();
    // if the cache contains the key return the previously created object.
    appendable
        .append("\nif (")
        .append(cacheVarName)
        .append(".containsKey(")
        .append(cacheKeyVarName)
        .append(")) {");
    appendable.increaseIndentation();
    appendable
        .append("\nreturn ")
        .append(cacheVarName)
        .append(".get(")
        .append(cacheKeyVarName)
        .append(");");
    appendable.decreaseIndentation().append("\n}");
    // execute the creation
    compiler.toJavaStatement(createExtensionInfo.getCreateExpression(), appendable, true);
    appendable.append("\n");
    appendable.append(resultVarName).append(" = ");
    compiler.toJavaExpression(createExtensionInfo.getCreateExpression(), appendable);
    appendable.append(";");

    // store the newly created object in the cache
    appendable
        .append("\n")
        .append(cacheVarName)
        .append(".put(")
        .append(cacheKeyVarName)
        .append(", ")
        .append(resultVarName)
        .append(");");

    // close synchronize block
    appendable.decreaseIndentation();
    appendable.append("\n}");
    appendable
        .append("\n")
        .append(initializerMethod.getSimpleName())
        .append("(")
        .append(resultVarName);
    for (JvmFormalParameter parameter : cacheMethod.getParameters()) {
      appendable.append(", ").append(parameter.getName());
    }
    appendable.append(");");
    // return the result
    appendable.append("\nreturn ");
    appendable.append(resultVarName).append(";");
    return appendable.toString();
  }
  /*
   * (non-Javadoc)
   * @see org.jboss.tools.seam.internal.core.project.facet.SeamFacetAbstractInstallDelegate#configureFacesConfigXml(org.eclipse.core.resources.IProject, org.eclipse.core.runtime.IProgressMonitor, java.lang.String)
   */
  @Override
  protected void configureFacesConfigXml(
      final IProject project, IProgressMonitor monitor, String webConfigName) {
    FacesConfigArtifactEdit facesConfigEdit = null;
    try {
      facesConfigEdit =
          FacesConfigArtifactEdit.getFacesConfigArtifactEditForWrite(project, webConfigName);
      FacesConfigType facesConfig = facesConfigEdit.getFacesConfig();
      EList applications = facesConfig.getApplication();
      ApplicationType applicationType = null;
      boolean applicationExists = false;
      if (applications.size() <= 0) {
        applicationType = FacesConfigFactory.eINSTANCE.createApplicationType();
      } else {
        applicationType = (ApplicationType) applications.get(0);
        applicationExists = true;
      }
      boolean localeConfigExists = false;
      for (Iterator iterator = applications.iterator(); iterator.hasNext(); ) {
        ApplicationType application = (ApplicationType) iterator.next();
        EList localeConfigs = application.getLocaleConfig();
        if (!localeConfigs.isEmpty()) {
          localeConfigExists = true;
          break;
        }
      }
      if (!localeConfigExists) {
        LocaleConfigType locale = FacesConfigFactory.eINSTANCE.createLocaleConfigType();
        DefaultLocaleType defaultLocale = FacesConfigFactory.eINSTANCE.createDefaultLocaleType();
        defaultLocale.setTextContent("en");
        locale.setDefaultLocale(defaultLocale);
        SupportedLocaleType supportedLocale =
            FacesConfigFactory.eINSTANCE.createSupportedLocaleType();
        supportedLocale.setTextContent("bg");
        locale.getSupportedLocale().add(supportedLocale);
        supportedLocale = FacesConfigFactory.eINSTANCE.createSupportedLocaleType();
        supportedLocale.setTextContent("de");
        locale.getSupportedLocale().add(supportedLocale);
        supportedLocale = FacesConfigFactory.eINSTANCE.createSupportedLocaleType();
        supportedLocale.setTextContent("en");
        locale.getSupportedLocale().add(supportedLocale);
        supportedLocale = FacesConfigFactory.eINSTANCE.createSupportedLocaleType();
        supportedLocale.setTextContent("fr");
        locale.getSupportedLocale().add(supportedLocale);
        supportedLocale = FacesConfigFactory.eINSTANCE.createSupportedLocaleType();
        supportedLocale.setTextContent("tr");
        locale.getSupportedLocale().add(supportedLocale);
        applicationType.getLocaleConfig().add(locale);
      }
      boolean viewHandlerExists = false;
      IDOMModel domModel = facesConfigEdit.getIDOMModel();
      if (domModel != null) {
        Element facesConfigElement = domModel.getDocument().getDocumentElement();
        if (facesConfigElement != null) {
          if (facesConfigElement.getAttribute("version").startsWith("1")) {
            for (Iterator iterator = applications.iterator(); iterator.hasNext(); ) {
              ApplicationType application = (ApplicationType) iterator.next();
              EList viewHandlers = application.getViewHandler();
              for (Iterator iterator2 = viewHandlers.iterator(); iterator2.hasNext(); ) {
                ViewHandlerType viewHandlerType = (ViewHandlerType) iterator2.next();
                if ("com.sun.facelets.FaceletViewHandler"
                    .equals(viewHandlerType.getTextContent().trim())) {
                  viewHandlerExists = true;
                  break;
                }
              }
            }
          } else {
            // Don't add facelet view handler for JSF 2
            viewHandlerExists = true;
          }
        }
      }

      if (!viewHandlerExists) {
        ViewHandlerType viewHandler = FacesConfigFactory.eINSTANCE.createViewHandlerType();
        viewHandler.setTextContent("com.sun.facelets.FaceletViewHandler");
        applicationType.getViewHandler().add(viewHandler);
      }
      if (!applicationExists) {
        facesConfig.getApplication().add(applicationType);
      }
      facesConfigEdit.save(monitor);
    } finally {
      if (facesConfigEdit != null) {
        facesConfigEdit.dispose();
      }
    }
  }
  /**
   * This method looks for inconsistent views of connectors to delete in case the connector is
   * re-oriented.
   *
   * @param viewsToDestroy the set of views of messages to destroy
   * @return the list of {@link View} of the connectors to delete
   */
  public static Set<View> addConnectorViewsToDestroy(Set<View> viewsToDestroy) {
    // for all the views to destroy, we have to classify them by their own connector,
    // then we have to verify for each connector that the set of messages (to destroy) on it are the
    // only messages that he contains
    // if yes, we have to add the view of the connector to list of views to destroy

    // the set connectors that are concerned by the deleted to the messages views
    Set<View> connectors = null;
    Set<View> newViewsToDestroy = new HashSet<View>(viewsToDestroy);
    // for all the messages to delete, search for their parent connector
    Iterator<?> it = viewsToDestroy.iterator();
    while (it.hasNext()) {
      View msgView = (View) it.next();
      if ((msgView instanceof DecorationNode) && (msgView.getElement() instanceof Message)) {
        if (msgView.eContainer() instanceof Connector) {
          if (connectors == null) {
            connectors = new HashSet<View>();
          }
          connectors.add((View) msgView.eContainer());
        }
      }
    }
    // Now the connectors set contains all the connectors that may have to be deleted
    // we have to check which connector have to be deleted
    if (connectors != null) {
      // for each connector we have to search for the set of its labels views to be destroyed

      Iterator<?> it1 = connectors.iterator();
      while (it1.hasNext()) {
        View conView = (View) it1.next();

        // Construct the list of viewsOfLabelsToDestroy
        Set<View> viewsOfLabelsToDestroy = null;
        Iterator<?> it2 = viewsToDestroy.iterator();
        while (it2.hasNext()) {
          View msgView = (View) it2.next();
          if ((msgView instanceof DecorationNode) && (msgView.getElement() instanceof Message)) {
            if ((msgView.eContainer() instanceof Connector)
                && (msgView.eContainer().equals(conView))) {
              if (viewsOfLabelsToDestroy == null) {
                viewsOfLabelsToDestroy = new HashSet<View>();
              }
              viewsOfLabelsToDestroy.add(msgView);
            }
          }
        }
        // if the set of viewsOfLabelsToDestroy contains all the real children of the connector
        // then add the connector to the views to destroy
        @SuppressWarnings("unchecked")
        EList<View> conChildren = conView.getChildren();
        Set<View> comparisonResult = new HashSet<View>(conChildren.size());
        for (Iterator<?> i = conChildren.iterator(); i.hasNext(); ) {
          View element = (View) i.next();
          if ((element instanceof DecorationNode) && (element.getElement() instanceof Message)) {
            if (!viewsOfLabelsToDestroy.contains(element)) {
              comparisonResult.add(element);
            }
          }
        }

        if (comparisonResult
            .isEmpty()) { // the set of viewsOfLabelsToDestroy contains all the real children of the
                          // connector
          newViewsToDestroy.add(conView);
        }
      }
    }
    return newViewsToDestroy;
  }
  /**
   * check the load from components bound to the given processor The components can be threads or
   * higher level components.
   *
   * @param curProcessor Component Instance of processor
   */
  protected void checkProcessorLoad(ComponentInstance curProcessor, final SystemOperationMode som) {
    boolean isCPUActive;

    if (curProcessor.getSubcomponent().getAllInModes().size() == 0) {
      isCPUActive = true;
    } else {
      isCPUActive = false;

      for (Mode mi : curProcessor.getSubcomponent().getAllInModes()) {
        // OsateDebug.osateDebug("somName=" + somName + " mi=" + mi);
        if (som.getName().equalsIgnoreCase(mi.getName())) {
          //	OsateDebug.osateDebug("cpu " + curProcessor.getName() +  "is active for mode" +
          // somName);
          isCPUActive = true;
        }
      }
    }

    if (isCPUActive == false) {
      return;
    }

    UnitLiteral mipsliteral = GetProperties.getMIPSUnitLiteral(curProcessor);
    double MIPScapacity = GetProperties.getMIPSCapacityInMIPS(curProcessor, 0.0);
    if (MIPScapacity == 0 && InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      MIPScapacity = GetProperties.getMIPSBudgetInMIPS(curProcessor);
    }
    long timeBefore = System.currentTimeMillis();
    OsateDebug.osateDebug(
        "[CPU] before get sw comps (CPU="
            + curProcessor.getName()
            + ",cat="
            + curProcessor.getComponentClassifier().getCategory().getName()
            + ")");
    EList<ComponentInstance> boundComponents = InstanceModelUtil.getBoundSWComponents(curProcessor);
    long timeAfter = System.currentTimeMillis();
    long period = timeAfter - timeBefore;
    OsateDebug.osateDebug("[CPU] after get sw comps, time taken=" + period + "ms");

    if (boundComponents.size() == 0 && MIPScapacity > 0) {
      errManager.infoSummary(
          curProcessor,
          som.getName(),
          "No application components bound to "
              + curProcessor.getComponentInstancePath()
              + " with MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral));
      return;
    }
    if (MIPScapacity == 0 && InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      errManager.warningSummary(
          curProcessor,
          som.getName(),
          "Virtual processor "
              + curProcessor.getComponentInstancePath()
              + " has no MIPS capacity or budget.");
      return;
    }
    if (MIPScapacity == 0 && InstanceModelUtil.isProcessor(curProcessor)) {
      errManager.errorSummary(
          curProcessor,
          som.getName(),
          "Processor "
              + curProcessor.getComponentInstancePath()
              + " has no MIPS capacity but has bound components.");
    }
    if (InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      logHeader(
          "\n\nDetailed Workload Report for Virtual Processor "
              + curProcessor.getComponentInstancePath()
              + " with Capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + "\n\nComponent,Budget,Actual");
    } else {
      logHeader(
          "\n\nDetailed Workload Report for Processor "
              + curProcessor.getComponentInstancePath()
              + " with Capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + "\n\nComponent,Budget,Actual");
    }
    double totalMIPS = 0.0;
    for (Iterator<ComponentInstance> it = boundComponents.iterator(); it.hasNext(); ) {
      ComponentInstance bci = (ComponentInstance) it.next();
      boolean isComponentActive;

      if ((som == null) || (bci.getSubcomponent().getAllInModes().size() == 0)) {
        isComponentActive = true;
      } else {
        isComponentActive = false;
        for (Mode mi : bci.getSubcomponent().getAllInModes()) {
          // OsateDebug.osateDebug("somName=" + somName + " mi=" + mi);
          if (som.getName().equalsIgnoreCase(mi.getName())) {
            //	OsateDebug.osateDebug("cpu " + curProcessor.getName() +  "is active for mode" +
            // somName);
            isComponentActive = true;
          }
        }
      }

      if (isComponentActive == true) {
        double actualmips = sumBudgets(bci, ResourceKind.MIPS, mipsliteral, true, som, "");
        totalMIPS += actualmips;
      }
    }
    logHeader("Total," + GetProperties.toStringScaled(totalMIPS, mipsliteral));
    if (totalMIPS > MIPScapacity) {
      errManager.errorSummary(
          curProcessor,
          som.getName(),
          "Total MIPS "
              + GetProperties.toStringScaled(totalMIPS, mipsliteral)
              + " of bound tasks exceeds MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + " of "
              + curProcessor.getComponentInstancePath());
    } else if (totalMIPS == 0.0) {
      errManager.warningSummary(curProcessor, som.getName(), "Bound app's have no MIPS budget.");
    } else {
      errManager.infoSummary(
          curProcessor,
          som.getName(),
          "Total MIPS "
              + GetProperties.toStringScaled(totalMIPS, mipsliteral)
              + " of bound tasks within "
              + "MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + " of "
              + curProcessor.getComponentInstancePath());
    }
  }
  /**
   * get the list of command to put an eobject before or after another EObject It will look for the
   * good role of the child eobject
   *
   * @param domain the Transactional Domain, cannot be null
   * @param targetOwner the eobject that will contain the drop object , cannot be null
   * @param objectLocation the object where we want to drop the object
   * @param newElement that we want to move, cannot be null
   * @return the list of commands to to the drop
   */
  protected List<Command> getOrderChangeCommand(
      TransactionalEditingDomain domain,
      EObject targetOwner,
      EObject objectLocation,
      EObject newElement,
      boolean before) {
    ArrayList<Command> commandList = new ArrayList<Command>();
    ArrayList<EStructuralFeature> possibleEFeatures = new ArrayList<EStructuralFeature>();
    EList<EStructuralFeature> featureList = targetOwner.eClass().getEAllStructuralFeatures();

    // Abort when trying to change order moving the element in one of its children
    if (EcoreUtil.isAncestor(newElement, targetOwner)) {
      return Collections.emptyList();
    }

    // find the feature between childreen and owner
    Iterator<EStructuralFeature> iterator = featureList.iterator();
    while (iterator.hasNext()) {
      EStructuralFeature eStructuralFeature = (EStructuralFeature) iterator.next();

      if (eStructuralFeature instanceof EReference) {
        EReference ref = (EReference) eStructuralFeature;

        if (ref.isContainment()) {

          if (isSubClass(ref.getEType(), newElement.eClass())) {
            possibleEFeatures.add(eStructuralFeature);
          }
        }
      }
    }

    // create the command
    Iterator<EStructuralFeature> iteratorFeature = possibleEFeatures.iterator();
    while (iteratorFeature.hasNext()) {
      EStructuralFeature eStructuralFeature = (EStructuralFeature) iteratorFeature.next();
      ArrayList<EObject> tmp = new ArrayList<EObject>();
      if (targetOwner.eGet(eStructuralFeature) instanceof Collection<?>) {
        // get all element of this efeature
        tmp.addAll((Collection<EObject>) targetOwner.eGet(eStructuralFeature));

        if (!newElement.equals(objectLocation)) {
          tmp.remove(newElement);
          // normally tmp.indexOf(objectLocation)!= -1
          // if this the case objectlocation=new element and
          // it has been removed
          int indexObject = tmp.indexOf(objectLocation);
          if (before && indexObject != -1) {
            tmp.add(tmp.indexOf(objectLocation), newElement);
          } else if (!before && indexObject != -1) {
            tmp.add(tmp.indexOf(objectLocation) + 1, newElement);
          }
        }
      } else {
        tmp.add(newElement);
      }

      SetRequest setRequest = new SetRequest(targetOwner, eStructuralFeature, tmp);
      IElementEditService provider = ElementEditServiceUtils.getCommandProvider(targetOwner);
      if (provider != null) {
        // Retrieve delete command from the Element Edit service
        ICommand command = provider.getEditCommand(setRequest);

        if (command != null) {
          commandList.add(new GMFtoEMFCommandWrapper(command));
        }
      }
    }
    return commandList;
  }
Esempio n. 26
0
  /**
   * _step Do the step for a single thread
   *
   * @param time
   * @param timeDelta
   * @param cycle
   * @param threadnum
   */
  protected void _step(STEMTime time, long timeDelta, int cycle, short threadnum) {
    //		this.setProgress(0.0);
    // We only deal with standard disease model decorators

    ArrayList<Decorator> iDecorators = new ArrayList<Decorator>();

    for (Decorator d : getDecorators()) {
      if (d instanceof IntegrationDecorator) iDecorators.add(d);
    }

    // First we get the step size, either the default step size
    // (initially 1.0) or the last step size used.

    double h = this.getStepSize();
    // x is to keep track of how far we have advanced in the solution. It is essentially
    // a double cycle representation

    double x = this.getCurrentX();

    // Substantial performance can be gained here. Basically if the current cycle
    // is greater than the cycle requested by the simulation, we are done. This
    // means that the error tolerance between last step and this step is small
    // enough so we don't need to update the labels. The error tolerance is
    // specified in the disease model

    // *** OBSERVE: Since we limit h to max 1 below, this code is never invoked. It's kept
    // *** around in case we want to allow time to be calculated far out in the future if
    // *** the error is small enough

    if (x >= cycle) {
      // Just copy the next value the same as the current value for all labels
      for (Decorator sdm : iDecorators) {
        EList<DynamicLabel> myLabels = sdm.getLabelsToUpdate(threadnum, num_threads);
        int numLabels = myLabels.size();
        double n = 0.0;
        int setProgressEveryNthNode = num_threads * numLabels / (MAX_PROGRESS_REPORTS);
        if (setProgressEveryNthNode == 0) setProgressEveryNthNode = 1;
        for (final Iterator<DynamicLabel> currentStateLabelIter = myLabels.iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          // The estimated disease value contains the value calculated at position x

          IntegrationLabelValue nextValueAtX =
              (IntegrationLabelValue) EcoreUtil.copy(diseaseLabel.getProbeValue());
          IntegrationLabelValue currentValueAtCycle =
              (IntegrationLabelValue) diseaseLabel.getCurrentValue();
          IntegrationLabelValue nextState = (IntegrationLabelValue) diseaseLabel.getNextValue();
          adjustValuesToCycle(currentValueAtCycle, nextValueAtX, x, cycle);
          // NextValueAtX has been modified here to the correct value for this cycle.
          nextState.set(nextValueAtX);
          // The next value is valid now.
          diseaseLabel.setNextValueValid(true);
          double progress = n / numLabels;
          jobs[threadnum].setProgress(progress);
          if (n % setProgressEveryNthNode == 0) {
            // Get the progress for all threads
            for (int i = 0; i < num_threads; ++i)
              if (i != threadnum && jobs[i] != null) progress += jobs[i].getProgress();
            progress /= num_threads;
            sdm.setProgress(progress);
          }
          n += 1.0;
        }
      } // For each decorator
      // So that validation code above is happy
      jobs[threadnum].h = h;
      jobs[threadnum].t = x;

      return;
    }

    // When x (or time) is this we're done
    double end = Math.floor(this.getCurrentX()) + 1.0;

    // Make sure we actually have labels to update
    boolean workToDo = false;
    for (Decorator sdm : iDecorators)
      if (sdm.getLabelsToUpdate(threadnum, num_threads).size() > 0) {
        workToDo = true;
        break;
      }

    if (!workToDo) {
      // Nothing to do, just advance x and set h
      jobs[threadnum].h = h;
      jobs[threadnum].t = x;
      // Be nice and walk in step with others until done
      while (x < end) {
        try {
          // Set to a large number to make sure it's larger than any step size reported
          // by another thread
          do {
            jobs[threadnum].h = Double.MAX_VALUE;
            stepSizeBarrier.await();
          } while (this.maximumError > 1.0);
          updateDoneBarrier.await();
        } catch (InterruptedException ie) {
          // Should never happen
          Activator.logError(ie.getMessage(), ie);
        } catch (BrokenBarrierException bbe) {
          // Should never happen
          Activator.logError(bbe.getMessage(), bbe);
        }
        // Set to the smallest value reported by another thread
        h = this.smallestH;
        x += h;
        jobs[threadnum].h = h;
        jobs[threadnum].t = x;
      }
      return;
    }
    // We use the Runge Kutta Kash Carp method to advance to the next
    // step in the simulation. Two estimates of the disease deltas
    // are calculated and compared to each other. If they differ
    // by more than a maximum error (determined by a parameter for
    // the disease model), we reduce the step size until an acceptable
    // error is reached.

    // These are used during Runge Kutta calculations:
    Map<IntegrationLabel, IntegrationLabelValue> k1map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();
    Map<IntegrationLabel, IntegrationLabelValue> k2map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();
    Map<IntegrationLabel, IntegrationLabelValue> k3map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();
    Map<IntegrationLabel, IntegrationLabelValue> k4map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();
    Map<IntegrationLabel, IntegrationLabelValue> k5map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();
    Map<IntegrationLabel, IntegrationLabelValue> k6map =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();

    // Used below as temporary place holder, one for each decorator
    IntegrationLabelValue _k1[], _k2[], _k3[], _k4[], _k5[], _k6[];
    int numDecorators = iDecorators.size();
    _k1 = new IntegrationLabelValue[numDecorators];
    _k2 = new IntegrationLabelValue[numDecorators];
    _k3 = new IntegrationLabelValue[numDecorators];
    _k4 = new IntegrationLabelValue[numDecorators];
    _k5 = new IntegrationLabelValue[numDecorators];
    _k6 = new IntegrationLabelValue[numDecorators];

    // The final estimates for label values are stored here
    Map<IntegrationLabel, IntegrationLabelValue> finalEstimate =
        new HashMap<IntegrationLabel, IntegrationLabelValue>();

    // Delta is used to scale the step (h)
    double delta = 0.0;

    int n = 0;
    for (Decorator sdm : iDecorators) {
      Iterator<DynamicLabel> iter = sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
      IntegrationLabel firstLabel = (IntegrationLabel) iter.next();
      // Initialize temporary place holders just by creating dups of the first label available
      _k1[n] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
      _k2[n] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
      _k3[n] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
      _k4[n] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
      _k5[n] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
      _k6[n++] = (IntegrationLabelValue) EcoreUtil.copy(firstLabel.getCurrentValue());
    }

    // Keep track if whether anyone want to stop
    // or pause updating labels
    boolean interrupt = false, pause = false;

    // We keep these around to determine when to call setProgress(...) on the decorators.
    // If we call too frequently we can too many callbacks which affects performance.
    double nextProgressReportStep = num_threads * (end - x) / MAX_PROGRESS_REPORTS;
    double nextProgressReport = x + nextProgressReportStep;

    //		HashMap<StandardDiseaseModelLabel, StandardDiseaseModelLabelValue> validate = new
    //			HashMap<StandardDiseaseModelLabel, StandardDiseaseModelLabelValue>();

    // This is the main loop we keep iterating over until we are done with the step
    while (x < end) {
      k1map.clear();
      k2map.clear();
      k3map.clear();
      k4map.clear();
      k5map.clear();
      k6map.clear();
      finalEstimate.clear();

      // Validation code kept here if needed in the future

      /*

        HashMap<StandardDiseaseModelLabel, StandardDiseaseModelLabelValue> validate = new HashMap<StandardDiseaseModelLabel, StandardDiseaseModelLabelValue>();


      if(!redo)
      	for(StandardDiseaseModelImpl sdm:diseaseModelDecorators) {
      		for (final Iterator<DynamicLabel> currentStateLabelIter = sdm.getLabelsToUpdate(threadnum, num_threads)
      			.iterator(); currentStateLabelIter.hasNext();) {
      			final StandardDiseaseModelLabel diseaseLabel = (StandardDiseaseModelLabel) currentStateLabelIter
      			.next();
      			final StandardDiseaseModelLabelValue val = (StandardDiseaseModelLabelValue)diseaseLabel.getCurrentDiseaseModelTempLabelValue();
      			validate.put(diseaseLabel, val);
      		}
      	}
      else {
      	for(StandardDiseaseModelImpl sdm:diseaseModelDecorators)
      		for (final Iterator<DynamicLabel> currentStateLabelIter = sdm.getLabelsToUpdate(threadnum, num_threads)
      				.iterator(); currentStateLabelIter.hasNext();) {
      				final StandardDiseaseModelLabel diseaseLabel = (StandardDiseaseModelLabel) currentStateLabelIter
      				.next();
      				final SIRLabelValue val = (SIRLabelValue)diseaseLabel.getCurrentDiseaseModelTempLabelValue();
      				validate.put(diseaseLabel, val);
      				final SIRLabelValue oldVal = (SIRLabelValue)validate.get(diseaseLabel);

      				if(val.getI() != oldVal.getI() ||
      						val.getS() != oldVal.getS() ||
      						val.getR() != oldVal.getR() ||
      						//val.getE() != oldVal.getE() ||
      						val.getBirths() != oldVal.getBirths() ||
      						val.getDeaths() != oldVal.getDeaths() ||
      						val.getDiseaseDeaths() != oldVal.getDiseaseDeaths()
      						)
      					Activator.logError("Error, old and new value not the same  label: "+diseaseLabel, new Exception());
      		}
      }
      */

      // ToDo: We should check if a maximum number of iterations have been
      // exceeded here and throw an error.

      // First, get the delta values at the current state
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Set the scaling factor for disease parameters for each decorator and location
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue scale = (IntegrationLabelValue) diseaseLabel.getErrorScale();
          scale.set((IntegrationLabelValue) diseaseLabel.getTempValue());

          IntegrationLabelValue dt =
              (IntegrationLabelValue) EcoreUtil.copy(diseaseLabel.getDeltaValue());
          dt.scale(h);
          dt.abs();
          dt.add(TINY);
          scale.abs();
          scale.add(dt);
        }
      }

      // Step 1 in Runge Kutta Fehlberg.
      // Get the delta values out of each node label and
      // build a first estimate of the next value'
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k1map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));

          deltaLabel.scale(h);
          deltaLabel.scale(b21);
          ((IntegrationLabelValue) diseaseLabel.getProbeValue())
              .set(deltaLabel.add((IntegrationLabelValue) diseaseLabel.getTempValue()));
        }
      }

      // Now get the next delta values
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Step 2 in Runge Kutta Fehlberg.
      // Get the delta values out of each node label and
      // build a second estimate of the next value
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k2map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));
          _k1[n].set(k1map.get(diseaseLabel));
          _k2[n].set(deltaLabel);

          IntegrationLabelValue estDelta = _k1[n].scale(b31);
          _k2[n].scale(b32);
          estDelta.add(_k2[n]);

          estDelta.scale(h);

          ((IntegrationLabelValue) diseaseLabel.getProbeValue())
              .set(estDelta.add((IntegrationLabelValue) diseaseLabel.getTempValue()));
        }
        ++n;
      }

      // Now get the next delta values
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Step 3 in Runge Kutta Fehlberg.
      // Get the delta values out of each node label and
      // build a third estimate of the next value
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k3map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));

          _k1[n].set(k1map.get(diseaseLabel));
          _k2[n].set(k2map.get(diseaseLabel));
          _k3[n].set(deltaLabel);

          _k1[n].scale(b41);
          _k2[n].scale(b42);
          _k3[n].scale(b43);
          IntegrationLabelValue estDelta = _k1[n];
          estDelta.add(_k2[n]);
          estDelta.add(_k3[n]);

          estDelta.scale(h);

          ((IntegrationLabelValue) diseaseLabel.getProbeValue())
              .set(estDelta.add((IntegrationLabelValue) diseaseLabel.getTempValue()));
        }
        ++n;
      }

      // Now get the next delta values
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Step 4 in Runge Kutta Fehlberg.
      // Get the delta values out of each node label and
      // build a fourth estimate of the next value
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {
          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k4map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));

          _k1[n].set(k1map.get(diseaseLabel));
          _k2[n].set(k2map.get(diseaseLabel));
          _k3[n].set(k3map.get(diseaseLabel));
          _k4[n].set(deltaLabel);

          _k1[n].scale(b51);
          _k2[n].scale(b52);
          _k3[n].scale(b53);
          _k4[n].scale(b54);

          IntegrationLabelValue estDelta = _k1[n];
          estDelta.add(_k2[n]);
          estDelta.add(_k3[n]);
          estDelta.add(_k4[n]);

          estDelta.scale(h);
          ((IntegrationLabelValue) diseaseLabel.getProbeValue())
              .set(estDelta.add((IntegrationLabelValue) diseaseLabel.getTempValue()));
        }
        ++n;
      }

      // Now get the next delta values
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Step 5 in Runge Kutta Fehlberg.
      // Get the delta values out of each node label and
      // build a fifth estimate of the next value
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {

          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k5map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));

          _k1[n].set(k1map.get(diseaseLabel));
          _k2[n].set(k2map.get(diseaseLabel));
          _k3[n].set(k3map.get(diseaseLabel));
          _k4[n].set(k4map.get(diseaseLabel));
          _k5[n].set(deltaLabel);

          _k1[n].scale(b61);
          _k2[n].scale(b62);
          _k3[n].scale(b63);
          _k4[n].scale(b64);
          _k5[n].scale(b65);

          IntegrationLabelValue estDelta = _k1[n];
          estDelta.add(_k2[n]);
          estDelta.add(_k3[n]);
          estDelta.add(_k4[n]);
          estDelta.add(_k5[n]);

          estDelta.scale(h);

          ((IntegrationLabelValue) diseaseLabel.getProbeValue())
              .set(estDelta.add((IntegrationLabelValue) diseaseLabel.getTempValue()));
        }
        ++n;
      }

      // Now get the next delta values
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .calculateDelta(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));
      for (Decorator sdm : iDecorators)
        ((IntegrationDecorator) sdm)
            .applyExternalDeltas(time, timeDelta, sdm.getLabelsToUpdate(threadnum, num_threads));

      // Step 6 in Runge Kutta Fehlberg.
      // Calculate k6
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {

          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue deltaLabel = (IntegrationLabelValue) diseaseLabel.getDeltaValue();
          k6map.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(deltaLabel));
        }
        ++n;
      }

      // Step 7 in Runge Kutta Fehlberg
      // Calculate the two estimates from k1, .. k6 values
      // and determine the maximum difference (error) between them.

      boolean success = true; // Were we able to update all labels without a large enough error?
      double maxerror = 0.0;
      n = 0;
      for (Decorator sdm : iDecorators) {
        for (final Iterator<DynamicLabel> currentStateLabelIter =
                sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
            currentStateLabelIter.hasNext(); ) {

          final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

          IntegrationLabelValue currentValue = (IntegrationLabelValue) diseaseLabel.getTempValue();

          _k1[n].set(k1map.get(diseaseLabel));
          _k3[n].set(k3map.get(diseaseLabel));
          _k4[n].set(k4map.get(diseaseLabel));
          _k5[n].set(k5map.get(diseaseLabel));
          _k6[n].set(k6map.get(diseaseLabel));

          _k1[n].scale(c1);
          _k3[n].scale(c3);
          _k4[n].scale(c4);
          _k6[n].scale(c6);

          // New Y
          IntegrationLabelValue yout =
              (IntegrationLabelValue) EcoreUtil.copy(_k1[n].add(_k3[n]).add(_k4[n]).add(_k6[n]));

          yout.scale(h);
          yout.add(currentValue);

          // Get the error
          _k1[n].set(k1map.get(diseaseLabel));
          _k3[n].set(k3map.get(diseaseLabel));
          _k4[n].set(k4map.get(diseaseLabel));
          _k5[n].set(k5map.get(diseaseLabel));
          _k6[n].set(k6map.get(diseaseLabel));

          _k1[n].scale(dc1);
          _k3[n].scale(dc3);
          _k4[n].scale(dc4);
          _k5[n].scale(dc5);
          _k6[n].scale(dc6);

          IntegrationLabelValue yerror =
              (IntegrationLabelValue)
                  EcoreUtil.copy(_k1[n].add(_k3[n]).add(_k4[n]).add(_k5[n]).add(_k6[n]));
          yerror.scale(h);

          yerror.divide((IntegrationLabelValue) diseaseLabel.getErrorScale());
          double error = yerror.max();
          error /= relativeTolerance;

          if (error > maxerror) {
            maxerror = error;
          }

          if (error <= 1.0)
            finalEstimate.put(diseaseLabel, (IntegrationLabelValue) EcoreUtil.copy(yout));
        }
        ++n;
      }

      jobs[threadnum].h = h;
      jobs[threadnum].maxerror = maxerror;
      try {
        stepSizeBarrier.await();
      } catch (InterruptedException ie) {
        // Should never happen
        Activator.logError(ie.getMessage(), ie);
      } catch (BrokenBarrierException bbe) {
        // Should never happen
        Activator.logError(bbe.getMessage(), bbe);
      }

      // At least one of the threads had to large of an error, fail
      if (this.maximumError > 1.0) success = false;

      // Are we done?
      if (success) {
        // Check to make sure
        if (this.smallestH > h)
          Activator.logError(
              "Error, h was less than the smallest, perhaps barrier process failed to execute? h:"
                  + h
                  + " vs "
                  + this.smallestH,
              new Exception());

        // Yes, hurrah, advance x using the step size h
        x += h;
        if (this.maximumError > ERRCON) h = SAFETY * h * Math.pow(this.maximumError, PGROW);
        else h = 5.0 * h;

        // Limit to max 1
        if (h > 1.0) h = 1.0;

        // Make sure we don't overshoot
        if (x < end && x + h > end) h = (end - x);

        // Update the current value to the new position
        for (Decorator sdm : iDecorators) {
          for (final Iterator<DynamicLabel> currentStateLabelIter =
                  sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
              currentStateLabelIter.hasNext(); ) {
            final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();
            ((IntegrationLabelValue) diseaseLabel.getTempValue())
                .set(finalEstimate.get(diseaseLabel));
            ((IntegrationLabelValue) diseaseLabel.getProbeValue())
                .set(finalEstimate.get(diseaseLabel));
          }
        }

        // Wait until all other threads have updated the current value
        try {
          updateDoneBarrier.await();
        } catch (InterruptedException ie) {
          // Should never happen
          Activator.logError(ie.getMessage(), ie);
        } catch (BrokenBarrierException bbe) {
          // Should never happen
          Activator.logError(bbe.getMessage(), bbe);
        }

        double progress = (end - x < 0.0) ? 1.0 : 1.0 - (end - x);
        jobs[threadnum].setProgress(progress);
        if (x > nextProgressReport) {
          // Get the progress for all threads
          for (int i = 0; i < num_threads; ++i)
            if (i != threadnum && jobs[i] != null) progress += jobs[i].getProgress();
          progress /= num_threads;
          for (Decorator sdm : iDecorators) sdm.setProgress(progress);
          nextProgressReport += nextProgressReportStep;
        }

      } else {
        // At least one thread failed, change the step size

        // Problem, error too big, we need to reduce the step size
        delta = SAFETY * h * Math.pow(this.maximumError, PSHRNK);
        if (h > 0.0) h = (delta > 0.1 * h) ? delta : 0.1 * h;
        else h = (delta > 0.1 * h) ? 0.1 * h : delta;

        // We didn't succeed.

        // Reset the estimated value back to the original, the step size
        // has been reduced so we well try again.
        // Set the estimated value back to the current original value
        for (Decorator sdm : iDecorators) {
          for (final Iterator<DynamicLabel> currentStateLabelIter =
                  sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
              currentStateLabelIter.hasNext(); ) {
            final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();
            ((IntegrationLabelValue) diseaseLabel.getProbeValue())
                .set((IntegrationLabelValue) diseaseLabel.getTempValue());
          }
        }
      }
    } // While x < end

    jobs[threadnum].t = x;
    jobs[threadnum].h = h;

    // Remember the step size and position in the solver
    this.setStepSize(h);
    this.setCurrentX(x);

    // We're done
    for (Decorator sdm : iDecorators) {
      for (final Iterator<DynamicLabel> currentStateLabelIter =
              sdm.getLabelsToUpdate(threadnum, num_threads).iterator();
          currentStateLabelIter.hasNext(); ) {
        final IntegrationLabel diseaseLabel = (IntegrationLabel) currentStateLabelIter.next();

        // This is the next state for the label
        IntegrationLabelValue nextState = (IntegrationLabelValue) diseaseLabel.getNextValue();
        // This is the original current state at the previous cycle
        IntegrationLabelValue originalState =
            (IntegrationLabelValue) diseaseLabel.getCurrentValue();
        // This is the final value calculated at position x.
        IntegrationLabelValue newValue = finalEstimate.get(diseaseLabel);
        // x could be larger than the requested cycle, so we do a linear interpolation
        // to fit it exactly to the requested cycle
        // *** Not needed since we always end exactly at the requested cycle
        // adjustValuesToCycle(originalState, newValue, x, cycle);

        // New value has been modified here to fit the requested cycle
        nextState.set(newValue);
        // Do any model specific work for instance add noise
        ((IntegrationDecorator) sdm).doModelSpecificAdjustments((LabelValue) nextState);
        // The next value is valid now.
        diseaseLabel.setNextValueValid(true);
      }
    }
  }
Esempio n. 27
0
  /**
   *
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @generated NOT
   */
  @Override
  public boolean step(STEMTime time, long timeDelta, int cycle) {

    // Validate all decorators that return deltas to make sure
    // they are of deterministic nature. The Runge Kutta integratio
    // can only handle determininistic variants

    for (Decorator decorator : this.getDecorators())
      if (decorator instanceof IntegrationDecorator) {
        IntegrationDecorator idec = (IntegrationDecorator) decorator;
        if (!idec.isDeterministic()) {
          Activator.logError(
              "Error, decorator: "
                  + idec
                  + " is not deterministic. The Runge Kutta Integrator can only handle deterministic models.",
              new Exception());
          return false;
        }
      }

    Activator act = org.eclipse.stem.ui.Activator.getDefault();
    if (act != null) {
      final Preferences preferences = act.getPluginPreferences();
      num_threads =
          (short)
              preferences.getInt(
                  org.eclipse.stem.ui.preferences.PreferenceConstants.SIMULATION_THREADS);
    } else num_threads = 2; // Just so we can run inside junit test

    final int c = cycle;

    // Initialize latches
    stepSizeBarrier =
        new CyclicBarrier(
            num_threads,
            new Runnable() {
              public void run() {
                // All threads successfully advanced time by some step h.
                // Find the smallest
                smallestH = Double.MAX_VALUE;
                maximumError = -Double.MAX_VALUE;
                for (int i = 0; i < num_threads; ++i) {
                  if (jobs[i].h <= smallestH) {
                    if (maximumError < jobs[i].maxerror) maximumError = jobs[i].maxerror;
                    smallestH = jobs[i].h;
                  }
                }
              }
            });

    updateDoneBarrier = new CyclicBarrier(num_threads);

    // Find triggers and make sure they are invoked
    for (Decorator decorator : this.getDecorators()) {
      if (decorator instanceof Trigger) {
        decorator.updateLabels(time, timeDelta, cycle);
      }
    }

    // First initialize the probe and temp label values from the current
    // label values.

    for (Decorator decorator : this.getDecorators()) {
      EList<DynamicLabel> allLabels = decorator.getLabelsToUpdate();
      for (final Iterator<DynamicLabel> currentStateLabelIter = allLabels.iterator();
          currentStateLabelIter.hasNext(); ) {
        if (decorator instanceof IntegrationDecorator) {
          // It's a standard disease model with a standard disease model label
          final IntegrationLabel iLabel = (IntegrationLabel) currentStateLabelIter.next();
          ((IntegrationLabelValue) iLabel.getProbeValue())
              .set((IntegrationLabelValue) iLabel.getCurrentValue());
          ((IntegrationLabelValue) iLabel.getTempValue())
              .set((IntegrationLabelValue) iLabel.getCurrentValue());
          ((IntegrationLabelValue) iLabel.getTempValue()).prepareCycle();
          ((IntegrationLabelValue) iLabel.getProbeValue()).prepareCycle();
        } else currentStateLabelIter.next();
      }
    }

    if (jobs == null || jobs.length != num_threads) {
      // Initialize the jobs if not done yet or of the number of threads changes
      jobs = new RkJob[num_threads];

      for (short i = 0; i < num_threads; ++i) {
        final short threadnum = i;
        jobs[i] = new RkJob("Worker " + i, threadnum, this);
      } // For each job
    } // If not initialized

    // Initialize
    int thread = 0;
    for (RkJob j : jobs) {
      j.cycle = c;
      j.time = time;
      j.timeDelta = timeDelta;
    }
    // Schedule. Jobs can be rescheduled after finished
    for (RkJob j : jobs) j.schedule();

    // Wait until all jobs completed
    for (RkJob j : jobs) {
      try {
        j.join();
      } catch (InterruptedException ie) {
        Activator.logError(ie.getMessage(), ie);
      }
    }

    // Set the common time and step size here and validate everything is right
    double minStep = Double.MAX_VALUE;
    double currentT = jobs[0].t;
    for (RkJob j : jobs) {
      // The jobs have calculated new step sizes after they finished. Pick the
      // smallest one for the next cycle
      if (j.h < minStep) minStep = j.h;
      if (j.t != currentT)
        Activator.logError(
            "Error, one thread was in misstep with other threads, its time was "
                + j.t
                + " versus "
                + currentT,
            new Exception());
    }
    return true;
  }
 /**
  * check the load from components bound to the given memory The components can be threads or
  * higher level components.
  *
  * @param curMemory Component Instance of memory
  */
 protected void doMemoryLoad(
     ComponentInstance curMemory, String somName, EList boundComponents, boolean isROM) {
   double totalMemory = 0.0;
   UnitLiteral kbliteral = GetProperties.getKBUnitLiteral(curMemory);
   String resourceName = isROM ? "ROM" : "RAM";
   double Memorycapacity =
       isROM
           ? GetProperties.getROMCapacityInKB(curMemory, 0.0)
           : GetProperties.getRAMCapacityInKB(curMemory, 0.0);
   if (boundComponents.size() == 0 && Memorycapacity > 0) {
     errManager.infoSummary(
         curMemory,
         somName,
         "No application components bound to "
             + curMemory.getComponentInstancePath()
             + " with "
             + resourceName
             + " capacity "
             + GetProperties.toStringScaled(Memorycapacity, kbliteral));
     return;
   }
   if (Memorycapacity == 0) {
     errManager.errorSummary(
         curMemory,
         somName,
         "Memory "
             + curMemory.getComponentInstancePath()
             + " has no "
             + resourceName
             + " capacity but has bound components.");
   }
   logHeader(
       "\n\nDetailed Workload Report for memory "
           + curMemory.getComponentInstancePath()
           + " with Capacity "
           + GetProperties.toStringScaled(Memorycapacity, kbliteral)
           + "\n\nComponent,Budget,Actual");
   Set budgeted = new HashSet();
   for (Iterator it = boundComponents.iterator(); it.hasNext(); ) {
     String notes = "";
     ComponentInstance bci = (ComponentInstance) it.next();
     double totalactual = sumMemoryActuals(bci, isROM);
     double budget =
         isROM
             ? GetProperties.getROMBudgetInKB(bci, 0.0)
             : GetProperties.getRAMBudgetInKB(bci, 0.0);
     if (totalactual > 0) {
       // only compare if there were actuals
       if (totalactual > budget) {
         notes =
             notes
                 + ",Error: "
                 + resourceName
                 + " subtotal exceeds budget by "
                 + (totalactual - budget)
                 + " KB";
       } else if (totalactual < budget) {
         notes =
             notes
                 + ",Warning: "
                 + resourceName
                 + " Subtotal under budget by "
                 + (budget - totalactual)
                 + " KB";
       }
     }
     if (totalactual == 0.0) {
       // we use a budget number as there are no actuals
       if (budget > 0 && !budgeted.contains(bci)) {
         // only add it if no children budget numbers have been added
         totalMemory += budget;
         detailedLog(bci, budget, kbliteral);
         // add ancestors to budgeted list so their budget does not get added later
         while ((bci = bci.getContainingComponentInstance()) != null) {
           budgeted.add(bci);
         }
       }
     } else {
       // add only the current actual; the children actual have been added before
       double currentActual =
           isROM
               ? GetProperties.getROMActualInKB(bci, 0.0)
               : GetProperties.getRAMActualInKB(bci, 0.0);
       detailedLog(bci, budget, kbliteral);
       totalMemory += currentActual;
     }
   }
   if (Memorycapacity == 0)
     errManager.errorSummary(
         curMemory,
         somName,
         ""
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + curMemory.getComponentInstancePath()
             + " has no memory capacity specified");
   if (totalMemory > Memorycapacity) {
     errManager.errorSummary(
         curMemory,
         somName,
         "Total Memory "
             + totalMemory
             + " KB of bounds tasks exceeds Memory capacity "
             + Memorycapacity
             + " KB of "
             + curMemory.getComponentInstancePath());
   } else if (totalMemory == 0.0 && Memorycapacity == 0.0) {
     errManager.warningSummary(
         curMemory,
         somName,
         ""
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + curMemory.getComponentInstancePath()
             + " has no capacity. Bound app's have no memory budget.");
   } else {
     errManager.infoSummary(
         curMemory,
         somName,
         "Total "
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + totalMemory
             + " KB of bound tasks within Memory capacity "
             + Memorycapacity
             + " KB of "
             + curMemory.getComponentInstancePath());
   }
 }
 public java.util.Iterator<E> iterator() {
   return copy.iterator();
 }
Esempio n. 30
0
  public String generate(Object argument) {
    final StringBuffer stringBuffer = new StringBuffer();
    OwlsCompositeProcess compositeProcess = (OwlsCompositeProcess) argument;
    Owls owls = compositeProcess.getDescribes().getOwnedBy();
    EList<OwlsInput> inputs = compositeProcess.getHasInputs();
    EList<OwlsOutput> outputs = compositeProcess.getHasOutputs();
    OwlsProcessFacade processFacade = new OwlsProcessFacade(compositeProcess);
    EList<OwlsProcess> processes = processFacade.getAllProcess();
    String ident = new String();

    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      processFacade.setProcessRName((OwlsProcess) i.next());
    }

    stringBuffer.append(TEXT_1);
    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      OwlsProcess process = (OwlsProcess) i.next();
      stringBuffer.append(TEXT_2);
      stringBuffer.append(process.getReferenceName());
      stringBuffer.append(TEXT_3);
      stringBuffer.append(processFacade.getProcessURI(process));
      stringBuffer.append(TEXT_4);
    }
    stringBuffer.append(TEXT_5);
    stringBuffer.append(owls.getNamespace());
    stringBuffer.append(TEXT_6);

    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      OwlsProcess process = (OwlsProcess) i.next();
      stringBuffer.append(TEXT_7);
      stringBuffer.append(process.getReferenceName());
      stringBuffer.append(TEXT_8);
    }
    stringBuffer.append(TEXT_9);
    stringBuffer.append(owls.getService().getID());
    stringBuffer.append(TEXT_10);
    stringBuffer.append(owls.getProfile().getID());
    stringBuffer.append(TEXT_11);
    stringBuffer.append(owls.getProcess().getID());
    stringBuffer.append(TEXT_12);
    stringBuffer.append(owls.getService().getSupports().getID());
    stringBuffer.append(TEXT_13);
    stringBuffer.append(owls.getProfile().getID());
    stringBuffer.append(TEXT_14);
    stringBuffer.append(owls.getService().getID());
    stringBuffer.append(TEXT_15);
    stringBuffer.append(compositeProcess.getLabel());
    stringBuffer.append(TEXT_16);

    for (Iterator i = inputs.iterator(); i.hasNext(); ) {
      OwlsInput input = (OwlsInput) i.next();

      stringBuffer.append(TEXT_17);
      stringBuffer.append(input.getID());
      stringBuffer.append(TEXT_18);
    }
    for (Iterator i = outputs.iterator(); i.hasNext(); ) {
      OwlsOutput output = (OwlsOutput) i.next();

      stringBuffer.append(TEXT_19);
      stringBuffer.append(output.getID());
      stringBuffer.append(TEXT_20);
    }
    stringBuffer.append(TEXT_21);
    stringBuffer.append(owls.getProcess().getID());
    stringBuffer.append(TEXT_22);
    stringBuffer.append(owls.getService().getID());
    stringBuffer.append(TEXT_23);
    for (Iterator i = inputs.iterator(); i.hasNext(); ) {
      OwlsInput input = (OwlsInput) i.next();

      stringBuffer.append(TEXT_24);
      stringBuffer.append(input.getID());
      stringBuffer.append(TEXT_25);
      String parameterType = input.getParameterType();
      if (parameterType.startsWith("http")) {
        stringBuffer.append(parameterType);
      } else {
        stringBuffer.append("&xsd;#" + parameterType);
      }
      stringBuffer.append(TEXT_26);
    }
    for (Iterator i = outputs.iterator(); i.hasNext(); ) {
      OwlsOutput output = (OwlsOutput) i.next();

      stringBuffer.append(TEXT_27);
      stringBuffer.append(output.getID());
      stringBuffer.append(TEXT_28);
      String parameterType = output.getParameterType();
      if (parameterType.startsWith("http")) {
        stringBuffer.append(parameterType);
      } else {
        stringBuffer.append("&xsd;#" + parameterType);
      }
      stringBuffer.append(TEXT_29);
    }
    stringBuffer.append(TEXT_30);

    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      OwlsProcess process = (OwlsProcess) i.next();
      EList<OwlsAssignClient> clientAssings = process.getMessagesBindings();
      for (Iterator j = clientAssings.iterator(); j.hasNext(); ) {
        EObject object = (EObject) j.next();
        if (object instanceof OwlsAssignOutputClient) {
          OwlsAssignOutputClient assignOut = (OwlsAssignOutputClient) object;
          stringBuffer.append(TEXT_31);
          stringBuffer.append(assignOut.getProcessReference().getPeformedBy().getID());
          stringBuffer.append(TEXT_32);
          stringBuffer.append(assignOut.getProcessReference().getReferenceName());
          stringBuffer.append(TEXT_33);
          stringBuffer.append(assignOut.getInputReferences().getID());
          stringBuffer.append(TEXT_34);
          stringBuffer.append(assignOut.getOutputsReferences().getID());
          stringBuffer.append(TEXT_35);
        }
      }
    }
    stringBuffer.append(TEXT_36);
    GenComposition gen = new GenComposition();
    List arg = new ArrayList();
    List objects = new ArrayList();
    objects.add(compositeProcess.getComposedOf());
    arg.add(objects);
    arg.add(ident);
    stringBuffer.append(gen.generate(arg));
    stringBuffer.append(TEXT_37);
    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      OwlsProcess process = (OwlsProcess) i.next();
      stringBuffer.append(TEXT_38);
      stringBuffer.append(process.getPeformedBy().getID());
      stringBuffer.append(TEXT_39);
      stringBuffer.append(process.getReferenceName());
      stringBuffer.append(TEXT_40);
      stringBuffer.append(process.getID());
      stringBuffer.append(TEXT_41);

      EList<OwlsAssignClient> clientAssings = process.getMessagesBindings();
      for (Iterator j = clientAssings.iterator(); j.hasNext(); ) {
        EObject object = (EObject) j.next();
        if (object instanceof OwlsAssignInputClient) {
          OwlsAssignInputClient assignIn = (OwlsAssignInputClient) object;
          stringBuffer.append(TEXT_42);
          stringBuffer.append(assignIn.getInputReferences().getID());
          stringBuffer.append(TEXT_43);
          stringBuffer.append(assignIn.getProcessReference().getReferenceName());
          stringBuffer.append(TEXT_44);
          stringBuffer.append(assignIn.getOutputsReferences().getID());
          stringBuffer.append(TEXT_45);
        }
      }
      EList<OwlsAssign> bindings = process.getBindings();
      for (Iterator j = bindings.iterator(); j.hasNext(); ) {
        EObject object = (EObject) j.next();
        OwlsAssign assign = (OwlsAssign) object;
        stringBuffer.append(TEXT_46);
        stringBuffer.append(assign.getSource().getPeformedBy().getID());
        stringBuffer.append(TEXT_47);
        stringBuffer.append(assign.getSource().getReferenceName());
        stringBuffer.append(TEXT_48);
        stringBuffer.append(assign.getOutputSource().getID());
        stringBuffer.append(TEXT_49);
        stringBuffer.append(assign.getTarget().getReferenceName());
        stringBuffer.append(TEXT_50);
        stringBuffer.append(assign.getInputTarget().getID());
        stringBuffer.append(TEXT_51);
      }
      stringBuffer.append(TEXT_52);
    }
    stringBuffer.append(TEXT_53);
    stringBuffer.append(owls.getService().getSupports().getID());
    stringBuffer.append(TEXT_54);
    stringBuffer.append(owls.getService().getID());
    stringBuffer.append(TEXT_55);

    for (Iterator i = processes.iterator(); i.hasNext(); ) {
      OwlsProcess process = (OwlsProcess) i.next();
      EList<OwlsWsdlAtomicProcessGrounding> groundings =
          process.getDescribes().getSupports().getHasAtomicProcessGrounding();
      OwlsWsdlAtomicProcessGrounding atomicGrounding =
          (OwlsWsdlAtomicProcessGrounding) groundings.get(0);
      stringBuffer.append(TEXT_56);
      stringBuffer.append(process.getReferenceName());
      stringBuffer.append(TEXT_57);
      stringBuffer.append(atomicGrounding.getID());
      stringBuffer.append(TEXT_58);
    }
    stringBuffer.append(TEXT_59);
    return stringBuffer.toString();
  }