/// /// <summary> * apply the parameters in this to all appropriate resources in parentNode or one of parentNode's children /// * </summary> /// * <param name="parentNode"> the node to search in </param> /// internal virtual void applyResourceCommand(JDFNode parentNode) { if (parentNode == null) { return; } VElement vNodes = parentNode.getvJDFNode(null, null, false); int size = vNodes.Count; for (int i = 0; i < size; i++) { JDFNode node = (JDFNode)vNodes[i]; if (!matchesNode(node)) { continue; } JDFResource resCmd = enclosingInstance.getResource(null); if (resCmd == null) { continue; } bool isIncremental = (enclosingInstance.getUpdateMethod() == EnumUpdateMethod.Incremental); // commented out, statements have no effect // double dAmount = -1.0; // if (hasAttribute (AttributeName.PRODUCTIONAMOUNT)) // { // dAmount = getProductionAmount (); // TODO: set ProductionAmount // } // final String strProcessUsage = getProcessUsage(); // TODO: use // ProcessUsage // final JDFElement.EnumNodeStatus status = getStatus(); // TODO: // set Status VJDFAttributeMap vamParts = enclosingInstance.getPartMapVector(); JDFResource resTarget = getTargetResource(node); if (resTarget == null) { resTarget = createNewResource(node, resCmd); if (resTarget == null) { continue; } } // get the most granular list of partIDKeys from the cmd or resource VString vsPartIDKeys = resTarget.getPartIDKeys(); VString vsPartIDKeysCmd = resCmd.getPartIDKeys(); int sizTarget = vsPartIDKeys == null ? 0 : vsPartIDKeys.Count; int sizCmd = vsPartIDKeysCmd == null ? 0 : vsPartIDKeysCmd.Count; if (sizCmd > sizTarget) { vsPartIDKeys = vsPartIDKeysCmd; } int sizeParts = vamParts == null ? 1 : vamParts.Count; for (int j = 0; j < sizeParts; j++) { JDFAttributeMap amParts = vamParts == null ? null : vamParts[j]; JDFResource resTargetPart = resTarget.getCreatePartition(amParts, vsPartIDKeys); if (resTargetPart == null) { continue; } string id = resTargetPart.getID(); if (!isIncremental) { JDFAttributeMap map = resTargetPart.getPartMap(); resTargetPart.flush(); resTargetPart.setAttributes(map); } JDFResource resCmdPart = resCmd.getPartition(amParts, EnumPartUsage.Implicit); JDFAttributeMap map2 = resCmdPart.getAttributeMap(); VString keys = map2.getKeys(); if (keys != null) { int keySize = keys.Count; for (int k = 0; k < keySize; k++) { string key = keys[k]; string @value = map2.get(key); if (@value == null || JDFConstants.EMPTYSTRING.Equals(@value)) { resCmdPart.removeAttribute(key); resTargetPart.removeAttribute(key); } } } resTargetPart.mergeElement(resCmdPart, false); resTarget.setID(id); } if (sizeParts > 0 && resTarget is JDFNodeInfo) { fixNodeStatusFromNodeInfo(node, resTarget); } } }
/// /// <summary> * sets the attribute occurence in the appropriate PartAmount when called for a resourceLink and creates the /// * AmountPool and/or PartAmount(s) if they are not yet there /// * </summary> /// * <param name="attrib"> the attribute name </param> /// * <param name="value"> value to set in string form. </param> /// * <param name="nameSpaceURI"> the XML-namespace </param> /// * <param name="vPart"> defines which part of this ResourceLink the Amount belongs to, if empty set the ResourceLink /// * root attribute. </param> /// * <exception cref="JDFException"> when called directly on a PartAmount /// * @since 060630 </exception> /// public static void setAmountPoolAttribute(IAmountPoolContainer poolParent, string attrib, string @value, string nameSpaceURI, VJDFAttributeMap vPart) { // ideally the method would be hidden in PartAmount if ((vPart == null) || (vPart.IsEmpty()) || vPart.Count == 1 && vPart[0].Count == 0) { poolParent.setAttribute(attrib, @value, nameSpaceURI); return; } poolParent.removeAttribute(attrib, nameSpaceURI); // either in the // pool or the // link, not both JDFAmountPool ap = poolParent.getCreateAmountPool(); JDFPartAmount pa0 = ap.getCreatePartAmount(vPart); pa0.setAttribute(attrib, @value, nameSpaceURI); }
public virtual VString copyResource(JDFResource r, JDFResource.EnumSpawnStatus copyStatus, VJDFAttributeMap vParts, string spawnID) { VString ss = getResIds(); VString v = new VString(); // r is not yet here copy r if (!ss.Contains(r.getID())) { JDFResource rNew = null; // if spawning, fix stati and locks if (copyStatus == JDFResource.EnumSpawnStatus.SpawnedRO) { // copy the complete resource as RO - no need to reduce // partitions r.appendSpawnIDs(spawnID); rNew = (JDFResource)copyElement(r, null); rNew.setLocked(true); r.setSpawnStatus(copyStatus); } else if (copyStatus == JDFResource.EnumSpawnStatus.SpawnedRW) { if (vParts.Count == 0) { // just copy the whole thing - no parts specified r.appendSpawnIDs(spawnID); rNew = (JDFResource)copyElement(r, null); r.setSpawnStatus(copyStatus); } else { rNew = (JDFResource)copyElement(r, null); rNew.reducePartitions(vParts); // reduce any unneeded leaves // loop over all part maps to get best matching resource for (int i = 0; i < vParts.Count; i++) { JDFResource pLeaf = r.getPartition(vParts[i], null); JDFResource pNewLeaf = rNew.getPartition(vParts[i], null); if (pLeaf != null) { pLeaf.setSpawnStatus(copyStatus); pLeaf.appendSpawnIDs(spawnID); } if (pNewLeaf != null) { pNewLeaf.appendSpawnIDs(spawnID); } } } } if (rNew != null) { v.Add(rNew.getID()); } } VString vs = r.getHRefs(null, false, true); // add recursively copied resources for (int i = 0; i < vs.Count; i++) { string id = vs[i]; // the referenced resource is in this pool - continue if (ss.Contains(id)) { continue; } // the referenced resource has already been merged in - continue if (v.Contains(id)) { continue; } JDFResource next = (JDFResource)getDocRoot().getTarget(id, AttributeName.ID); if (next == null) { // 071101 RP added r is by definition in the original document // which also contains the rrefs elements next = (JDFResource)r.getDocRoot().getTarget(id, AttributeName.ID); // and now all those interlinked resources VString vv = copyResource(next, copyStatus, vParts, spawnID); v.AddRange(vv); } } return(v); }
/// /// <summary> * } getAudits - get all audits with attributes and partMap /// * </summary> /// * <param name="typ"> type of the audit to take </param> /// * <param name="mAttributes"> attribute map to filter the audits </param> /// * <param name="vParts"> the partmap vector - note that not all audits legally have parts </param> /// * <returns> VElement - all elements, that matches the filter /// * /// * default: getAudits(null, null, null) </returns> /// public virtual VElement getAudits(JDFAudit.EnumAuditType typ, JDFAttributeMap mAttributes, VJDFAttributeMap vParts) { VJDFAttributeMap vPartsLocal = vParts; string strAuditType = null; if (typ != null) { strAuditType = typ.getName(); } VElement vElem = getPoolChildrenGeneric(strAuditType, mAttributes, null); if (vPartsLocal != null && vPartsLocal.Count == 0) { vPartsLocal = null; } for (int i = vElem.Count - 1; i >= 0; i--) { // remove known comments - this would be aught in the next check but // we avoid the exception if (!(vElem[i] is JDFAudit)) { vElem.RemoveAt(i); continue; // look at next element } JDFAudit audit = (JDFAudit)vElem[i]; if (vPartsLocal != null && !vPartsLocal.Equals(audit.getPartMapVector())) { vElem.RemoveAt(i); continue; // look at next element } } return(vElem); }
/// /// * <param name="icsLevel"> </param> /// protected internal virtual void initPlateXM(EnumUsage usage) { JDFResourceLink rl = null; if (thePreviousNode != null) // either input (for cp, or output for // plateset) { rl = theNode.linkResource(thePreviousNode.getResource(ElementName.EXPOSEDMEDIA, null, 0), usage, null); } if (rl == null && theParentNode != null) { rl = theNode.ensureLink(theParentNode.getResource(ElementName.EXPOSEDMEDIA, null, 0), usage, null); } JDFExposedMedia xm = (JDFExposedMedia)theNode.getCreateResource(ElementName.EXPOSEDMEDIA, usage, 0); xm.setPartUsage(EnumPartUsage.Explicit); rl = theNode.getLink(xm, null); JDFMedia m = ((JDFExposedMedia)xm.getLeaves(false)[0]).getMedia(); if (m == null) { m = initPlateMedia(); } else { m = (JDFMedia)m.getResourceRoot(); if (theParentNode != null) { theNode.ensureLink(theParentNode.getResource("Media", EnumUsage.Input, 0), EnumUsage.Input, null); } } xm.setResStatus(EnumResStatus.Unavailable, false); if (!bPartitionedPlateMedia && xm.getMedia() == null) { xm.refElement(m); } if (EnumUsage.Input.Equals(usage)) { rl.setProcessUsage(EnumProcessUsage.Plate); JDFResourceLink link = theNode.getLink(m, null); if (link != null) { link.deleteNode(); } } if (vParts != null) { for (int i = 0; i < vParts.Count; i++) { JDFAttributeMap part = new JDFAttributeMap(vParts[i]); JDFResource xmp = xm.getCreatePartition(part, partIDKeys); int ncols = "Front".Equals(part.get("Side")) ? nCols[0] : nCols[1]; for (int j = 0; j < ncols; j++) { part.put(EnumPartIDKey.Separation, cols.stringAt(j)); xmp.getCreatePartition(part, partIDKeys); } } if (bPartitionedPlateMedia) { VJDFAttributeMap vSheets = getReducedMap(new VString("Side Separation PartVersion", null)); for (int i = 0; i < vSheets.Count; i++) { JDFAttributeMap part = new JDFAttributeMap(vSheets[i]); JDFExposedMedia xmp = (JDFExposedMedia)xm.getCreatePartition(part, partIDKeys); if (xmp.getMedia() == null) { xmp.refMedia((JDFMedia)m.getCreatePartition(part, null)); } } } } }
/// /// <summary> * Append a Spawned audit element /// * </summary> /// * <param name="spawned"> the spawned node </param> /// * <param name="rRefsRO"> a vector of rRefs that are spawned read-only </param> /// * <param name="rRefsRW"> a vector of rRefs that are spawned read-write </param> /// * <param name="by"> the author keyword </param> /// * <param name="vmParts"> /// * </param> /// * <returns> JDFAudit - the newly created Spawned audit /// * /// * default: AddSpawned(spawned, new Vector(), new Vector(), JDFConstants.EMPTYSTRING, new /// * VJDFAttributeMap()) </returns> /// public virtual JDFSpawned addSpawned(JDFNode spawned, VString rRefsRO, VString rRefsRW, string by, VJDFAttributeMap vmParts) { JDFSpawned a = (JDFSpawned)addAudit(JDFAudit.EnumAuditType.Spawned, by); a.setAttribute(JDFConstants.JREF, spawned.getID(), null); string ms = null; if (rRefsRO != null && !rRefsRO.IsEmpty()) { ms = StringUtil.setvString(rRefsRO); a.setAttribute(AttributeName.RREFSROCOPIED, ms, null); } if (rRefsRW != null && !rRefsRW.IsEmpty()) { ms = StringUtil.setvString(rRefsRW); a.setAttribute(AttributeName.RREFSRWCOPIED, ms, null); } a.setPartMapVector(vmParts); return(a); }
/// /// <summary> * Append a Notification audit element with a Class attribute of Severity /// * </summary> /// * <param name="by"> the author keyword </param> /// * <param name="s"> the severity /// * </param> /// * <returns> JDFAudit - the newly created Notification audit </returns> /// public virtual JDFNotification addNotification(JDFNotification.EnumClass severity, string by, VJDFAttributeMap vmParts) { JDFNotification l = (JDFNotification)addAudit(JDFAudit.EnumAuditType.Notification, by); if (l != null) { if (severity != null) { l.setClass(severity); } l.setPartMapVector(vmParts); } return(l); }
/// /// <summary> * sets the attribute occurence in the appropriate PartAmount when called for a resourceLink and creates the /// * AmountPool and/or PartAmount(s) if they are not yet there /// * </summary> /// * <param name="attrib"> the attribute name </param> /// * <param name="value"> value to set in string form. </param> /// * <param name="nameSpaceURI"> the XML-namespace </param> /// * <param name="vPart"> defines which part of this ResourceLink the Amount belongs to, if empty set the ResourceLink root /// * attribute. </param> /// * <exception cref="JDFException"> when called directly on a PartAmount /// * @since 060630 </exception> /// public virtual void setAmountPoolAttribute(string attrib, string @value, string nameSpaceURI, VJDFAttributeMap vPart) { AmountPoolHelper.setAmountPoolAttribute(this, attrib, @value, nameSpaceURI, vPart); }
/// /// <summary> * returns the attribute occurence in PartAmount, or the default in the ResourceLink /// * </summary> /// * <param name="attrib"> the attribute name </param> /// * <param name="nameSpaceURI"> the XML-namespace </param> /// * <param name="vPart"> defines which part of this ResourceLink the Amount belongs to. If null get the ResourceLink root /// * attribute. </param> /// * <returns> value of attribute found, null if not available /// * @since 071103 </returns> /// public virtual string getAmountPoolAttribute(string attrib, string nameSpaceURI, VJDFAttributeMap vPart) { return(AmountPoolHelper.getAmountPoolAttribute(this, attrib, nameSpaceURI, vPart)); }
/// /// <summary> * check whether the Ancestor pool contains any part elements /// * </summary> /// * <returns> true if the pool comtains part elements </returns> /// public virtual bool isPartitioned() { VJDFAttributeMap partMapVector = getPartMapVector(); return(partMapVector != null && partMapVector.Count > 0); }
/// /// <summary> * create a BaseGoldenTicket /// * </summary> /// * <param name="_icsLevel"> the level to init to (1,2 or 3) </param> /// * <param name="jdfVersion"> the version to generate a golden ticket for </param> /// * <param name="_jmfLevel"> level of jmf ICS to support </param> /// * <param name="_misLevel"> level of MIS ICS to support </param> /// * <param name="isGrayBox"> if true, write a grayBox </param> /// * <param name="vPartMap"> the partmap vector for this node </param> /// public MISCPGoldenTicket(int _icsLevel, EnumVersion jdfVersion, int _jmfLevel, int _misLevel, bool isGrayBox, VJDFAttributeMap vPartMap) : base(_misLevel, jdfVersion, _jmfLevel) { icsLevel = _icsLevel; vParts = vPartMap; grayBox = isGrayBox; setup(); }
public virtual VString findQueueEntries(string strJobID, string strJobPartID, VJDFAttributeMap vamParts, EnumQueueEntryStatus status) { VString vsQEntryIDs = new VString(); int entryCount = getEntryCount(); for (int i = 0; i < entryCount; i++) { JDFQueueEntry entry = getQueueEntry(i); string strQEJobID = entry.getJobID(); string strQEJobPartID = entry.getJobPartID(); VJDFAttributeMap vamQEParts = entry.getPartMapVector(); EnumQueueEntryStatus statusQE = entry.getQueueEntryStatus(); if (strJobID.Equals(strQEJobID) && strJobPartID.Equals(strQEJobPartID) && vamParts.Equals(vamQEParts)) { if ((status == null) || (status.Equals(statusQE))) { vsQEntryIDs.appendUnique(entry.getQueueEntryID()); } } } return(vsQEntryIDs); }
public virtual void testDirtyIDs() { // -i bookintent.jdf -o spawned.jdf -p 4 string xmlFile = "bookintent.jdf"; string outFile = "spawned.jdf"; string strPartID = "4"; JDFParser p = new JDFParser(); JDFDoc jdfDocIn = p.parseFile(sm_dirTestData + xmlFile); Assert.IsTrue(jdfDocIn != null); if (jdfDocIn == null) { return; // soothe findbugs ;) } XMLDocUserData xmlUserData = jdfDocIn.getCreateXMLDocUserData(); xmlUserData.setDirtyPolicy(XMLDocUserData.EnumDirtyPolicy.ID); JDFNode rootIn = (JDFNode)jdfDocIn.getRoot(); JDFNode nodeToSpawn; if (strPartID.Equals("")) { nodeToSpawn = rootIn; } else { nodeToSpawn = rootIn.getJobPart(strPartID, ""); } if (nodeToSpawn == null) { Assert.Fail("No such JobPartID: " + strPartID); } else { ArrayList vRWResources = new ArrayList(); vRWResources.Add("Component"); vRWResources.Add("RunList"); VJDFAttributeMap vSpawnParts = new VJDFAttributeMap(); JDFSpawn spawn = new JDFSpawn(nodeToSpawn); JDFNode node = spawn.spawn(xmlFile, outFile, vRWResources, vSpawnParts, false, false, false, false); // neu gespawntes FileInfo rausschreiben JDFNode rootOut = node; XMLDoc docOut = rootOut.getOwnerDocument_KElement(); docOut.write2File(sm_dirTestDataTemp + outFile, 0, true); // verändertes Ausgangsfile rausschreiben string strOutXMLFile = "_" + xmlFile; rootIn.eraseEmptyNodes(true); jdfDocIn.write2File(sm_dirTestDataTemp + strOutXMLFile, 0, true); Assert.IsTrue(true, "SpawnJDF ok"); // test, if all changed nodes are in our list // Java to C# Conversion - Java version indicated there should be 5 Dirty IDs, but it only checks for 4. // C# version returns 4 Dirty IDs. Set it to 4 for now. VString vstrDirtyIDs = jdfDocIn.getDirtyIDs(); Assert.AreEqual(4, vstrDirtyIDs.Count); Assert.IsTrue(vstrDirtyIDs.Contains("n0014")); // audit pool was added Assert.IsTrue(vstrDirtyIDs.Contains("n0016")); // status changed: // waiting --> spawned Assert.IsTrue(vstrDirtyIDs.Contains("r0017")); //SpawnStatus="SpawnedRW" // added Assert.IsTrue(vstrDirtyIDs.Contains("r0018")); // SizeIntent added } }
/// /// <summary> * create a BaseGoldenTicket /// * </summary> /// * <param name="icsLevel"> the level to init to (1,2 or 3) </param> /// * <param name="jdfVersion"> the version to generate a golden ticket for </param> /// * <param name="jmfLevel"> level of jmf ICS to support </param> /// * <param name="misLevel"> level of MIS ICS to support </param> /// * <param name="isGrayBox"> if true, write a grayBox </param> /// public MISFinGoldenTicket(int _icsLevel, EnumVersion jdfVersion, int _jmfLevel, int _misLevel, bool isGrayBox, VJDFAttributeMap vPartMap) : base(_misLevel, jdfVersion, _jmfLevel) { catMap.Add(MISFIN_SHEETFIN, new VString("Cutting Folding", null)); partIDKeys = new VString("SignatureName,SheetName", ","); vParts = vPartMap; icsLevel = _icsLevel; }
/// /// <summary> * set all parts to those defined by vParts /// * </summary> /// * <param name="vParts"> vector of attribute maps for the parts </param> /// public override void setPartMapVector(VJDFAttributeMap vParts) { base.setPartMapVector(vParts); }
public virtual double getAmountPoolSumDouble(string attName, VJDFAttributeMap vPart) { return(AmountPoolHelper.getAmountPoolSumDouble(this, attName, vPart)); }
/// /// <summary> * Add a ProcessRun Audit /// * </summary> /// * <param name="s"> the node status at this time </param> /// * <param name="by"> the author keyword </param> /// * <returns> the newly created ProcessRun audit /// * /// * default: AddProcessRun(s, JDFConstants.EMPTYSTRING) </returns> /// public virtual JDFProcessRun addProcessRun(JDFElement.EnumNodeStatus s, string by, VJDFAttributeMap vmParts) { JDFProcessRun pr = (JDFProcessRun)addAudit(JDFAudit.EnumAuditType.ProcessRun, by); pr.setStart(null); pr.setEnd(null); pr.setEndStatus(s); pr.setPartMapVector(vmParts); return(pr); }
/// /// <summary> * returns the attribute occurence in PartAmount, or the default in the ResourceLink /// * </summary> /// * <param name="attrib"> the attribute name </param> /// * <param name="nameSpaceURI"> the XML-namespace </param> /// * <param name="vPart"> defines which part of this ResourceLink the Amount belongs to. If null get the ResourceLink root /// * attribute. </param> /// * <returns> value of attribute found, null if not available /// * @since 071103 </returns> /// public static string getAmountPoolAttribute(IAmountPoolContainer poolParent, string attrib, string nameSpaceURI, VJDFAttributeMap vPart) { // want a map but already in a partamount - snafu if (poolParent is JDFPartAmount) { if (vPart != null) { throw new JDFException("JDFResourceLink.getAmountPoolAttribute: calling method on PartAmount object"); } return(poolParent.getAttribute(attrib, nameSpaceURI, null)); } // default to attribute if no amountpool JDFAmountPool amountPool = poolParent.getAmountPool(); if (amountPool == null || vPart == null) { return(poolParent.getAttribute(attrib, nameSpaceURI, null)); } JDFPartAmount pa = amountPool.getPartAmount(vPart); if (pa != null) // we have a pa; if it has the attribute return its // value, else get the link attribute { string ret = pa.getAttribute(attrib, nameSpaceURI, null); if (ret != null) { return(ret); } } return(poolParent.getAttribute(attrib, nameSpaceURI, null)); }
/// /// <summary> * Append a Merged audit element /// * </summary> /// * <param name="merged"> the merged node </param> /// * <param name="rRefsOverwritten"> a vector of rRefs that are overwritten </param> /// * <param name="by"> the author keyword /// * </param> /// * <returns> JDFMerged - the newly created Merged audit /// * /// * default: AddMerged(merged, rRefsOverwritten, JDFConstants.EMPTYSTRING, null) </returns> /// public virtual JDFMerged addMerged(JDFNode merged, VString rRefsOverwritten, string by, VJDFAttributeMap vmParts) { VString rRefsOverwrittenLocal = rRefsOverwritten; JDFMerged mergedAudit = (JDFMerged)addAudit(JDFAudit.EnumAuditType.Merged, by); mergedAudit.setjRef(merged.getID()); if (rRefsOverwrittenLocal != null && rRefsOverwrittenLocal.IsEmpty()) { rRefsOverwrittenLocal = null; } mergedAudit.setrRefsOverwritten(rRefsOverwrittenLocal); mergedAudit.setPartMapVector(vmParts); return(mergedAudit); }
/// /// <summary> * get the exactly matching AmountPool/PartAmount/@AttName as a double /// * </summary> /// * <param name="attName"> </param> /// * <param name="vPart"> </param> /// * <returns> double - </returns> /// * <exception cref="JDFException"> if the element can not be cast to double </exception> /// public static double getAmountPoolDouble(IAmountPoolContainer poolParent, string attName, VJDFAttributeMap vPart) { double d = 0; string w = getAmountPoolAttribute(poolParent, attName, null, vPart); if (w == null) { return(-1); } d = StringUtil.parseDouble(w, -1.234567); if (d == -1.234567) { throw new JDFException("JDFResourceLink.getAmountPoolDouble: Attribute " + attName + " has an invalid value"); } return(d); }
public virtual JDFPhaseTime getLastPhase(VJDFAttributeMap vPartMap) { return(getLastPhase(vPartMap, null)); }
/// /// /// <summary> * gets the sum of all matching tags, with the assumpzion that no condition defaults to good /// * </summary> /// * <param name="poolParent"> </param> /// * <param name="attName"> </param> /// * <param name="vPart"> </param> /// * <returns> the sum /// * </returns> /// public static double getAmountPoolSumDouble(IAmountPoolContainer poolParent, string attName, VJDFAttributeMap vPart) { VJDFAttributeMap vPartLocal = vPart; if (vPartLocal == null) { vPartLocal = poolParent.getPartMapVector(); } if (poolParent.hasAttribute(attName)) { return(poolParent.getRealAttribute(attName, null, 0)); } VJDFAttributeMap vm = vPartLocal == null ? null : new VJDFAttributeMap(vPartLocal); JDFResource linkRoot = poolParent.getLinkRoot(); if (linkRoot != null && vm != null) { SupportClass.SetSupport <string> @set = linkRoot.getPartIDKeys().getSet(); @set.Add(AttributeName.CONDITION); // retain good / waste vm.reduceMap(@set); } if (vm == null) { vm = new VJDFAttributeMap(); vm.Add((JDFAttributeMap)null); } double dd = 0; JDFAmountPool ap = poolParent.getAmountPool(); if (ap == null) { return(poolParent.getRealAttribute(attName, null, 0.0)); } VElement vParts = ap.getChildElementVector(ElementName.PARTAMOUNT, null); if (vParts.IsEmpty()) { return(poolParent.getRealAttribute(attName, null, 0.0)); } bool isWaste = vPartLocal != null && vPartLocal.subMap(new JDFAttributeMap(AttributeName.CONDITION, "Waste")); if (!isWaste && (vPartLocal == null || !vPartLocal.subMap(new JDFAttributeMap(AttributeName.CONDITION, "*")))) { vPartLocal = new VJDFAttributeMap(vPartLocal); vPartLocal.Add(new JDFAttributeMap(AttributeName.CONDITION, "Good")); } for (int j = 0; j < vParts.Count; j++) { JDFPartAmount pa = (JDFPartAmount)vParts[j]; VJDFAttributeMap partMapVector = pa.getPartMapVector(); if (isWaste) { bool hasCondition = partMapVector.subMap(new JDFAttributeMap(AttributeName.CONDITION, "*")); if (!hasCondition) { continue; } } if (!partMapVector.overlapsMap(vm)) { continue; } string ret = null; ret = pa.getAttribute(attName, null, null); if (ret == null) { ret = poolParent.getAttribute(attName, null, null); } dd += StringUtil.parseDouble(ret, 0.0); } return(dd); }
/// /// <summary> * get the index'th audit of the given typ /// * </summary> /// * <param name="index"> index of the audit negativ values are possible and will be substracted from the vector size. For /// * example,your given Filter returns a Vector of 10 Posible Elements and your index is -7 you will get 10 /// * - 7 = Element Number 3 </param> /// * <param name="typ"> type of the audit to take </param> /// * <param name="mAttributes"> attribute map to filter the audits </param> /// * <param name="vParts"> the partmap vector - note that not all audits legally have parts </param> /// * <returns> an Audit that matches the filers /// * /// * default: getAudit(index, typ, null) </returns> /// public virtual JDFAudit getAudit(int index, JDFAudit.EnumAuditType typ, JDFAttributeMap mAttributes, VJDFAttributeMap vParts) { int indexLocal = index; VElement v = getAudits(typ, mAttributes, vParts); if (indexLocal < 0) { indexLocal = v.Count + indexLocal; } if (indexLocal >= v.Count || indexLocal < 0) { return(null); } return((JDFAudit)v[indexLocal]); }
public virtual void setActivePart(VJDFAttributeMap vp, bool bFirst) { theStatusCounter.setActiveNode(theExpandedNode, vp, getNodeLinks()); }