Ejemplo n.º 1
0
 /**
  * For each port of the given entity, if the port's derived level is greater than 0 (i.e., it is
  * created automatically by the entity), store the persistent attributes of the port in a "port"
  * XML element.
  *
  * @param entity The entity whose ports are looked at.
  * @param output The output writer.
  * @param depth The depth for the MoML output.
  * @exception IOException If the output writer cannot be written to.
  */
 public static void exportPortProperties(GTEntity entity, Writer output, int depth)
     throws IOException {
   if (entity instanceof Entity) {
     Entity ptEntity = (Entity) entity;
     for (Object portObject : ptEntity.portList()) {
       Port port = (Port) portObject;
       if (port.getDerivedLevel() == 0) {
         continue;
       }
       boolean outputStarted = false;
       for (Object attributeObject : port.attributeList()) {
         Attribute attribute = (Attribute) attributeObject;
         if (attribute.isPersistent()) {
           if (!outputStarted) {
             output.write(
                 StringUtilities.getIndentPrefix(depth)
                     + "<port name=\""
                     + port.getName()
                     + "\">\n");
             outputStarted = true;
           }
           attribute.exportMoML(output, depth + 1);
         }
       }
       if (outputStarted) {
         output.write(StringUtilities.getIndentPrefix(depth) + "</port>\n");
       }
     }
   }
 }
Ejemplo n.º 2
0
  /**
   * Return the container entity for the specified ASTPtRootNode.
   *
   * @param node The specified ASTPtRootNode.
   * @return The container entity for the specified ASTPtRootNode.
   */
  public Entity getContainerEntity(ASTPtRootNode node) {
    Attribute attribute = _solver.getAttribute(node);
    NamedObj container = attribute.getContainer();

    while (!(container instanceof Entity)) {
      container = container.getContainer();
    }
    return (Entity) container;
  }
Ejemplo n.º 3
0
  /**
   * Return the list of property-able Attributes. A property-able Attribute is a StringAttribute
   * with the name "guardTransition", a StringAttribute in an Expression actor, a StringAttribute
   * with the name "expression" or a Variable with full visibility. However, Variables with certain
   * names are excluded.
   *
   * @return The list of property-able Attributes.
   */
  protected List<Attribute> _getPropertyableAttributes() {
    List<Attribute> result = new LinkedList<Attribute>();
    Iterator attributes = ((Entity) getComponent()).attributeList().iterator();

    while (attributes.hasNext()) {
      Attribute attribute = (Attribute) attributes.next();

      // only consider StringAttributes, ignore all subclasses
      if (attribute.getClass().equals(ptolemy.kernel.util.StringAttribute.class)) {
        if (((StringAttribute) attribute).getName().equalsIgnoreCase("guardTransition")
            || ((StringAttribute) attribute).getContainer() instanceof Expression
                && ((StringAttribute) attribute).getName().equalsIgnoreCase("expression")) {

          result.add(attribute);
        }
      } else if (attribute instanceof Variable) {
        if (((Variable) attribute).getVisibility() == Settable.FULL) {

          // filter Parameters with certain names; ignore all
          // subclasses
          if (attribute instanceof PortParameter) {
            result.add(attribute);
          } else if (attribute.getClass().equals(ptolemy.data.expr.Parameter.class)
              || attribute.getClass().equals(ptolemy.data.expr.StringParameter.class)) {

            // FIXME: implement filter interface, so that adapter
            // classes can specify which attributes
            // need to be filtered (either by name or by class)
            // Currently all filtered attributes need to be
            // specified here
            if (((Parameter) attribute).getName().equals("firingCountLimit")
                || ((Parameter) attribute).getName().equals("NONE")
                || ((Parameter) attribute).getName().equals("_hideName")
                || ((Parameter) attribute).getName().equals("_showName")
                || ((Parameter) attribute).getName().equals("conservativeAnalysis")
                || ((Parameter) attribute).getName().equals("directorClass")
                || ((Parameter) attribute).getName().equals("stateDependentCausality")
                || ((Parameter) attribute).getName().equals("delayed")
                || ((Parameter) attribute).getName().equals("displayWidth")) {

              // do nothing, ignore the parameter
            } else {
              result.add(attribute);
            }
          }
        }
      }
    }

    return result;
  }
