private void ClassBuilderToWizard(ClassBuilder builder)
{
mWizardInfo.ClassBuilder = builder;
Application.DoEvents();
WizardToControls();
Application.DoEvents();
if (mWizardInfo.ClassBuilder is FixedLengthClassBuilder)
{
radFixed.Checked = true;
mControlType = typeof(FieldFixedControl);
mFieldType = typeof(FixedFieldBuilder);
txtFieldLength.Enabled = true;
}
else
{
txtFieldLength.Enabled = false;
radDelimited.Checked = true;
mControlType = typeof(FieldDelimitedControl);
mFieldType = typeof(DelimitedFieldBuilder);
txtDelimiter.Text = "";
string delimiter = mWizardInfo.DelimitedBuilder.Delimiter;
if (delimiter == "|")
radDelVertBar.Checked = true;
else if (delimiter == ",")
radDelComma.Checked = true;
else if (delimiter == ";")
radDelSemiCol.Checked = true;
else if (delimiter == "\t")
radDelTabs.Checked = true;
else
{
radDelCustom.Checked = true;
txtDelimiter.Text = delimiter;
}
}
panFields.SuspendLayout();
panFields.Controls.Clear();
foreach (FieldBuilder info in mWizardInfo.ClassBuilder.Fields)
{
panFields.Controls.Add(CreateFieldControlFromInfo(info));
}
panFields.ResumeLayout();
panFields.Focus();
mLoadingFile = false;
ReLoadPreview();
}
/// <summary>
/// Create a fixed length field of name, length and type
/// </summary>
/// <param name="fieldName">Name of the field</param>
/// <param name="length">Length of field on file</param>
/// <param name="fieldType">Type of the field</param>
internal FixedFieldBuilder(string fieldName, int length, Type fieldType)
: this(fieldName, length, ClassBuilder.TypeToString(fieldType))
{
}
/// <summary>
/// Add the general attributes to the field
/// </summary>
/// <param name="attbs">Attributes added here</param>
/// <param name="lang">Language C# or Visual Basic</param>
private void AddAttributesInternal(AttributesBuilder attbs, NetLanguage lang)
{
if (mFieldOptional)
{
attbs.AddAttribute("FieldOptional()");
}
if (mFieldHidden)
{
attbs.AddAttribute("FieldHidden()");
}
if (mFieldValueDiscarded)
{
attbs.AddAttribute("FieldValueDiscarded()");
}
if (mFieldInNewLine)
{
attbs.AddAttribute("FieldInNewLine()");
}
if (mFieldNotEmpty)
{
attbs.AddAttribute("FieldNotEmpty()");
}
if (mFieldNotIncluded)
{
attbs.AddAttribute("FieldNotIncluded()");
}
if (mFieldNullValue != null)
{
if (mFieldNullValue is string)
{
attbs.AddAttribute("FieldNullValue(\"" + mFieldNullValue.ToString() + "\")");
}
else
{
string t = ClassBuilder.TypeToString(mFieldNullValue.GetType());
string gt = string.Empty;
if (lang == NetLanguage.CSharp)
{
gt = "typeof(" + t + ")";
}
else if (lang == NetLanguage.VbNet)
{
gt = "GetType(" + t + ")";
}
attbs.AddAttribute("FieldNullValue(" + gt + ", \"" + mFieldNullValue.ToString() + "\")");
}
}
attbs.AddAttribute(mConverter.GetConverterCode(lang));
if (mTrimMode != TrimMode.None)
{
if (" \t" == mTrimChars)
{
attbs.AddAttribute("FieldTrim(TrimMode." + mTrimMode.ToString() + ")");
}
else
{
attbs.AddAttribute("FieldTrim(TrimMode." + mTrimMode.ToString() + ", \"" + mTrimChars.ToString() +
"\")");
}
}
}
/// <summary>
/// Create the field with attributes so that it can be added to the class
/// </summary>
/// <param name="lang">Language C# of Visual Basic</param>
/// <returns>Field as text</returns>
internal string GetFieldCode(NetLanguage lang)
{
var sb = new StringBuilder(100);
var attbs = new AttributesBuilder(lang);
AddAttributesInternal(attbs, lang);
AddAttributesCode(attbs, lang);
sb.Append(attbs.GetAttributesCode());
NetVisibility visi = mVisibility;
string currentName = mFieldName;
if (mClassBuilder.GenerateProperties)
{
visi = NetVisibility.Private;
currentName = "m" + mFieldName;
}
switch (lang)
{
case NetLanguage.VbNet:
sb.Append(ClassBuilder.GetVisibility(lang, visi) + currentName + " As " + mFieldType);
break;
case NetLanguage.CSharp:
sb.Append(ClassBuilder.GetVisibility(lang, visi) + mFieldType + " " + currentName + ";");
break;
default:
break;
}
sb.Append(StringHelper.NewLine);
if (mClassBuilder.GenerateProperties)
{
sb.Append(StringHelper.NewLine);
switch (lang)
{
case NetLanguage.VbNet:
sb.Append("Public Property " + mFieldName + " As " + mFieldType);
sb.Append(StringHelper.NewLine);
sb.Append(" Get");
sb.Append(StringHelper.NewLine);
sb.Append(" Return m" + mFieldName);
sb.Append(StringHelper.NewLine);
sb.Append(" End Get");
sb.Append(StringHelper.NewLine);
sb.Append(" Set (value As " + mFieldType + ")");
sb.Append(StringHelper.NewLine);
sb.Append(" m" + mFieldName + " = value");
sb.Append(StringHelper.NewLine);
sb.Append(" End Set");
sb.Append(StringHelper.NewLine);
sb.Append("End Property");
break;
case NetLanguage.CSharp:
sb.Append("public " + mFieldType + " " + mFieldName);
sb.Append(StringHelper.NewLine);
sb.Append("{");
sb.Append(StringHelper.NewLine);
sb.Append(" get { return m" + mFieldName + "; }");
sb.Append(StringHelper.NewLine);
sb.Append(" set { m" + mFieldName + " = value; }");
sb.Append(StringHelper.NewLine);
sb.Append("}");
break;
default:
break;
}
sb.Append(StringHelper.NewLine);
sb.Append(StringHelper.NewLine);
}
return(sb.ToString());
}
/// <summary>
/// Loads the XML representation of a ClassBuilder inheritor and return
/// it. (for XML saved with SaveToXml method)
/// </summary>
/// <remarks>
/// ClassBuilder inheritors: <see cref="DelimitedClassBuilder"/> or <see cref="FixedLengthClassBuilder"/>
/// </remarks>
/// <param name="document">The XML document with the representation of the record class.</param>
/// <returns>A new instance of a ClassBuilder inheritor: <see cref="DelimitedClassBuilder"/> or <see cref="FixedLengthClassBuilder"/> </returns>
public static ClassBuilder LoadFromXml(XmlDocument document)
{
ClassBuilder res = null;
string classtype = document.DocumentElement.LocalName;
if (classtype == "DelimitedClass")
{
res = DelimitedClassBuilder.LoadXmlInternal(document);
}
else
{
res = FixedLengthClassBuilder.LoadXmlInternal(document);
}
XmlNode node = document.DocumentElement["IgnoreLastLines"];
if (node != null)
{
res.IgnoreLastLines = int.Parse(node.InnerText);
}
node = document.DocumentElement["IgnoreFirstLines"];
if (node != null)
{
res.IgnoreFirstLines = int.Parse(node.InnerText);
}
node = document.DocumentElement["IgnoreEmptyLines"];
if (node != null)
{
res.IgnoreEmptyLines = true;
}
node = document.DocumentElement["CommentMarker"];
if (node != null)
{
res.IgnoreCommentedLines.CommentMarker = node.InnerText;
}
node = document.DocumentElement["CommentInAnyPlace"];
if (node != null)
{
res.IgnoreCommentedLines.InAnyPlace = bool.Parse(node.InnerText.ToLower());
}
node = document.DocumentElement["SealedClass"];
res.SealedClass = node != null;
node = document.DocumentElement["Namespace"];
if (node != null)
{
res.Namespace = node.InnerText;
}
node = document.DocumentElement["Visibility"];
if (node != null)
{
res.Visibility = (NetVisibility)Enum.Parse(typeof(NetVisibility), node.InnerText);
}
node = document.DocumentElement["RecordCondition"];
if (node != null)
{
res.RecordCondition.Condition = (RecordCondition)Enum.Parse(typeof(RecordCondition), node.InnerText);
}
node = document.DocumentElement["RecordConditionSelector"];
if (node != null)
{
res.RecordCondition.Selector = node.InnerText;
}
node = document.DocumentElement["CommentText"];
if (node != null)
{
res.CommentText = node.InnerText;
}
res.ReadClassElements(document);
node = document.DocumentElement["Fields"];
XmlNodeList nodes;
if (classtype == "DelimitedClass")
{
nodes = node.SelectNodes("/DelimitedClass/Fields/Field");
}
else
{
nodes = node.SelectNodes("/FixedLengthClass/Fields/Field");
}
foreach (XmlNode n in nodes)
{
res.ReadField(n);
}
return(res);
}
/// <summary>
/// Create a class from a XML file generated with the Wizard or
/// saved using the SaveToXml Method.
/// </summary>
/// <param name="filename">The filename with the XML definition.</param>
/// <returns>The compiled class.</returns>
public static Type ClassFromXmlFile(string filename)
{
ClassBuilder cb = LoadFromXml(filename);
return(cb.CreateRecordClass());
}
