/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception name="InvalidOperationException">
/// Property with name <c>PropertyName</c> passed to the <see cref="Initialize"/> method was not found. -or-
/// Type with name <c>TypeName</c> passed to the <see cref="Initialize"/> method was not found.
/// </exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
CodeMemberProperty property = null;
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberProperty && m.Name == propertyName)
{
property = (CodeMemberProperty)m;
break;
}
}
if (property == null)
{
throw new InvalidOperationException(string.Format(Resources.ex_PropertyNotFound, propertyName));
}
CodeAttributeDeclaration atrd;
property.CustomAttributes.Add(atrd = new CodeAttributeDeclaration(attributeName));
if (attrParams != null)
{
atrd.Arguments.AddRange(attrParams.ToArray());
}
}
//private List<CodeAttributeArgument> attrParams = new List<CodeAttributeArgument>();
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type provided in the <c>TypeName</c> parameter or property provided in <c>PropertyName</c> parameter was not found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
CodeMemberProperty property = null;
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberProperty && m.Name == propertyName)
{
property = (CodeMemberProperty)m;
break;
}
}
if (property == null)
{
throw new InvalidOperationException(string.Format(Resources.ex_PropertyNotFound, propertyName));
}
List <CodeStatement> getStatements = new List <CodeStatement>(property.GetStatements.Count);
foreach (CodeStatement statement in property.GetStatements)
{
if (statement is CodeMethodReturnStatement)
{
getStatements.Add(new CodeAssignStatement(
new CodeVariableReferenceExpression("property_return_value"),
((CodeMethodReturnStatement)statement).Expression)
{
LinePragma = statement.LinePragma
});
getStatements[getStatements.Count - 1].StartDirectives.AddRange(statement.StartDirectives);
getStatements[getStatements.Count - 1].EndDirectives.AddRange(statement.EndDirectives);
foreach (DictionaryEntry ud in statement.UserData)
{
getStatements[getStatements.Count - 1].UserData.Add(ud.Key, ud.Value);
}
}
else
{
getStatements.Add(statement);
}
}
property.GetStatements.Clear();
property.GetStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(string)), "property_return_value"));
property.GetStatements.AddRange(getStatements.ToArray());
property.GetStatements.Add(new CodeConditionStatement(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "IsNullOrEmpty"),
new CodeExpression[] { new CodeVariableReferenceExpression("property_return_value") }),
new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(empty ? string.Empty : null)) },
new CodeStatement[] { new CodeMethodReturnStatement(new CodeVariableReferenceExpression("property_return_value")) }));
}
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type provided in the <c>Type</c> parameter was not found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
if (typeName != null)
{
CodeTypeDeclaration extenstionHelpersFindType;
try {
extenstionHelpersFindType = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
processType(extenstionHelpersFindType);
}
else
{
foreach (CodeTypeDeclaration t in code.Types)
{
processType(t);
}
}
}
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type provided in the <c>Type</c> parameter was not found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(this.type, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
List <CodeTypeMember> rem = new List <CodeTypeMember>();
foreach (CodeTypeMember m in type.Members)
{
if (Array.IndexOf(names, m.Name) >= 0)
{
rem.Add(m);
}
}
foreach (var item in rem)
{
type.Members.Remove(item);
}
}
//private List<CodeAttributeArgument> attrParams = new List<CodeAttributeArgument>();
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type provided in the <c>TypeName</c> parameter or property provided in <c>PropertyName</c> parameter was not found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
CodeMemberProperty property = null;
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberProperty && m.Name == propertyName)
{
property = (CodeMemberProperty)m;
break;
}
}
if (property == null)
{
throw new InvalidOperationException(string.Format(Tools.VisualStudioT.GeneratorsT.XsdGenerator.Resources.ex_PropertyNotFound, propertyName));
}
//Get XML-serialization-related attributes
List <CodeAttributeDeclaration> attrs = new List <CodeAttributeDeclaration>();
foreach (CodeAttributeDeclaration custAttr in property.CustomAttributes)
{
if (custAttr.AttributeType.BaseType.StartsWith("System.Xml.Serialization.Xml"))
{
attrs.Add(custAttr);
}
}
//Remove it from original property
foreach (CodeAttributeDeclaration removeIt in attrs)
{
property.CustomAttributes.Remove(removeIt);
}
//Make it XML-ignored
property.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlIgnoreAttribute))));
//Create backing property
CodeMemberProperty newProperty = new CodeMemberProperty();
newProperty.Name = property.Name + "_AsString";
newProperty.Attributes = property.Attributes;
newProperty.Type = new CodeTypeReference(typeof(string));
//Getter
newProperty.GetStatements.AddRange(new CodeStatement[] {
new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(
new CodeCastExpression(
new CodeTypeReference(typeof(IFormattable)),
new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name)), "ToString"), new CodeExpression[] {
new CodePrimitiveExpression(format),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Globalization.CultureInfo)), "InvariantCulture")
}))
});
//Setter
newProperty.SetStatements.AddRange(new CodeStatement[] {
new CodeAssignStatement(
new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name),
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(property.Type), "Parse"),
new CodeExpression[] {
new CodePropertySetValueReferenceExpression(),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Globalization.CultureInfo)), "InvariantCulture")
}
)
)
});
//Check XML attributes (if name is not set it must be set to name of original property)
CodeAttributeDeclaration attribute = null;
foreach (var attr in attrs)
{
if (attr.AttributeType.BaseType == typeof(XmlElementAttribute).FullName)
{
attribute = attr;
break;
}
else if (attr.AttributeType.BaseType == typeof(XmlAttributeAttribute).FullName)
{
attribute = attr;
break;
}
}
if (attribute == null)
{
newProperty.CustomAttributes.Add(new CodeAttributeDeclaration(
new CodeTypeReference(typeof(XmlElementAttribute)),
new CodeAttributeArgument(new CodePrimitiveExpression(property.Name))
));
}
else
{
int i = 0;
bool NameSet = false;
foreach (CodeAttributeArgument arg in attribute.Arguments)
{
if (string.IsNullOrEmpty(arg.Name))
{
if (i == 0 && arg.Value is CodePrimitiveExpression && ((CodePrimitiveExpression)arg.Value).Value is string)
{
NameSet = true;
break;
}
i++;
}
else if (arg.Name == (attribute.AttributeType.BaseType == typeof(XmlAttributeAttribute).FullName ? "AttributeName" : "ElementName"))
{
NameSet = true;
break;
}
}
if (!NameSet)
{
attribute.Arguments.Add(new CodeAttributeArgument(
attribute.AttributeType.BaseType == typeof(XmlAttributeAttribute).FullName ? "AttributeName" : "ElementName",
new CodePrimitiveExpression(property.Name)
));
}
}
newProperty.CustomAttributes.AddRange(attrs.ToArray());
newProperty.CustomAttributes.AddRange(new CodeAttributeDeclaration[] {
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(BrowsableAttribute)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodePrimitiveExpression(false)) }
),
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(EditorBrowsableAttribute)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never")) }
),
new CodeAttributeDeclaration(
new CodeTypeReference(typeof(DesignerSerializationVisibility)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(DesignerSerializationVisibility)), "Hidden")) }
)
});
type.Members.Insert(type.Members.IndexOf(property) + 1, newProperty);
}
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type, property or filed cannot be found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
CodeMemberProperty property = null;
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberProperty && m.Name == propertyName)
{
property = (CodeMemberProperty)m;
break;
}
}
if (property == null)
{
throw new InvalidOperationException(string.Format(Resources.ex_PropertyNotFound, propertyName));
}
CodeMemberField field = null;
if (backingField != null)
{
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberField && m.Name == backingField)
{
field = (CodeMemberField)m;
break;
}
}
if (field == null)
{
throw new InvalidOperationException(string.Format(Resources.ex_FieldNotFound, backingField));
}
}
if (newName != null)
{
property.Name = newName;
}
property.Attributes &= andAttributes;
property.Attributes |= orAttributes;
if (newPropertyType != null)
{
CodeTypeReference newType;
if (newPropertyType.EndsWith("?"))
{
newType = new CodeTypeReference(typeof(System.Nullable <>));
newType.TypeArguments.Add(new CodeTypeReference(newPropertyType.Substring(0, newPropertyType.Length - 1)));
}
else
{
newType = new CodeTypeReference(newPropertyType);
}
if (!newArrayRank.HasValue)
{
property.Type = new CodeTypeReference(newPropertyType);
}
else
{
property.Type = new CodeTypeReference(newPropertyType, newArrayRank.Value);
}
if (field != null)
{
field.Type = property.Type;
}
}
}
//private List<CodeAttributeArgument> attrParams = new List<CodeAttributeArgument>();
/// <summary>Called when extension shall processs generated CodeDOM</summary>
/// <param name="code">Object tree representing generated CodeDOM</param>
/// <param name="schema">Input XML schema</param>
/// <param name="provider">CodeDOM provider (the language)</param>
/// <exception cref="InvalidOperationException">Type provided in the <c>TypeName</c> parameter or property provided in <c>PropertyName</c> parameter was not found.</exception>
public void Process(CodeNamespace code, XmlSchema schema, CodeDomProvider Provider)
{
CodeTypeDeclaration type;
try {
type = ExtenstionHelpers.FindType(typeName, code);
} catch (ArgumentException ex) {
throw new InvalidOperationException(ex.Message, ex);
}
CodeMemberProperty property = null;
foreach (CodeTypeMember m in type.Members)
{
if (m is CodeMemberProperty && m.Name == propertyName)
{
property = (CodeMemberProperty)m;
break;
}
}
if (property == null)
{
throw new InvalidOperationException(string.Format(Resources.ex_PropertyNotFound, propertyName));
}
//New property name unsafe_...
string oldName = property.Name;
property.Name = "unsafe_" + oldName;
//It must be xml-serialized under old name
bool found = false;
foreach (CodeAttributeDeclaration attr in property.CustomAttributes)
{
if (attr.AttributeType.BaseType == typeof(XmlElementAttribute).FullName)
{
foreach (CodeAttributeArgument aa in attr.Arguments)
{
if (aa.Name == null && aa.Value is CodePrimitiveExpression && ((CodePrimitiveExpression)aa.Value).Value is string)
{
found = true;
}
break;
}
if (!found)
{
attr.Arguments.Add(new CodeAttributeArgument("ElementName", new CodePrimitiveExpression(oldName)));
}
found = true;
}
else if (attr.AttributeType.BaseType == typeof(XmlAnyAttributeAttribute).FullName)
{
foreach (CodeAttributeArgument aa in attr.Arguments)
{
if (aa.Name == null && aa.Value is CodePrimitiveExpression && ((CodePrimitiveExpression)aa.Value).Value is string)
{
found = true;
}
break;
}
if (!found)
{
attr.Arguments.Add(new CodeAttributeArgument("AttributeName", new CodePrimitiveExpression(oldName)));
}
found = true;
found = true;
}
}
//Hide it form user and developper
if (!found)
{
property.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlElementAttribute)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodePrimitiveExpression(oldName)) }));
}
property.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(BrowsableAttribute)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodePrimitiveExpression(false)) }));
property.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(EditorBrowsableAttribute)),
new CodeAttributeArgument[] { new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never")) }));
//Alter getter
if (empty.HasValue)
{
List <CodeStatement> getStatements = new List <CodeStatement>(property.GetStatements.Count);
foreach (CodeStatement statement in property.GetStatements)
{
if (statement is CodeMethodReturnStatement)
{
getStatements.Add(new CodeAssignStatement(
new CodeVariableReferenceExpression("property_return_value"),
((CodeMethodReturnStatement)statement).Expression)
{
LinePragma = statement.LinePragma
});
getStatements[getStatements.Count - 1].StartDirectives.AddRange(statement.StartDirectives);
getStatements[getStatements.Count - 1].EndDirectives.AddRange(statement.EndDirectives);
foreach (DictionaryEntry ud in statement.UserData)
{
getStatements[getStatements.Count - 1].UserData.Add(ud.Key, ud.Value);
}
}
else
{
getStatements.Add(statement);
}
}
property.GetStatements.Clear();
property.GetStatements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(string)), "property_return_value"));
property.GetStatements.AddRange(getStatements.ToArray());
property.GetStatements.Add(new CodeConditionStatement(
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "IsNullOrEmpty"),
new CodeExpression[] { new CodeVariableReferenceExpression("property_return_value") }),
new CodeStatement[] { new CodeMethodReturnStatement(new CodePrimitiveExpression(empty.Value ? string.Empty : null)) },
new CodeStatement[] { new CodeMethodReturnStatement(new CodeVariableReferenceExpression("property_return_value")) }));
}
//Add new property
CodeMemberProperty NewProperty = new CodeMemberProperty();
NewProperty.Name = oldName;
NewProperty.Type = new CodeTypeReference(typeof(DateTime?));
NewProperty.Attributes = property.Attributes;
NewProperty.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlIgnoreAttribute))));
NewProperty.CustomAttributes.Add(
new CodeAttributeDeclaration(new CodeTypeReference(typeof(DesignerSerializationVisibilityAttribute)), new CodeAttributeArgument[] {
new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(DesignerSerializationVisibility)), "Hidden"))
}));
NewProperty.GetStatements.Add(new CodeConditionStatement(
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)), "IsNullOrEmpty", new CodeExpression[] {
new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name)
}),
/*True*/ new CodeStatement[] {
new CodeMethodReturnStatement(new CodeDefaultValueExpression(new CodeTypeReference(typeof(DateTime?))))
},
/*False*/ new CodeStatement[] {
new CodeMethodReturnStatement(new CodeCastExpression(new CodeTypeReference(typeof(DateTime?)), new CodeCastExpression(typeof(DateTime),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(XAttribute)), new CodeExpression[] {
new CodePrimitiveExpression("x"),
new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name)
}
))))
}
));
NewProperty.SetStatements.Add(new CodeConditionStatement(
new CodePropertyReferenceExpression(new CodePropertySetValueReferenceExpression(), "HasValue"),
/*True*/ new CodeStatement[] {
new CodeAssignStatement(new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name),
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodePropertyReferenceExpression(new CodePropertySetValueReferenceExpression(), "Value"), "ToString"), new CodeExpression[] {
new CodePrimitiveExpression(dateOnly ? "yyyy-MM-dd" : "yyyy-MM-ddTHH:mm:ss"),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Globalization.CultureInfo)), "InvariantCulture")
})
)
},
/*False*/ new CodeStatement[] {
new CodeAssignStatement(new CodePropertyReferenceExpression(
(property.Attributes & MemberAttributes.Static) == MemberAttributes.Static ? (CodeExpression) new CodeTypeReferenceExpression(type.Name) : (CodeExpression) new CodeThisReferenceExpression(),
property.Name),
new CodePrimitiveExpression(null)
)
}
));
type.Members.Insert(type.Members.IndexOf(property) + 1, NewProperty);
}
