source: branches/OKB/HeuristicLab.Services.OKB.DataAccess/3.3/L2ST4.ttinclude @ 7603

<#@ assembly name="System.Core"
#><#@ assembly name="System.Data.Linq"
#><#@ assembly name="EnvDTE"
#><#@ assembly name="System.Xml"
#><#@ assembly name="System.Xml.Linq"
#><#@ import namespace="System"
#><#@ import namespace="System.CodeDom"
#><#@ import namespace="System.CodeDom.Compiler"
#><#@ import namespace="System.Collections.Generic"
#><#@ import namespace="System.Data.Linq"
#><#@ import namespace="System.Data.Linq.Mapping"
#><#@ import namespace="System.IO"
#><#@ import namespace="System.Linq"
#><#@ import namespace="System.Reflection"
#><#@ import namespace="System.Text"
#><#@ import namespace="System.Xml.Linq"
#><#@ import namespace="Microsoft.VisualStudio.TextTemplating"
#><#+
// L2ST4 - LINQ to SQL templates for T4 v0.82 - http://www.codeplex.com/l2st4
// Copyright (c) Microsoft Corporation.  All rights reserved.
// This source code is made available under the terms of the Microsoft Public License (MS-PL)

// DBML Database element > code DataContext class
class Data
{
  public XNamespace NS = "http://schemas.microsoft.com/linqtosql/dbml/2007";
  public String BaseClassName { get; private set; }
  public String ConnectSettingsObject { get; private set; }
  public String ConnectSettingsProperty { get; private set; }
  public String ContextName { get; private set; }
  public String ContextNamespace { get; set; }
  public String DatabaseName { get; private set; }
  public String DbmlFileName { get; private set; }
  public String EntityBase { get; private set; }
  public String EntityNamespace { get; set; }
  public List<Function> Functions { get; private set; }
  public List<FunctionClass> FunctionClasses { get; private set; }
  public bool Serialization { get; private set; }
  public string SpecifiedContextNamespace { get; private set; }
  public string SpecifiedEntityNamespace { get; private set; }
  public TypeAttributes TypeAttributes { get; private set; }
  public List<Table> Tables { get; private set; }
  public List<TableClass> TableClasses { get; private set; }
  
  public Data(String dbmlFileName) {
    DbmlFileName = dbmlFileName;
    if (!File.Exists(DbmlFileName))
      throw new Exception(String.Format("DBML file '{0}' could not be found.", DbmlFileName));
    XElement xe = XDocument.Load(DbmlFileName).Root;
    TableClasses = new List<TableClass>();
    FunctionClasses = new List<FunctionClass>();
    
    foreach(XElement connection in xe.Elements(NS + "Connection")) {
      ConnectSettingsObject = (String) connection.Attribute("SettingsObjectName");
      ConnectSettingsProperty = (String) connection.Attribute("SettingsPropertyName");
    }
    BaseClassName = (String) xe.Attribute("BaseType") ?? "DataContext";
    ContextName = (String) xe.Attribute("Class");
    ContextNamespace = SpecifiedContextNamespace = (String) xe.Attribute("ContextNamespace");
    DatabaseName = (String) xe.Attribute("Name") ?? "";
    EntityBase = (String) xe.Attribute("EntityBase");
    EntityNamespace = SpecifiedEntityNamespace = (String) xe.Attribute("EntityNamespace");
    Serialization = (String) xe.Attribute("Serialization") == "Unidirectional";
    TypeAttributes = Class.DecodeAccess((String) xe.Attribute("AccessModifier")) | Class.DecodeModifier((String) xe.Attribute("Modifier"));
    Tables = (from t in xe.Elements(NS + "Table")
      select new Table(this, t)).ToList();
    Functions = (from f in xe.Elements(NS + "Function")
      select new Function(this, f)).ToList();
  }
    
  static internal Type GetType(String typeName, bool canBeNull) {
    Type type = null;
    switch(typeName) {
      case "System.Xml.Linq.XElement": type = typeof(System.Xml.Linq.XElement); break;
      case "System.Data.Linq.Binary": type = typeof(System.Data.Linq.Binary); break;
      default: type = Type.GetType(typeName); break;
    }
    if (type == null)
      type = new TypeStub(typeName);
    if (type.IsValueType && canBeNull)
      type = typeof(Nullable<>).MakeGenericType(type);
    return type;
  }
}