Ejemplo n.º 4
0
 /**
  * this function returns an array conatining the Attributes added by the opal interface it took me
  * lots of time to figure out this code, maybe there is a cleaner way to get them...
  */
 private Attribute[] _getOpalAttributes() throws IllegalActionException {
   List attrList = this.attributeList();
   // list of attributes that will be deleted
   ArrayList opalAttrs = new ArrayList();
   Iterator attrs = attrList.iterator();
   // first we have to find the parameter we wanna delete
   while (attrs.hasNext()) {
     Attribute a = (Attribute) attrs.next();
     if ((!a.getName().equals("serviceURL"))
         && // these are the types that we wanna save all the other
         // will be deleted
         (!a.getName().equals("methods"))
         && (!a.getName().equals("class"))
         && (!a.getName().equals("semanticType00"))
         && (!a.getName().equals("semanticType11"))
         && (!a.getName().equals("KeplerDocumentation"))
         && (!a.getName().equals("entityId"))
         && (!a.getName().equals("numberOfExtraInputFiles"))
         && (!a.getName().startsWith("_"))) {
       log.info("Opal attribute: " + a.getName());
       opalAttrs.add(a);
       // a.setContainer(null);
     } // if
   } // while
   return (Attribute[]) opalAttrs.toArray(new Attribute[opalAttrs.size()]);
 }
Ejemplo n.º 5
0
  /**
   * Check the class of the container in which the attribute is to be placed. If the container is
   * not an intended one, throw an IllegalActionException.
   *
   * @param attribute The attribute to check.
   * @param container The container.
   * @param containerClass The intended class of container.
   * @param deep Whether containers of the container should be checked instead, if the container
   *     does not qualify.
   * @exception IllegalActionException If this attribute cannot be used with the given container.
   */
  public static void checkContainerClass(
      Attribute attribute,
      NamedObj container,
      Class<? extends CompositeEntity> containerClass,
      boolean deep)
      throws IllegalActionException {
    while (deep
        && container != null
        && !containerClass.isInstance(container)
        && !(container instanceof EntityLibrary)) {
      container = container.getContainer();
      if (container instanceof EntityLibrary) {
        return;
      }
    }

    if (container == null
        || !containerClass.isInstance(container) && !(container instanceof EntityLibrary)) {
      _delete(attribute);
      throw new IllegalActionException(
          attribute.getClass().getSimpleName()
              + " can only be added to "
              + containerClass.getSimpleName()
              + ".");
    }
  }
Ejemplo n.º 6
0
 /* (non-Javadoc)
  * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
  */
 public String getText(Object element) {
   if (element == null) return "";
   if (element instanceof GeneralAttribute) {
     GeneralAttribute.ATTRIBUTE_TYPE type = ((GeneralAttribute) element).getType();
     switch (type) {
       case NAME:
         return "Name";
       case TYPE:
         return "Type";
       case CLASS:
         return "Class";
     }
     return "";
   }
   final Attribute att = (Attribute) element;
   return att.getDisplayName();
 }
Ejemplo n.º 7
0
 /**
  * puts entity in container
  *
  * @param container The new container value
  * @param entity The new container value
  * @exception NameDuplicationException Description of the Exception
  * @exception IllegalActionException Description of the Exception
  */
 private static void setContainer(CompositeEntity container, NamedObj entity)
     throws NameDuplicationException, IllegalActionException {
   if (entity instanceof Attribute) {
     ((Attribute) entity).setContainer(container);
   } else if (entity instanceof ComponentEntity) {
     ((ComponentEntity) entity).setContainer(container);
   }
 }
