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 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 CodeNamespaceCollection(CodeNamespaceCollection value) {}