// DBML Table element > Base entity class, events & property on DataContext class
class Table
{
  public TableClass BaseClass {
    get { return Classes.First(); }
  }
  public IEnumerable<TableClass> Classes {
    get { return Data.TableClasses.Where(c => c.Table == this); }
  }
  public Data Data { get; private set; }
  private String member;
  public String Member {
    get { return member ?? Name; }
    set { member = value; }
  }
  public String Name { get; set; }
  public List<TableOperation> Operations { get; private set; }

  public Table(Data data, XElement xe) {
    Data = data;
    Name = (String) xe.Attribute("Name");
    Member = (String) xe.Attribute("Member");
    Data.TableClasses.AddRange(from c in xe.Elements(Data.NS + "Type")
      select new TableClass(this, c));
    Operations = new List<TableOperation>();
    foreach(OperationType operationType in Enum.GetValues(typeof(OperationType)))
      Operations.AddRange((from o in xe.Elements(Data.NS + operationType.ToString() + "Function")
        select new TableOperation(this, o)).ToList());
  }
}

// DBML Type element > Entity class, subclasses or stored procedure return type
class Class
{
  public Class SuperClass { get; protected set; }
  public List<Column> Columns { get; private set; }
  public Data Data {get; private set; }
  public String Id { get; private set; }
  public String InheritanceCode { get; private set; }
  public Boolean IsInheritanceDefault { get; private set; }
  public Boolean IsSerializable {
    get { return (TypeAttributes & TypeAttributes.VisibilityMask) == TypeAttributes.Public; }
  }
  protected String name;
  public virtual String Name {
    get { return name; }
    set { name = value; }
  }
  public String QualifiedName {
    get { return (String.IsNullOrEmpty(Data.EntityNamespace) || (Data.EntityNamespace == Data.ContextNamespace))
        ? Name : Data.EntityNamespace + '.' + Name; }
  }
  public TypeAttributes TypeAttributes { get; private set; }
  
  public Class(Data data, XElement xe) {
    Data = data;
    Id = (String) xe.Attribute("Id");
    InheritanceCode = (String) xe.Attribute("InheritanceCode");
    IsInheritanceDefault = (Boolean ?) xe.Attribute("IsInheritanceDefault") ?? false;
    Name = (String) xe.Attribute("Name");
    TypeAttributes = DecodeAccess((String) xe.Attribute("AccessModifier")) | DecodeModifier((String) xe.Attribute("Modifier"));
    Columns = (from c in xe.Elements(Data.NS + "Column")
      select new Column(this, c)).ToList();
  }
  
  internal static TypeAttributes DecodeAccess(String access) {
    switch(access) {
      case "Private": return TypeAttributes.NestedPrivate;
      case "Internal": return TypeAttributes.NestedAssembly;
      case "Protected": return TypeAttributes.NestedFamily;
      case "ProtectedInternal": return TypeAttributes.NestedFamORAssem;
      default: return TypeAttributes.Public;
    }
  }
  
  internal static TypeAttributes DecodeModifier(String modifier) {
    switch(modifier) {
      case "Abstract": return TypeAttributes.Abstract;
      case "Sealed": return TypeAttributes.Sealed;
      default: return TypeAttributes.Class;
    }
  }
}

// DBML Type element > Classes and subclasses that map to tables
class TableClass : Class
{
  public List<Association> Associations { get; private set; }
  public Boolean HasPrimaryKey {
    get { return Columns.Any(c => c.IsPrimaryKey); }
  }
  public override String Name { get; set; }
  public IList<Column> PrimaryKey {
    get { return Columns.Where(c => c.IsPrimaryKey).ToList(); }
  }
  public MemberAttributes PropertyChangeAccess {
    get { return ((TypeAttributes & TypeAttributes.Sealed) != 0) ? MemberAttributes.Private | MemberAttributes.Final : MemberAttributes.Public; }
  }
  public IEnumerable<TableClass> Subclasses {
    get { return Table.Data.TableClasses.Where(c => c.SuperClass == this); }
  }
  public Table Table { get; private set; }