Ejemplo n.º 8
0
 /**
  * React to a change in an attribute.
  *
  * @param attribute The changed parameter.
  * @exception IllegalActionException If the parameter set is not valid.
  */
 public void attributeChanged(Attribute attribute) throws IllegalActionException {
   String tmp = null;
   if (attribute == serverName) {
     // --------------    the user has changed serverName -----------
     String strServerName = serverName.getExpression();
     if (_serverNameString == null) {
       // the value is loaded from the moml file
       // don't cal the _createSubmission
       _serverNameString = strServerName;
       log.info("_serverNameString is set according to original value of moml file.");
       if (!strServerName.equals("")) {
         _appMetadata = AppMetadataParser.parseAppMetadata(strServerName);
         if (_appMetadata == null) {
           // something bad happen while getting the appMetadata
           log.error("Failed to parse metadata at " + strServerName);
           throw new IllegalActionException(
               this, "The selected URL does not point to a valid Opal service");
         }
       }
     } else if (!strServerName.equals(_serverNameString)) {
       // the user changed the value, we have to update the actor
       log.info("Got a new server name: " + strServerName);
       _appMetadata = AppMetadataParser.parseAppMetadata(strServerName);
       if (_appMetadata != null) {
         if (_appMetadata.isArgMetadataEnable())
           // complex submission form
           _createSubmission(_appMetadata);
         else
           // simple submission form
           _createSimpleSubmission(_appMetadata);
         _addDocumentation(_appMetadata);
       } else {
         // something bad happen while getting the appMetadata
         log.error("Failed to parse metadata at " + strServerName);
         throw new IllegalActionException(
             this, "The selected URL does not point to a valid Opal service");
       }
       _serverNameString = strServerName;
       this.propagateValues();
     }
   } else if (attribute == numberFiles) {
     // --------------    the user has changed the number of files -----------
     int numFiles = 1;
     try {
       numFiles = Integer.parseInt(numberFiles.stringValue());
     } catch (NumberFormatException e) {
       throw new IllegalActionException(
           this, "The numberFiles parameter is not a valid integer, please correct the value");
     }
     if (numFiles != _numberFiles) {
       _updateUploadFileNumber(numFiles);
       _numberFiles = numFiles;
     }
   } else {
     log.debug("the user has changed: " + attribute.toString());
   }
   super.attributeChanged(attribute);
 } // attributeChanged
Ejemplo n.º 9
0
  /**
   * Check whether the attribute is unique in the given container.
   *
   * @param attribute The attribute to check.
   * @param container The container.
   * @exception IllegalActionException If the container already has an attribute in the same class.
   */
  public static void checkUniqueness(Attribute attribute, NamedObj container)
      throws IllegalActionException {
    if (container instanceof EntityLibrary) {
      return;
    }

    try {
      container.workspace().getReadAccess();
      List<? extends Attribute> attributeList = container.attributeList(attribute.getClass());
      for (Attribute existingAttribute : attributeList) {
        if (existingAttribute != attribute && existingAttribute.isPersistent()) {
          _delete(attribute);
          throw new IllegalActionException(
              "Only 1 " + attribute.getClass().getSimpleName() + " can be used.");
        }
      }
    } finally {
      container.workspace().doneReading();
    }
  }
Ejemplo n.º 10
0
 /**
  * Remove all the attributes in the given class from the given container and all of its children
  * including ports, entities and relations, but not including attributes.
  *
  * @param container The container.
  * @param attributeClass The attribute class.
  * @exception IllegalActionException If an attribute cannot be removed.
  */
 public static void deepRemoveAttributes(
     NamedObj container, Class<? extends Attribute> attributeClass) throws IllegalActionException {
   List<Object> attributes = new LinkedList<Object>(container.attributeList(attributeClass));
   for (Object attribute : attributes) {
     try {
       ((Attribute) attribute).setContainer(null);
     } catch (NameDuplicationException e) {
       // This should not happen.
     }
   }
   for (Object child : getChildren(container, false, true, true, true)) {
     deepRemoveAttributes((NamedObj) child, attributeClass);
   }
 }
Ejemplo n.º 11
0
 @Override
 public void attributeChanged(Attribute attribute) throws IllegalActionException {
   if ("portMode".equalsIgnoreCase(attribute.getName())) {
     try {
       PortMode newMode = PortMode.valueOf(((Settable) attribute).getExpression());
       if (!newMode.equals(getMode())) {
         setMode(newMode);
       }
     } catch (Exception e) {
       // ignore just keep default portmode then
     }
   } else {
     super.attributeChanged(attribute);
   }
 }
Ejemplo n.º 12
0
 /**
  * Request a MoMLChangeRequest to delete this attribute from its container.
  *
  * @param attribute The attribute to be deleted.
  */
 private static void _delete(Attribute attribute) {
   String moml = "<deleteProperty name=\"" + attribute.getName() + "\"/>";
   attribute.requestChange(new MoMLChangeRequest(attribute, attribute.getContainer(), moml));
 }
