private static IEnumerable <CodeNamespace> SafeToEnumerable(CodeNamespaceCollection collection) { foreach (CodeNamespace @namespace in collection) { yield return(@namespace); } }
internal static void FixStandardNamespacesAndRootNamespace(CodeNamespaceCollection codeNamespaces, string rootNS, SupportedLanguages language) { if (language == SupportedLanguages.VB) { foreach (CodeNamespace namespace2 in codeNamespaces) { if (namespace2.Name == rootNS) { namespace2.Name = string.Empty; namespace2.UserData.Add("TruncatedNamespace", null); } else if (namespace2.Name.StartsWith(rootNS + ".", StringComparison.Ordinal)) { namespace2.Name = namespace2.Name.Substring(rootNS.Length + 1); namespace2.UserData.Add("TruncatedNamespace", null); } } } foreach (CodeNamespace namespace3 in codeNamespaces) { Hashtable hashtable = new Hashtable(); foreach (CodeNamespaceImport import in namespace3.Imports) { hashtable.Add(import.Namespace, import); } foreach (string str in standardNamespaces) { if (!hashtable.Contains(str)) { namespace3.Imports.Add(new CodeNamespaceImport(str)); } } } }
public void AddRange() { CodeNamespace ns1 = new CodeNamespace(); CodeNamespace ns2 = new CodeNamespace(); CodeNamespace ns3 = new CodeNamespace(); CodeNamespaceCollection coll1 = new CodeNamespaceCollection(); coll1.Add(ns1); coll1.Add(ns2); CodeNamespaceCollection coll2 = new CodeNamespaceCollection(); coll2.Add(ns3); coll2.AddRange(coll1); Assert.AreEqual(3, coll2.Count, "#1"); Assert.AreEqual(1, coll2.IndexOf(ns1), "#2"); Assert.AreEqual(2, coll2.IndexOf(ns2), "#3"); Assert.AreEqual(0, coll2.IndexOf(ns3), "#4"); CodeNamespaceCollection coll3 = new CodeNamespaceCollection(); coll3.Add(ns3); coll3.AddRange(new CodeNamespace[] { ns1, ns2 }); Assert.AreEqual(3, coll2.Count, "#5"); Assert.AreEqual(1, coll2.IndexOf(ns1), "#6"); Assert.AreEqual(2, coll2.IndexOf(ns2), "#7"); Assert.AreEqual(0, coll2.IndexOf(ns3), "#8"); }
public override CodeNamespaceCollection GenerateClassesToGenerate(Activity activity, Dictionary <string, string> variables) { JavaActivity javaActivity = (JavaActivity)activity; var javaNamespace = new CodeNamespace(javaActivity.PackageName); // Generate the Service javaNamespace.Imports.AddRange(this.GenerateImports()); var javaClass = this.GenerateClass(javaActivity); javaClass.Members.Add(this.GenerateInvokeMethod()); javaNamespace.Types.Add(javaClass); var codeNameSpaces = new CodeNamespaceCollection { javaNamespace }; // Generate the corresponding interface if (ConfigurationApp.GetProperty("IsJavaInterfaceAlreadyGenerated") != "true") { //TODO : Refactor because it's a bit dirty var javaServiceInterfaceNameSpace = InterfaceExtractorFromClass.Extract(javaClass, TargetAppNameSpaceService.javaToolsNameSpace()); javaServiceInterfaceNameSpace.Types[0].Name = IJavaActivityService; codeNameSpaces.Add(javaServiceInterfaceNameSpace); ConfigurationApp.SaveProperty("IsJavaInterfaceAlreadyGenerated", "true"); } return(codeNameSpaces); }
public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) { var collection = new CodeNamespaceCollection(); AssertExtensions.Throws <ArgumentOutOfRangeException>("index", () => collection[index]); AssertExtensions.Throws <ArgumentOutOfRangeException>("index", () => collection[index] = new CodeNamespace()); }
/// <summary>Finds the client type by name in the provided collection of namespaces.</summary> /// <param name="typeName">The name of the client type for which to search.</param> /// <param name="namespaces">The collection of namespaces to search.</param> /// <returns>The client type if found; otherwise, null.</returns> internal static CodeTypeDeclaration FindClientType(string typeName, CodeNamespaceCollection namespaces) { return((from ns in namespaces.Cast <CodeNamespace>() from type in ns.Types.Cast <CodeTypeDeclaration>() where type.Name == typeName select type).FirstOrDefault()); }
public void Should_Return_One_DataAccess_Classes_To_Generate_When_JdbcQueryActivity_is_Mapped() { SqlRequestToActivityMapper.ClearActivityHasSet(); CodeNamespaceCollection classToGenerate = jdbcQueryActivityBuilder.GenerateClassesToGenerate(jdbcQueryActivity, new Dictionary <string, string>()); Assert.AreEqual("CurrencyDataAccess", classToGenerate [0].Types[0].Name); }
protected CodeTypeDeclaration GetCodeTypeDeclaration(CodeGenerationManager manager, string fullClassName) { if (manager == null) { throw new ArgumentNullException("manager"); } if (fullClassName == null) { throw new ArgumentNullException("fullClassName"); } string namespaceName; string className; Helpers.GetNamespaceAndClassName(fullClassName, out namespaceName, out className); CodeNamespaceCollection codeNamespaces = manager.Context[typeof(CodeNamespaceCollection)] as CodeNamespaceCollection; if (codeNamespaces == null) { throw new InvalidOperationException(SR.GetString(SR.Error_ContextStackItemMissing, typeof(CodeNamespaceCollection).Name)); } CodeNamespace codeNS = null; return(Helpers.GetCodeNamespaceAndClass(codeNamespaces, namespaceName, className, out codeNS)); }
private CodeNamespaceCollection GenerateProcessVariablesNamespaces(TibcoBWProcess tibcoBwProcessToGenerate) { var processVariableNameNamespaces = new CodeNamespaceCollection(); if (tibcoBwProcessToGenerate.ProcessVariables != null) { foreach (var item in tibcoBwProcessToGenerate.ProcessVariables) { if (!CodeDomUtils.IsBasicType(item.Parameter.Type)) { try { processVariableNameNamespaces.Add( this.xsdClassGenerator.Build(item.ObjectXNodes, TargetAppNameSpaceService.myAppName() + "." + tibcoBwProcessToGenerate.VariablesNameSpace)); } catch (Exception e) { Log.Error( "unable to generate Process Variable object class for this process: " + tibcoBwProcessToGenerate.ProcessName, e); } } } } return(processVariableNameNamespaces); }
static CodeNamespace[] _ToArray(CodeNamespaceCollection refs) { var result = new CodeNamespace[refs.Count]; refs.CopyTo(result, 0); return(result); }
protected virtual void ThrowOnNoTypes(CodeNamespaceCollection namespaces, string element) { if (namespaces.Count == 0) { throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, Properties.Resources.CodeGenerationElementWithoutType, element)); } }
public void Constructor1_NullItem() { CodeNamespace[] namespaces = new CodeNamespace[] { new CodeNamespace(), null }; CodeNamespaceCollection coll = new CodeNamespaceCollection( namespaces); }
public void AddRange_Self() { CodeNamespaceCollection coll = new CodeNamespaceCollection(); coll.Add(new CodeNamespace()); Assert.AreEqual(1, coll.Count, "#1"); coll.AddRange(coll); Assert.AreEqual(2, coll.Count, "#2"); }
public void Should_Return_One_Method_With_no_inputParameter() { this.jdbcQueryActivity.Type = ActivityType.jdbcCallActivityType; this.jdbcQueryActivity.QueryStatementParameters = new Dictionary <string, string> (); this.jdbcQueryActivityBuilder.ServiceToInvoke = "MyService"; CodeNamespaceCollection classToGenerate = jdbcQueryActivityBuilder.GenerateClassesToGenerate(jdbcQueryActivity, new Dictionary <string, string>()); Assert.AreEqual(0, ((CodeMemberMethod)(classToGenerate [0].Types[0].Members[3])).Parameters.Count); }
public void Constructor0() { CodeNamespaceCollection coll = new CodeNamespaceCollection(); Assert.IsFalse(((IList)coll).IsFixedSize, "#1"); Assert.IsFalse(((IList)coll).IsReadOnly, "#2"); Assert.AreEqual(0, coll.Count, "#3"); Assert.IsFalse(((ICollection)coll).IsSynchronized, "#4"); Assert.IsNotNull(((ICollection)coll).SyncRoot, "#5"); }
public static CodeNamespace Find(this CodeNamespaceCollection collection, string name) { foreach (CodeNamespace ns in collection) { if (ns.Name == name) { return(ns); } } return(null); }
public void ItemSet_Get_ReturnsExpected() { var value1 = new CodeNamespace(); var value2 = new CodeNamespace(); var collection = new CodeNamespaceCollection(); collection.Add(value1); collection[0] = value2; Assert.Equal(1, collection.Count); Assert.Same(value2, collection[0]); }
public override CodeNamespaceCollection GenerateClassesToGenerate(Activity activity, Dictionary <string, string> variables) { var result = new CodeNamespaceCollection(); if (ConfigurationApp.GetProperty("IsEngineCommandServiceAlreadyGenerated") != "true") { result.AddRange(this.engineCommandServiceHelperBuilder.Build()); ConfigurationApp.SaveProperty("IsEngineCommandServiceAlreadyGenerated", "true"); } return(result); }
public CodeNamespaceCollection GenerateClassesToGenerate(Activity activity, Dictionary <string, string> variables) { var namespaces = new CodeNamespaceCollection(); if (ConfigurationApp.GetProperty("IsSubscriberInterfaceAlreadyGenerated") != "true") { namespaces.AddRange(this.subscriberBuilder.GenerateClasses()); ConfigurationApp.SaveProperty("IsSubscriberInterfaceAlreadyGenerated", "true"); } return(namespaces); }
public void Constructor1() { CodeNamespace ns1 = new CodeNamespace(); CodeNamespace ns2 = new CodeNamespace(); CodeNamespace[] namespaces = new CodeNamespace[] { ns1, ns2 }; CodeNamespaceCollection coll = new CodeNamespaceCollection( namespaces); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(ns1), "#2"); Assert.AreEqual(1, coll.IndexOf(ns2), "#3"); }
public static CodeNamespace Add(this CodeNamespaceCollection namespaces, string @namespace, params string [] imports) { var codeNamespace = new CodeNamespace(@namespace); foreach (var import in imports) { codeNamespace.Imports.Add(new CodeNamespaceImport(import)); } namespaces.Add(codeNamespace); return(codeNamespace); }
public void Constructor1_Deny_Unrestricted() { CodeNamespaceCollection coll = new CodeNamespaceCollection(array); coll.CopyTo(array, 0); Assert.AreEqual(1, coll.Add(cn), "Add"); Assert.AreSame(cn, coll[0], "this[int]"); coll.AddRange(array); coll.AddRange(coll); Assert.IsTrue(coll.Contains(cn), "Contains"); Assert.AreEqual(0, coll.IndexOf(cn), "IndexOf"); coll.Insert(0, cn); coll.Remove(cn); }
private static void RemoveXmlDocumentation(CodeNamespaceCollection namespaces) { foreach (CodeNamespace @namespace in namespaces) { RemoveXmlDocumentation(@namespace.Comments); foreach (CodeTypeDeclaration typeDeclaration in @namespace.Types) { RemoveXmlDocumentation(typeDeclaration.Comments); foreach (CodeTypeMember typeMember in typeDeclaration.Members) { RemoveXmlDocumentation(typeMember.Comments); } } } }
public void Insert() { CodeNamespace ns1 = new CodeNamespace(); CodeNamespace ns2 = new CodeNamespace(); CodeNamespaceCollection coll = new CodeNamespaceCollection(); coll.Add(ns1); Assert.AreEqual(1, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(ns1), "#2"); coll.Insert(0, ns2); Assert.AreEqual(2, coll.Count, "#3"); Assert.AreEqual(1, coll.IndexOf(ns1), "#4"); Assert.AreEqual(0, coll.IndexOf(ns2), "#5"); }
public CodeNamespaceCollection GenerateClassesToGenerate(Activity groupActivity, Dictionary <string, string> variables) { this.activityNameToServiceNameDictionnary = new Dictionary <string, CodeStatementCollection>(); var activities = ((GroupActivity)groupActivity).Activities; var activityBuilderFactory = new ActivityBuilderFactory(); var activityClasses = new CodeNamespaceCollection(); foreach (var activity in activities) { var activityBuilder = activityBuilderFactory.Get(activity.Type); activityClasses.AddRange(activityBuilder.GenerateClassesToGenerate(activity, variables)); this.activityNameToServiceNameDictionnary.Add(activity.Name, activityBuilder.GenerateInvocationCode(activity, variables)); } return(activityClasses); }
public void Constructor2() { CodeNamespace ns1 = new CodeNamespace(); CodeNamespace ns2 = new CodeNamespace(); CodeNamespaceCollection c = new CodeNamespaceCollection(); c.Add(ns1); c.Add(ns2); CodeNamespaceCollection coll = new CodeNamespaceCollection(c); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(ns1), "#2"); Assert.AreEqual(1, coll.IndexOf(ns2), "#3"); }
public void Remove() { CodeNamespace cns1 = new CodeNamespace(); CodeNamespace cns2 = new CodeNamespace(); CodeNamespaceCollection coll = new CodeNamespaceCollection(); coll.Add(cns1); coll.Add(cns2); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(cns1), "#2"); Assert.AreEqual(1, coll.IndexOf(cns2), "#3"); coll.Remove(cns1); Assert.AreEqual(1, coll.Count, "#4"); Assert.AreEqual(-1, coll.IndexOf(cns1), "#5"); Assert.AreEqual(0, coll.IndexOf(cns2), "#6"); }
/// <summary> /// Writes each types in each namespaces into individual files. /// </summary> /// <param name="outputdir">name of directory to write to.</param> public virtual void WriteTypes(string outputdir) { var cscp = new CSharpCodeProvider(); var opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; opts.BlankLinesBetweenMembers = false; CodeNamespaceCollection nsc = CompileUnit.Namespaces; for (int i = 0; i < nsc.Count; i++) { var ns = nsc[i]; string dir = outputdir; foreach (string name in CodeGenUtil.Instance.UnMangle(ns.Name).Split('.')) { dir = Path.Combine(dir, name); } Directory.CreateDirectory(dir); var new_ns = new CodeNamespace(ns.Name); new_ns.Comments.Add(CodeGenUtil.Instance.FileComment); foreach (CodeNamespaceImport nci in CodeGenUtil.Instance.NamespaceImports) { new_ns.Imports.Add(nci); } var types = ns.Types; for (int j = 0; j < types.Count; j++) { var ctd = types[j]; string file = Path.Combine(dir, Path.ChangeExtension(CodeGenUtil.Instance.UnMangle(ctd.Name), "cs")); using (var writer = new StreamWriter(file, false)) { new_ns.Types.Add(ctd); cscp.GenerateCodeFromNamespace(new_ns, writer, opts); new_ns.Types.Remove(ctd); } } } }
public override CodeNamespaceCollection GenerateClassesToGenerate(Activity activity, Dictionary <string, string> variables) { var result = new CodeNamespaceCollection(); if (activity.ObjectXNodes != null) { try { result.Add(this.xsdBuilder.Build(activity.ObjectXNodes, this.TargetNamespace(activity))); } catch (System.Exception) { return(null); } } return(result); }
/// <summary> /// Writes each types in each namespaces into individual files /// </summary> /// <param name="outputdir">name of directory to write to</param> public virtual void WriteTypes(string outputdir) { CodeDomProvider cscp = DoJava ? (CodeDomProvider) Type.GetType("Microsoft.VJSharp.VJSharpCodeProvider").GetConstructor( new Type[0]).Invoke(new object[0]) : new CSharpCodeProvider(); var opts = new CodeGeneratorOptions(); opts.BracingStyle = "C"; opts.IndentString = "\t"; opts.BlankLinesBetweenMembers = false; CodeNamespaceCollection nsc = CompileUnit.Namespaces; for (int i = 0; i < nsc.Count; i++) { var ns = nsc[i]; string dir = outputdir + "\\" + CodeGenUtil.Instance.UnMangle(ns.Name).Replace('.', '\\'); Directory.CreateDirectory(dir); var new_ns = new CodeNamespace(ns.Name); new_ns.Comments.Add(CodeGenUtil.Instance.FileComment); foreach (CodeNamespaceImport nci in CodeGenUtil.Instance.NamespaceImports) { new_ns.Imports.Add(nci); } var types = ns.Types; for (int j = 0; j < types.Count; j++) { var ctd = types[j]; string file = dir + "\\" + CodeGenUtil.Instance.UnMangle(ctd.Name) + (DoJava ? ".java" : ".cs"); using (var writer = new StreamWriter(file, false)) { new_ns.Types.Add(ctd); cscp.GenerateCodeFromNamespace(new_ns, writer, opts); new_ns.Types.Remove(ctd); } } } }
public void AddRange(CodeNamespaceCollection value) {}
public NamespaceHelper(CodeNamespaceCollection namespaces) { this.codeNamespaces = namespaces; }
public void Item_InvalidIndex_ThrowsArgumentOutOfRangeException(int index) { var collection = new CodeNamespaceCollection(); Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index]); Assert.Throws<ArgumentOutOfRangeException>("index", () => collection[index] = new CodeNamespace()); }
private static void VerifyCollection(CodeNamespaceCollection collection, CodeNamespace[] contents) { Assert.Equal(contents.Length, collection.Count); for (int i = 0; i < contents.Length; i++) { CodeNamespace content = contents[i]; Assert.Equal(i, collection.IndexOf(content)); Assert.True(collection.Contains(content)); Assert.Same(content, collection[i]); } const int Index = 1; var copy = new CodeNamespace[collection.Count + Index]; collection.CopyTo(copy, Index); Assert.Null(copy[0]); for (int i = Index; i < copy.Length; i++) { Assert.Same(contents[i - Index], copy[i]); } }
public CodeNamespaceCollection(CodeNamespaceCollection value) {}