  public TableClass(TableClass superClass, XElement xe) : this(superClass.Table, xe) {
    SuperClass = superClass;
  }

  public TableClass(Table table, XElement xe) : base(table.Data, xe) {
    Table = table;
    Associations = (from a in xe.Elements(Data.NS + "Association")
      select new Association(this, a)).ToList();
    Table.Data.TableClasses.AddRange(from c in xe.Elements(Data.NS + "Type")
      select new TableClass(this, c));
  }
}

// DBML Type > Classes that map to stored procedure return types
class FunctionClass : Class
{
  public Function Function { get; set; }
  
  public FunctionClass(Function function, XElement xe) : base(function.Data, xe) {
    Function = function;
  }
}

// DBML type Column > Properties on a class
class Column
{
  private String member, typeName, storage;

  private AutoSync autoSync;
  public AutoSync AutoSync {
    get {
      if (IsDbGenerated)
        if (IsPrimaryKey)
          return AutoSync.OnInsert;
        else
          return AutoSync.Always;
      return autoSync;
    }
    private set { autoSync = value; }
  }
  public Boolean CanBeNull { get; private set; }
  public Class Class { get; private set; }
  public String DbType { get; private set; }
  public String Expression { get; private set; }
  private Boolean isDbGenerated;
  public Boolean IsDbGenerated {
    get { return (!String.IsNullOrEmpty(Expression) || IsVersion) ? true : isDbGenerated;  }
    private set { isDbGenerated = value; }
  }
  public Boolean IsDelayLoaded { get; private set; }
  public Boolean IsDiscriminator { get; private set; }
  public List<Association> ForeignKeyAssociations {
    get {
      if (Class is TableClass) {
        return ((TableClass)Class).Associations.Where(a => a.ThisKey.Contains(this) && a.IsForeignKey).ToList();
      }
      else
        return new List<Association>();
    }
  }
  public Boolean IsPrimaryKey { get; private set; }
  private Boolean isReadOnly;
  public Boolean IsReadOnly {
    get { return (Class.Data.Serialization) ? false : isReadOnly; }
    private set { isReadOnly = value; }
  }
  public Boolean IsVersion { get; private set; }
  public String Member {
    get { return member + ((member == Class.Name) ? "1" : ""); }
    set { member = value; }
  }
  public MemberAttributes MemberAttributes { get; private set; }
  public String Name { get; private set; }
  public String Storage {
    get { return String.IsNullOrEmpty(storage) ? "_" + Member : storage; }
    set { storage = value; }
  }
  public Type StorageType {
    get { return (IsDelayLoaded) ? typeof(Link<>).MakeGenericType(Type) : Type; }
  }
  public String StorageValue {
    get { return (IsDelayLoaded) ? Storage + ".Value" : Storage; }
  }
  public Type Type {
    get { return Data.GetType(typeName, CanBeNull); }
  }
  private UpdateCheck updateCheck;
  public UpdateCheck UpdateCheck {
    get { return (IsReadOnly) ? UpdateCheck.Never : updateCheck; }
    private set { updateCheck = value; }
  }
  
  public Column(Class class1, XElement xe) {
    Class = class1;
    Name = (String) xe.Attribute("Name") ?? "";
    Member = (String) xe.Attribute("Member") ?? Name;
    typeName = xe.Attribute("Type").Value;
    CanBeNull = (Boolean?) xe.Attribute("CanBeNull") ?? false;
    DbType = (String) xe.Attribute("DbType") ?? "";
    Expression = (String) xe.Attribute("Expression") ?? "";
    IsDbGenerated = (Boolean?) xe.Attribute("IsDbGenerated") ?? (IsVersion);
    IsDelayLoaded = (Boolean?) xe.Attribute("IsDelayLoaded") ?? false;
    IsDiscriminator = (Boolean?) xe.Attribute("IsDiscriminator") ?? false;
    IsPrimaryKey = (Boolean?) xe.Attribute("IsPrimaryKey") ?? false;
    IsReadOnly = (Boolean?) xe.Attribute("IsReadOnly") ?? false;
    IsVersion = (Boolean?) xe.Attribute("IsVersion") ?? false;
    Storage = (String) xe.Attribute("Storage") ?? "";
    AutoSync autoSyncDefault = (IsDbGenerated) ? AutoSync.OnInsert : AutoSync.Default;
    AutoSync = Util.ParseEnum((String) xe.Attribute("AutoSync"), (IsVersion) ? AutoSync.Always : autoSyncDefault);
    UpdateCheck = Util.ParseEnum((String) xe.Attribute("UpdateCheck"), (IsVersion || IsPrimaryKey) ? UpdateCheck.Never : UpdateCheck.Always);
    MemberAttributes = Util.DecodeMemberAccess((String) xe.Attribute("AccessModifier")) | Util.DecodeMemberModifier((String) xe.Attribute("Modifier"));
  }
}

