//
// * // Element getter / setter
//
//
// * (non-Javadoc)
// *
// * @see
// * org.cip4.jdflib.resource.devicecapability.JDFAbstractState#addValue(java
// * .lang.String, org.cip4.jdflib.datatypes.JDFBaseDataTypes.EnumFitsValue)
//
public override void addValue(string @value, EnumFitsValue testlists)
{
if (fitsValue(@value, testlists))
{
return;
}
if (!StringUtil.isNumber(@value))
{
return;
}
double d = StringUtil.parseDouble(@value, 0);
if (testlists == null || EnumFitsValue.Allowed.Equals(testlists))
{
JDFNumberRangeList list = getAllowedValueList();
if (list == null)
{
list = new JDFNumberRangeList();
}
list.Append(d);
setAllowedValueList(list);
}
if (testlists == null || EnumFitsValue.Present.Equals(testlists))
{
JDFNumberRangeList list = getPresentValueList();
if (list == null || !hasAttribute(AttributeName.PRESENTVALUELIST))
{
list = new JDFNumberRangeList();
}
list.Append(d);
setPresentValueList(list);
}
}
///
/// <summary> * fitsXYZTolerance - checks whether this Evaluation has a specified
/// * Tolerance that it is not equal "0 0", and expands the original rangelist
/// * to the rangelist that fits the Tolerance.
/// * </summary>
/// * <param name="rangeList">
/// * original rangelist </param>
/// * <returns> JDFNumberRangeList - expanded rangelist, returns original range
/// * if Tolerance=="0 0" </returns>
///
public virtual JDFNumberRangeList fitsXYZTolerance(JDFNumberRangeList origRangeList)
{
double nt = getTolerance().X; // negative tolerance
double pt = getTolerance().Y; // positive tolerance
if ((nt == 0) && (pt == 0))
{
return(origRangeList);
}
// expand our original range into the range +/- Tolerance
JDFNumberRangeList rangeList = new JDFNumberRangeList(origRangeList);
JDFNumberRangeList tolRangeList = new JDFNumberRangeList();
int size = rangeList.Count;
for (int i = 0; i < size; i++)
{
JDFNumberRange range = (JDFNumberRange)rangeList[i];
JDFNumberRange r = new JDFNumberRange();
r.Left = range.Left - nt;
r.Right = range.Right + pt;
tolRangeList.Append(r);
}
return(tolRangeList);
}
public void testAddValue()
{
JDFNumberRangeList integerList = new JDFNumberRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(integerList);
iState.addValue("24", EnumFitsValue.Allowed);
Assert.AreEqual(integerList, iState.getAllowedValueList());
iState.addValue("45", EnumFitsValue.Allowed);
Assert.AreEqual(new JDFNumberRangeList("1 2 3 4 ~ 44 45"), iState.getAllowedValueList());
iState.addValue("48", EnumFitsValue.Present);
Assert.AreEqual(new JDFNumberRangeList("48"), iState.getPresentValueList());
}
public virtual JDFNumberRangeList getZ()
{
try
{
JDFNumberRangeList nrl = new JDFNumberRangeList(getAttribute(AttributeName.Z));
return(nrl);
}
catch (FormatException)
{
throw new JDFException("JDFShapeEvaluation.getZ: Attribute Z is not capable to create JDFNumberRangeList");
}
}
public void testSetAllowedValueList()
{
JDFNumberRangeList integerList = new JDFNumberRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(integerList);
Assert.AreEqual(integerList, iState.getPresentValueList());
Assert.AreEqual(integerList, iState.getAllowedValueList());
JDFNumberRangeList integerList2 = new JDFNumberRangeList("1 2 3 7~77");
iState.setPresentValueList(integerList2);
Assert.AreEqual(integerList2, iState.getPresentValueList());
Assert.AreEqual(integerList, iState.getAllowedValueList());
}
///
/// <summary> * (20) get JDFNumberRangeList attribute ValueList </summary>
/// * <returns> JDFNumberRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFNumberRangeList </returns>
///
public virtual JDFNumberRangeList getValueList()
{
string strAttrName = "";
JDFNumberRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.VALUELIST, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFNumberRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * (20) get JDFNumberRangeList attribute ForceFrontSide </summary>
/// * <returns> JDFNumberRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFNumberRangeList </returns>
///
public virtual JDFNumberRangeList getForceFrontSide()
{
string strAttrName = "";
JDFNumberRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.FORCEFRONTSIDE, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFNumberRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * fitsContainedList - tests whether <code>value</code> matches the given
/// * testlist (ListType=ContainedList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches testlist </returns>
///
private bool fitsContainedList(JDFNumberRangeList @value, JDFNumberRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
for (int i = 0; i < v_size; i++)
{
for (int j = 0; j < l_size; j++)
{
if (@value[i].Equals(list[j]))
{
return(true);
}
}
}
return(false);
}
public virtual void testNumberState()
{
JDFDoc d = new JDFDoc("NumberState");
JDFNumberState ns = (JDFNumberState)d.getRoot();
JDFNumberRangeList nrl = new JDFNumberRangeList("12.45~15.88");
ns.setAllowedValueList(nrl);
ns.setListType(EnumListType.RangeList);
Assert.IsTrue(ns.fitsValue("12.45~15.88", EnumFitsValue.Allowed));
Assert.IsTrue(ns.fitsValue("12.45~13.0", EnumFitsValue.Allowed));
Assert.IsFalse(ns.fitsValue("19.0~33.234", EnumFitsValue.Allowed));
nrl = new JDFNumberRangeList("12.45~15.88 19.0~33.234");
ns.setAllowedValueList(nrl);
Assert.IsTrue(ns.fitsValue("12.45", EnumFitsValue.Allowed));
Assert.IsTrue(ns.fitsValue("19.0~33.234", EnumFitsValue.Allowed));
Assert.IsFalse(ns.fitsValue("16.01", EnumFitsValue.Allowed));
}
///
/// <summary> * fitsValueList - checks whether <code>rangelist</code> matches the
/// * AllowedValueList/PresentValueList specified for this State
/// * </summary>
/// * <param name="rangelist">
/// * range list to test </param>
/// * <param name="valuelist">
/// * switches between AllowedValueList and PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>rangelist</code> matches the valuelist
/// * or if AllowedValueList is not specified </returns>
///
private bool fitsValueList(JDFNumberRangeList rangelist, EnumFitsValue valuelist)
{
JDFNumberRangeList list;
if (valuelist.Equals(EnumFitsValue.Allowed))
{
list = getAllowedValueList();
}
else
{
list = getPresentValueList();
}
if (list == null)
{
return(true);
}
EnumListType listType = getListType();
if (listType.Equals(EnumListType.CompleteList))
{
return(fitsCompleteList(rangelist, list));
}
else if (listType.Equals(EnumListType.CompleteOrderedList))
{
return(fitsCompleteOrderedList(rangelist, list));
}
else if (listType.Equals(EnumListType.ContainedList))
{
return(fitsContainedList(rangelist, list));
}
int siz = rangelist.Count;
for (int i = 0; i < siz; i++)
{
JDFNumberRange range = (JDFNumberRange)rangelist[i];
if (!list.isPartOfRange(range))
{
return(false);
}
}
return(true);
}
///
/// <summary> * fitsValue - checks whether <code>value</code> matches the Allowed/Present
/// * test lists specified for this State
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="testlists">
/// * the test lists the value has to match. In this State the test
/// * lists are ValueList AND ValueMod.<br>
/// * Choose one of two values: FitsValue_Allowed or
/// * FitsValue_Present. (Defaults to Allowed)
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches testlists or if
/// * AllowedValueList and AllowedValueMod are not specified </returns>
///
public override bool fitsValue(string @value, EnumFitsValue testlists)
{
if (fitsListType(@value))
{
JDFNumberRangeList rangelist = null;
try
{
rangelist = new JDFNumberRangeList(@value);
}
catch (FormatException)
{
return(false);
}
return(fitsValueList(rangelist, testlists) && fitsValueMod(rangelist, testlists));
}
return(false); // the value doesn't fit ListType attribute of this State
}
public void testIsValid()
{
JDFNumberList numberList = new JDFNumberList("1 2 3");
iState.setDefaultValue(numberList);
iState.setCurrentValue(numberList);
Assert.IsFalse(iState.isValid(EnumValidationLevel.Complete));
iState.setListType(EnumListType.List);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
JDFNumberRangeList numberRList = new JDFNumberRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(numberRList);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
JDFNumberRangeList numberList2 = new JDFNumberRangeList("1 2 3 7~77");
iState.setPresentValueList(numberList2);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
}
///
/// <summary> * fitsCompleteList - tests whether <code>value</code> matches the given
/// * testlist (ListType=fitsCompleteList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlist </returns>
///
private bool fitsCompleteList(JDFNumberRangeList @value, JDFNumberRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
if (v_size != l_size)
{
return(false);
}
if ([email protected]())
{
return(false);
}
JDFNumberRangeList valueList = new JDFNumberRangeList(@value);
bool bFound;
for (int i = l_size - 1; i >= 0; i--)
{
bFound = false;
for (int j = valueList.Count - 1; j >= 0; j--)
{
if (list[i].Equals(valueList[j]))
{
valueList.erase(j);
bFound = true;
break;
}
}
if (!bFound)
{
return(false);
}
}
return(true);
}
public void testFitsValue()
{
JDFParser p = new JDFParser();
string strNode = "<NumberState Name=\"BitDepth\" DefaultValue=\"1\" AllowedValueList=\"1 8.5 12\"/>";
JDFDoc jdfDoc = p.parseString(strNode);
JDFNumberState state = (JDFNumberState)jdfDoc.getRoot();
JDFNumberRangeList list = new JDFNumberRangeList();
list.Append(new JDFNumberRange(1, 12.5)); // 1~12
// list.append(12);
state.setListType(EnumListType.RangeList);
Assert.IsFalse(state.fitsValue(list.ToString(), EnumFitsValue.Allowed), "ListType=RangeList");
JDFNumberRangeList list2 = new JDFNumberRangeList();
list2.Append(new JDFNumberRange(1, 12.5)); // 1~-2
JDFNumberRangeList allowedVL = new JDFNumberRangeList();
allowedVL.Append(new JDFNumberRange(1, 32.666)); // 1~32
state.setAllowedValueList(allowedVL); // new AllowedVlaueList
Assert.IsTrue(state.fitsValue(list2.ToString(), EnumFitsValue.Allowed));
list.erase(list.Count - 1); // erase "1~12"
list.Append(2);
list.Append(12);
list.Append(22);
state.setListType(EnumListType.List);
state.setAllowedValueMod(new JDFXYPair(10, 2));
Assert.IsTrue(state.fitsValue(list.ToString(), EnumFitsValue.Allowed), "ListType=List, ValueMod=" + state.getAllowedValueMod());
}
///
/// <summary> * fitsCompleteOrderedList - tests whether <code>value</code> matches the
/// * given testlist (ListType=CompleteOrderedList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlist </returns>
///
private bool fitsCompleteOrderedList(JDFNumberRangeList @value, JDFNumberRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
if (v_size != l_size)
{
return(false);
}
if ([email protected]())
{
return(false);
}
for (int i = 0; i < l_size; i++)
{
if (!list[i].Equals(@value[i]))
{
return(false);
}
}
return(true);
}
public virtual void setAllowedValueList(JDFNumberRangeList @value)
{
setAttribute(AttributeName.ALLOWEDVALUELIST, @value.ToString(), null);
}
///
/// <summary> * Set attribute Range as a JDFNumberRangeList
/// * </summary>
/// * <param name="JDFNumberRangeList"> value - the value to set </param>
///
public virtual void setRange(JDFNumberRangeList @value)
{
setAttribute(AttributeName.RANGE, @value.ToString(), null);
}
// ---------------------------------------------------------------------
// Methods for Attribute ForceFrontSide
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute ForceFrontSide </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setForceFrontSide(JDFNumberRangeList @value)
{
setAttribute(AttributeName.FORCEFRONTSIDE, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute Z
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute Z </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setZ(JDFNumberRangeList @value)
{
setAttribute(AttributeName.Z, @value, null);
}
///
/// <summary> * fitsValueMod - checks whether <code>range</code> matches the
/// * <code>ValueMod</code> specified for this State.
/// * </summary>
/// * <param name="rangelist">
/// * range list to test </param>
/// * <param name="valuemod">
/// * switches between AllowedValueMod and PresentValueMod.
/// * </param>
/// * <returns> boolean - true, if <code>rangelist</code> matches the valuemod or
/// * if AllowedValueMod is not specified </returns>
///
private bool fitsValueMod(JDFNumberRangeList rangelist, EnumFitsValue valuemod)
{
if (valuemod.Equals(EnumFitsValue.Allowed))
{
if (!hasAttribute(AttributeName.ALLOWEDVALUEMOD))
{
return(true);
}
}
else
{
if (!hasAttribute(AttributeName.ALLOWEDVALUEMOD) && !hasAttribute(AttributeName.PRESENTVALUEMOD))
{
return(true);
}
}
JDFXYPair mod;
if (valuemod.Equals(EnumFitsValue.Allowed))
{
mod = getAllowedValueMod();
}
else
{
mod = getPresentValueMod();
}
int size = rangelist.Count;
for (int i = 0; i < size;)
{
JDFNumberRange range = (JDFNumberRange)rangelist[i];
double left = range.Left;
double right = range.Right;
if (left != right) // if we have a range return false, check only
// single value
{
return(false);
}
double elem = left; // single value
double divi = mod.X; // X - the Modulo
double shift = mod.Y; // Y - offset of the allowed/present
// value
if (divi == 0)
{
return(false);
}
// if ValueMod is not "0 x"
double n = ((elem - divi * (int)(elem / divi)) - shift); // n =
// elem
// %
// divi
// -
// shift
if (Math.Abs(n) < JDFBaseDataTypes_Fields.EPSILON * Math.Abs(divi))
{
return(true);
}
double m = (n - divi * (int)(n / divi)); // m = ( elem % divi -
// shift ) % divi
if (Math.Abs(m) < JDFBaseDataTypes_Fields.EPSILON * Math.Abs(divi))
{
return(true);
}
return(false);
}
return(true);
}
// ---------------------------------------------------------------------
// Methods for Attribute ValueList
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute ValueList </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setValueList(JDFNumberRangeList @value)
{
setAttribute(AttributeName.VALUELIST, @value, null);
}
public virtual void setPresentValueList(JDFNumberRangeList @value)
{
setAttribute(AttributeName.PRESENTVALUELIST, @value.ToString(), null);
}
public virtual JDFNumberRangeList getPresentValueList()
{
JDFNumberRangeList nl = getNumberRangeList(AttributeName.PRESENTVALUELIST);
return((nl == null) ? getAllowedValueList() : nl);
}