Ejemplo n.º 13
0
  /**
   * Specify the container. If the container is not the same as the previous container, then start
   * monitoring the new container.
   *
   * @param container The container to attach this attribute to..
   * @exception IllegalActionException If this attribute is not of the expected class for the
   *     container, or it has no name, or the attribute and container are not in the same workspace,
   *     or the proposed container would result in recursive containment.
   * @exception NameDuplicationException If the container already has an attribute with the name of
   *     this attribute.
   * @see #getContainer()
   */
  public void setContainer(final NamedObj container)
      throws IllegalActionException, NameDuplicationException {
    if (_debugging) {
      _debug("set container method called");
    }
    NamedObj previousContainer = getContainer();
    if (previousContainer == container) {
      return;
    }

    if ((previousContainer != null) && (previousContainer instanceof CompositeActor)) {
      // _piggybackContainer should be non-null, but we check anyway.
      if (_piggybackContainer != null) {
        _piggybackContainer.removePiggyback(_executable);
      }
      _executable = null;
      String name;
      try {
        workspace().getWriteAccess();
        List<Actor> entities = ((CompositeActor) previousContainer).deepEntityList();
        for (Actor entity : entities) {
          List<Attribute> paramList = ((Entity) entity).attributeList();
          for (Attribute param : paramList) {
            name = param.getDisplayName();
            if (name.equals("WCET") || name.equals("executionTime")) {
              // param.setPersistent(false);
            }
          }
        }
      } catch (Exception ex) { // this should later be replaced with a more specific exception
        throw new InternalErrorException(ex);
      } finally {
        workspace().doneTemporaryWriting();
      }
      if (_debugging) {
        _debug("I should remove all the attributes that were added here.");
      }
    }
    super.setContainer(container);

    if (container != null && container instanceof CompositeActor) {
      if (_executable == null) {

        _executable =
            new Executable() {

              public void initialize() throws IllegalActionException {
                if (_random == null || ((BooleanToken) resetOnEachRun.getToken()).booleanValue()) {
                  _createGenerator();
                }
                _needNew = true;
              }

              public boolean postfire() throws IllegalActionException {

                if (_debugging) {
                  _debug("I should now check to see if there are cumulative overruns");
                }
                _needNew = true;

                // here check to see if there were cumulative timing overruns

                if (_debugging) {
                  _debug(
                      "execution times are: "
                          + _totalObservedExecutionTime
                          + " period is: "
                          + _totalExpectedExecutionTime);
                }
                if (_totalObservedExecutionTime > _totalExpectedExecutionTime) {
                  if (_debugging) {
                    _debug("There was a timing overrun");
                  }
                  if (_debugging) {
                    _debug("There was a timing overrun");
                  }
                  handleModelError(
                      container,
                      new IllegalActionException(
                          container,
                          "total ExecutionTime  of ("
                              + _totalObservedExecutionTime
                              + ") is larger than Period of ("
                              + _totalExpectedExecutionTime
                              + ")  for actor "
                              + container.getDisplayName()));
                }
                _totalObservedExecutionTime = 0; // reset the observed time

                ChangeRequest request =
                    new ChangeRequest(
                        this,
                        "SetVariable change request",
                        true /*Although this not a structural change in my point of view
                             , we however for some reason need to specify it is, otherwise the GUI won't update.*/) {
                      protected void _execute() throws IllegalActionException {}
                    };
                // To prevent prompting for saving the model, mark this
                // change as non-persistent.
                request.setPersistent(false);
                requestChange(request);
                if (_debugging) {
                  _debug("Finished checking for overruns");
                }
                return true;
              }

              public void wrapup() {
                ChangeRequest request =
                    new ChangeRequest(this, "SetVariable change request", true) {
                      protected void _execute() throws IllegalActionException {}
                    };
                // To prevent prompting for saving the model, mark this
                // change as non-persistent.
                request.setPersistent(false);
                requestChange(request);
              }

              public void fire() throws IllegalActionException {
                if (!_readyToFire) {
                  return;
                }
                if (_debugging) {
                  _debug("Inside the fire method and the container is " + container);
                }
                if (_debugging) {
                  _debug("Fire method called in the quantity manager");
                }
                if (_needNewGenerator) {
                  _createGenerator();
                }

                if (_needNew) {
                  _generateRandomNumber();
                  _needNew = false;
                }

                if (!_readyToFire) {
                  return;
                }

                while ((_unitIndex < _schedule.size())) {

                  // Grab the next minor cycle (unit) schedule to execute.
                  Schedule unitSchedule = (Schedule) _schedule.get(_unitIndex);

                  Iterator scheduleIterator = unitSchedule.iterator();

                  while (scheduleIterator.hasNext()) {
                    Actor actor = ((Firing) scheduleIterator.next()).getActor();
                    if (_debugging) {
                      _debug("actor to be fired in this iteration has name " + actor.getFullName());
                    }

                    _myPhysicalTime =
                        actor.getDirector().getModelTime().getDoubleValue() + _overRunThusFar;

                    double actorWCET;
                    Attribute executionTime = ((Entity) actor).getAttribute("executionTime");

                    Attribute WCET = ((Entity) actor).getAttribute("WCET");
                    actorWCET = ((DoubleToken) ((Variable) WCET).getToken()).doubleValue();
                    double t =
                        _random.nextDouble()
                            * 2
                            * actorWCET; // I multiply by actorWCET in an attempt to scale
                    if (_debugging) {
                      _debug("simulated execution time is " + t);
                    }
                    _totalObservedExecutionTime += t;
                    if (t > actorWCET) {
                      _overRunThusFar += (t - actorWCET);
                      _myPhysicalTime += t; // (_overRunThusFar;
                      if (_debugging) {
                        _debug(
                            "the actor WCET estimate was "
                                + actorWCET
                                + " and the actual execution time was "
                                + t);
                        _debug(
                            "there was an error at model time "
                                + (actor.getDirector().getModelTime().getDoubleValue() + actorWCET)
                                + "physical time is actually "
                                + _myPhysicalTime);
                      }
                    }
                    Parameter dummyP = (Parameter) executionTime;
                    dummyP.setExpression(Double.toString(t));

                    if (_debugging) {
                      _debug(
                          "Done firing actor "
                              + actor
                              + " now going to check to see if it went over time.");
                    }
                  }

                  scheduleIterator = unitSchedule.iterator();

                  while (scheduleIterator.hasNext()) {
                    Actor actor1 = ((Firing) scheduleIterator.next()).getActor();

                    if (_debugging) {
                      _debug("Iterating " + ((NamedObj) actor1).getFullName());
                    }

                    if (actor1.iterate(1) == STOP_ITERATING) {
                      // FIXME: How to handle this?
                      // put the actor on a no-fire hashtable?
                      System.err.println(
                          "Warning: Giotto iterate returned "
                              + "STOP_ITERATING for actor \""
                              + actor1.getFullName()
                              + "\"");
                    }
                  }

                  _unitIndex++;
                }

                if (_unitIndex >= _schedule.size()) {
                  _unitIndex = 0;
                }
              }

              public boolean isFireFunctional() {
                return true;
              }

              public boolean isStrict() {
                return true;
              }

              public int iterate(int count) {
                return Executable.COMPLETED;
              }

              public boolean prefire() throws IllegalActionException {

                return true;
              }

              public void stop() {}

              public void stopFire() {}

              public void terminate() {}

              public void addInitializable(Initializable initializable) {}

              public void preinitialize() throws IllegalActionException {
                double wcet = 0;
                double _periodValue = 0;

                wcet = _getDirectorWCET(container);
                _periodValue = _getDirectorPeriod(container);

                // Next, construct the schedule.
                // FIXME: Note that mutations will not be supported since the
                // schedule is constructed only once.
                GiottoScheduler scheduler =
                    (GiottoScheduler)
                        ((GiottoDirector) ((CompositeActor) container).getDirector())
                            .getScheduler();
                _schedule = scheduler.getSchedule();
                // _unitTimeIncrement = scheduler._getMinTimeStep(_periodValue);

                if (_debugging) {
                  _debug(
                      "the WCET time seen by the director is "
                          + wcet
                          + " and the period is "
                          + _periodValue);
                }
                if (wcet > _periodValue) {

                  if (_debugging) {
                    _debug("throw an exception");
                  }
                  // this is the static check before execution
                  throw new IllegalActionException(
                      container,
                      "total WCET of ("
                          + wcet
                          + ") is larger than period ("
                          + _periodValue
                          + ") for actor "
                          + ((CompositeActor) (getContainer())).getDisplayName());
                } // end of if
                if (_debugging) {
                  _debug("at the end of preinitialize in the timing quantity manager.");
                }
              }

              public void removeInitializable(Initializable initializable) {}
            };
      }

      _piggybackContainer = (CompositeActor) container;
      _piggybackContainer.addPiggyback(_executable);
    }
  }