// DBML Association element > EntitySet or EntityRef between two table-mapped classes
class Association
{
  private TableClass thisClass;
  private String typeName, storage;

  public Association OtherSide {
    get { return Type.Associations.Find(a => a.Name == Name && a != this); }
  }
  public Boolean DeleteOnNull { get; private set; }
  public String DeleteRule { get; private set; }
  public Boolean IsForeignKey { get; private set; }
  public Boolean IsMany { get; private set; }
  public Boolean IsSerializable {
    get { return ((MemberAttributes & MemberAttributes.AccessMask) == MemberAttributes.Public); }
  }
  public Boolean IsUnique {
    get { return (!IsMany && !IsForeignKey); }
  }
  public Boolean ManagesKeys {
    get { return !(IsMany || (OtherSide == null) || !IsForeignKey); }
  }
  public String Member { get; private set; }
  public MemberAttributes MemberAttributes { get; private set; }
  public String Name { get; private set; }
  public IList<Column> OtherKey {
    get { return OtherKeyMembers.Select(o => Type.Columns.Single(c => c.Member == o)).ToList(); }
  }
  private String[] otherKeyMembers;
  public String[] OtherKeyMembers {
    get { return (otherKeyMembers != null) ? otherKeyMembers : Type.PrimaryKey.Select(p => p.Member).ToArray(); }
    set { otherKeyMembers = value; }
  }
  public String Storage { get { return storage ?? "_" + Member; } }
  public IList<Column> ThisKey {
    get { return ThisKeyMembers.Select(o => thisClass.Columns.Single(c => c.Member == o)).ToList(); }
  }
  private String[] thisKeyMembers;
  public String[] ThisKeyMembers {
    get { return (thisKeyMembers != null) ? thisKeyMembers : thisClass.PrimaryKey.Select(p => p.Member).ToArray(); }
    set { thisKeyMembers = value; }
  }
  public TableClass Type {
    get { return thisClass.Table.Data.TableClasses.Find(c => c.Name == typeName); }
  }
  
  public Association(TableClass thisClass, XElement xe) {
    this.thisClass = thisClass;
    typeName = (String) xe.Attribute("Type");
    String thisKey = ((String) xe.Attribute("ThisKey"));
    if (thisKey != null)
      thisKeyMembers = thisKey.Split(',');
    storage = (String) xe.Attribute("Storage");
    String otherKey = ((String) xe.Attribute("OtherKey"));
    if (otherKey != null)
      otherKeyMembers = otherKey.Split(',');
    DeleteOnNull = (Boolean?) xe.Attribute("DeleteOnNull") ?? false;
    DeleteRule = (String) xe.Attribute("DeleteRule");
    IsForeignKey = (xe.Attribute("IsForeignKey") != null);
    Member = (String) xe.Attribute("Member");
    MemberAttributes = Util.DecodeMemberAccess((String) xe.Attribute("AccessModifier")) | Util.DecodeMemberModifier((String) xe.Attribute("Modifier"));
    Name = (String) xe.Attribute("Name");
    String cardinality = (String) xe.Attribute("Cardinality");
    IsMany = (cardinality == null) ? !IsForeignKey : (cardinality.Equals("Many"));
  }
}

