private static void ApplyBaseClassToClass(Shape end, ClassElement startElement)
{
var endClass = end as UmlClass;
var endElement = (endClass.DataSource as UmlClassData).Owner.Type as ClassElement;
startElement.Inherits = endElement.Name;
}
private void AddClass()
{
var element = new ClassElement();
element.Name = "New Class";
DiagramNode.Parent.GetChild <NamespaceElement>().AddChild(element);
}
GenerateChildrenSample()
{
var list = new List <IDiscriminatedElement>();
var ns = new NameSpaceElement(new PhysicalStorage(PathA));
AttachName(ns, NameSpaceA);
var sample = new InterfaceElement(ns, ScopeCategories.Public, false, false);
list.Add(AttachName(sample, "ISample"));
IDiscriminatedElement tmp = new InterfaceElement(sample, ScopeCategories.Public, false, false);
AttachName(tmp, "IInner");
list.Add(tmp);
tmp = new StructElement(sample, ScopeCategories.Public, false, false);
AttachName(tmp, "StructInner");
list.Add(tmp);
tmp = new ClassElement(sample, ScopeCategories.Public, false, false, false, false, false);
AttachName(tmp, "ReferenceInner");
list.Add(tmp);
yield return(sample, list);
}
public void CreateIndexer()
{
TestUtils.InitializeDefaultExtensionPoints();
_indexerPath = Path.GetTempPath() + "luceneindexer";
Directory.CreateDirectory(_indexerPath);
_solutionKey = new SolutionKey(Guid.NewGuid(), "C:/SolutionPath");
ServiceLocator.RegisterInstance(_solutionKey);
ServiceLocator.RegisterInstance <Analyzer>(new SimpleAnalyzer());
_indexer = new DocumentIndexer(TimeSpan.FromSeconds(1));
ServiceLocator.RegisterInstance(_indexer);
ClassElement classElement = SampleProgramElementFactory.GetSampleClassElement(
accessLevel: AccessLevel.Public,
definitionLineNumber: 11,
extendedClasses: "SimpleClassBase",
fullFilePath: "C:/Projects/SimpleClass.cs",
implementedInterfaces: "IDisposable",
name: "SimpleName",
namespaceName: "Sanod.Indexer.UnitTests"
);
SandoDocument sandoDocument = DocumentFactory.Create(classElement);
_indexer.AddDocument(sandoDocument);
MethodElement methodElement = SampleProgramElementFactory.GetSampleMethodElement(
accessLevel: AccessLevel.Protected,
name: "SimpleName",
returnType: "Void",
fullFilePath: "C:/stuff"
);
sandoDocument = DocumentFactory.Create(methodElement);
_indexer.AddDocument(sandoDocument);
}
private ClassElement AddClass(string line)
{
var @class = new ClassElement(line);
_classes.Add(@class);
return @class;
}
public void ClassInheritanceTest()
{
bool seenClass = false;
var parser = new SrcMLCSharpParser(generator);
var elements = parser.Parse("TestFiles\\InheritanceCSharpFile.txt");
Assert.IsNotNull(elements);
Assert.IsTrue(elements.Count > 0);
foreach (ProgramElement pe in elements)
{
if (pe is ClassElement)
{
ClassElement classElem = (ClassElement)pe;
if (classElem.Name == "IndexerException")
{
seenClass = true;
Assert.AreEqual(classElem.DefinitionLineNumber, 8);
Assert.AreEqual(classElem.AccessLevel, AccessLevel.Public);
Assert.AreEqual(classElem.Namespace, "Sando.Indexer.Exceptions");
//TODO - make this not dependent upon your path...
//Assert.AreEqual(classElem.FullFilePath, "C:\\Users\\kosta\\sando\\Parser\\Parser.UnitTests\\TestFiles\\InheritanceCSharpFile.txt");
Assert.AreEqual(classElem.ExtendedClasses, "SandoException");
}
}
}
Assert.IsTrue(seenClass);
}
public void ParseClassTest()
{
bool seenClass = false;
var parser = new SrcMLCSharpParser(generator);
var elements = parser.Parse("TestFiles\\ShortCSharpFile.txt");
Assert.IsNotNull(elements);
Assert.IsTrue(elements.Count > 0);
foreach (ProgramElement pe in elements)
{
if (pe is ClassElement)
{
ClassElement classElem = (ClassElement)pe;
if (classElem.Name == "SrcMLGenerator")
{
seenClass = true;
Assert.AreEqual(classElem.DefinitionLineNumber, 14);
Assert.AreEqual(classElem.AccessLevel, AccessLevel.Public);
Assert.AreEqual(classElem.Namespace, "Sando.Parser");
Assert.True(classElem.FullFilePath.EndsWith("TestFiles\\ShortCSharpFile.txt"));
}
}
}
Assert.IsTrue(seenClass);
}
private void AppendBaseTypes(ClassElement entity, StringBuilder builder)
{
// 扩展属性
if (entity.BaseTypes.Contains("ExtendBase"))
{
builder.AppendLine(" .Column(x => x.ExtendProperties)");
}
else if (entity.BaseTypes.Contains("CategoryBase"))
{
builder.AppendLine(" .Column(x => x.Id)");
builder.AppendLine(" .Column(x => x.Name)");
if (_file.IsUsing("Gentings.Saas.Categories"))
{
builder.AppendLine(" .Column(x => x.SiteId)");
}
}
else if (entity.BaseTypes.Any(x => x.StartsWith("GroupBase<")))
{
builder.AppendLine(" .Column(x => x.Id)");
builder.AppendLine(" .Column(x => x.Name)");
builder.AppendLine(" .Column(x => x.ParentId)");
if (_file.IsUsing("Gentings.Saas.Groups"))
{
builder.AppendLine(" .Column(x => x.SiteId)");
}
}
}
private ClassElement ParseClass(string item)
{
ClassElement cls = new ClassElement();
ParseGeneric(cls, item);
return(cls);
}
private ClassElement AddClass(string line)
{
var @class = new ClassElement(line);
_classes.Add(@class);
return(@class);
}
public CodeBuilder(string className)
{
_className = className;
_classElement = new ClassElement()
{
Name = className
};
}
public ProjectElement Parse(String[] inputfiles)
{
ProjectElement project = new ProjectElement();
// Open file
using (CoverageInfo info = JoinCoverageFiles(inputfiles))
{
CoverageDS dataSet = info.BuildDataSet();
Dictionary <String, PackageElement> packages = new Dictionary <String, PackageElement>();
Dictionary <uint, string> files = new Dictionary <uint, string>();
// Namespaces
DataTable namespacesTable = dataSet.Tables["NameSpaceTable"];
DataTable classesTable = dataSet.Tables["Class"];
DataTable filesTable = dataSet.Tables["SourceFileNames"];
CreateIndexPackages(project, namespacesTable, packages);
CreateIndexFiles(filesTable, files);
foreach (DataRow iclass in classesTable.Rows)
{
string className = System.Security.SecurityElement.Escape((string)iclass["ClassName"]);
ClassElement ce = new ClassElement(className);
DataRow[] methodRows = iclass.GetChildRows("Class_Method");
foreach (DataRow imethod in methodRows)
{
// Get First Line in class
DataRow[] lineRows = imethod.GetChildRows("Method_Lines");
bool includeFile = lineRows.Length < 1 ? false : files.ContainsKey(lineRows[0].Field <uint>("SourceFileID"));
if (includeFile)
{
string methodName = (string)imethod["MethodName"]; // System.Security.SecurityElement.Escape((string)imethod["MethodName"]);
MethodElement me = new MethodElement(methodName);
uint coveredBlocks = (uint)imethod["BlocksCovered"];
uint totalBlocks = coveredBlocks + (uint)imethod["BlocksNotCovered"];
uint coveredLines = (uint)imethod["LinesCovered"];
uint totalLines = coveredLines + (uint)imethod["LinesNotCovered"] + (uint)imethod["LinesPartiallyCovered"];
me.Metrics = new MethodMetrics(totalBlocks, coveredBlocks, totalLines, coveredLines);
ce.AddMethod(me);
}
}
if (packages.ContainsKey((string)iclass["NamespaceKeyName"]))
{
PackageElement pe = packages[(string)iclass["NamespaceKeyName"]];
pe.AddClass(ce);
}
}
}
return(project);
}
public RazorPageTransfer(FileInfo file)
: base(file)
{
_file = new FileElement(Source);
Entity = _file.GetTypes <ClassElement>()
.Where(x => x.IsDefined("Table"))
.FirstOrDefault();
FileName = $"{Entity.Name}Query.cs";
}
public static Document GetLuceneDocument()
{
ClassElement element = SampleProgramElementFactory.GetSampleClassElement();
Document document = DocumentFactory.Create(element).GetDocument();
document.Add(new Field("Bam", "Zaow", Field.Store.YES, Field.Index.ANALYZED));
document.RemoveField(ProgramElement.CustomTypeTag);
document.Add(new Field(ProgramElement.CustomTypeTag, typeof(MyCustomClassForTesting).AssemblyQualifiedName, Field.Store.YES, Field.Index.NO));
return(document);
}
public void InvalidRegisterChildTest()
{
var ns = new NameSpaceElement(new PhysicalStorage(PathA));
var sample = new DelegateElement(ns, ScopeCategories.Public, false);
AttachName(sample, "BinOp");
Assert.Throws <ArgumentException>(() =>
_ = new InterfaceElement(sample, ScopeCategories.Public, false, false));
Assert.Throws <ArgumentException>(() =>
_ = new ClassElement(sample, ScopeCategories.Public, false, false, false, false, false));
}
public void Generate()
{
CSharpFile customTypeManagerGenerator = new CSharpFile();
customTypeManagerGenerator.Name = string.Format("{0}TypeManager", name);
customTypeManagerGenerator.cSharpFileElements.Add(new UsingElement(typeof(CustomTypeGenerator)));
customTypeManagerGenerator.cSharpFileElements.Add(new UsingElement(typeof(CreateAssetMenuAttribute)));
customTypeManagerGenerator.cSharpFileElements.Add(new UsingElement(typeof(SerializableAttribute)));
customTypeManagerGenerator.cSharpFileElements.Add(new NewLineElement());
NamespaceElement namespaceElement = new NamespaceElement(string.IsNullOrEmpty(@namespace) ? "CustomType" : @namespace);
customTypeManagerGenerator.cSharpFileElements.Add(namespaceElement);
ClassElement managerClass = new ClassElement(string.Format("{0}TypeManager", name));
managerClass.ClassAttributes.Add(new CreateAssetMenuElement(name));
managerClass.DerivedFrom = new SingletonTypeManagerElement(string.Format("{0}TypeManager", name));
namespaceElement.cSharpFileElements.Add(managerClass);
ClassElement typeClass = new ClassElement(name);
typeClass.ClassAttributes.Add(new AttributeElement(typeof(SerializableAttribute)));
typeClass.DerivedFrom = new CustomTypeEelemnt();
namespaceElement.cSharpFileElements.Add(typeClass);
customTypeManagerGenerator.Save(string.Format("{0}/{1}", path, name));
CSharpFile propertyGenerator = new CSharpFile();
propertyGenerator.cSharpFileElements.Add(new UsingElement(typeof(CustomPropertyDrawer)));
propertyGenerator.cSharpFileElements.Add(new UsingElement(typeof(CustomTypeGenerator)));
propertyGenerator.cSharpFileElements.Add(new UsingElement(typeof(CreateAssetMenuAttribute)));
propertyGenerator.cSharpFileElements.Add(namespaceElement);
ClassElement propertyClass = new ClassElement(string.Format("{0}PropertyDrower", name));
propertyGenerator.Name = propertyClass.Name;
propertyClass.DerivedFrom = new TypePropertyDrowerElement(managerClass.Name);
propertyClass.ClassAttributes.Add(new WeaponModeTypePropertyDrowerAttributeElement(typeClass.Name));
namespaceElement.cSharpFileElements.Clear();
namespaceElement.cSharpFileElements.Add(propertyClass);
propertyGenerator.Save(string.Format("{0}/{1}/Editor", path, name));
AssetDatabase.Refresh();
}
private ClassElement GetClassImpl()
{
if (classElem == null)
{
VCCodeClass targetClassElem = GetClassCodeElem();
if (targetClassElem != null)
{
classElem = new ClassElement(targetClassElem, this);
}
}
return(classElem);
}
public override List <Field> GetFieldsForLucene()
{
List <Field> fields = new List <Field>();
ClassElement classElement = (ClassElement)programElement;
fields.Add(new Field(SandoField.Namespace.ToString(), classElement.Namespace.ToSandoSearchable(), Field.Store.YES, Field.Index.ANALYZED));
AddBodyField(fields, new Field(SandoField.Body.ToString(), classElement.Body.ToSandoSearchable(), Field.Store.NO, Field.Index.ANALYZED));
fields.Add(new Field(SandoField.AccessLevel.ToString(), classElement.AccessLevel.ToString().ToLower(), Field.Store.YES, Field.Index.NOT_ANALYZED));
fields.Add(new Field(SandoField.ExtendedClasses.ToString(), classElement.ExtendedClasses.ToSandoSearchable(), Field.Store.YES, Field.Index.ANALYZED));
fields.Add(new Field(SandoField.ImplementedInterfaces.ToString(), classElement.ImplementedInterfaces.ToSandoSearchable(), Field.Store.YES, Field.Index.ANALYZED));
fields.Add(new Field(SandoField.Modifiers.ToString(), classElement.Modifiers, Field.Store.YES, Field.Index.ANALYZED));
return(fields);
}
private AddDocumentContainer AddModel(IEnumerable <PropertyElement> properties)
{
string projectName = "TestApp";
List <UsingElement> usingElements = new List <UsingElement>()
{
new UsingElement("System.ComponentModel.DataAnnotations")
};
var namespaceElement = new NamespaceElement($"{projectName}");
var classElement = new ClassElement(this.ModelName, "public", properties);
var documentElement = new DocumentElement(usingElements, namespaceElement, classElement);
return(new AddDocumentContainer(projectName, this.ModelName, documentElement));
}
// End of code changes
private void ParseProperties(List <ProgramElement> programElements, XElement elements, string fileName)
{
IEnumerable <XElement> props =
from el in elements.Descendants(SRC.Declaration)
where el.Element(SRC.Name) != null &&
el.Element(SRC.Type) != null &&
el.Element(SRC.Block) != null &&
el.Elements().Count() == 3
select el;
foreach (XElement prop in props)
{
string name;
int definitionLineNumber;
int definitionColumnNumber;
SrcMLParsingUtils.ParseNameAndLineNumber(prop, out name, out definitionLineNumber, out definitionColumnNumber);
ClassElement classElement = SrcMLParsingUtils.RetrieveClassElement(prop, programElements);
Guid classId = classElement != null ? classElement.Id : Guid.Empty;
string className = classElement != null ? classElement.Name : String.Empty;
//parse access level and type
XElement accessElement = prop.Element(SRC.Type);
AccessLevel accessLevel = SrcMLParsingUtils.RetrieveAccessLevel(accessElement);
IEnumerable <XElement> types = prop.Element(SRC.Type).Elements(SRC.Name);
//oops, namespaces have the same structure in srcml so need this check
if (types.Count() == 0 || types.First().Value == "namespace")
{
continue;
}
string propertyType = String.Empty;
foreach (XElement type in types)
{
propertyType += type.Value + " ";
}
propertyType = propertyType.TrimEnd();
string body = SrcMLParsingUtils.ParseBody(prop);
string fullFilePath = System.IO.Path.GetFullPath(fileName);
string source = SrcMLParsingUtils.RetrieveSource(prop);
programElements.Add(new PropertyElement(name, definitionLineNumber, definitionColumnNumber, fullFilePath, source, accessLevel, propertyType, body, classId, className, String.Empty));
}
}
public void DocumentIndexer_AddDocumentDoesNotThrowWhenValidData()
{
try
{
_documentIndexer = new DocumentIndexer();
ClassElement classElement = SampleProgramElementFactory.GetSampleClassElement();
SandoDocument sandoDocument = DocumentFactory.Create(classElement);
Assert.NotNull(sandoDocument);
Assert.NotNull(sandoDocument.GetDocument());
_documentIndexer.AddDocument(sandoDocument);
}
catch (Exception ex)
{
Assert.Fail(ex.Message + ". " + ex.StackTrace);
}
}
private static ClassElement ParseClass(TextReader sr)
{
string line;
ClassElement classEl = new ClassElement()
{
MaxScale = double.MaxValue,
MinScale = double.MinValue,
Styles = new List <StyleElement>()
};
while ((line = sr.ReadLine()) != null)
{
line = TrimFixLine(line);
string[] parts = ParseLine(line);
if (parts != null && parts.Length > 0)
{
if (string.Compare(parts[0], "END", StringComparison.InvariantCultureIgnoreCase) == 0)
{
return(classEl);
}
else if (string.Compare(parts[0], "STYLE", StringComparison.InvariantCultureIgnoreCase) == 0)
{
classEl.Styles.Add(ParseStyle(sr));
}
else if (string.Compare(parts[0], "MAXSCALEDENOM", StringComparison.InvariantCultureIgnoreCase) == 0)
{
classEl.MaxScale = Convert.ToDouble(parts[1], CultureInfo.InvariantCulture);
}
else if (string.Compare(parts[0], "MINSCALEDENOM", StringComparison.InvariantCultureIgnoreCase) == 0)
{
classEl.MinScale = Convert.ToDouble(parts[1], CultureInfo.InvariantCulture);
}
else if (string.Compare(parts[0], "EXPRESSION", StringComparison.InvariantCultureIgnoreCase) == 0)
{
classEl.Expression = parts[1];
}
else if (string.Compare(parts[0], "NAME", StringComparison.InvariantCultureIgnoreCase) == 0)
{
classEl.Name = parts[1];
}
}
}
return(null);
}
private void Load(IDiagram diagram)
{
string notation = diagram.CreateGenerator().Generate();
var stringReader = new StringReader(notation);
Queue <string> lines = stringReader.ReadAllLines();
while (lines.Count > 0)
{
string line = lines.Dequeue();
if (line.StartsWith("class") && line.EndsWith("{"))
{
ClassElement @class = this.AddClass(line);
@class.Load(DequeueTo("}", lines));
}
}
}
public override ParseResult Parse()
{
var element = new ClassElement();
element
.Add(ParseKeyword(Keywords.Class))
.Add(ParseIdentifier())
.Add(ParseSymbol(Symbols.OpeningCurlyBrace))
.Add(ParseZeroOrMore(
ClassVariableDeclarationParser.IsClassVariableDeclaration,
ElementCategory.ClassVariableDeclaration))
.Add(ParseZeroOrMore(
ClassSubroutineDeclarationParser.IsClassSubroutineDeclaration,
ElementCategory.ClassSubroutineDeclaration))
.Add(ParseSymbol(Symbols.ClosingCurlyBrace));
return(new ParseResult(ConsumedTokensCount, element));
}
public void ProgramElementReader_ReadProgramElementFromDocumentReturnValidClassElementForValidDocument()
{
ClassElement element = SampleProgramElementFactory.GetSampleClassElement();
Document document = DocumentFactory.Create(element).GetDocument();
ClassElement returnedElement = ConverterFromHitToProgramElement.Create(document).Convert() as ClassElement;
Assert.IsNotNull(returnedElement, "returned class element is null!");
Assert.True(element.AccessLevel == returnedElement.AccessLevel, "AccessLevel is different!");
Assert.True(element.DefinitionLineNumber == returnedElement.DefinitionLineNumber, "DefinitionLineNumber is different!");
Assert.True(element.ExtendedClasses == returnedElement.ExtendedClasses, "ExtendedClasses is different!");
Assert.True(StandardizeFilePath(element.FullFilePath) == returnedElement.FullFilePath, "FullFilePath is different!");
Assert.True(element.ImplementedInterfaces == returnedElement.ImplementedInterfaces, "ImplementedInterfaces is different!");
Assert.True(element.Name == returnedElement.Name, "Name is different!");
Assert.True(element.Namespace == returnedElement.Namespace, "Namespace is different!");
Assert.True(element.ProgramElementType == returnedElement.ProgramElementType, "ProgramElementType is different!");
Assert.True(element.RawSource == returnedElement.RawSource, "Snippet is different!");
}
private static FieldElement ParseField(List <ProgramElement> programElements, string fileName, XElement field)
{
try
{
string name;
int definitionLineNumber;
int definitionColumnNumber;
SrcMLParsingUtils.ParseNameAndLineNumber(field, out name, out definitionLineNumber, out definitionColumnNumber);
ClassElement classElement = RetrieveClassElement(field, programElements);
Guid classId = classElement != null ? classElement.Id : Guid.Empty;
string className = classElement != null ? classElement.Name : String.Empty;
//parse access level and type
var typeElement = field.Element(SRC.Type);
AccessLevel accessLevel = RetrieveAccessLevel(typeElement);
IEnumerable <XElement> types = typeElement.Elements(SRC.Name);
string fieldType = String.Empty;
foreach (XElement type in types)
{
fieldType += type.Value + " ";
}
fieldType = fieldType.TrimEnd();
string initialValue = String.Empty;
XElement initialValueElement = field.Element(SRC.Init);
if (initialValueElement != null)
{
initialValue = initialValueElement.Element(SRC.Expression).Value;
}
string fullFilePath = System.IO.Path.GetFullPath(fileName);
string snippet = RetrieveSource(field);
return(new FieldElement(name, definitionLineNumber, definitionColumnNumber, fullFilePath, snippet, accessLevel, fieldType, classId, className, String.Empty, initialValue));
}
catch (Exception error)
{
Type t = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
LogEvents.ParserGenericException(t, error);
return(null);
}
}
public void MethodLinksToClassTest()
{
return;
//NOTE: this test fails because of a bug in srcML
//please turn this test back on once we receive a fix
//from the srcML guys
SrcMLCSharpParser parser = new SrcMLCSharpParser();
var elements = parser.Parse("..\\..\\Parser\\Parser.UnitTests\\TestFiles\\ImageCaptureCS.txt");
ClassElement ImageCaptureClassElement = null;
bool foundMethod = false;
// first find the class element
foreach (ProgramElement pe in elements)
{
if (pe is ClassElement)
{
ClassElement cls = (ClassElement)pe;
if (cls.Name == "ImageCapture")
{
ImageCaptureClassElement = cls;
}
}
}
// then the method element that should link to it
foreach (ProgramElement pe in elements)
{
if (pe is MethodElement)
{
MethodElement method = (MethodElement)pe;
if (method.Name == "CaptureByHdc")
{
foundMethod = true;
Assert.AreEqual(method.ClassId, ImageCaptureClassElement.Id);
Assert.AreEqual(method.ClassName, ImageCaptureClassElement.Name);
}
}
}
Assert.IsTrue(foundMethod);
}
GenerateGetAncestorsSample()
{
var list = new List <IDiscriminatedElement>();
IDiscriminatedElement parent = new NameSpaceElement(new PhysicalStorage(PathA));
AttachName(parent, NameSpaceA);
list.Add(parent);
parent = new ClassElement(parent, ScopeCategories.Public, false, false, false, false, false);
AttachName(parent, "Envelope");
list.Add(parent);
var sample = new EnumElement(parent, ScopeCategories.Public);
AttachName(sample, "Sample");
list.Reverse();
yield return(sample, list);
}
/// <summary>
/// 转换Xml为Dictionary，以便程序处理
/// </summary>
/// <returns></returns>
public Dictionary <string, object> ToDictionary()
{
base.Init();
//1.从配置文件:autocode.config.xml获取配置信息
string Save_Dir = App_Dir + "autocode.config.xml";
if (!File.Exists(Save_Dir))
{
return(null);
}
XDocument xmlDoc = XDocument.Load(Save_Dir);
Dictionary <string, object> dict = new Dictionary <string, object>();
List <XElement> lists = xmlDoc.XPathSelectElements("classes/class").ToList();
string className = "";
foreach (XElement ClassElement in lists)
{
className = ClassElement.Attribute("name").Value;
List <XElement> listConditions = ClassElement.XPathSelectElements("conditions/condition").ToList();
List <Dictionary <string, string> > conditions = new List <Dictionary <string, string> >();
Dictionary <string, object> ClassDict = new Dictionary <string, object>();
foreach (XElement ConditionElement in listConditions)
{
Dictionary <string, string> dictCondition = new Dictionary <string, string>();
dictCondition.Add("ConditionName", ConditionElement.Value);
if (ConditionElement.HasAttributes)
{
dictCondition.Add("RelationClass", ConditionElement.Attribute("relation_class").Value);
dictCondition.Add("ShowName", ConditionElement.Attribute("show_name").Value);
}
conditions.Add(dictCondition);
}
ClassDict.Add("Conditions", conditions);
dict.Add(className, ClassDict);
}
return(dict);
}
protected override IEnumerable <(InterfaceElement sample, IQualified expected)> GenerateQualifiedNameSample()
{
IDiscriminatedElement parent = new NameSpaceElement(new PhysicalStorage(PathA));
AttachName(parent, "NameSpace");
parent = new ClassElement(parent, ScopeCategories.Public, false, false, false, false, false);
AttachName(parent, "Class");
var sample = new InterfaceElement(parent, ScopeCategories.Public, false, false);
AttachName(sample, "ISample");
var expected = new QualifiedElement();
_ = new IdentityElement(expected, ScopeCategories.Public, IdentityCategories.Namespace, "NameSpace");
_ = new IdentityElement(expected, ScopeCategories.Public, IdentityCategories.Class, "Class");
_ = new IdentityElement(expected, ScopeCategories.Public, IdentityCategories.Interface, "ISample");
yield return(sample, expected);
}
GenerateDescendantsSample()
{
var list = new List <IDiscriminatedElement>();
var ns = new NameSpaceElement(new PhysicalStorage(PathA));
AttachName(ns, NameSpaceA);
var sample = new InterfaceElement(ns, ScopeCategories.Public, false, false);
var q = new QualifiedElement(sample);
list.Add(q);
list.Add(new IdentityElement(q, "ISample"));
IDiscriminatedElement child =
new ClassElement(sample, ScopeCategories.Public, false, false, false, false, false);
q = new QualifiedElement(child);
list.Add(child);
list.Add(q);
list.Add(new IdentityElement(q, "InnerClass"));
child = new StructElement(sample, ScopeCategories.Public, false, false);
q = new QualifiedElement(child);
list.Add(child);
list.Add(q);
list.Add(new IdentityElement(q, "InnerStruct"));
yield return(sample, list);
child = new StructElement(child, ScopeCategories.Public, false, false);
q = new QualifiedElement(child);
list.Add(child);
list.Add(q);
list.Add(new IdentityElement(q, "InnerInner"));
yield return(sample, list);
}
protected string XSDToCppType(ClassElement element)
{
string retVal = string.Empty;
switch (element.Type)
{
case XmlTypeCode.Float:
retVal = "double"; break;
case XmlTypeCode.Short:
switch (_targetLanguage)
{
case TargetLanguage.CSharp:
retVal = "Int16"; break;
default:
retVal = "int"; break;
} break;
case XmlTypeCode.Byte:
retVal = "byte"; break;
case XmlTypeCode.String:
switch (_targetLanguage)
{
case TargetLanguage.CPP:
retVal = "tstring"; break;
case TargetLanguage.CPP_CLI:
retVal = "String"; break;
case TargetLanguage.CSharp:
retVal = "string"; break;
default:
retVal = "tstring"; break;
}break;
case XmlTypeCode.Long:
retVal = "long"; break;
case XmlTypeCode.Double:
retVal = "double"; break;
case XmlTypeCode.Decimal:
switch (_targetLanguage)
{
case TargetLanguage.CPP:
retVal = "double"; break;
case TargetLanguage.CPP_CLI:
retVal = "System::Decimal"; break;
case TargetLanguage.CSharp:
retVal = "System.Decimal"; break;
default:
retVal = "double"; break;
}break;
case XmlTypeCode.Int:
case XmlTypeCode.Integer:
case XmlTypeCode.PositiveInteger:
case XmlTypeCode.NegativeInteger:
retVal = "int"; break;
case XmlTypeCode.Boolean:
retVal = "bool"; break;
case XmlTypeCode.Element:
retVal = element.CustomType; break;
case XmlTypeCode.DateTime:
case XmlTypeCode.Date:
retVal = _targetLanguage == TargetLanguage.CPP ? "void" : "System" + NamespaceToken + "DateTime"; break;
default:
retVal = _targetLanguage == TargetLanguage.CPP ? "void" : "Object"; break;
}
return AppendCaretIfRequired(element, retVal);
}
private static ClassElement ParseClass(StreamReader sr, Map m)
{
string line;
ClassElement classel = new ClassElement()
{
MaxScale = double.MaxValue,
MinScale = double.MinValue,
Styles = new List<StyleElement>()
};
while ((line = sr.ReadLine()) != null)
{
line = TrimFixLine(line);
string[] parts = ParseLine(line);
if (parts != null && parts.Length > 0)
{
if (string.Compare(parts[0],"END",true) == 0)
{
return classel;
}
else if (string.Compare(parts[0], "STYLE", true) == 0)
{
classel.Styles.Add(ParseStyle(sr));
}
else if (string.Compare(parts[0], "MAXSCALEDENOM", true) == 0)
{
classel.MaxScale = Convert.ToDouble(parts[1], CultureInfo.InvariantCulture);
}
else if (string.Compare(parts[0], "MINSCALEDENOM", true) == 0)
{
classel.MinScale = Convert.ToDouble(parts[1], CultureInfo.InvariantCulture);
}
else if (string.Compare(parts[0], "EXPRESSION", true) == 0)
{
classel.Expression = parts[1];
}
else if (string.Compare(parts[0], "NAME", true) == 0)
{
classel.Name= parts[1];
}
}
}
return null;
}
protected String AppendCaretIfRequired(ClassElement element, String str)
{
if (_targetLanguage == TargetLanguage.CPP_CLI)
{
String caret = "";
switch (element.Type)
{
case XmlTypeCode.AnyAtomicType:
break;
case XmlTypeCode.AnyUri:
break;
case XmlTypeCode.Attribute:
break;
case XmlTypeCode.Base64Binary:
break;
case XmlTypeCode.Boolean:
break;
case XmlTypeCode.Byte:
break;
case XmlTypeCode.Comment:
break;
case XmlTypeCode.Date:
caret = "^";
break;
case XmlTypeCode.DateTime:
caret = "^";
break;
case XmlTypeCode.DayTimeDuration:
break;
case XmlTypeCode.Decimal:
break;
case XmlTypeCode.Document:
break;
case XmlTypeCode.Double:
break;
case XmlTypeCode.Duration:
break;
case XmlTypeCode.Element:
break;
case XmlTypeCode.Entity:
break;
case XmlTypeCode.Float:
break;
case XmlTypeCode.GDay:
break;
case XmlTypeCode.GMonth:
break;
case XmlTypeCode.GMonthDay:
break;
case XmlTypeCode.GYear:
break;
case XmlTypeCode.GYearMonth:
break;
case XmlTypeCode.HexBinary:
break;
case XmlTypeCode.Id:
break;
case XmlTypeCode.Idref:
caret = "^";
break;
case XmlTypeCode.Int:
break;
case XmlTypeCode.Integer:
break;
case XmlTypeCode.Item:
break;
case XmlTypeCode.Language:
break;
case XmlTypeCode.Long:
break;
case XmlTypeCode.NCName:
break;
case XmlTypeCode.Name:
break;
case XmlTypeCode.Namespace:
break;
case XmlTypeCode.NegativeInteger:
break;
case XmlTypeCode.NmToken:
break;
case XmlTypeCode.Node:
break;
case XmlTypeCode.NonNegativeInteger:
break;
case XmlTypeCode.NonPositiveInteger:
break;
case XmlTypeCode.None:
break;
case XmlTypeCode.NormalizedString:
break;
case XmlTypeCode.Notation:
break;
case XmlTypeCode.PositiveInteger:
break;
case XmlTypeCode.ProcessingInstruction:
break;
case XmlTypeCode.QName:
break;
case XmlTypeCode.Short:
break;
case XmlTypeCode.String:
caret = "^";
break;
case XmlTypeCode.Text:
break;
case XmlTypeCode.Time:
break;
case XmlTypeCode.Token:
break;
case XmlTypeCode.UnsignedByte:
break;
case XmlTypeCode.UnsignedInt:
break;
case XmlTypeCode.UnsignedLong:
break;
case XmlTypeCode.UnsignedShort:
break;
case XmlTypeCode.UntypedAtomic:
break;
case XmlTypeCode.YearMonthDuration:
break;
default:
break;
}
str += caret;
}
return str;
}
protected string CreateFormattedVectorDeclaration(ClassElement var)
{
if (var.CustomType == null) return String.Format("{0}_VECTOR", var.Type);
string[] cParts = var.CustomType.Split("::".ToCharArray());
string cName = cParts[cParts.Length - 1];
string collectionTypeDecl = String.Format("{0}_VECTOR", cName);
return collectionTypeDecl;
}
protected string GetDefaultsString(ClassElement e, Dictionary<String, List<EnumElement>> enumsToGenerateMap)
{
string retString = "";
XmlTypeCode type = e.Type;
if (e.IsEnum)
{
string nspace = string.Empty;
retString = enumsToGenerateMap[e.CustomType][0].Name;
nspace = enumsToGenerateMap[e.CustomType][0].NameSpace;
if (_targetLanguage == TargetLanguage.CSharp || _targetLanguage == TargetLanguage.JAVA)
return nspace + "." + retString;
else
return nspace + "::" + retString;
}
switch (type)
{
case XmlTypeCode.AnyAtomicType:
break;
case XmlTypeCode.AnyUri:
break;
case XmlTypeCode.Attribute:
break;
case XmlTypeCode.Base64Binary:
break;
case XmlTypeCode.Boolean: retString = "false";
break;
case XmlTypeCode.Byte: retString = "0";
break;
case XmlTypeCode.Comment:
break;
case XmlTypeCode.Date:
break;
case XmlTypeCode.DateTime:
break;
case XmlTypeCode.DayTimeDuration:
break;
case XmlTypeCode.Decimal:
switch (_targetLanguage)
{
case TargetLanguage.CSharp:
retString = "default(decimal)"; break;
case TargetLanguage.CPP_CLI:
retString = "0"; break;
default:
retString = "0.0"; break;
} break;
case XmlTypeCode.Document:
break;
case XmlTypeCode.Double:
switch (_targetLanguage)
{
case TargetLanguage.CSharp:
retString = "default(double)"; break;
default:
retString = "0.0"; break;
} break;
case XmlTypeCode.Duration:
break;
case XmlTypeCode.Element:
break;
case XmlTypeCode.Entity:
break;
case XmlTypeCode.Float: retString = "0.0";
break;
case XmlTypeCode.GDay:
break;
case XmlTypeCode.GMonth:
break;
case XmlTypeCode.GMonthDay:
break;
case XmlTypeCode.GYear:
break;
case XmlTypeCode.GYearMonth:
break;
case XmlTypeCode.HexBinary: retString = "0";
break;
case XmlTypeCode.Id:
break;
case XmlTypeCode.Idref:
break;
case XmlTypeCode.Int: retString = "0";
break;
case XmlTypeCode.Integer: retString = "0";
break;
case XmlTypeCode.Item:
break;
case XmlTypeCode.Language:
break;
case XmlTypeCode.Long: retString = "0";
break;
case XmlTypeCode.NCName:
break;
case XmlTypeCode.Name:
break;
case XmlTypeCode.Namespace:
break;
case XmlTypeCode.NegativeInteger: retString = "0";
break;
case XmlTypeCode.NmToken:
break;
case XmlTypeCode.Node:
break;
case XmlTypeCode.NonNegativeInteger: retString = "0";
break;
case XmlTypeCode.NonPositiveInteger: retString = "0";
break;
case XmlTypeCode.None:
break;
case XmlTypeCode.NormalizedString:
break;
case XmlTypeCode.Notation:
break;
case XmlTypeCode.PositiveInteger: retString = "0";
break;
case XmlTypeCode.ProcessingInstruction:
break;
case XmlTypeCode.QName:
break;
case XmlTypeCode.Short: retString = "0";
switch (_targetLanguage)
{
case TargetLanguage.CSharp:
retString = "default(Int16)"; break;
default:
retString = "0"; break;
} break;
case XmlTypeCode.String: retString = "";
break;
case XmlTypeCode.Text: retString = "";
break;
case XmlTypeCode.Time:
break;
case XmlTypeCode.Token:
break;
case XmlTypeCode.UnsignedByte: retString = "0";
break;
case XmlTypeCode.UnsignedInt: retString = "0";
break;
case XmlTypeCode.UnsignedLong: retString = "0";
break;
case XmlTypeCode.UnsignedShort: retString = "0";
break;
case XmlTypeCode.UntypedAtomic:
break;
case XmlTypeCode.YearMonthDuration:
break;
default:
break;
}
return retString;
}