Ejemplo n.º 14
0
  /**
   * this function adds all the parameters necessary to have the documentation of the OpalClient
   * abviously this documentation is fetch from the remote server
   */
  private void _addDocumentation(AppMetadata app) throws IllegalActionException {
    // let's get the variable we need
    Attribute documentation = this.getAttribute("KeplerDocumentation");
    if (documentation == null)
      throw new IllegalActionException(
          this, "Unable to set the custom documentation (KeplerDocumentation not present).");
    Attribute userDoc = documentation.getAttribute("userLevelDocumentation");
    if (userDoc == null)
      throw new IllegalActionException(
          this, "Unable to set the custom documentation (userLevelDocumentation not present).");
    // -- we have to delete all the documentation that is already there
    // before updating it
    List tempList = documentation.attributeList();
    Attribute[] paramArray = (Attribute[]) tempList.toArray(new Attribute[tempList.size()]);
    for (int i = 0; i < paramArray.length; i++) {
      try {
        if (paramArray[i].getName().startsWith("prop:")
            || paramArray[i].getName().startsWith("port:output")
            || paramArray[i].getName().startsWith("port:baseUrl"))
          // let's remove the parameters
          paramArray[i].setContainer(null);
      } catch (NameDuplicationException e) {
        log.error(
            "The parameter could not be deleted from the documentation. Error message: "
                + e.getMessage());
        throw new IllegalActionException(
            this,
            "Error resetting the ducumentation, there is a duplicated name: " + e.getMessage());
      }
    }
    // After deleting we can finally set the documentation
    String stringDoc = _docHead;
    // let's set the general documentaion
    if (app.getUsage() != null) stringDoc += "<p>" + app.getUsage() + "</p>";
    if (app.getInfo() != null) {
      String[] infos = app.getInfo();
      for (int i = 0; i < infos.length; i++) stringDoc += "<pre>" + forXML(infos[i]) + "</pre>";
    } // if
    log.debug("the stringDoc is: " + stringDoc);
    ((ConfigurableAttribute) userDoc).setExpression(stringDoc);

    // -- let's set the documentation for the various properties --
    // some properties are always there... hence also the documentation
    // should be always there
    try {
      ((ConfigurableAttribute) userDoc).value();
      ConfigurableAttribute parameterDoc = new ConfigurableAttribute(documentation, "port:output");
      parameterDoc.setExpression(
          "It returns a list of Strings, containing the URL of the output files");
      parameterDoc = new ConfigurableAttribute(documentation, "port:baseUrl");
      parameterDoc.setExpression(
          "The base URL containing the working directory of the running jobs");
      parameterDoc = new ConfigurableAttribute(documentation, "prop:serviceURL");
      parameterDoc.setExpression("The URL of the Opal service that you want to execute");
      parameterDoc = new ConfigurableAttribute(documentation, "prop:numberOfExtraInputFiles");
      parameterDoc.setExpression(
          "The number of extra input files that are needed to execture the application");
      // parameterDoc = new ConfigurableAttribute(documentation,
      // "prop:methods");
      // parameterDoc.setExpression("Not implemented yet.");
    } catch (NameDuplicationException e) {
      log.error("The parameter could not be instantiated. Error message: " + e.getMessage());
      throw new IllegalActionException(
          this, "Error building the ducumentation, there is a duplicated name: " + e.getMessage());
    } catch (IOException e) {
      log.error("There is an error while setting the general documentation: " + e.getMessage());
    }
    // we have to list the documentation for every parameters
    if (app.isArgMetadataEnable()) {
      Group[] group = app.getGroups();
      try {
        if (group != null) {
          for (int i = 0; i < group.length; i++) {
            // first the parameters
            ArgParam[] argParams = group[i].getArgParams();
            if (argParams != null) {
              for (int paramCount = 0; paramCount < argParams.length; paramCount++) {
                ConfigurableAttribute parameterDoc =
                    new ConfigurableAttribute(
                        documentation, "prop:" + argParams[paramCount].getId());
                parameterDoc.setExpression(forXML(argParams[paramCount].getTextDesc()));
              } // for argParam
            } // argParams
            // and then the flags
            ArgFlag[] argFlags = group[i].getArgFlags();
            if (argFlags != null) {
              for (int paramCount = 0; paramCount < argFlags.length; paramCount++) {
                ConfigurableAttribute parameterDoc =
                    new ConfigurableAttribute(
                        documentation, "prop:" + argFlags[paramCount].getId());
                parameterDoc.setExpression(forXML(argFlags[paramCount].getTextDesc()));
                log.info(
                    "The parameter "
                        + argFlags[paramCount].getId()
                        + " has the following doc: "
                        + parameterDoc.value());
                parameterDoc.validate();
              }
            } // argFlags
          }
        } // group
      } catch (NameDuplicationException e) {
        log.error("The parameter could not be instantiated. Error message: " + e.getMessage());
        throw new IllegalActionException(
            this,
            "Error building the ducumentation, there is a duplicated name: " + e.getMessage());
      } catch (IOException e) {
        log.error(
            "There is an error while setting the documentation of an element with messge: "
                + e.getMessage());
      }
    } // if we have metadata
    else {
      // if we don't have metadata we document the standard parameters
      try {
        ConfigurableAttribute parameterDoc =
            new ConfigurableAttribute(documentation, "prop:commandLine");
        parameterDoc.setExpression(
            "Insert the command line you want to execute (without the application name)");
        parameterDoc = new ConfigurableAttribute(documentation, "prop:cpuNumber");
        parameterDoc.setExpression("If it is a parallel application insert the CPU number");
        parameterDoc = new ConfigurableAttribute(documentation, "prop:inputFile");
        parameterDoc.setExpression("Select an input file");
      } catch (NameDuplicationException e) {
        log.error("The parameter could not be instantiated. Error message: " + e.getMessage());
        throw new IllegalActionException(
            this,
            "Error building the ducumentation, there is a duplicated name: " + e.getMessage());
      }
    }
  } // _addDocumentation
  /**
   * Get the change request to update the object in the host model.
   *
   * @param pattern The pattern of the transformation rule.
   * @param replacement The replacement of the transformation rule.
   * @param matchResult The match result.
   * @param patternObject The object in the pattern, or null.
   * @param replacementObject The object in the replacement that corresponds to the object in the
   *     pattern.
   * @param hostObject The object in the host model corresponding to the object in the replacement.
   * @return The change request.
   * @exception IllegalActionException If error occurs in generating the change request.
   */
  @Override
  public ChangeRequest getChangeRequest(
      Pattern pattern,
      Replacement replacement,
      MatchResult matchResult,
      NamedObj patternObject,
      NamedObj replacementObject,
      NamedObj hostObject)
      throws IllegalActionException {
    if (_valueParseTree == null) {
      _reparse();
    }

    String attributeName = ((StringToken) _attributeName.getToken()).stringValue();
    String attributeClass;
    if (isAttributeClassEnabled()) {
      attributeClass = _attributeClass;
    } else {
      Attribute oldAttribute = hostObject.getAttribute(attributeName);
      if (oldAttribute == null) {
        throw new IllegalActionException(
            "Unable to determine the class"
                + " of attribute "
                + _attributeName
                + " for entity "
                + hostObject
                + ".");
      }
      attributeClass = oldAttribute.getClassName();
    }

    ParserScope scope = NamedObjVariable.getNamedObjVariable(hostObject, true).getParserScope();
    GTParameter.Evaluator evaluator = new GTParameter.Evaluator(pattern, matchResult);
    String expression;
    if (_valueParseTree instanceof ASTPtSumNode) {
      StringBuffer buffer = new StringBuffer();
      for (int i = 0; i < _valueParseTree.jjtGetNumChildren(); i++) {
        ASTPtRootNode child = (ASTPtRootNode) _valueParseTree.jjtGetChild(i);
        if (!(child.isConstant() && child.getToken() instanceof StringToken)) {
          ASTPtLeafNode newNode = _evaluate(child, evaluator, scope);
          buffer.append(_parseTreeWriter.parseTreeToExpression(newNode));
        } else {
          buffer.append(((StringToken) child.getToken()).stringValue());
        }
      }
      expression = buffer.toString();
    } else if (!(_valueParseTree.isConstant()
        && _valueParseTree.getToken() instanceof StringToken)) {
      ASTPtRootNode newRoot = _evaluate(_valueParseTree, evaluator, scope);
      expression = _parseTreeWriter.parseTreeToExpression(newRoot);
    } else {
      expression = _attributeValue.get();
    }
    String moml =
        "<property name=\""
            + attributeName
            + "\" class=\""
            + attributeClass
            + "\" value=\""
            + StringUtilities.escapeForXML(expression)
            + "\"/>";
    return new MoMLChangeRequest(this, hostObject, moml, null);
  }
