private void ParseTypes()
{
var pi = 0;
for (int i = 0; i < _solution.Projects.Count; i++)
{
pi = i;
var types = _solution.Projects[i].Compilation.MainAssembly.TopLevelTypeDefinitions.ToList();
for (int j = 0; j < types.Count; j++)
{
if (types[j].Kind != TypeKind.Delegate)
{
PostProgress(_sdBuildStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name), j, types.Count, pi, _solution.Projects.Count);
var sdType = CreateSDType(types[j]);
EventParser.ParseMinimalFields(sdType, types[j]);
PropertyParser.ParseMinimalProperties(sdType, types[j]);
FieldParser.ParseMinimalFields(sdType, types[j]);
MethodParser.ParseMinimalConstructors(sdType, types[j]);
MethodParser.ParseMinimalMethods(sdType, types[j]);
_repository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier);
}
}
}
}
protected internal static Field[] ParseFields(System.Xml.XmlElement template, ParsingContext context)
{
System.Xml.XmlNodeList childNodes = template.ChildNodes;
var fields = new List <Field>();
for (int i = 0; i < childNodes.Count; i++)
{
System.Xml.XmlNode item = childNodes.Item(i);
if (IsElement(item))
{
if ("typeRef".Equals(item.Name) || "length".Equals(item.Name))
{
continue;
}
var element = (System.Xml.XmlElement)item;
FieldParser fieldParser = context.GetFieldParser(element);
if (fieldParser == null)
{
context.ErrorHandler.Error(Error.FastConstants.PARSE_ERROR, "No parser registered for " + element.Name);
}
if (fieldParser != null)
{
fields.Add(fieldParser.Parse(element, context));
}
}
}
return(fields.ToArray());
}
/// <summary>
/// Le Main
/// </summary>
/// <param name="args">
/// Program arguments
/// </param>
public static void Main(string[] args)
{
var counter = 1;
// repeat until "0 0" is entered for dimension size input
while (true)
{
// read dimension
Console.Write("Field dimension (format 'n m'): ");
string dimensionInput = Console.ReadLine();
if (String.IsNullOrEmpty(dimensionInput))
{
Console.WriteLine("Expecting dimension input");
break;
}
string[] dimensionParts = dimensionInput.Trim().Split(new[] { ' ' }, 2);
if (dimensionParts.Length != 2)
{
Console.WriteLine("Invalid input given, expecting dimension in format \"Width Height\" (e.g. \"4 3\"");
break;
}
int width, height;
if (!ParseDimension(dimensionParts[0], "Width", out width))
{
break;
}
if (!ParseDimension(dimensionParts[1], "Height", out height))
{
break;
}
// validate input
if (width == 0 && height == 0)
{
break;
}
string fieldString = ReadField(width, height);
// init
var fieldParser = new FieldParser(MaxSize);
var mineCounter = new MineCounter();
var fieldSolver = new FieldSolver(mineCounter);
Field field = fieldParser.ParseAsync(width, height, fieldString).Result;
char[,] result = fieldSolver.GetTextualRepresentation(field);
// output
Console.WriteLine();
Console.WriteLine("Field #{0}: ", counter);
WriteResult(result);
Console.WriteLine();
++counter;
}
}
public void UninitializedParserTest()
{
FieldParser parser = FieldParser.BuildParserWithTwoDelimitersAndQualifier(",", "\r\n", "\"");
Assert.AreEqual <bool>(false, parser.RowDelimiterMatch);
Assert.AreEqual <string>(string.Empty, parser.CurrentText);
}
public override void InitModel(TestModel model, Dictionary <string, string> cellMap)
{
/// id;
if (cellMap["Id"] != null)
{
model.Id = FieldParser.IntParser(cellMap["Id"]);
}
/// 测试1;
if (cellMap["Test1"] != null)
{
model.Test1 = FieldParser.IntParser(cellMap["Test1"]);
}
/// 测试2;
if (cellMap["Test2"] != null)
{
model.Test2 = FieldParser.FloatParser(cellMap["Test2"]);
}
/// 测试3;
if (cellMap["Test3"] != null)
{
model.Test3 = FieldParser.IntArrayParser(cellMap["Test3"]);
}
/// 测试4;
if (cellMap["Test4"] != null)
{
model.Test4 = FieldParser.IntArraysParser(cellMap["Test4"]);
}
/// 测试5;
if (cellMap["Test5"] != null)
{
model.Test5 = cellMap["Test5"];
}
}
public List <StudentEntity> ReadRecords(string filePath)
{
try
{
var reader = new StreamReader(File.OpenRead(filePath));
List <StudentEntity> students = new List <StudentEntity>();
StudentEntity student;
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var studentDataArray = line.Split(Separator);
if (studentDataArray.Length == 4)
{
var stage = studentDataArray[0];
var gender = studentDataArray[2];
var lastModifiedDate = FieldParser.ConvertToDate(studentDataArray[3]);
student = new StudentEntity(stage, studentDataArray[1], gender, lastModifiedDate);
students.Add(student);
}
}
return(students);
}
catch (Exception ex)
{
throw new InvalidOperationException("ReadRecords:" + ex.Message + ex.StackTrace);
}
}
public void TestParseFailure()
{
var reader = ReaderFromCode(string.Empty);
var parser = new FieldParser(null, Modifier.None);
parser.TryParse(reader, out var _).IsFalse();
}
private void StructureParseTypes(CSharpProject project, SDRepository sdRepository)
{
var types = project.Compilation.MainAssembly.TopLevelTypeDefinitions.ToList();
for (int j = 0; j < types.Count; j++)
{
var type = types[j];
if (types[j].Kind != TypeKind.Delegate)
{
PostParseMessage(_parserStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name));
var nameSpace = sdRepository.GetNamespaceByIdentifier(type.Namespace);
var namespaceRef = nameSpace ?? new SDNamespace(type.Namespace)
{
IsProjectStranger = true
};
var sdType = new SDType(type.GetIdentifier(), type.Name, namespaceRef)
{
Accessibility = type.GetDefinition().Accessibility.ToString().ToLower()
};
sdRepository.AddType(sdType);
EventParser.ParseMinimalFields(sdType, types[j]);
PropertyParser.ParseMinimalProperties(sdType, types[j]);
FieldParser.ParseMinimalFields(sdType, types[j]);
MethodParser.ParseMinimalConstructors(sdType, types[j]);
MethodParser.ParseMinimalMethods(sdType, types[j]);
sdRepository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier);
}
}
}
public void TestField()
{
var res = FieldParser.ParseOrThrow("string bar");
Assert.That(res.Name, Is.EqualTo("bar"));
Assert.That(res.FieldType, Is.EqualTo(new MTypePrimitive(PrimitiveTypeCode.String)));
}
public void Should_Generate_GetHashCode_Method_For_Partial_Fields()
{
// Arrange
var updateSummaryMessageType = UpdateSummaryDynamicMessageTypesFactory.GenerateDynamicObjectType(PartialFields);
// Act
var emptyInstance = Activator.CreateInstance(updateSummaryMessageType);
var parseMethod = updateSummaryMessageType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static);
var parsedInstance = parseMethod.Invoke(null, new object[] { "P,AAPL,188.3500,52500,03/30/2021,19:59:14.503633,2" });
// calculate the expected hashes
var expectedHashCodeEmptyInstance = 17;
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + ((string)null).GetHashCodeOrDefault();
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(double).GetHashCode();
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(int).GetHashCode();
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(DateTime).GetHashCode();
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(TimeSpan).GetHashCode();
expectedHashCodeEmptyInstance = expectedHashCodeEmptyInstance * 29 + default(int).GetHashCode();
var expectedHashCodeParsedInstance = 17;
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + "AAPL".GetHashCode();
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 188.35.GetHashCode();
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 52500.GetHashCode();
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + FieldParser.ParseDate("03/30/2021", FundamentalMessage.FundamentalDateTimeFormat).GetHashCode();
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + FieldParser.ParseTime("19:59:14.503633", UpdateSummaryMessage.UpdateMessageTimeFormat).GetHashCode();
expectedHashCodeParsedInstance = expectedHashCodeParsedInstance * 29 + 2.GetHashCode();
// Assert
Assert.IsNotNull(emptyInstance);
Assert.AreEqual(expectedHashCodeEmptyInstance, emptyInstance.GetHashCode());
Assert.IsNotNull(parsedInstance);
Assert.AreEqual(expectedHashCodeParsedInstance, parsedInstance.GetHashCode());
}
private static void checkFields(String expected)
{
String field = expected.Replace("(", "").Replace(")", "");
String actual = FieldParser.parseFieldsInGeneralPurpose(field);
Assert.AreEqual(expected, actual);
}
public void TryParse_ParseAttributeTryParseThrowsException_ExceptionIsPropogated()
{
var property = typeof(MockRecord).GetProperty(nameof(MockRecord.ExceptionThrowingField));
var fieldParser = new FieldParser();
fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage);
}
public void Should_Generate_ToString_Method_For_Partial_Fields()
{
// Arrange
var updateSummaryMessageType = UpdateSummaryDynamicMessageTypesFactory.GenerateDynamicObjectType(PartialFields);
// Act
var emptyInstance = Activator.CreateInstance(updateSummaryMessageType);
var parseMethod = updateSummaryMessageType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static);
var parsedInstance = parseMethod.Invoke(null, new object[] { "P,AAPL,188.3500,52500,03/30/2021,19:59:14.503633,2" });
// generate the expected string values
var expectedStringEmptyInstance = $"Symbol: <NULL>, MostRecentTrade: {default(double)}, MostRecentTradeSize: {default(int)}, " +
$"MostRecentTradeDate: {default(DateTime)}, " +
$"MostRecentTradeTime: {default(TimeSpan)}, " +
$"MostRecentTradeAggressor: {default(int)}";
var expectedStringParsedInstance = $"Symbol: AAPL, MostRecentTrade: 188.35, MostRecentTradeSize: 52500, " +
$"MostRecentTradeDate: {FieldParser.ParseDate("03/30/2021", FundamentalMessage.FundamentalDateTimeFormat)}, " +
$"MostRecentTradeTime: {FieldParser.ParseTime("19:59:14.503633", UpdateSummaryMessage.UpdateMessageTimeFormat)}, " +
$"MostRecentTradeAggressor: 2";
// Assert
Assert.IsNotNull(emptyInstance);
Assert.AreEqual(expectedStringEmptyInstance, emptyInstance.ToString());
Assert.IsNotNull(parsedInstance);
Assert.AreEqual(expectedStringParsedInstance, parsedInstance.ToString());
}
public void ParseAsyncWhenInvalidInputWithShortLineGivenThenExceptionExpected()
{
var parser = new FieldParser();
Func <Task> act = async() => await parser.ParseAsync(10, 10, "...");
act.ShouldThrow <Exception>();
}
private static void DoGetTests(string dataFile, Dictionary <string, string> good, Dictionary <string, string> bad)
{
const string sep = "#------------------------------------------------------------------------------";
string contents = File.ReadAllText(dataFile);
string[] tests = contents.Split(new string[] { sep }, StringSplitOptions.RemoveEmptyEntries);
foreach (string test in tests)
{
Field[] fields = FieldParser.Parse(test);
if (fields[1].Name == "stdout")
{
good.Add(DoSanitize(fields[0].Value), DoSanitize(fields[1].Value));
}
else if (fields[1].Name == "stderr")
{
bad.Add(DoSanitize(fields[0].Value), DoSanitize(fields[1].Value));
}
else
{
System.Diagnostics.Debug.Assert(false);
}
}
}
public void ParseAsyncWhenInvalidHeightPassedThenArgumentExceptionExpected()
{
var parser = new FieldParser();
Func <Task> act = async() => await parser.ParseAsync(100, -1, "dummy");
act.ShouldThrow <ArgumentException>();
}
public void ParseAsyncWhenNullPassedAsFieldThenArgumentNullExceptionExpected()
{
var parser = new FieldParser();
Func <Task> act = async() => await parser.ParseAsync(100, 100, null);
act.ShouldThrow <ArgumentException>();
}
/// <summary>
/// Exporta as tabelas existentes no database para arquivos XML, os dados são gravados no XML em
/// formato pronto para INSERT (sem informação de tipo porém no formato esperado pelo BD)
/// </summary>
public Boolean DBExport(String databaseName)
{
if (!OpenConnection())
{
return(false);
}
currentDatabase = databaseName;
decimalSeparatorIsComma = FieldParser.IsCommaDecimalSeparator();
DBQuery dbQuery = new DBQuery(sqlConnection);
dbQuery.Query = "use " + currentDatabase;
dbQuery.Execute(false);
dbQuery.Query = "SELECT name, id FROM sysObjects WHERE xtype = 'U'";
dbQuery.Execute(true);
List <Object> tableList = dbQuery.ExtractFromResultset(typeof(DBObject));
if (tableList.Count < 1)
{
CloseConnection();
return(false);
}
foreach (DBObject table in tableList)
{
// Verifica a quantidade de registros da tabela
dbQuery.Query = "SELECT COUNT(1) FROM " + table.name;
dbQuery.Execute(true);
int?rowCount = dbQuery.ExtractFromResultset();
if (rowCount > 1000000)
{
continue; // Pula tabelas com mais de 1 milhão de registros ( backup manual )
}
dbQuery.Query = "SELECT name FROM sysColumns WHERE id = " + table.id;
dbQuery.Execute(true);
List <Object> fieldList = dbQuery.ExtractFromResultset(new String[] { "name" });
String[] fieldNames = new String[fieldList.Count];
for (int index = 0; index < fieldList.Count; index++)
{
fieldNames[index] = (String)((Object[])fieldList[index])[0];
}
dbQuery.Query = "SELECT * FROM " + table.name;
dbQuery.Execute(true);
List <Object> rowList = dbQuery.ExtractFromResultset(fieldNames);
Boolean tableExported = ExportTable(table.name, fieldNames, rowList);
if (!tableExported)
{
CloseConnection();
return(false);
}
}
CloseConnection();
return(true);
}
public ContentTypeFieldParser(FieldParser original) : base(original)
{
m_TokenPattern = PatternFactory.GetInstance().Get(typeof(RFC822.Pattern.TokenPattern));
m_ContentPattern = PatternFactory.GetInstance().Get(typeof(Pattern.ContentTypePattern));
m_TypePattern = PatternFactory.GetInstance().Get(typeof(Pattern.TypePattern));
SubTypePattern = PatternFactory.GetInstance().Get(typeof(Pattern.SubTypePattern));
m_ParameterPattern = PatternFactory.GetInstance().Get(typeof(Pattern.ParameterPattern));
m_ValuePattern = PatternFactory.GetInstance().Get(typeof(Pattern.ValuePattern));
}
/** Static constructor. */
static Parser()
{
var SFBool = new FieldParser(ParseSFBool);
//var MFBool = new FieldParser(ParseMFBool);
var SFColor = new FieldParser(ParseSFColor);
var MFColor = new FieldParser(ParseMFColor);
var SFFloat = new FieldParser(ParseSFFloat);
var MFFloat = new FieldParser(ParseMFFloat);
var SFImage = new FieldParser(ParseSFImage);
var SFInt32 = new FieldParser(ParseSFInt32);
var MFInt32 = new FieldParser(ParseMFInt32);
var SFNode = new FieldParser(ParseSFNode);
var MFNode = new FieldParser(ParseMFNode);
var SFRotation = new FieldParser(ParseSFRotation);
var MFRotation = new FieldParser(ParseMFRotation);
var SFString = new FieldParser(ParseSFString);
var MFString = new FieldParser(ParseMFString);
var SFTime = new FieldParser(ParseSFFloat);
//var MFTime = new FieldParser(ParseMFFloat);
var SFVec2f = new FieldParser(ParseSFVec2f);
var MFVec2f = new FieldParser(ParseMFVec2f);
var SFVec3f = new FieldParser(ParseSFVec3f);
var MFVec3f = new FieldParser(ParseMFVec3f);
// Dictionary<string, (FieldParser, object)> fields;
// Lookup table for Vrml97 node types.
// For each node type a NodeParseInfo entry specifies how
// to handle this kind of node.
m_parseInfoMap = new SymbolDict <NodeParseInfo>
{
// DEF
[Vrml97Sym.DEF] = new NodeParseInfo(new NodeParser(ParseDEF)),
// USE
[Vrml97Sym.USE] = new NodeParseInfo(new NodeParser(ParseUSE)),
// ROUTE
[Vrml97Sym.ROUTE] = new NodeParseInfo(new NodeParser(ParseROUTE)),
// NULL
[Vrml97Sym.NULL] = new NodeParseInfo(new NodeParser(ParseNULL))
};
var defaultBBoxCenter = (SFVec3f, (object)V3f.Zero);
var defaultBBoxSize = (SFVec3f, (object)new V3f(-1, -1, -1));
(FieldParser, object) fdd(FieldParser fp, object obj) => (fp, obj);
(FieldParser, object) fd(FieldParser fp) => (fp, null);
// Anchor
m_parseInfoMap["Anchor"] = new NodeParseInfo(
new SymbolDict <(FieldParser, object)>()
{
{ "children", fd(MFNode) },
{ "description", fd(SFString) },
public void ParseSimpleRowsTest()
{
IFileReader reader = FileReaderTest.GetReader("A,B,C\r\n1,2,3");
FieldParser parser = FieldParser.BuildParserWithSingleDelimiter("\r\n");
VerifySuccessfulFieldParsing(parser, reader, "A,B,C");
VerifyFieldParsing(parser, reader, "1,2,3");
Assert.AreEqual(reader.IsEOF, true);
}
public void ParseDelimitedRowsWithQualifiersTest()
{
IFileReader reader = FileReaderTest.GetReader("\"A,B,C\r\n1\",2,3\r\n1,2,3,\"4\"");
FieldParser parser = FieldParser.BuildParserWithSingleDelimiterAndQualifier("\r\n", "\"");
VerifySuccessfulFieldParsing(parser, reader, "A,B,C\r\n1,2,3");
VerifyFieldParsing(parser, reader, "1,2,3,\"4\"");
Assert.AreEqual(reader.IsEOF, true);
}
public void TryParse_EnumFieldWithInvalidStringValue_ParseFails()
{
var property = typeof(MockRecord).GetProperty(nameof(MockRecord.EnumField));
var fieldParser = new FieldParser();
var couldParse = fieldParser.TryParse(property, "Four", out var parsedFieldValue, out var failureMessage);
Assert.IsFalse(couldParse);
Assert.IsNull(parsedFieldValue);
Assert.AreEqual("Field is invalid.", failureMessage);
}
public void TryParse_UnparsableStringFieldWithParseAttribute_ParseFails()
{
var property = typeof(MockRecord).GetProperty(nameof(MockRecord.UnparsableStringFieldWithParseAttribute));
var fieldParser = new FieldParser();
var couldParse = fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage);
Assert.IsFalse(couldParse);
Assert.IsNull(parsedFieldValue);
Assert.AreEqual("Could not parse.", failureMessage);
}
public void TryParse_ParsableStringFieldWithParseAttribute_ParsedFieldIsReturned()
{
var property = typeof(MockRecord).GetProperty(nameof(MockRecord.ParsableStringFieldWithParseAttribute));
var fieldParser = new FieldParser();
var couldParse = fieldParser.TryParse(property, "1", out var parsedFieldValue, out var failureMessage);
Assert.IsTrue(couldParse);
Assert.AreEqual("A", parsedFieldValue);
Assert.IsNull(failureMessage);
}
public void TryParse_EnumFieldWithInvalidIntValue_ParsedFieldIsReturned()
{
var property = typeof(MockRecord).GetProperty(nameof(MockRecord.EnumField));
var fieldParser = new FieldParser();
var couldParse = fieldParser.TryParse(property, "4", out var parsedFieldValue, out var failureMessage);
Assert.IsTrue(couldParse);
Assert.AreEqual((MockEnum)4, parsedFieldValue);
Assert.IsNull(failureMessage);
}
private static void ParseTypeConfig(TypeConfig cfg)
{
if (cfg.Methods != null)
{
var list = new List <WhitelistMethodDefine>();
foreach (var m in cfg.Methods)
{
try
{
list.Add(MethodParser.ParseOrThrow(m));
}
catch (ParseException e)
{
Logger.ErrorS("res.typecheck", $"Parse exception for '{m}': {e}");
}
}
cfg.MethodsParsed = list.ToArray();
}
else
{
cfg.MethodsParsed = Array.Empty <WhitelistMethodDefine>();
}
if (cfg.Fields != null)
{
var list = new List <WhitelistFieldDefine>();
foreach (var f in cfg.Fields)
{
try
{
list.Add(FieldParser.ParseOrThrow(f));
}
catch (ParseException e)
{
Logger.ErrorS("res.typecheck", $"Parse exception for '{f}': {e}");
}
}
cfg.FieldsParsed = list.ToArray();
}
else
{
cfg.FieldsParsed = Array.Empty <WhitelistFieldDefine>();
}
if (cfg.NestedTypes != null)
{
foreach (var nested in cfg.NestedTypes.Values)
{
ParseTypeConfig(nested);
}
}
}
public void TestSimpleField()
{
var labelName = "Article.List";
var templateContent = @"@title";
var field = FieldParser.Parse(labelName, templateContent).FirstOrDefault();
Assert.AreNotEqual(null, field);
Assert.AreEqual("title", field.Name);
}
private static void TestEmbeddedQualifiers(string textToParse, string[] expectedFields)
{
IFileReader reader = FileReaderTest.GetReader(textToParse);
FieldParser parser = FieldParser.BuildParserWithTwoDelimitersAndQualifier(",", "\r\n", "\"");
foreach (string fieldData in expectedFields)
{
VerifySuccessfulFieldParsing(parser, reader, fieldData);
}
Assert.AreEqual(reader.IsEOF, true);
}
public void TestCustomField()
{
var labelName = "PageLink";
var templateContent = "@next";
var field = FieldParser.Parse(labelName, templateContent).FirstOrDefault();
Assert.AreNotEqual(null, field);
Assert.AreEqual("next", field.Name);
Assert.AreEqual("SparrowCMS.Base.Labels.PageLink.Fields.Next", field.GetType().FullName);
}
//todo: remove second argument
public static ProtoFieldStatement Parse(ParserContext context, Action<ParserContext> nodeStatementParser) {
context.ReadKeyword("field");
var fieldType = context.ParseFieldType();
var fieldId = context.ParseFieldId();
var field = context.CreateField(fieldType);
var fieldParser = new FieldParser(context, nodeStatementParser);
field.AcceptVisitor(fieldParser);
return new ProtoFieldStatement {
FieldType = fieldType,
FieldId = fieldId,
Value = field
};
}
public virtual void AddFieldParser(FieldParser parser)
{
FieldParsers.Add(parser);
}
public void AddFieldParser(FieldParser fieldParser)
{
initialContext.FieldParsers.Add(fieldParser);
}