// DBML Function element (stored procedure) > Method on DataContext
class Function
{
  public List<Class> Classes { get; private set; }
  public Data Data { get; private set; }
  private Boolean? hasMultipleResults = null;
  public Boolean HasMultipleResults {
    get { return (hasMultipleResults.HasValue) ? hasMultipleResults.Value : Classes.Count() > 1; }
  }
  public String ID { get; private set; }
  public Boolean IsComposable { get; private set; }
  public MemberAttributes MemberAttributes { get; private set; }
  public String Method { get; private set; }
  public String Name { get; private set; }
  public List<Parameter> Parameters { get; private set; }
  public Return Return { get; private set; }
  public CodeTypeReference ReturnType {
    get {
      if (Return != null)
        return new CodeTypeReference(Return.Type);
      else
        if (HasMultipleResults)
          return new CodeTypeReference(typeof(IMultipleResults));
        else {
          CodeTypeReference typeRef = new CodeTypeReference(typeof(ISingleResult<>));
          typeRef.TypeArguments.Add(new CodeTypeReference(Classes[0].QualifiedName));
          return typeRef;
        }
    }
  }
  
  public Function(Data data, XElement xe) {
    Data = data;
    String hasMultiResultsElement = (String) xe.Attribute("HasMultipleResults");
    if (hasMultiResultsElement != null)
      hasMultipleResults = Boolean.Parse(hasMultiResultsElement);
    ID = (String) xe.Attribute("Id");
    IsComposable = (Boolean ?) xe.Attribute("IsComposable") ?? false;
    Name = (String) xe.Attribute("Name");
    Method = (String) xe.Attribute("Method");
    MemberAttributes = Util.DecodeMemberAccess((String) xe.Attribute("AccessModifier")) | Util.DecodeMemberModifier((String) xe.Attribute("Modifier"));
    Parameters = (from p in xe.Elements(Data.NS + "Parameter")
      select new Parameter(this, p)).ToList();
    Return = (from r in xe.Elements(Data.NS + "Return")
      select new Return(this, r)).SingleOrDefault();
    Classes = new List<Class>();
    foreach(XElement fxe in xe.Elements(Data.NS + "ElementType")) {
      String idRef = (String) fxe.Attribute("IdRef");
      if (idRef == null) {
        var functionClass = new FunctionClass(this, fxe);
        Classes.Add(functionClass);
        Data.FunctionClasses.Add(functionClass);
      }
      else
        Classes.Add(Data.TableClasses.Single(c => c.Id == idRef));
    }
  }
}

// Function return type -> Method return type
class Return
{
  private String typeName;
  public String DbType { get; private set; }
  public Function Function { get; private set; }
  public Type Type {
    get { return Data.GetType(typeName, false); }
  }
  
  public Return(Function function, XElement xe) {
    Function = function;
    DbType = (String) xe.Attribute("DbType");
    typeName = (String) xe.Attribute("Type");
  }
}

public enum ParameterDirection { In, Out, InOut };
public enum OperationType { Insert, Update, Delete };
public enum ArgumentVersion { Original, New };

// Function parameter -> Method parameter
class Parameter
{
  private String typeName;
  public String DbType { get; private set; }
  public Function Function { get; private set; }
  public String Name { get; private set; }
  public String DbName { get; private set; }
  public ParameterDirection Direction { get; private set; }
  public Type Type {
    get { return Data.GetType(typeName, true); }
  }
  
  public Parameter(Function function, XElement xe) {
    Function = function;
    DbName = (String) xe.Attribute("Name");
    Name = (String) xe.Attribute("Parameter") ?? DbName;
    DbType = (String) xe.Attribute("DbType");
    typeName = (String) xe.Attribute("Type");
    Direction = Util.ParseEnum((String) xe.Attribute("Direction"), ParameterDirection.In);
  }
}

