private static string FormatOctetMATHF(PropertyTypeEnum exportPropertyType, TypeOfOctet octetType, ExportPropertyGeneral property)
{
double Num;
string propertyValue = null;
double value = 0;
if (property != null)
{
propertyValue = property.Value;
value = double.Parse(propertyValue);
if (exportPropertyType == PropertyTypeEnum.PhysicalModulusOfElasticity)
{
value = value * 1000;
}
}
string emptyOctet = EMPTYOCTET;
if (exportPropertyType != PropertyTypeEnum.PhysicalPoissonCoefficient)
{
emptyOctet = FillEmptySpace(0, octetType, 8);
}
return(propertyValue != null && double.TryParse(propertyValue, out Num) ? FillEmptySpace(value, octetType, 8) : emptyOctet);
}
/// <summary>
/// Fills the octet with values according to if value is double, int, or value which lenght is bigger then 8 characters.
/// Also we must consider value align in octet.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public static String FillOctet(double value, TypeOfOctet type, TMPropertyTypeEnum exportType)
{
string formatedValue = "";
switch (exportType)
{
case TMPropertyTypeEnum.None:
break;
case TMPropertyTypeEnum.PhysicalModulusOfElasticity:
formatedValue = (String.Format(CultureInfo.InvariantCulture, "{0:0.###E+0}", value * 1000000)).Replace("E", "");
formatedValue = formatedValue.PadRight(8);
break;
case TMPropertyTypeEnum.PhysicalPoissonCoefficient:
formatedValue = value.ToString().PadRight(8);
break;
case TMPropertyTypeEnum.PhysicalDensity:
formatedValue = value.ToString().PadRight(8);
break;
case TMPropertyTypeEnum.PhysicalMeanCoeffThermalExpansion:
formatedValue = (String.Format(CultureInfo.InvariantCulture, "{0:0.###E+0}", value / 1000000)).Replace("E", "");
formatedValue = formatedValue.PadRight(8);
break;
default:
break;
}
return(formatedValue);
}
/// <summary>
/// Formats the octet.
/// </summary>
/// <param name="export">The export.</param>
/// <param name="exportType">Type of the export.</param>
/// <returns></returns>
private static string FormatOctet(ExportPropertyGeneral property, TypeOfOctet octetType)
{
double Num;
string propertyValue = null;
if (property != null)
{
propertyValue = property.Value;
}
return(propertyValue != null && double.TryParse(propertyValue, out Num) ? FillOctet(double.Parse(propertyValue), octetType) : EMPTYOCTET);
}
/// <summary>
/// Fills the octet with values according to if value is double, int, or value which lenght is bigger then 8 characters.
/// Also we must consider value align in octet.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public static String FillOctet(double value, TypeOfOctet type)
{
string stringValue = value.ToString();
int stringLength = stringValue.Length;
int freeSpaces = Octet - stringValue.Length;
if (stringLength > Octet)
{
if (stringValue.Split('.').Count() > 1 && stringValue.Split('.')[1] != null)
{
int beforeComma = stringValue.Split('.')[0].Count();
int afterComma = stringValue.Split('.')[1].Count();
string returnValue = Math.Round(value, Octet - beforeComma - 1).ToString();
if (returnValue.Length == 8)
{
return(returnValue);
}
freeSpaces = Octet - returnValue.Length;
return(AddEmptySpaces(returnValue, freeSpaces, type));
}
else
{
stringValue = stringValue.Substring(0, 1) + ".0+" + (stringValue.Length - 1).ToString();
freeSpaces = Octet - stringValue.Length;
return(AddEmptySpaces(stringValue, freeSpaces, type));
// return stringValue + ".0";
}
}
if (stringValue.IndexOf(".") > -1 && stringValue.Split('.')[1] != null)
{
return(AddEmptySpaces(stringValue, freeSpaces, type));
}
if (stringValue.Length > Octet - 2)
{
stringValue = "1.0+" + (stringValue.Length - 1).ToString();
freeSpaces = Octet - stringValue.Length;
return(AddEmptySpaces(stringValue, freeSpaces, type));
}
else
{
stringValue = stringValue + ".0";
freeSpaces = freeSpaces - 2;
return(AddEmptySpaces(stringValue, freeSpaces, type));
}
}
/// <summary>
/// Adds the empty spaces according to type Of octet.
/// </summary>
/// <param name="stringValue">The string value.</param>
/// <param name="freeSpaces">The free spaces.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
private static string AddEmptySpaces(string stringValue, int freeSpaces, TypeOfOctet type)
{
if (type == TypeOfOctet.Left)
{
for (int i = 0; i < freeSpaces; i++)
{
stringValue = stringValue + " ";
}
}
else
{
for (int i = 0; i < freeSpaces; i++)
{
stringValue = " " + stringValue;
}
}
return(stringValue);
}
/// <summary>
/// Formats the octet.
/// </summary>
/// <param name="export">The export.</param>
/// <param name="exportType">Type of the export.</param>
/// <returns></returns>
private static string FormatOctet(IList <ExportPropertyGeneral> properties, TMPropertyTypeEnum exportType, TypeOfOctet octetType)
{
double Num;
string propertyValue = null;
ExportPropertyGeneral property = (from u in properties where u.Type == exportType select u).FirstOrDefault();
if (property != null)
{
propertyValue = property.Value;
return(propertyValue != null && double.TryParse(propertyValue, out Num) ? FillOctet(double.Parse(propertyValue), octetType, exportType) : EMPTYOCTET);
}
else
{
return(ZERO);
}
}