public TypescriptCodeProvider()
 {
     var unity = new UnityContainer();
     var startup = new Startup(unity);
     startup.Initialize();
     _codeGenerator = unity.Resolve<ICodeGenerator>();
 }

		public static void Generate (DataSet dataSet,
			CodeNamespace codeNamespace,
			ICodeGenerator codeGen)
		{
			CustomDataClassGenerator.CreateDataSetClasses (
				dataSet, codeNamespace, codeGen, null);
		}

 public MethodVirtualizer(IMethodVirtualizerInfoWrapper wrapper, ICodeGenerator codeGenerator)
 {
     ArgumentUtility.CheckNotNull ("wrapper", wrapper);
       ArgumentUtility.CheckNotNull ("codeGenerator", codeGenerator);
       _wrapper = wrapper;
       _codeGenerator = codeGenerator;
 }

        public static CodeGenFile[] Generate(ICodeGeneratorDataProvider provider, string directory, ICodeGenerator[] codeGenerators)
        {
            directory = GetSafeDir(directory);
            CleanDir(directory);

            var generatedFiles = new List<CodeGenFile>();

            foreach (var generator in codeGenerators.OfType<IPoolCodeGenerator>()) {
                var files = generator.Generate(provider.poolNames);
                generatedFiles.AddRange(files);
                writeFiles(directory, files);
            }

            foreach (var generator in codeGenerators.OfType<IComponentCodeGenerator>()) {
                var files = generator.Generate(provider.componentInfos);
                generatedFiles.AddRange(files);
                writeFiles(directory, files);
            }

            foreach (var generator in codeGenerators.OfType<IBlueprintsCodeGenerator>()) {
                var files = generator.Generate(provider.blueprintNames);
                generatedFiles.AddRange(files);
                writeFiles(directory, files);
            }

            return generatedFiles.ToArray();
        }

        public override void ToSpecifiedRegister(ICodeGenerator g, Register result)
        {
            string opCode;
              string shifter;
              int multiplier;
              switch(array.ExpressionType) {
            case ExpressionType.WordArray:
              opCode="LDR";
              shifter=",LSL 2";
              multiplier=4;
              break;

            case ExpressionType.ByteArray:
              opCode="LDRB";
              shifter="";
              multiplier=1;
              break;

            default:
              throw new Exception("Can't index an expression of type "+array.ExpressionType);
              }

              throw new NotImplementedException("NIY");
            //
            //      array.LoadToNewRegister(g, arrayRegister =>
            //        index.ToRegisterOrImmediate(g,
            //          indexRegister => g.Emit(OpCodes.TODO, opCode+" "+result+",["+arrayRegister+",+"+indexRegister+shifter+"]"),
            //          indexImmediate => g.Emit(OpCodes.TODO, opCode+" "+result+",["+arrayRegister+",+#"+indexImmediate*multiplier+"]")));
        }

 public SchemaBrowserVM(ISchemaBrowserModel iSchemaBrowserModel, ICodeGenerator iCodeGenerator, DbConnectionInfo dbConnectionInfo)
 {
     model = iSchemaBrowserModel;
     codeGenerator = iCodeGenerator;
     currentDb = dbConnectionInfo;
     GeneratCodeCommand = new DelegateCommand<object>(GeneratCode);
 }

        // given a variable name, this method will check to see if the 
        // name is a valid identifier name. if this is not the case, then
        // at the moment will replace all the blank space with underscores.
        public static string GenerateIdName(string name, ICodeGenerator codeGen) {
            if (codeGen.IsValidIdentifier(name)) {
                return name;
            }

            string ret = name.Replace(' ', '_');
            if (! codeGen.IsValidIdentifier(ret)) {
                ret = "_" + ret;
                UnicodeCategory unc;
                for (int i = 1; i < ret.Length; i++) {
                    unc = Char.GetUnicodeCategory(ret[i]);
                    if (
                        UnicodeCategory.UppercaseLetter      != unc &&  
                        UnicodeCategory.LowercaseLetter      != unc &&  
                        UnicodeCategory.TitlecaseLetter      != unc &&
                        UnicodeCategory.ModifierLetter       != unc &&
                        UnicodeCategory.OtherLetter          != unc &&
                        UnicodeCategory.LetterNumber         != unc &&
                        UnicodeCategory.NonSpacingMark       != unc &&
                        UnicodeCategory.SpacingCombiningMark != unc &&
                        UnicodeCategory.DecimalDigitNumber   != unc &&
                        UnicodeCategory.ConnectorPunctuation != unc 
                    ) {
                        ret = ret.Replace(ret[i], '_');
                    } // if
                } // for
            }

            return ret;
        }

 public CommandProxies(ITypeDiscoverer typeDiscoverer, ITypeImporter typeImporter, ICodeGenerator codeGenerator, WebConfiguration configuration)
 {
     _typeDiscoverer = typeDiscoverer;
     _typeImporter = typeImporter;
     _codeGenerator = codeGenerator;
     
     _configuration = configuration;
 }

 public ReservationController(ITwilioMessageRepository repository, IMessageProvider<TwilioMessage> twilioMessageProvider,
                           IPersonRepository personRepository, ICodeGenerator codeGenerator)
 {
     _twilioRepository = repository;
       _personRepository = personRepository;
       _twilioMessageProvider = twilioMessageProvider;
       _codeGenerator = codeGenerator;
 }

        public virtual void Initialize()
        {
            DependenciesMock = new Mock<ICodeGeneratorDependencies>();

            ArgumentsMock = new Mock<ICodeGeneratorGenerateArguments>();

            CodeGenerator = new Logics.CodeGenerator(DependenciesMock.Object);
        }

	public Phase2Parser( TokenizerBase tokenStream,
						 ICodeGenerator gen )
	 : base(tokenStream)
		{
		this.gen = gen;
		
		loops = new Stack();
		withs = new Stack();
		} // Phase2Parser constructor

 public EntityFrameworkMappingGenerator(
     ICodeGenerator codeGenerator,
     IPluginsContainer<IConceptMapping> plugins,
     ILogProvider logProvider)
 {
     _plugins = plugins;
     _codeGenerator = codeGenerator;
     _performanceLogger = logProvider.GetLogger("Performance");
 }

 // overcome bug in ANTLR 3.2
 public TemplateParser(ITokenStream input, RecognizerSharedState state, ICodeGenerator gen, TemplateName enclosingTemplateName)
     : base(null, null)
 {
     this.input = input;
     this.state = state;
     if (gen != null)
         this.gen = gen;
     this._enclosingTemplateName = enclosingTemplateName;
 }

 public CaptchaMiddleware(
     RequestDelegate next,
     ICodeGenerator codeGenerator,
     IGraphicGenerator graphicGenerator)
 {
     _next = next;
     _codeGenerator = codeGenerator;
     _graphicGenerator = graphicGenerator;
 }

 public QueryProxies(
     ITypeDiscoverer typeDiscoverer,
     ICodeGenerator codeGenerator,
     WebConfiguration configuration)
 {
     _typeDiscoverer = typeDiscoverer;
     _codeGenerator = codeGenerator;
     _configuration = configuration;
 }

 public CompositeClassGenerator(
     BaseCustomTool customTool, ICodeGenerator codeGenerator, string inputFileName)
 {
     _codeGenerator = codeGenerator;
     _inputFileName = inputFileName;
     _vsHelper = new VsHelper();
     EnvDTE.Project project = _vsHelper.GetProject();
     _assemblies = _vsHelper.GetReferencedAssemblies(customTool, false);
     _projectDirectory = _vsHelper.GetProjectDirectory();
 }

 public CommandSecurityProxies(
     ITypeDiscoverer typeDiscoverer,
     ICodeGenerator codeGenerator,
     ICommandSecurityManager commandSecurityManager,
     WebConfiguration configuration)
 {
     _typeDiscoverer = typeDiscoverer;
     _codeGenerator = codeGenerator;
     _configuration = configuration;
     _commandSecurityManager = commandSecurityManager;
 }

 public NHibernateMappingGenerator(
     ICodeGenerator codeGenerator,
     IPluginsContainer<IConceptMappingCodeGenerator> plugins,
     IDomainObjectModel domainObjectModel,
     ILogProvider logProvider)
 {
     _plugins = plugins;
     _codeGenerator = codeGenerator;
     _domainObjectModel = domainObjectModel;
     _performanceLogger = logProvider.GetLogger("Performance");
 }

        public static void Generate(ICodeGeneratorDataProvider provider, string directory, ICodeGenerator[] codeGenerators) {
            directory = GetSafeDir(directory);
            CleanDir(directory);
            
            foreach (var generator in codeGenerators.OfType<IPoolCodeGenerator>()) {
                writeFiles(directory, generator.Generate(provider.poolNames));
            }

            foreach (var generator in codeGenerators.OfType<IComponentCodeGenerator>()) {
                writeFiles(directory, generator.Generate(provider.componentInfos));
            }
        }

        public static void Generate()
        {
            var generatedFolder = getEntitasProjectDir() + "/Tests/Tests/Entitas/CodeGenerator/Fixtures/Generated/";

            var codeGenerators = new ICodeGenerator[] {
                new ComponentExtensionsGenerator(),
                new ComponentIndicesGenerator(),
                new ContextAttributesGenerator(),
                new ContextsGenerator(),
                new BlueprintsGenerator()
            };

            var types = new [] {
                typeof(AnimatingComponent),
                typeof(CComponent),
                typeof(ComponentWithFieldsAndProperties),
                typeof(CustomPrefixComponent),
                typeof(DefaultContextComponent),
                typeof(MovableComponent),
                typeof(MultipleContextAndDefaultContextComponent),
                typeof(NamespaceComponent),
                typeof(OtherContextComponent),
                typeof(PersonComponent),
                typeof(SomeClass),
                typeof(SomeClassHideInBlueprintInspector),
                typeof(SomeStruct),
                typeof(UserComponent)
            };

            var contexts = new [] {
                "ContextA",
                "ContextB",
                "ContextC",
                "OtherContext",
                "SomeContext",
                "SomeOtherContext"
            };

            var blueprints = new [] {
                "Gem",
                "Blocker"
            };

            var provider = new TypeReflectionProvider(types, contexts, blueprints);
            var files = CodeGenerator.Generate(provider, generatedFolder, codeGenerators);

            foreach(var file in files) {
                Console.WriteLine("Generated: " + file.fileName);
            }

            Console.WriteLine("Done. Press any key...");
            Console.Read();
        }