// Functions associated with a table's CUD operations
class TableOperation
{
  private String functionID;
  private Function function;
  public List<Argument> Arguments { get; private set; }
  public OperationType Type { get; private set; }
  public Function Function {
    get {
      if ((function == null) && (!String.IsNullOrEmpty(functionID)))
        function = Table.Data.Functions.Where(f => f.ID == functionID).SingleOrDefault();
      return function;
    }
    set {
      function = value;
      functionID = null;
    }
  }
  public Table Table { get; private set; }
  public TableOperation(Table table, XElement xe) {
    Table = table;
    functionID = (String) xe.Attribute("FunctionId");
    Type = (OperationType) Enum.Parse(typeof(OperationType), xe.Name.LocalName.Replace("Function",""));
    Arguments = (from a in xe.Elements(Table.Data.NS + "Argument") select new Argument(this, a)).ToList();
  }
}

// Argument to a function
class Argument
{
  private String parameterName;
  private Parameter parameter;
  public TableOperation TableOperation;
  public Parameter Parameter {
    get {
      if ((parameter == null) && (!String.IsNullOrEmpty(parameterName)))
        parameter = TableOperation.Function.Parameters.Single(p => p.Name == parameterName);
      return parameter;
    }
    set {
      parameter = value;
      parameterName = null;
    }
  }
  public String Member { get; private set; }
  public ArgumentVersion Version { get; private set; }
  
  public Argument(TableOperation tableOperation, XElement xe) {
    TableOperation = tableOperation;
    parameterName = (String) xe.Attribute("Parameter");
    Member = (String) xe.Attribute("Member");
    Version = Util.ParseEnum((String) xe.Attribute("Version"), ArgumentVersion.New);
  }
}

abstract class CodeLanguage
{
  public CodeDomProvider CodeDomProvider { get; protected set; }
  public abstract String GetAccess(MemberAttributes memberAttributes);
  public abstract String GetAccess(TypeAttributes typeAttributes);
  public abstract String GetModifier(MemberAttributes memberAttributes);
  public abstract String GetModifier(TypeAttributes typeAttributes);
  
  public String Format(Type type) {
    return Format(new CodeTypeReference(type));
  }
  
  public virtual String ShortenTypeRef(String typeRef) {
    return (typeRef.LastIndexOf('.') != 6) ? typeRef.Replace("System.Data.Linq.","") : typeRef.Replace("System.","");
  }
  
  public String Format(CodeTypeReference codeTypeRef) {
    return ShortenTypeRef(CodeDomProvider.GetTypeOutput(codeTypeRef));
  }
  
  public abstract String Format(ParameterDirection direction);
  
  public String Format(MemberAttributes memberAttributes) {
    return GetAccess(memberAttributes) + GetModifier(memberAttributes);
  }

  public String Format(TypeAttributes typeAttributes) {
    return GetAccess(typeAttributes) + GetModifier(typeAttributes);
  }
}

class CSharpCodeLanguage : CodeLanguage
{
  public CSharpCodeLanguage() {
    CodeDomProvider = new Microsoft.CSharp.CSharpCodeProvider();
  }
  
  public override String Format(ParameterDirection direction) {
    switch(direction) {
      case ParameterDirection.InOut: return "ref ";
      case ParameterDirection.Out: return "out ";
      default: return "";
    }
  }

  public override String ShortenTypeRef(String typeRef) {
    if (typeRef.StartsWith("System.Nullable<"))
      typeRef = typeRef.Replace("System.Nullable<","").Replace(">","?");
    return base.ShortenTypeRef(typeRef);
  }

  public override String GetAccess(MemberAttributes memberAttributes) {
    switch(memberAttributes & MemberAttributes.AccessMask) {
      case MemberAttributes.Private: return "private ";
      case MemberAttributes.Public: return "public ";
      case MemberAttributes.Family: return "protected ";
      case MemberAttributes.Assembly: return "internal ";
      case MemberAttributes.FamilyAndAssembly: return "protected internal ";
      default: return memberAttributes.ToString();
    }
  }

  public override String GetAccess(TypeAttributes typeAttributes) {
    switch(typeAttributes & TypeAttributes.VisibilityMask) {
      case TypeAttributes.NestedPrivate: return "private ";
      case TypeAttributes.NestedAssembly: return "internal ";
      case TypeAttributes.NestedFamily: return "protected ";
      case TypeAttributes.NestedFamORAssem: return "protected internal ";
      default: return "public ";
    }
  }