Ejemplo n.º 16
0
  /**
   * Evaluate the specified command.
   *
   * @param command The command.
   * @return The return value of the command, or null if there is none.
   * @exception Exception If something goes wrong processing the command.
   */
  public String evaluateCommand(String command) throws Exception {
    if (command.trim().equals("")) {
      return "";
    }

    PtParser parser = new PtParser();
    ASTPtRootNode node = parser.generateSimpleAssignmentParseTree(command);
    String targetName = null;

    // Figure out if we got an assignment... if so, then get the
    // identifier name and only evaluated the expression part.
    if (node instanceof ASTPtAssignmentNode) {
      ASTPtAssignmentNode assignmentNode = (ASTPtAssignmentNode) node;
      targetName = assignmentNode.getIdentifier();
      node = assignmentNode.getExpressionTree();
    }

    final NamedObj model = ((ExpressionShellEffigy) getContainer()).getModel();
    ParserScope scope =
        new ModelScope() {
          public ptolemy.data.Token get(String name) throws IllegalActionException {
            Variable result = getScopedVariable(null, model, name);

            if (result != null) {
              return result.getToken();
            } else {
              return null;
            }
          }

          public ptolemy.data.type.Type getType(String name) throws IllegalActionException {
            Variable result = getScopedVariable(null, model, name);

            if (result != null) {
              return result.getType();
            } else {
              return null;
            }
          }

          public InequalityTerm getTypeTerm(String name) throws IllegalActionException {
            Variable result = getScopedVariable(null, model, name);

            if (result != null) {
              return result.getTypeTerm();
            } else {
              return null;
            }
          }

          public Set identifierSet() {
            return getAllScopedVariableNames(null, model);
          }
        };

    Token result = _evaluator.evaluateParseTree(node, scope);

    // If a target was specified, instantiate a new token.
    if (targetName != null) {
      Attribute attribute = model.getAttribute(targetName);

      if (attribute != null && !(attribute instanceof Parameter)) {
        attribute.setContainer(null);
        attribute = null;
      }

      if (attribute == null) {
        attribute = new Parameter(model, targetName);
      }

      ((Parameter) attribute).setToken(result);
    }

    if (result == null) {
      return "";
    } else {
      return result.toString();
    }
  }
