public void Init()
{
functionalConstructor = null;
staticConstructor = null;
hasElementWildCards = false;
contentModelExpression = null;
if (propertyNameTypeTable != null) {
propertyNameTypeTable.Clear();
}
}
public CodeCompileUnit InitialiseCompileUnit(GLSLAssembly assembly)
{
var contentUnit = new CodeCompileUnit ();
SetVersionNumber (contentUnit, assembly.Version);
string nameSpace = assembly.Namespace;
if (string.IsNullOrWhiteSpace (nameSpace))
{
nameSpace = System.IO.Path.GetFileNameWithoutExtension (assembly.OutputAssembly);
}
var contentNs = new CodeNamespace (nameSpace);
contentUnit.Namespaces.Add (contentNs);
var uniforms = CreateClass (contentNs, "Uniforms");
var defaultConstructor = new CodeTypeConstructor ();
defaultConstructor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
uniforms.Members.Add (defaultConstructor);
defaultConstructor.Statements.Add (new CodeVariableDeclarationStatement (typeof(int), "testInt", new CodePrimitiveExpression (0)));
foreach (var block in mExtractor.Blocks)
{
AddStruct (contentNs, uniforms, block);
}
return contentUnit;
}
CodeTypeConstructor RegisterColums()
{
var c = new CodeTypeConstructor();
foreach (var col in this.Columns)
{
c.Statements.Add(GetRegisterMethod("RegisterColumn", col.Member, new CodeTypeReference(col.GetColumnType())));
}
foreach(var a in this.Associations)
{
if (a.IsForeignKey || (!a.IsForeignKey && a.Cardinality == "One"))
{
c.Statements.Add(GetRegisterMethod("RegisterAssociation", a.Member, new CodeTypeReference(a.Type)));
}
}
return c;
}
protected override void GenerateTypeConstructor (CodeTypeConstructor e)
{
}
protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)
{
if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface)
return;
OutputAttributes (constructor.CustomAttributes, null,
LineHandling.ContinueLine);
Output.WriteLine ("Shared Sub New()");
Indent++;
GenerateStatements (constructor.Statements);
Indent--;
Output.WriteLine ("End Sub");
}
public void Visit (CodeTypeConstructor o)
{
g.GenerateTypeConstructor (o);
}
public CodeTypeConstructor ParseTypeConstructor()
{
CodeTypeConstructor ctor = new CodeTypeConstructor();
ExpectKeyword("typeconstructor");
ExpectKeyword("begin");
while (!IsKeyword("end") && TokenType != CDILToken.EOF)
{
ctor.Statements.Add(ParseStatement());
if (TokenType == CDILToken.Semicolon)
Expect(CDILToken.Semicolon);
else
break;
}
ExpectKeyword("end");
return ctor;
}
public override void BuildCodeDomTree (CodeCompileUnit compileUnit)
{
CodeThisReferenceExpression @this = new CodeThisReferenceExpression ();
CodeBaseReferenceExpression @base = new CodeBaseReferenceExpression ();
CodeTypeReferenceExpression thisType = new CodeTypeReferenceExpression (new CodeTypeReference (GeneratedTypeName));
CodeTypeReference uriType = new CodeTypeReference (typeof(Uri));
CodeMemberField executableField = new CodeMemberField {
Name = "_Executable",
Type = new CodeTypeReference(typeof(XsltExecutable)),
Attributes = MemberAttributes.Private | MemberAttributes.Static
};
// methods
// cctor
CodeTypeConstructor cctor = new CodeTypeConstructor {
CustomAttributes = {
new CodeAttributeDeclaration(DebuggerNonUserCodeTypeReference)
}
};
CodeVariableDeclarationStatement procVar = new CodeVariableDeclarationStatement {
Name = "proc",
Type = new CodeTypeReference(typeof(IXsltProcessor)),
InitExpression = new CodeIndexerExpression {
TargetObject = new CodePropertyReferenceExpression {
PropertyName = "Xslt",
TargetObject = new CodeTypeReferenceExpression(typeof(Processors))
},
Indices = {
new CodePrimitiveExpression(parser.ProcessorName)
}
}
};
CodeVariableDeclarationStatement sourceVar = new CodeVariableDeclarationStatement {
Name = "source",
Type = new CodeTypeReference(typeof(Stream)),
InitExpression = new CodePrimitiveExpression(null)
};
CodeVariableDeclarationStatement sourceUriVar = new CodeVariableDeclarationStatement {
Name = "sourceUri",
Type = uriType,
InitExpression = new CodeObjectCreateExpression {
CreateType = uriType,
Parameters = {
new CodePrimitiveExpression(ValidatorUri.AbsoluteUri)
}
}
};
CodeVariableDeclarationStatement resolverVar = new CodeVariableDeclarationStatement {
Name = "resolver",
Type = new CodeTypeReference(typeof(XmlResolver)),
InitExpression = new CodeObjectCreateExpression(typeof(XmlEmbeddedResourceResolver))
};
CodeTryCatchFinallyStatement trySt = new CodeTryCatchFinallyStatement {
TryStatements = {
new CodeAssignStatement {
Left = new CodeVariableReferenceExpression(sourceVar.Name),
Right = new CodeCastExpression {
TargetType = new CodeTypeReference(typeof(Stream)),
Expression = new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "GetEntity",
TargetObject = new CodeVariableReferenceExpression(resolverVar.Name)
},
Parameters = {
new CodeVariableReferenceExpression(sourceUriVar.Name),
new CodePrimitiveExpression(null),
new CodeTypeOfExpression(typeof(Stream))
}
}
}
}
}
};
CodeVariableDeclarationStatement optionsVar = new CodeVariableDeclarationStatement {
Name = "options",
Type = new CodeTypeReference(typeof(XsltCompileOptions)),
};
optionsVar.InitExpression = new CodeObjectCreateExpression (optionsVar.Type);
trySt.TryStatements.Add (optionsVar);
trySt.TryStatements.Add (new CodeAssignStatement {
Left = new CodePropertyReferenceExpression {
PropertyName = "BaseUri",
TargetObject = new CodeVariableReferenceExpression(optionsVar.Name)
},
Right = new CodeVariableReferenceExpression(sourceUriVar.Name)
});
trySt.TryStatements.Add (new CodeAssignStatement {
Left = new CodeFieldReferenceExpression {
FieldName = executableField.Name,
TargetObject = thisType
},
Right = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression {
MethodName = "Compile",
TargetObject = new CodeVariableReferenceExpression(procVar.Name)
},
new CodeVariableReferenceExpression(sourceVar.Name),
new CodeVariableReferenceExpression(optionsVar.Name)
)
});
CodeConditionStatement disposeIf = new CodeConditionStatement {
Condition = new CodeBinaryOperatorExpression {
Left = new CodeVariableReferenceExpression(sourceVar.Name),
Operator = CodeBinaryOperatorType.IdentityInequality,
Right = new CodePrimitiveExpression(null)
},
TrueStatements = {
new CodeMethodInvokeExpression {
Method = new CodeMethodReferenceExpression {
MethodName = "Dispose",
TargetObject = new CodeVariableReferenceExpression(sourceVar.Name)
}
}
}
};
trySt.FinallyStatements.Add (disposeIf);
cctor.Statements.AddRange (new CodeStatement[] {
procVar,
sourceVar,
sourceUriVar,
resolverVar,
trySt
});
// ctor
CodeConstructor ctor = new CodeConstructor {
Attributes = MemberAttributes.Public,
CustomAttributes = {
new CodeAttributeDeclaration(DebuggerNonUserCodeTypeReference)
},
BaseConstructorArgs = {
new CodeFieldReferenceExpression {
FieldName = executableField.Name,
TargetObject = thisType
}
}
};
// class
CodeTypeDeclaration codeType = new CodeTypeDeclaration {
Name = GeneratedTypeName,
IsClass = true,
BaseTypes = { typeof(SchematronXsltValidator) },
Members = { cctor, ctor, executableField }
};
CodeNamespace codeNamespace = new CodeNamespace {
Name = GeneratedTypeNamespace,
Types = { codeType }
};
compileUnit.Namespaces.Add (codeNamespace);
}
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based class constructor
/// representation.
/// </para>
/// </devdoc>
private void GenerateTypeConstructor(CodeTypeConstructor e) {
if (!(IsCurrentClass || IsCurrentStruct)) return;
if (e.CustomAttributes.Count > 0) {
GenerateAttributes(e.CustomAttributes);
}
Output.Write("static ");
Output.Write(CurrentTypeName);
Output.Write("()");
OutputStartingBrace();
Indent++;
GenerateStatements(e.Statements);
Indent--;
Output.WriteLine("}");
}
protected override void GenerateTypeConstructor(System.CodeDom.CodeTypeConstructor e)
{
throw new Exception("The method or operation is not implemented.");
}
private void Write(CodeTypeConstructor e, string typeName){
TextWriter w = this.writer;
this.WriteIndent();
w.Write("static ");
this.WriteIdentifier(typeName);
w.Write("() ");
this.WriteStartingBrace();
this.Write(e.Statements);
this.WriteClosingBrace();
}
protected override void GenerateTypeConstructor(CodeTypeConstructor e)
{
FlushOutput(e);
MyGenerateStatements(e.Statements);
}
protected override void GenerateTypeConstructor(CodeTypeConstructor e)
{
if (base.IsCurrentClass || base.IsCurrentStruct)
{
base.Output.Write("static ");
this.OutputStartingBrace();
this.GenerateMethodStatements(e.Statements);
this.OutputEndingBrace();
}
}
protected virtual CodeTypeConstructor Rewrite(CodeTypeConstructor source, ref bool didRewrite)
{
if (source == null)
{
return source;
}
bool didChildRewrite = false;
CodeTypeConstructor result = new CodeTypeConstructor();
result.ReturnType = this.Rewrite(source.ReturnType, ref didChildRewrite);
this.Rewrite(result.Statements, source.Statements, ref didChildRewrite);
this.Rewrite(result.Parameters, source.Parameters, ref didChildRewrite);
result.PrivateImplementationType = this.Rewrite(source.PrivateImplementationType, ref didChildRewrite);
this.Rewrite(result.ImplementationTypes, source.ImplementationTypes, ref didChildRewrite);
this.Rewrite(result.ReturnTypeCustomAttributes, source.ReturnTypeCustomAttributes, ref didChildRewrite);
this.Rewrite(result.TypeParameters, source.TypeParameters, ref didChildRewrite);
result.Name = source.Name;
result.Attributes = this.Rewrite(source.Attributes, ref didChildRewrite);
this.Rewrite(result.CustomAttributes, source.CustomAttributes, ref didChildRewrite);
result.LinePragma = this.Rewrite(source.LinePragma, ref didChildRewrite);
this.Rewrite(result.Comments, source.Comments, ref didChildRewrite);
this.Rewrite(result.StartDirectives, source.StartDirectives, ref didChildRewrite);
this.Rewrite(result.EndDirectives, source.EndDirectives, ref didChildRewrite);
this.Rewrite(result.UserData, source.UserData, ref didChildRewrite);
if (didChildRewrite)
{
didRewrite = true;
return result;
}
else
{
return source;
}
}
protected override void GenerateTypeConstructor(CodeTypeConstructor constructor)
{
if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface)
return;
Output.Write ("static " + GetSafeName (CurrentTypeName));
OutputStartBrace ();
Indent++;
GenerateStatements (constructor.Statements);
Indent--;
Output.WriteLine ('}');
}
private void ValidateTypeConstructor(CodeTypeConstructor e) {
ValidateStatements(e.Statements);
}
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based class constructor
/// representation.
/// </para>
/// </devdoc>
protected override void GenerateTypeConstructor(CodeTypeConstructor e) {
if (!(IsCurrentClass || IsCurrentStruct)) return;
if (e.CustomAttributes.Count > 0) {
OutputAttributes(e.CustomAttributes, false);
}
Output.WriteLine("Shared Sub New()");
Indent++;
GenerateVBStatements(e.Statements);
Indent--;
Output.WriteLine("End Sub");
}
/// <include file='doc\CSharpCodeProvider.uex' path='docs/doc[@for="CSharpCodeGenerator.GenerateTypeConstructor"]/*' />
/// <devdoc>
/// <para>
/// Generates code for the specified CodeDom based class constructor
/// representation.
/// </para>
/// </devdoc>
protected override void GenerateTypeConstructor(CodeTypeConstructor e) {
if (!(IsCurrentClass || IsCurrentStruct)) return;
Output.Write("static ");
Output.Write(CurrentTypeName);
Output.Write("()");
OutputStartingBrace();
Indent++;
GenerateStatements(e.Statements);
Indent--;
Output.WriteLine("}");
}
public void Generate(CodeTypeConstructor member)
{
Generate(member.Comments);
foreach (CodeStatement statement in member.Statements)
Generate(statement);
}
internal DryadLinqCodeGen(DryadLinqContext context, VertexCodeGen vertexCodeGen)
{
this.m_context = context;
this.m_vertexCodeGen = vertexCodeGen;
this.m_loadedVertexAssembly = null;
this.m_dryadLinqUnit = new CodeCompileUnit();
// Create a namespace
this.m_dryadCodeSpace = new CodeNamespace(TargetNamespace);
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Collections"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Text"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Linq"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Linq.Expressions"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Diagnostics"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Runtime.Serialization"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Data.SqlTypes"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Data.Linq"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("System.Data.Linq.Mapping"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("Microsoft.Research.DryadLinq"));
this.m_dryadCodeSpace.Imports.Add(new CodeNamespaceImport("Microsoft.Research.DryadLinq.Internal"));
this.m_dryadLinqUnit.Namespaces.Add(this.m_dryadCodeSpace);
// Create the class for all the DryadLinq extension methods
this.m_dryadExtensionClass = new CodeTypeDeclaration(ExtensionClassName);
this.m_dryadExtensionClass.IsClass = true;
this.m_dryadExtensionClass.IsPartial = true;
this.m_dryadExtensionClass.TypeAttributes = TypeAttributes.Public;
this.m_dryadCodeSpace.Types.Add(this.m_dryadExtensionClass);
// Create the static constructor for the vertex extension class
this.m_extensionStaticCtor = new CodeTypeConstructor();
this.m_dryadExtensionClass.Members.Add(this.m_extensionStaticCtor);
// Create the class for all the DryadLinq vertex methods
this.m_dryadVertexClass = new CodeTypeDeclaration(VertexClassName);
this.m_dryadVertexClass.IsClass = true;
this.m_dryadVertexClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
this.m_dryadCodeSpace.Types.Add(this.m_dryadVertexClass);
this.AddCopyResourcesMethod();
// The set of input/output channel datatypes
this.m_dryadDataTypes = new HashSet<Type>();
this.m_dryadDataTypes.Add(typeof(byte));
this.m_dryadDataTypes.Add(typeof(sbyte));
this.m_dryadDataTypes.Add(typeof(bool));
this.m_dryadDataTypes.Add(typeof(char));
this.m_dryadDataTypes.Add(typeof(short));
this.m_dryadDataTypes.Add(typeof(ushort));
this.m_dryadDataTypes.Add(typeof(int));
this.m_dryadDataTypes.Add(typeof(uint));
this.m_dryadDataTypes.Add(typeof(long));
this.m_dryadDataTypes.Add(typeof(ulong));
this.m_dryadDataTypes.Add(typeof(float));
this.m_dryadDataTypes.Add(typeof(decimal));
this.m_dryadDataTypes.Add(typeof(double));
this.m_dryadDataTypes.Add(typeof(DateTime));
this.m_dryadDataTypes.Add(typeof(string));
this.m_dryadDataTypes.Add(typeof(LineRecord));
this.m_dryadDataTypes.Add(typeof(SqlDateTime));
this.m_dryadDataTypes.Add(typeof(Guid));
// The set of datatypes we have added serialization methods
this.m_serializationDatatypes = new HashSet<Type>();
this.m_fieldToStaticName = new Dictionary<FieldInfo, string>();
this.m_staticFieldDefined = new HashSet<string>();
this.m_typeToSerializerName = new Dictionary<Type, string>();
this.m_anonymousTypeToName = new Dictionary<Type, string>();
this.m_nameToAlias = new Dictionary<string, string>();
}
public void Constructor0 ()
{
CodeTypeConstructor ctc = new CodeTypeConstructor ();
Assert.AreEqual (MemberAttributes.Private | MemberAttributes.Final,
ctc.Attributes, "#1");
Assert.IsNotNull (ctc.Comments, "#2");
Assert.AreEqual (0, ctc.Comments.Count, "#3");
Assert.IsNotNull (ctc.CustomAttributes, "#4");
Assert.AreEqual (0, ctc.CustomAttributes.Count, "#5");
Assert.IsNotNull (ctc.StartDirectives, "#6");
Assert.AreEqual (0, ctc.StartDirectives.Count, "#7");
Assert.IsNotNull (ctc.EndDirectives, "#8");
Assert.AreEqual (0, ctc.EndDirectives.Count, "#9");
Assert.IsNotNull (ctc.TypeParameters, "#10");
Assert.AreEqual (0, ctc.TypeParameters.Count, "#11");
Assert.IsNull (ctc.LinePragma, "#12");
Assert.IsNotNull (ctc.Name, "#13");
Assert.AreEqual (".cctor", ctc.Name, "#14");
Assert.IsNotNull (ctc.UserData, "#15");
Assert.AreEqual (typeof(ListDictionary), ctc.UserData.GetType (), "#16");
Assert.AreEqual (0, ctc.UserData.Count, "#17");
Assert.IsNotNull (ctc.ImplementationTypes, "#18");
Assert.AreEqual (0, ctc.ImplementationTypes.Count, "#19");
Assert.IsNotNull (ctc.Parameters, "#20");
Assert.AreEqual (0, ctc.Parameters.Count, "#21");
Assert.IsNull (ctc.PrivateImplementationType, "#22");
Assert.IsNotNull (ctc.ReturnType, "#23");
Assert.AreEqual (typeof(void).FullName, ctc.ReturnType.BaseType, "#24");
Assert.IsNotNull (ctc.ReturnTypeCustomAttributes, "#25");
Assert.AreEqual (0, ctc.ReturnTypeCustomAttributes.Count, "#26");
Assert.IsNotNull (ctc.Statements, "#27");
Assert.AreEqual (0, ctc.Statements.Count, "#28");
string name = "mono";
ctc.Name = name;
Assert.IsNotNull (ctc.Name, "#29");
Assert.AreSame (name, ctc.Name, "#30");
ctc.Name = null;
Assert.IsNotNull (ctc.Name, "#31");
Assert.AreEqual (string.Empty, ctc.Name, "#32");
CodeLinePragma clp = new CodeLinePragma ("mono", 10);
ctc.LinePragma = clp;
Assert.IsNotNull (ctc.LinePragma, "#33");
Assert.AreSame (clp, ctc.LinePragma, "#34");
ctc.LinePragma = null;
Assert.IsNull (ctc.LinePragma, "#35");
}
private static void PrintTypeConstructor(TextWriter output, CodeTypeConstructor typeConstructor)
{
output.WriteLine("typeconstructor");
foreach (CodeAttributeDeclaration cad in typeConstructor.CustomAttributes)
{
output.Write(" customattribute ");
PrintCustomAttributeDeclaration(output, cad);
output.WriteLine();
}
output.WriteLine("begin");
for (int i = 0; i < typeConstructor.Statements.Count; ++i)
{
output.Write(" ");
PrintStatement(output, typeConstructor.Statements[i]);
if (i + 1 < typeConstructor.Statements.Count)
output.WriteLine(';');
else
output.WriteLine();
}
output.WriteLine("end");
}
private void GenerateTypeConstructor(CodeTypeConstructor e)
{
if (this.IsCurrentClass || this.IsCurrentStruct)
{
if (e.CustomAttributes.Count > 0)
{
this.GenerateAttributes(e.CustomAttributes);
}
this.Output.Write("static ");
this.Output.Write(this.CurrentTypeName);
this.Output.Write("()");
this.OutputStartingBrace();
this.Indent++;
this.GenerateStatements(e.Statements);
this.Indent--;
this.Output.WriteLine("}");
}
}
protected abstract void GenerateTypeConstructor (CodeTypeConstructor constructor);
internal static CodeTypeDeclaration CreateTypeManager(XmlQualifiedName rootElementName,
bool enableServiceReference,
CodeStatementCollection typeDictionaryStatements,
CodeStatementCollection elementDictionaryStatements,
CodeStatementCollection wrapperDictionaryStatements) {
//Create the services type class and add members
string servicesClassName = NameGenerator.GetServicesClassName();
CodeTypeDeclaration servicesTypeDecl = new CodeTypeDeclaration(servicesClassName);
servicesTypeDecl.Attributes = MemberAttributes.Public;
//Create singleton
CodeMemberField singletonField = CodeDomHelper.CreateMemberField(Constants.TypeManagerSingletonField, servicesClassName, MemberAttributes.Static, true);
CodeMemberProperty singletonProperty = CodeDomHelper.CreateProperty(Constants.TypeManagerInstance, null, singletonField, MemberAttributes.Public | MemberAttributes.Static, false);
MemberAttributes privateStatic = MemberAttributes.Private | MemberAttributes.Static;
//Create static constructor
CodeTypeConstructor staticServicesConstructor = new CodeTypeConstructor();
CodeTypeReference returnType = CodeDomHelper.CreateDictionaryType("XName", "System.Type");
CodeTypeReference wrapperReturnType = CodeDomHelper.CreateDictionaryType("System.Type", "System.Type");
//Create a dictionary of TypeName vs System.Type and the method to create it
CodeMemberProperty typeDictProperty = null;
if (typeDictionaryStatements.Count > 0) {
typeDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.GlobalTypeDictionary, Constants.ILinqToXsdTypeManager, returnType, Constants.TypeDictionaryField);
CodeMemberField staticTypeDictionary = CodeDomHelper.CreateDictionaryField(Constants.TypeDictionaryField, "XName", "System.Type");
CodeMemberMethod buildTypeDictionary = CodeDomHelper.CreateMethod(Constants.BuildTypeDictionary, privateStatic, null);
buildTypeDictionary.Statements.AddRange(typeDictionaryStatements);
staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, Constants.BuildTypeDictionary));
servicesTypeDecl.Members.Add(staticTypeDictionary);
servicesTypeDecl.Members.Add(buildTypeDictionary);
}
else {
typeDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.GlobalTypeDictionary, Constants.ILinqToXsdTypeManager, returnType);
typeDictProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(Constants.XTypedServices), Constants.EmptyDictionaryField)));
}
//Create a dictionary of ElementName Vs System.Type - For Auto typing and substitutionGroups
CodeMemberProperty elementDictProperty = null;
if (elementDictionaryStatements.Count > 0) {
elementDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.GlobalElementDictionary, Constants.ILinqToXsdTypeManager, returnType, Constants.ElementDictionaryField);
CodeMemberField staticElementDictionary = CodeDomHelper.CreateDictionaryField(Constants.ElementDictionaryField, "XName", "System.Type");
CodeMemberMethod buildElementDictionary = CodeDomHelper.CreateMethod(Constants.BuildElementDictionary, privateStatic, null);
buildElementDictionary.Statements.AddRange(elementDictionaryStatements);
staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, Constants.BuildElementDictionary));
servicesTypeDecl.Members.Add(staticElementDictionary);
servicesTypeDecl.Members.Add(buildElementDictionary);
}
else {
elementDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.GlobalElementDictionary, Constants.ILinqToXsdTypeManager, returnType);
elementDictProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(Constants.XTypedServices), Constants.EmptyDictionaryField)));
}
//Create a dictionary of Wrapper Element Type Vs Wrapper Type - For Auto typing when casting from XElement to Type
CodeMemberProperty wrapperDictProperty = null;
if (wrapperDictionaryStatements.Count > 0) {
wrapperDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.RootContentTypeMapping, Constants.ILinqToXsdTypeManager, wrapperReturnType, Constants.WrapperDictionaryField);
CodeMemberField staticWrapperDictionary = CodeDomHelper.CreateDictionaryField(Constants.WrapperDictionaryField, "System.Type", "System.Type");
CodeMemberMethod buildWrapperDictionary = CodeDomHelper.CreateMethod(Constants.BuildWrapperDictionary, privateStatic, null);
buildWrapperDictionary.Statements.AddRange(wrapperDictionaryStatements);
staticServicesConstructor.Statements.Add(CodeDomHelper.CreateMethodCall(null, Constants.BuildWrapperDictionary));
servicesTypeDecl.Members.Add(staticWrapperDictionary);
servicesTypeDecl.Members.Add(buildWrapperDictionary);
}
else {
wrapperDictProperty = CodeDomHelper.CreateInterfaceImplProperty(Constants.RootContentTypeMapping, Constants.ILinqToXsdTypeManager, wrapperReturnType);
wrapperDictProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(Constants.XTypedServices), Constants.EmptyTypeMappingDictionary)));
}
//Implement IXmlSerializable AddSchemas method for the XmlSchemaProvider method and Schemas get set property for runtime access to schemas
//if (enableServiceReference) { //Since property is on the interface, it has to be implemented;
string schemaSetFieldName = "schemaSet";
CodeTypeReference schemaSetType = new CodeTypeReference("XmlSchemaSet");
CodeMemberField schemaSetField = new CodeMemberField(schemaSetType, schemaSetFieldName);
schemaSetField.Attributes = MemberAttributes.Private | MemberAttributes.Static;
//AddSchemas method
CodeMemberMethod addSchemasMethod = CodeDomHelper.CreateMethod("AddSchemas", MemberAttributes.FamilyOrAssembly | MemberAttributes.Static, null);
addSchemasMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlSchemaSet", "schemas"));
//schemas.Add(schemaSet);
addSchemasMethod.Statements.Add(CodeDomHelper.CreateMethodCall(new CodeVariableReferenceExpression("schemas"), "Add", new CodeFieldReferenceExpression(null, schemaSetFieldName)));
CodeTypeReferenceExpression interLockedType = new CodeTypeReferenceExpression("System.Threading.Interlocked");
CodeMemberProperty schemaSetProperty = CodeDomHelper.CreateInterfaceImplProperty("Schemas", Constants.ILinqToXsdTypeManager, schemaSetType);
CodeFieldReferenceExpression schemaSetFieldRef = new CodeFieldReferenceExpression(null, schemaSetFieldName);
CodeDirectionExpression schemaSetParam = new CodeDirectionExpression(FieldDirection.Ref, schemaSetFieldRef);
schemaSetProperty.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(schemaSetFieldRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)),
new CodeVariableDeclarationStatement(schemaSetType, "tempSet", new CodeObjectCreateExpression(schemaSetType)),
new CodeExpressionStatement(
CodeDomHelper.CreateMethodCall(interLockedType, "CompareExchange",
schemaSetParam,
new CodeVariableReferenceExpression("tempSet"),
new CodePrimitiveExpression(null)))));
schemaSetProperty.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeVariableReferenceExpression(schemaSetFieldName)));
//Setter
schemaSetProperty.SetStatements.Add(new CodeAssignStatement(schemaSetFieldRef, new CodePropertySetValueReferenceExpression()));
servicesTypeDecl.Members.Add(schemaSetField);
servicesTypeDecl.Members.Add(schemaSetProperty);
servicesTypeDecl.Members.Add(addSchemasMethod);
//}
//Implement ILinqToXsdTypeManager
servicesTypeDecl.Members.Add(typeDictProperty);
servicesTypeDecl.Members.Add(elementDictProperty);
servicesTypeDecl.Members.Add(wrapperDictProperty);
servicesTypeDecl.BaseTypes.Add(Constants.ILinqToXsdTypeManager);
//Add a getter that will get the root type name
CodeMemberMethod getRootType = new CodeMemberMethod();
getRootType.Attributes = MemberAttributes.Static | MemberAttributes.Public;
getRootType.Name = Constants.GetRootType;
getRootType.ReturnType = new CodeTypeReference("System.Type");
if (rootElementName.IsEmpty) {
getRootType.Statements.Add(
new CodeMethodReturnStatement(
CodeDomHelper.Typeof("Xml.Schema.Linq.XTypedElement")));
}
else {
getRootType.Statements.Add(
new CodeMethodReturnStatement(
new CodeIndexerExpression(
CodeDomHelper.CreateFieldReference(null, Constants.ElementDictionaryField),
CodeDomHelper.XNameGetExpression(rootElementName.Name, rootElementName.Namespace))));
}
servicesTypeDecl.Members.Add(staticServicesConstructor);
servicesTypeDecl.Members.Add(getRootType);
servicesTypeDecl.Members.Add(singletonField);
servicesTypeDecl.Members.Add(singletonProperty);
return servicesTypeDecl;
}
private void CreateConstructor()
{
//create the constructor
CodeConstructor constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
classDom.Members.Add(constructor);
Comment(constructor, string.Format("Construct an instance of the '{0}' shader", this.techniqueName));
foreach (DomBase dom in this.domList)
dom.AddConstructor(this, delegate(CodeStatement s) { constructor.Statements.Add(s); });
//create the static constructor
CodeTypeConstructor staticConstructor = new CodeTypeConstructor();
Comment(staticConstructor, string.Format("Static Constructor for '{0}'", this.techniqueName));
staticConstructor.Attributes = MemberAttributes.Private | MemberAttributes.Final;
foreach (DomBase dom in this.domList)
dom.AddStaticConstructor(this, delegate(CodeStatement s) { staticConstructor.Statements.Add(s); });
if (staticConstructor.Statements.Count > 0)
classDom.Members.Add(staticConstructor);
}
/// <summary>
/// Generates code for the specified class constructor.
/// </summary>
/// <remarks>Not supported.</remarks>
protected override void GenerateTypeConstructor(CodeTypeConstructor e)
{
throw new Exception("The method or operation is not implemented.");
}
protected override void GenerateTypeConstructor(CodeTypeConstructor e)
{
if (base.IsCurrentClass || base.IsCurrentStruct)
{
if (e.CustomAttributes.Count > 0)
{
this.OutputAttributes(e.CustomAttributes, false);
}
base.Output.WriteLine("Shared Sub New()");
base.Indent++;
this.GenerateVBStatements(e.Statements);
base.Indent--;
base.Output.WriteLine("End Sub");
}
}
protected string GenerateTypeConstructor (CodeGeneratorOptions options)
{
TypeDeclaration.Name = "Test1";
CodeTypeConstructor typeCtor = new CodeTypeConstructor ();
// access, scope and vtable modifiers should be ignored
typeCtor.Attributes |= MemberAttributes.Public | MemberAttributes.Abstract
| MemberAttributes.Const | MemberAttributes.Final
| MemberAttributes.New | MemberAttributes.Overloaded
| MemberAttributes.Override | MemberAttributes.Static;
TypeDeclaration.Members.Add (typeCtor);
// custom attributes
CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
attrDec.Name = "A";
typeCtor.CustomAttributes.Add (attrDec);
attrDec = new CodeAttributeDeclaration ();
attrDec.Name = "B";
typeCtor.CustomAttributes.Add (attrDec);
// parameter should be ignored
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
typeof (object), "value1");
typeCtor.Parameters.Add (param);
// implementation types should be ignored on type ctors
typeCtor.ImplementationTypes.Add (new CodeTypeReference ("IPolicy"));
// private immplementation type should be ignored on type ctors
typeCtor.PrivateImplementationType = new CodeTypeReference (typeof (int));
// return type should be ignored on type ctors
typeCtor.ReturnType = new CodeTypeReference (typeof (int));
// return TypeDeclaration custom attributes
attrDec = new CodeAttributeDeclaration ();
attrDec.Name = "A";
attrDec.Arguments.Add (new CodeAttributeArgument ("A1",
new CodePrimitiveExpression (false)));
attrDec.Arguments.Add (new CodeAttributeArgument ("A2",
new CodePrimitiveExpression (true)));
typeCtor.ReturnTypeCustomAttributes.Add (attrDec);
return GenerateCodeFromType (TypeDeclaration, options);
}
protected override void GenerateTypeConstructor(CodeTypeConstructor e)
{
Output.WriteLine("[CodeTypeConstructor : {0}]", e.ToString());
}
protected override void GenerateTypeConstructor (CodeTypeConstructor constructor)
{
if (IsCurrentDelegate || IsCurrentEnum || IsCurrentInterface) {
return;
}
#if NET_2_0
OutputAttributes (constructor.CustomAttributes, null, false);
#endif
Output.Write ("static " + GetSafeName (CurrentTypeName) + "()");
OutputStartBrace ();
Indent++;
GenerateStatements (constructor.Statements);
Indent--;
Output.WriteLine ('}');
}