  public override String GetModifier(MemberAttributes memberAttributes) {
    switch(memberAttributes & MemberAttributes.ScopeMask) {
      case MemberAttributes.Final: return "";
      case MemberAttributes.Abstract: return "abstract ";
      case MemberAttributes.Override: return "override ";
      default: return "virtual ";
    }
  }
  
  public override String GetModifier(TypeAttributes typeAttributes) {
    if ((typeAttributes & TypeAttributes.Abstract) != 0) return "abstract ";
    if ((typeAttributes & TypeAttributes.Sealed) != 0) return "sealed ";
    return "";
  }
}

class VBCodeLanguage : CodeLanguage
{
  public VBCodeLanguage() {
    CodeDomProvider = new Microsoft.VisualBasic.VBCodeProvider();
  }
  
  public override String Format(ParameterDirection direction) {
    switch(direction) {
      case ParameterDirection.InOut: return "ByRef ";
      case ParameterDirection.Out: return "ByRef ";
      default: return "";
    }
  }

  public override String GetAccess(MemberAttributes memberAttributes) {
    switch(memberAttributes & MemberAttributes.AccessMask) {
      case MemberAttributes.Private: return "Private ";
      case MemberAttributes.Public: return "Public ";
      case MemberAttributes.Family: return "Protected ";
      case MemberAttributes.Assembly: return "Friend ";
      case MemberAttributes.FamilyAndAssembly: return "Protected Friend ";
      default: return memberAttributes.ToString();
    }
  }
  
  public override String GetAccess(TypeAttributes typeAttributes) {
    switch(typeAttributes & TypeAttributes.VisibilityMask) {
      case TypeAttributes.NestedPrivate: return "Private ";
      case TypeAttributes.NestedAssembly: return "Friend ";
      case TypeAttributes.NestedFamily: return "Protected ";
      case TypeAttributes.NestedFamORAssem: return "protected internal ";
      default: return "Public ";
    }
  }

  public override String GetModifier(MemberAttributes memberAttributes) {
    switch(memberAttributes & MemberAttributes.ScopeMask) {
      case MemberAttributes.Final: return "";
      case MemberAttributes.Abstract: return "MustOverride ";
      case MemberAttributes.Override: return "Override ";
      default: return "Overridable ";
    }
  }
  
  public override String GetModifier(TypeAttributes typeAttributes) {
    if ((typeAttributes & TypeAttributes.Abstract) != 0) return "MustInherit ";
    if ((typeAttributes & TypeAttributes.Sealed) != 0) return "NotInheritable ";
    return "";
  }
}

// Manager class records the various blocks so it can split them up
class Manager
{
  private struct Block {
    public String Name;
    public int Start, Length;
  }
  
  private List<Block> blocks = new List<Block>();
  private Block currentBlock;
  private Block footerBlock = new Block();
  private Block headerBlock = new Block();
  private ITextTemplatingEngineHost host;
  private ManagementStrategy strategy;
  private StringBuilder template;
  public String OutputPath { get; set; }
  
  public Manager(ITextTemplatingEngineHost host, StringBuilder template, bool commonHeader) {
    this.host = host;
    this.template = template;
    OutputPath = String.Empty;
    strategy = ManagementStrategy.Create(host);   
  }
    
  public void StartBlock(String name) {
    currentBlock = new Block { Name = name, Start = template.Length };
  }

  public void StartFooter() {
    footerBlock.Start = template.Length;
  }
  
  public void EndFooter() {
    footerBlock.Length = template.Length - footerBlock.Start;
  }
  
  public void StartHeader() {
    headerBlock.Start = template.Length;
  }
  
  public void EndHeader() {
    headerBlock.Length = template.Length - headerBlock.Start;
  } 

  public void EndBlock() {
    currentBlock.Length = template.Length - currentBlock.Start;
    blocks.Add(currentBlock);
  }
    
  public void Process(bool split) {
    String header = template.ToString(headerBlock.Start, headerBlock.Length);
    String footer = template.ToString(footerBlock.Start, footerBlock.Length);
    blocks.Reverse();   
    foreach(Block block in blocks) {
      String fileName = Path.Combine(OutputPath, block.Name);
      if (split) {
        String content = header + template.ToString(block.Start, block.Length) + footer;
        strategy.CreateFile(fileName, content);
        template.Remove(block.Start, block.Length);
      } else {
        strategy.DeleteFile(fileName);
      }
    }
  }