Ejemplo n.º 17
0
  /**
   * Write a MoML description of the contents of this object, wrapped in a configure element. This
   * is done by first populating the model, and then exporting its contents into a configure
   * element. This method is called by exportMoML(). Each description is indented according to the
   * specified depth and terminated with a newline character.
   *
   * @param output The output stream to write to.
   * @param depth The depth in the hierarchy, to determine indenting.
   * @exception IOException If an I/O error occurs.
   */
  protected void _exportMoMLContents(Writer output, int depth) throws IOException {
    populate();
    // Export top level attributes and ports

    List _attributes = attributeList();
    String _displayName = getDisplayName();

    // FIXME: start of duplicated code from NamedObj
    // If the display name has been set, then include a display element.
    // Note that copying parameters that have _displayName set need
    // to export _displayName.
    // See: http://bugzilla.ecoinformatics.org/show_bug.cgi?id=3361
    if (!_displayName.equals(getName())) {
      output.write("<display name=\"");
      output.write(StringUtilities.escapeForXML(_displayName));
      output.write("\"/>");
    }

    // Callers of this method should hold read access
    // so as to avoid ConcurrentModificationException.
    if (_attributes != null) {
      // Iterator attributes = _attributes.elementList().iterator();
      Iterator attributes = _attributes.iterator();

      while (attributes.hasNext()) {
        Attribute attribute = (Attribute) attributes.next();
        attribute.exportMoML(output, depth);
      }
    }
    // FIXME: end of duplicated code from NamedObj

    // FIXME: start of duplicated code from Entity
    Iterator ports = portList().iterator();

    while (ports.hasNext()) {
      Port port = (Port) ports.next();
      port.exportMoML(output, depth);
    }
    // FIXME: end of duplicated code from Entity

    // Everything else is in a configure

    output.write(_getIndentPrefix(depth) + "<configure>\n");
    output.write(_getIndentPrefix(depth + 1) + "<group>\n");

    // FIXME: start of duplicated code from CompositeEntity
    Iterator classes = classDefinitionList().iterator();

    while (classes.hasNext()) {
      ComponentEntity entity = (ComponentEntity) classes.next();
      entity.exportMoML(output, depth + 2);
    }

    Iterator entities = entityList().iterator();

    while (entities.hasNext()) {
      ComponentEntity entity = (ComponentEntity) entities.next();
      entity.exportMoML(output, depth + 2);
    }

    Iterator relations = relationList().iterator();

    while (relations.hasNext()) {
      ComponentRelation relation = (ComponentRelation) relations.next();
      relation.exportMoML(output, depth + 2);
    }

    // NOTE: We used to write the links only if
    // this object did not defer to another
    // (getMoMLInfo().deferTo was null), and
    // would instead record links in a MoMLAttribute.
    // That mechanism was far too fragile.
    // EAL 3/10/04
    output.write(exportLinks(depth + 2, null));
    // FIXME: end of duplicated code from CompositeEntity

    output.write(_getIndentPrefix(depth + 1) + "</group>\n");
    output.write(_getIndentPrefix(depth) + "</configure>\n");
  }