public void testDoubleStorage()
{
FieldFormat ff = FieldFormat.create("<s1><E>");
double d = 123456789.123456D;
Assert.AreEqual(d, ff.valueFromString(ff.valueToString(d)));
}
public void TestFloatFieldToString()
{
var dr = new DataRecord(new TableFormat(FieldFormat.create("data", FieldFormat.FLOAT_FIELD)));
dr.setValue(0, 1.1f);
Assert.AreEqual("1,1", dr.dataAsString(false, false));
}
private static void ProcessFieldFormat(FieldFormat ff, XmlWriter xmlw)
{
xmlw.WriteStartElement("FieldFormat");
//if (ff.BooleanFormat != null)
//{
ProcessBooleanFormat(ff.BooleanFormat, xmlw);
//}
//else if(ff.CommonFormat!=null)
//{
ProcessCommonFormat(ff.CommonFormat, xmlw);
//}
//else if (ff.DateTimeFormat != null)//datetime before date and time
//{
ProcessDateTimeFormat(ff.DateTimeFormat, xmlw);
//}
//else if (ff.DateFormat != null)
//{
ProcessDateFormat(ff.DateFormat, xmlw);
//}
//else if (ff.NumericFormat != null)
//{
ProcessNumericFormat(ff.NumericFormat, xmlw);
//}
//else if (ff.TimeFormat != null)
//{
ProcessTimeFormat(ff.TimeFormat, xmlw);
//}
//else
//{
// ((Action)(() => { }))();
//}
xmlw.WriteEndElement();
}
private Field(byte id, byte size, long value)
{
_id = id;
_size = size;
_format = FieldFormat.Number;
_value = value;
}
public LimitsValidator(FieldFormat fieldFormat, string source)
{
var minMax = StringUtils.split(source, MIN_MAX_SEPARATOR);
if (fieldFormat.getType() == FieldFormat.DATA_FIELD ||
fieldFormat.getType() == FieldFormat.STRING_FIELD)
{
if (minMax.Count > 1)
{
this.min = int.Parse(minMax[0]);
this.max = int.Parse(minMax[1]);
}
else
{
this.max = int.Parse(minMax[0]);
}
}
else
{
if (minMax.Count > 1)
{
this.min = (IComparable)fieldFormat.valueFromString(minMax[0]);
this.max = (IComparable)fieldFormat.valueFromString(minMax[1]);
}
else
{
this.max = (IComparable)fieldFormat.valueFromString(minMax[0]);
}
}
}
/// <summary>
/// Encode object as text, using current encoding
/// </summary>
/// <param name="field"></param>
/// <param name="fieldFormat"></param>
/// <returns></returns>
/// <exception cref="ValueTypeMismatchException"> </exception>
private byte[] EncodeText(object field, FieldFormat fieldFormat)
{
var s = field as string;
if (s != null)
{
string value = s;
int size = fieldFormat.ByteSize;
if (value.Length > size)
{
return(_encoding.GetBytes(value.Substring(0, size)));
}
else if (value.Length < size)
{
StringBuilder sb = new StringBuilder(size);
sb.Append(value);
for (int i = 0; i < size - value.Length; i++)
{
sb.Append(' ');
}
return(_encoding.GetBytes(sb.ToString()));
}
else
{
return(_encoding.GetBytes(value));
}
}
else
{
throw GetValueTypeMismatchException(field, fieldFormat, "string");
}
}
public void FieldFormat()
{
//ExStart
//ExFor:Field.Format
//ExFor:FieldFormat
//ExFor:FieldFormat.DateTimeFormat
//ExFor:FieldFormat.NumericFormat
//ExFor:FieldFormat.GeneralFormats
//ExFor:GeneralFormat
//ExFor:GeneralFormatCollection.Add(GeneralFormat)
//ExSummary:Shows how to formatting fields
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);
Field field = builder.InsertField("MERGEFIELD Date");
FieldFormat format = field.Format;
format.DateTimeFormat = "dddd, MMMM dd, yyyy";
format.NumericFormat = "0.#";
format.GeneralFormats.Add(GeneralFormat.CharFormat);
//ExEnd
MemoryStream dstStream = new MemoryStream();
doc.Save(dstStream, SaveFormat.Docx);
field = doc.Range.Fields[0];
format = field.Format;
Assert.AreEqual("0.#", format.NumericFormat);
Assert.AreEqual("dddd, MMMM dd, yyyy", format.DateTimeFormat);
Assert.AreEqual(GeneralFormat.CharFormat, format.GeneralFormats[0]);
}
/// <summary>
/// Encode decimal to binary. Only accept decimal or throw ValueTypeMismatchException.
/// </summary>
/// <param name="field"></param>
/// <param name="fieldFormat"></param>
/// <returns></returns>
/// <exception cref="ValueTypeMismatchException"> </exception>
private byte[] EncodeBinary(object field, FieldFormat fieldFormat)
{
if (!(field is decimal))
{
throw GetValueTypeMismatchException(field, fieldFormat, "decimal");
}
decimal value = (decimal)field;
if (fieldFormat.Decimal != GetScale(value))
{
value = Math.Round(value, fieldFormat.Decimal);
}
byte[] bytes = GetUnscaledValueAsByteArray(value);
if (bytes.Length == fieldFormat.ByteSize)
{
return(bytes);
}
byte[] result = new byte[fieldFormat.ByteSize];
if (value < 0)
{
for (var i = 0; i < result.Length - bytes.Length; i++)
{
result[i] = 255;
}
}
Buffer.BlockCopy(bytes, 0, result, result.Length - bytes.Length, bytes.Length);
return(result);
}
static DataFieldFormat()
{
var modeF = create(MODE_FIELD, STRING_FIELD);
modeF.setNullable(true);
var edF = create(EXTENSIONS_DESCR_FIELD, STRING_FIELD);
edF.setNullable(true);
// Default value for 'extensions' field
var extF = create(EXTENSION_FIELD, STRING_FIELD);
EXTENSIONS_FORMAT.addField(extF);
var dt = new DataTable(EXTENSIONS_FORMAT);
FieldFormat extsF = create(EXTENSIONS_FIELD, DATATABLE_FIELD);
extsF.setDefault(dt);
extsF.setNullable(true);
var folderF = create(FOLDER_FIELD, STRING_FIELD);
folderF.setNullable(true);
DATA_EDITOR_OPTIONS_FORMAT.addField(modeF);
DATA_EDITOR_OPTIONS_FORMAT.addField(edF);
DATA_EDITOR_OPTIONS_FORMAT.addField(extsF);
DATA_EDITOR_OPTIONS_FORMAT.addField(folderF);
}
/// <summary>
/// Decode a byte array using the packed format
/// </summary>
/// <param name="bytes"></param>
/// <param name="fieldFormat"></param>
/// <returns></returns>
private static decimal DecodePacked(byte[] bytes, FieldFormat fieldFormat)
{
decimal result = ParsePacked(bytes);
result = ScaleResult(fieldFormat, result);
return(result);
}
public void testFieldFormat()
{
FieldFormat ff1 = FieldFormat.create("<s1><S><F=N><D=Test>");
FieldFormat ff2 = FieldFormat.create("<s1><S><D=Test>");
Assert.IsTrue(ff1.extend(ff2), ff1.extendMessage(ff2));
}
/// <summary>
/// write a fied that is a collection
/// </summary>
/// <typeparam name="T"> </typeparam>
/// <param name="field"></param>
/// <param name="fieldFormat"></param>
private void WriteField <T>(List <T> field, FieldFormat fieldFormat)
{
foreach (T item in field)
{
_stream.Write(_encoder.Encode(item, fieldFormat));
}
}
public void testHashCodesAreEqual()
{
FieldFormat ff1 = FieldFormat.create("<value><E><A=0.0>");
FieldFormat ff2 = FieldFormat.create("<value><E><A=0.0>");
Assert.AreEqual(ff1.getDefaultValue().GetHashCode(), ff2.getDefaultValue().GetHashCode());
//Assert.AreEqual(ff1.description == null) ? 0 : description.GetHashCode());
//Assert.AreEqual(ff1.editor == null) ? 0 : editor.GetHashCode());
//Assert.AreEqual(ff1.editorOptions == null) ? 0 : editorOptions.GetHashCode());
//Assert.AreEqual(ff1.getIcon().GetHashCode(), );
//result = prime * result + ((group == null) ? 0 : group.GetHashCode());
//result = prime * result + (extendableSelectionValues ? 1231 : 1237);
//result = prime * result + ((help == null) ? 0 : help.GetHashCode());
//result = prime * result + (hidden ? 1231 : 1237);
//result = prime * result + (inlineData ? 1231 : 1237);
//result = prime * result + (keyField ? 1231 : 1237);
//result = prime * result + ((name == null) ? 0 : name.GetHashCode());
//result = prime * result + (notReplicated ? 1231 : 1237);
//result = prime * result + (nullable ? 1231 : 1237);
//result = prime * result + (optional ? 1231 : 1237);
//// result = prime * result + (readonly ? 1231 : 1237);
//// result = prime * result + (advanced ? 1231 : 1237);
//Assert.AreEqual(ff1.getSelectionValues().GetHashCode(), ff2.getSelectionValues().GetHashCode());
//result = prime * result + (transferEncode ? 1231 : 1237);
Assert.AreEqual(ff1.getValidators().GetHashCode(), ff2.getValidators().GetHashCode());
Assert.AreEqual(ff1.GetHashCode(), ff2.GetHashCode());
}
static AgentContext()
{
FOFT_LOGIN.addField("<" + FOF_LOGIN_OWNER + "><S>");
FOFT_LOGIN.addField("<" + FOF_LOGIN_NAME + "><S>");
FOFT_LOGIN.addField("<" + FOF_LOGIN_RESPONSE + "><S>");
FOFT_GET_HISTORY.addField("<" + FOF_GET_HISTORY_VARIABLE + "><S>");
FOFT_GET_HISTORY.addField("<" + FOF_GET_HISTORY_TIMESTAMP + "><D>");
FOFT_GET_HISTORY.addField("<" + FOF_GET_HISTORY_VALUE + "><T>");
FIFT_ACKNOWLEDGE_EVENT.addField("<" + FIF_ACKNOWLEDGE_EVENT_ID + "><L><F=N>");
FIFT_ACKNOWLEDGE_EVENT.addField("<" + FIF_ACKNOWLEDGE_EVENT_DATE + "><D>");
FIFT_ACKNOWLEDGE_EVENT.addField("<" + FIF_ACKNOWLEDGE_EVENT_AUTHOR + "><S><F=N>");
FIFT_ACKNOWLEDGE_EVENT.addField("<" + FIF_ACKNOWLEDGE_EVENT_ACKNOWLEDGEMENT + "><S>");
FIFT_ACKNOWLEDGE_EVENT.addField("<" + FIF_ACKNOWLEDGE_EVENT_EVENT_DATA + "><T>");
FOFT_ASSET.addField("<" + FIELD_ID + "><S><F=HRK>");
FOFT_ASSET.addField("<" + FIELD_DESCRIPTION + "><S><F=R><D=" + Cres.get().getString("description") + ">");
FOFT_ASSET.addField("<" + FIELD_ENABLED + "><B><A=1><D=" + Cres.get().getString("enabled") + ">");
FOFT_ASSET.addField(FieldFormat.create("<" + FIELD_CHILDREN + "><T><F=N><D=" + Cres.get().getString("devNestedAssets") + ">"));
FOFT_ASSET.setNamingExpression(AGGREGATE + "({}, \"{env/previous} + ({" + FIELD_ENABLED + "} ? 1 : 0)\", 0) + '/' + {#" + RECORDS + "}");
String reff = FIELD_CHILDREN + "#" + PROPERTY_ENABLED;
String exp = "{" + FIELD_ENABLED + "}";
FOFT_ASSET.addBinding(reff, exp);
}
public static ABCFormatInfo GetFormatInfo(FieldFormat format)
{
ABCFormatInfo result = null;
FormatList.TryGetValue(format, out result);
return(result);
}
public void TestDoubleFieldToString()
{
var dr = new DataRecord(new TableFormat(FieldFormat.create("data", FieldFormat.DOUBLE_FIELD)));
dr.setValue(0, 123456789.123456789d);
Assert.AreEqual("123456789,123457", dr.dataAsString(false, false));
}
public void testFloatStorage()
{
FieldFormat ff = FieldFormat.create("<s1><F>");
float f = 12345.12f;
Assert.AreEqual(f, (float)ff.valueFromString(ff.valueToString(f)));
}
public void testHashCodesDiffer()
{
FieldFormat ff1 = FieldFormat.create("<value><E><A=0.0>");
FieldFormat ff2 = FieldFormat.create("<value><I><A=0>");
Assert.IsFalse(ff1.GetHashCode() == ff2.GetHashCode());
}
public ColumnVm(FieldFormat fieldFormat, string fieldName, IEnumerable <string> availableFields)
{
FieldFormat = fieldFormat;
AvailableFields = availableFields;
TemplateType = typeof(DefaultCellTemplateVm);
Name = fieldName;
IsVisible = true;
}
/// <summary>
/// return filler
/// </summary>
/// <param name="format"></param>
/// <returns></returns>
private object GetFillValue(FieldFormat format)
{
if (DecimalTypes.Contains(format.Type))
{
return(0m);
}
return("");
}
public void testClone()
{
string format = "<s1><S><F=N><A=default><D=Test><S=<desc=default><desc2=val2>><V=<L=1 10>>";
FieldFormat ff = FieldFormat.create(format);
FieldFormat cl = (FieldFormat)ff.Clone();
Assert.AreEqual(format, cl.encode(new ClassicEncodingSettings(true)));
}
/// <summary>
/// Encode date
/// </summary>
/// <param name="date"></param>
/// <param name="format"></param>
/// <returns></returns>
private object EncodeDate(DateTime date, FieldFormat format)
{
if (DecimalTypes.Contains(format.Type))
{
return(DateParser.EncodeDecimal(date));
}
return(DateParser.EncodeString(date));
}
public void TestCreatingBoolean()
{
var ff = FieldFormat.create("name", 'B');
Assert.IsNotNull(ff);
Assert.AreEqual(ff.getName(), "name");
Assert.AreEqual(ff.getType(), 'B');
}
public void TestCreatingString()
{
var ff = FieldFormat.create("reference", 'S');
Assert.IsNotNull(ff);
Assert.AreEqual(ff.getName(), "reference");
Assert.AreEqual(ff.getType(), 'S');
}
/// <summary>
/// Custom constructor using FieldFormat and read data
/// </summary>
/// <param name="fieldFormat"></param>
/// <param name="readData"></param>
public FieldParsingException(FieldFormat fieldFormat, byte[] readData) :
base(string.Format("Error while reading field {0} - read data: {1}",
fieldFormat.Name,
readData))
{
_fieldFormat = fieldFormat;
_readData = new byte[readData.Length];
readData.CopyTo(_readData, 0);
}
/// <summary>
/// Scale result using the given fieldFormat
/// </summary>
/// <param name="fieldFormat"></param>
/// <param name="result"></param>
/// <returns></returns>
private static decimal ScaleResult(FieldFormat fieldFormat, decimal result)
{
decimal returnedResult = result;
if (fieldFormat.Decimal > 0 && fieldFormat.ImpliedDecimal)
{
returnedResult = returnedResult * (decimal)Math.Pow(10, -fieldFormat.Decimal);
}
return(returnedResult);
}
public void testHashCodesAreEqual2()
{
var ff1 = FieldFormat.create("dt", FieldFormat.DATATABLE_FIELD, "dt", new DataTable());
var ff2 = FieldFormat.create("dt", FieldFormat.DATATABLE_FIELD, "dt", new DataTable());
//Assert.AreEqual(ff1.getSelectionValues().GetHashCode(), ff2.getSelectionValues().GetHashCode());
Assert.AreEqual(ff1.getDefaultValue().GetHashCode(), ff2.getDefaultValue().GetHashCode());
Assert.AreEqual(ff1.GetHashCode(), ff2.GetHashCode());
}
private static void ProcessFieldFormat(FieldFormat ff, Utf8JsonWriter jsonw, CrFieldValueTypeEnum vt)
{
switch (vt)
{
case CrFieldValueTypeEnum.crFieldValueTypeBooleanField:
{
ProcessBooleanFormat(ff.BooleanFormat, jsonw);
break;
}
case CrFieldValueTypeEnum.crFieldValueTypeDateField:
{
ProcessDateFormat(ff.DateFormat, jsonw);
break;
}
case CrFieldValueTypeEnum.crFieldValueTypeDateTimeField:
{
ProcessDateTimeFormat(ff.DateTimeFormat, jsonw);
break;
}
case CrFieldValueTypeEnum.crFieldValueTypeCurrencyField:
case CrFieldValueTypeEnum.crFieldValueTypeInt16sField:
case CrFieldValueTypeEnum.crFieldValueTypeInt16uField:
case CrFieldValueTypeEnum.crFieldValueTypeInt32sField:
case CrFieldValueTypeEnum.crFieldValueTypeInt32uField:
case CrFieldValueTypeEnum.crFieldValueTypeInt8sField:
case CrFieldValueTypeEnum.crFieldValueTypeInt8uField:
case CrFieldValueTypeEnum.crFieldValueTypeNumberField:
{
ProcessNumericFormat(ff.NumericFormat, jsonw);
break;
}
case CrFieldValueTypeEnum.crFieldValueTypeStringField:
{
ProcessStringFormat(ff.StringFormat, jsonw);
break;
}
case CrFieldValueTypeEnum.crFieldValueTypeTimeField:
{
ProcessTimeFormat(ff.TimeFormat, jsonw);
break;
}
default:
{
break;
}
}
ProcessCommonFormat(ff.CommonFormat, jsonw);
}
/// <summary>
/// Encode objet as packed number
/// </summary>
/// <param name="field"></param>
/// <param name="fieldFormat"></param>
/// <returns></returns>
/// <exception cref="ValueTypeMismatchException"> </exception>
private byte[] EncodePacked(object field, FieldFormat fieldFormat)
{
if (field is decimal)
{
return(EncodePacked((decimal)field, fieldFormat.ByteSize, fieldFormat.Decimal, fieldFormat.Signed));
}
else
{
throw GetValueTypeMismatchException(field, fieldFormat, "decimal");
}
}
static EventUtils()
{
IntFieldFormat ff = (IntFieldFormat)FieldFormat.create("<" + FIELD_SEVERITY_STATS_LEVEL + "><I><D=" +
Cres.get().getString(FIELD_SEVERITY_STATS_LEVEL) + ">");
ff.setSelectionValues(EventLevel.getSelectionValues());
SEVERITY_STATS_FORMAT.addField(ff);
SEVERITY_STATS_FORMAT.addField(
FieldFormat.create("<" + FIELD_SEVERITY_STATS_NUMBER + "><I><D=" + Cres.get().getString("efEventCount") + ">"));
SEVERITY_STATS_FORMAT.addField(FieldFormat.create("<" + FIELD_SEVERITY_STATS_COLOR + "><C><F=H>"));
}
public void SetupForDataType(FieldFormat fieldFormat)
{
//Chart.SetYAxisFormat(HelperMethods.DisplayformatForDataType(fieldFormat));
boundInfraGrid1.ApplyDisplayDoubleFormat(HelperMethods.DisplayformatForDataType(fieldFormat));
boundInfraGrid1.AutoSizeGridColumns();
}