  public string GetCustomToolNamespace(string fileName) {
    return strategy.GetCustomToolNamespace(fileName);
  }
  
  public string DefaultProjectNamespace {
    get { return strategy.DefaultProjectNamespace; }
  }
}

class ManagementStrategy
{
  internal static ManagementStrategy Create(ITextTemplatingEngineHost host) {
    return (host is IServiceProvider) ? new VSManagementStrategy(host) : new ManagementStrategy(host);
  }

  internal ManagementStrategy(ITextTemplatingEngineHost host) { }

  internal virtual void CreateFile(String fileName, String content) {
    File.WriteAllText(fileName, content);
  }
  
  internal virtual void DeleteFile(String fileName) {
    if (File.Exists(fileName))
      File.Delete(fileName);
  }
  
  internal virtual string DefaultProjectNamespace {
    get { return null; }
  }
    
  internal virtual string GetCustomToolNamespace(string fileName) {
    return null;
  }
}

class VSManagementStrategy : ManagementStrategy
{
  private EnvDTE.ProjectItem templateProjectItem;
  private EnvDTE.DTE dte;
  
  internal VSManagementStrategy(ITextTemplatingEngineHost host) : base(host) {
    IServiceProvider hostServiceProvider = (IServiceProvider)host;
    if(hostServiceProvider == null)
      throw new ArgumentNullException("Could not obtain hostServiceProvider");
    
    dte = (EnvDTE.DTE)hostServiceProvider.GetService(typeof(EnvDTE.DTE));
    if(dte == null)
      throw new ArgumentNullException("Could not obtain DTE from host");
    
    templateProjectItem = dte.Solution.FindProjectItem(host.TemplateFile);      
  }
  
  internal override void CreateFile(String fileName, String content) {
    base.CreateFile(fileName, content);
    ((EventHandler)delegate { templateProjectItem.ProjectItems.AddFromFile(fileName); }).BeginInvoke(null, null, null, null);
  }
  
  internal override void DeleteFile(String fileName) {
    ((EventHandler)delegate { FindAndDeleteFile(fileName); }).BeginInvoke(null, null, null, null);
  }
  
  private void FindAndDeleteFile(String fileName) { 
    foreach(EnvDTE.ProjectItem projectItem in templateProjectItem.ProjectItems) {
      if (projectItem.get_FileNames(0) == fileName) {
        projectItem.Delete();
        return;
      }
    }
  }

  internal override string DefaultProjectNamespace {
    get { return templateProjectItem.ContainingProject.Properties.Item("DefaultNamespace").Value.ToString(); }
  }
  
  internal override string GetCustomToolNamespace(string fileName) {
    return dte.Solution.FindProjectItem(fileName).Properties.Item("CustomToolNamespace").Value.ToString();
  }
}

// Methods that deserve a better home
public static class Util
{
  public static T ParseEnum<T>(String value, T defaultValue) where T:struct {
    try { return (T)Enum.Parse(typeof(T), value); }
    catch { return defaultValue; }
  }
  
  public static MemberAttributes DecodeMemberAccess(String access) {
    switch(access) {
      case "Private": return MemberAttributes.Private;
      case "Internal": return MemberAttributes.Assembly;
      case "Protected": return MemberAttributes.Family;
      case "ProtectedInternal": return MemberAttributes.FamilyAndAssembly;
      default: return MemberAttributes.Public;
    }
  }
  
  public static MemberAttributes DecodeMemberModifier(String modifier) {
    switch(modifier) {
      case "Virtual": return 0;
      case "Override": return MemberAttributes.Override;
      default: return MemberAttributes.Final;
    }
  }
}

class TypeStub : System.Reflection.TypeDelegator
{
  private String name;
  
  public TypeStub(String name) : base(typeof(System.Enum)) {
    this.name = name;
  }
  
  public override String Name {
    get { return name; }
  }
  
  public override String FullName {
    get { return name; }
  }
}#>