public void SimpleInputObject() { var body = new Source( @" input Hello { world: String }".ToLF()); var doc = SchemaParser.ParseSchema(body); var expected = new SchemaDocument { Definitions = ImmutableArray.Create <SchemaDefinition>( new InputObjectDefinition { Name = new Name("Hello", new Location(7, 12, body)), Fields = ImmutableArray.Create( new InputValueDefinition { Name = new Name("world", new Location(17, 22, body)), Type = new NamedType("String", 24, 30, body), Location = new Location(17, 30, body), }), Location = new Location(1, 32, body), }), Location = new Location(1, 32, body), }; doc.ShouldBeEquivalentToDeepDynamic(expected); }
public void TestLoadSingleMessage2() { var oMsg = Creator.Message("2.4", "ORU", "R01"); oMsg.Add(Creator.Segment("PID")); oMsg.Add(Creator.Segment("PV1")); oMsg.Add(Creator.Segment("ORC")); oMsg.Add(Creator.Segment("OBR")); oMsg.Add(Creator.Segment("OBX")); oMsg.Segment("PID").Element(3).Add(Creator.Field("100^^CODE^CODE2")); oMsg.Segment("PID").Element(3).Add(Creator.Field("1003^^CODE^CODE3")); int test = oMsg.Segment("PID").Element(3).RepeatCount; oMsg.Segment("PID").Field(5).Component(1).AsString = "Millar"; oMsg.Segment("PID").Field(5).Component(2).AsString = "Angus"; var SingleMessage = SchemaParser.LoadSingleMessage(oMsg.PathDetail.MessageVersionSupported, oMsg.PathDetail.MessageType, oMsg.PathDetail.MessageEvent); Assert.AreEqual(SingleMessage.MessageStructureList[0].MessageType, "ORU"); Assert.AreEqual(SingleMessage.MessageStructureList[0].MessageEvent, "R01"); var PatientResult = SingleMessage.MessageStructureList[0].MessageItemList[1] as PeterPiper.Hl7.V2.Schema.Model.MessageSegmentGroup; var OrderObservation = PatientResult.SegmentGroupItemList[1] as PeterPiper.Hl7.V2.Schema.Model.MessageSegmentGroup; var Observation = OrderObservation.SegmentGroupItemList[4] as PeterPiper.Hl7.V2.Schema.Model.MessageSegmentGroup; var OBX = Observation.SegmentGroupItemList[0] as PeterPiper.Hl7.V2.Schema.Model.MessageSegment; Assert.AreEqual(OBX.Segment.Code, "OBX"); Assert.AreEqual(OBX.Segment.SegmentFieldList[5].Description, "Observation Value"); }
public void SimpleNonNullType() { var body = new Source( @" type Hello { world: String! }".ToLF()); var doc = SchemaParser.ParseSchema(body); var expected = new SchemaDocument { Definitions = ImmutableArray.Create <SchemaDefinition>( new TypeDefinition { Name = new Name("Hello", new Location(6, 11, body)), Fields = ImmutableArray.Create( new FieldDefinition { Name = new Name("world", new Location(16, 21, body)), Type = new NonNullType { Type = new NamedType("String", 23, 29, body), Location = new Location(23, 30, body), }, Location = new Location(16, 30, body), }), Location = new Location(1, 32, body), }), Location = new Location(1, 32, body), }; doc.ShouldBeEquivalentToDeepDynamic(expected); }
public void ParseTypesJObject() { var schemaParser = new SchemaParser() .Add(typeof(DataAnonymous)) .Add("DataType1", 1, typeof(DataType1Version1)) .Add("DataType2", 1, typeof(DataType2Version1)) .Add("DataType2", 2, typeof(DataType2Version2)); var dataOfDifferentVersions = new List <object>() { new DataAnonymous { Zero = Guid.NewGuid().ToString() }, new DataType1Version1 { First = Guid.NewGuid().ToString() }, new DataType2Version1 { Second = Guid.NewGuid().ToString() }, new DataType2Version2 { Third = Guid.NewGuid().ToString() } }; foreach (var dataBefore in dataOfDifferentVersions) { var jObject = JObject.FromObject(dataBefore); var success = schemaParser.TryParse(jObject, out _, out _, out var dataAfter); UT.Assert.IsTrue(success); UT.Assert.AreEqual(dataBefore, dataAfter); } }
public void SimpleInterface() { var body = new Source( @" interface Hello { world: String }".ToLF()); var doc = SchemaParser.ParseSchema(body); var expected = new SchemaDocument { Definitions = ImmutableArray.Create <SchemaDefinition>( new InterfaceDefinition { Name = new Name("Hello", new Location(11, 16, body)), Fields = ImmutableArray.Create( new FieldDefinition { Name = new Name("world", new Location(21, 26, body)), Type = new NamedType("String", 28, 34, body), Location = new Location(21, 34, body), }), Location = new Location(1, 36, body), }), Location = new Location(1, 36, body), }; doc.ShouldBeEquivalentToDeepDynamic(expected); }
/// <summary>Gets the schema for a given attribute type /// </summary> /// <param name="attrType">Attribute type</param> /// <returns>A SchemaParser object</returns> public SchemaParser GetAttributeTypeSchema(string attrType) { LdapEntry[] entries = server.Search( server.GetSchemaDN(), LdapConnection.SCOPE_BASE, server.DefaultSearchFilter, new string[] { "attributetypes" }); if (entries == null) { return(null); } foreach (LdapEntry entry in entries) { LdapAttribute la = entry.getAttribute("attributetypes"); foreach (string s in la.StringValueArray) { SchemaParser sp = new SchemaParser(s); foreach (string a in sp.Names) { if (attrType.Equals(a)) { return(sp); } } } } return(null); }
public void TestSchemaParsing() { var parser = new SchemaParser(@"TODO FILENAME"); parser.Parse(); int i = 0; }
public void SimpleFieldWithArg() { var body = new Source( @" type Hello { world(flag: Boolean): String }".ToLF()); var doc = SchemaParser.ParseSchema(body); var expected = new SchemaDocument { Definitions = ImmutableArray.Create <SchemaDefinition>( new TypeDefinition { Name = new Name("Hello", new Location(6, 11, body)), Fields = ImmutableArray.Create( new FieldDefinition { Name = new Name("world", new Location(16, 21, body)), Type = new NamedType("String", 38, 44, body), Arguments = ImmutableArray.Create( new InputValueDefinition { Name = new Name("flag", new Location(22, 26, body)), Type = new NamedType("Boolean", 28, 35, body), Location = new Location(22, 35, body), }), Location = new Location(16, 44, body), }), Location = new Location(1, 46, body), }), Location = new Location(1, 46, body), }; doc.ShouldBeEquivalentToDeepDynamic(expected); }
/// <summary> /// Constructs a matching rule definition from the raw string values /// returned from a schema query for "matchingRule" and for /// "matchingRuleUse" for the same rule. /// </summary> /// <param name="rawMatchingRule"> /// The raw string value returned on a directory /// query for "matchingRule". /// </param> /// <param name="rawMatchingRuleUse"> /// The raw string value returned on a directory /// query for "matchingRuleUse". /// </param> public LdapMatchingRuleSchema(string rawMatchingRule, string rawMatchingRuleUse) : base(LdapSchema.SchemaTypeNames[LdapSchema.Matching]) { try { var matchParser = new SchemaParser(rawMatchingRule); if (matchParser.Names != null) { Names = new string[matchParser.Names.Length]; matchParser.Names.CopyTo(Names, 0); Id = matchParser.Id; Description = matchParser.Description; Obsolete = matchParser.Obsolete; SyntaxString = matchParser.Syntax; if (rawMatchingRuleUse != null) { var matchUseParser = new SchemaParser(rawMatchingRuleUse); Attributes = matchUseParser.Applies; } Value = FormatString(); } else { Logger.Log.LogDebug($"Can not parse matching rule schema {rawMatchingRule}"); } } catch (IOException ex) { Logger.Log.LogWarning("Exception swallowed", ex); } }
/// <summary> /// Constructs a syntax from the raw string value returned on a schema /// query for LdapSyntaxes. /// </summary> /// <param name="raw"> /// The raw string value returned from a schema /// query for ldapSyntaxes. /// </param> public LdapSyntaxSchema(string raw) : base(LdapSchema.SchemaTypeNames[LdapSchema.Syntax]) { try { var parser = new SchemaParser(raw); if (parser.Id != null) { Oid = parser.Id; } if (parser.Description != null) { Description = parser.Description; } var qualifiers = parser.Qualifiers; while (qualifiers.MoveNext()) { var attrQualifier = (AttributeQualifier)qualifiers.Current; SetQualifier(attrQualifier.Name, attrQualifier.Values); } Value = FormatString(); } catch (IOException e) { throw new Exception(e.ToString()); } }
public static void Main(string[] args) { var argsList = new List <string>(args); var verbose = false; if (argsList.Contains("-v") || argsList.Contains("-verbose")) { verbose = true; argsList.RemoveAll(s => s == "-v" || s == "-verbose"); } if (argsList.Count != 1) { Usage(); return; } try { var parser = new SchemaParser(argsList[0]); if (verbose) { parser.Logger = new ConsoleLogger(); } parser.Compile(); var elements = parser.GetXmlElements(); var serializer = new CodeMirrorSchemaInfoSerializer(elements); serializer.Pretty = true; var json = serializer.ToJsonString(); Console.WriteLine(json); } catch (Exception e) { Console.Error.WriteLine(e.GetType().Name); Console.Error.WriteLine(e.Message); Console.Error.WriteLine(e.StackTrace); Environment.Exit(1); } }
private TreeNode MessageToTreeNode(OperationMessage omsg, SoapBindingUse use) { Message msg=_services.GetMessage (omsg.Message); TreeNode node=new TreeNode() ; SchemaParser ngen=new SchemaParser(_schemas); ngen.BindingUse=use; foreach (MessagePart part in msg.Parts) { if (part.Element == XmlQualifiedName.Empty) { TreeNode partNode=ngen.Translate(part.Type); partNode.ImageIndex=5; partNode.SelectedImageIndex=5; partNode.Text=part.Name; node.Nodes.Add(partNode); } else { TreeNode partNode=ngen.Translate(part.Element); partNode.ImageIndex=5; partNode.SelectedImageIndex=5; partNode.Text=part.Name; node.Nodes.Add(partNode); } } return node; }
/// <summary>Gets the schema information for a given ldap syntax /// </summary> /// <param name="attrType">LDAP syntax</param> /// <returns>schema information</returns> public SchemaParser GetLdapSyntax(string synName) { LdapEntry[] entries = server.Search( server.GetSchemaDN(), LdapConnection.SCOPE_BASE, "", new string[] { "ldapSyntaxes" }); if (entries == null) { return(null); } LdapAttribute la = entries[0].getAttribute("ldapSyntaxes"); foreach (string s in la.StringValueArray) { SchemaParser sp = new SchemaParser(s); if (synName.Equals(sp.Description)) { return(sp); } } return(null); }
/// <summary>Gets the schema information for a given matching rule /// </summary> /// <param name="attrType">Matching rule</param> /// <returns>schema information</returns> public SchemaParser GetMatchingRule(string matName) { LdapEntry[] entries = server.Search( server.GetSchemaDN(), LdapConnection.SCOPE_BASE, "", new string[] { "matchingRules" }); if (entries == null) { return(null); } LdapAttribute la = entries[0].getAttribute("matchingRules"); foreach (string s in la.StringValueArray) { SchemaParser sp = new SchemaParser(s); foreach (string a in sp.Names) { if (matName.Equals(a)) { return(sp); } } } return(null); }
/// <summary> /// Constructs a matching rule definition from the raw string values /// returned from a schema query for "matchingRule" and for /// "matchingRuleUse" for the same rule. /// </summary> /// <param name="rawMatchingRule"> /// The raw string value returned on a directory /// query for "matchingRule". /// </param> /// <param name="rawMatchingRuleUse"> /// The raw string value returned on a directory /// query for "matchingRuleUse". /// </param> public LdapMatchingRuleSchema(string rawMatchingRule, string rawMatchingRuleUse) : base(LdapSchema.SchemaTypeNames[LdapSchema.Matching]) { try { var matchParser = new SchemaParser(rawMatchingRule); names = new string[matchParser.Names.Length]; matchParser.Names.CopyTo(names, 0); Oid = matchParser.Id; Description = matchParser.Description; Obsolete = matchParser.Obsolete; SyntaxString = matchParser.Syntax; if (rawMatchingRuleUse != null) { var matchUseParser = new SchemaParser(rawMatchingRuleUse); Attributes = matchUseParser.Applies; } Value = FormatString(); } catch (IOException ex) { Logger.Warn("Exception swallowed", ex); } }
/// <summary>Gets the servers matching rules (if available). /// </summary> /// <returns>matching rules</returns> public string[] GetMatchingRules() { LdapEntry[] entries = server.Search( server.GetSchemaDN(), LdapConnection.SCOPE_BASE, "", new string[] { "matchingRules" }); if (entries == null) { return(null); } List <string> tmp = new List <string> (); LdapAttribute la = entries[0].getAttribute("matchingRules"); foreach (string s in la.StringValueArray) { SchemaParser sp = new SchemaParser(s); tmp.Add(sp.Names[0]); } tmp.Sort(); return(tmp.ToArray()); }
/// <summary>Gets the schema of a given object class. /// </summary> /// <param name="objClass">Name of object class</param> /// <returns>A SchemaParser object</returns> public SchemaParser GetObjectClassSchema(string objClass) { LdapEntry[] entries; entries = server.Search( server.GetSchemaDN(), LdapConnection.SCOPE_BASE, server.DefaultSearchFilter, new string[] { "objectclasses" }); foreach (LdapEntry entry in entries) { LdapAttribute la = entry.getAttribute("objectclasses"); foreach (string s in la.StringValueArray) { SchemaParser sp = new SchemaParser(s); foreach (string a in sp.Names) { if (objClass.Equals(a)) { return(sp); } } } } return(null); }
public Xsd2XmlGenerator(string currentFileName) { InitializeComponent(); _currentFileName = currentFileName; try { SchemaParser schema = new SchemaParser(currentFileName, false); IEnumerable <IXsdNode> nodes = schema.GetVirtualRoot().GetChildren(); foreach (IXsdNode xsdNode in nodes) { XsdElement ele = xsdNode as XsdElement; if (ele != null) { cboRoot.Items.Add(ele.Name); } } } catch { //do nothing } _foldingManager = FoldingManager.Install(edtResult.TextArea); _foldingStrategy = new XmlFoldingStrategy(); }
void ShowAttrTypeSchema(SchemaParser sp) { try { attrIDEntry.Text = sp.ID; attrDescriptionEntry.Text = sp.Description; string tmp = ""; foreach (string a in sp.Names) { tmp += String.Format("{0}\n", a); } attrNameTextview.Buffer.Text = tmp; attrEqualityEntry.Text = sp.Equality; attrOrderingEntry.Text = sp.Ordering; attrSubstringEntry.Text = sp.Substring; attrSyntaxEntry.Text = sp.Syntax; attrObsoleteCheckbutton.Active = sp.Obsolete; attrSingleCheckbutton.Active = sp.Single; attrCollectiveCheckbutton.Active = sp.Collective; attrUserModCheckbutton.Active = sp.UserMod; tmp = ""; foreach (string b in sp.Superiors) { tmp += String.Format("{0}\n", b); } attrSuperiorTextview.Buffer.Text = tmp; } catch {} }
/// <summary> /// Constructs a syntax from the raw string value returned on a schema /// query for LdapSyntaxes. /// </summary> /// <param name="raw"> /// The raw string value returned from a schema /// query for ldapSyntaxes. /// </param> public LdapSyntaxSchema(string raw) : base(LdapSchema.schemaTypeNames[LdapSchema.SYNTAX]) { try { var parser = new SchemaParser(raw); if ((object)parser.ID != null) { oid = parser.ID; } if ((object)parser.Description != null) { description = parser.Description; } var qualifiers = parser.Qualifiers; AttributeQualifier attrQualifier; while (qualifiers.MoveNext()) { attrQualifier = (AttributeQualifier)qualifiers.Current; setQualifier(attrQualifier.Name, attrQualifier.Values); } Value = formatString(); } catch (IOException e) { throw new Exception(e.ToString()); } }
private static async Task <ISchema> ParseAndValidateSchemas(List <string> schemaPaths, string nameSpace) { var parser = new SchemaParser(schemaPaths, nameSpace); var schema = await parser.Evaluate(); schema.Validate(); return(schema); }
private static async Task <int> CheckSchema(string textualSchema) { var parser = new SchemaParser(textualSchema, "CheckNameSpace"); var schema = await parser.Parse(); schema.Validate(); return(await ReportSchemaDiagnostics(schema)); }
/// <summary> /// Constructs an object class definition from the raw string value /// returned from a directory query for "objectClasses". /// </summary> /// <param name="raw"> /// The raw string value returned from a directory /// query for "objectClasses". /// </param> public LdapObjectClassSchema(string raw) : base(LdapSchema.SchemaTypeNames[LdapSchema.ObjectClass]) { try { var parser = new SchemaParser(raw); if (parser.Names != null) { names = new string[parser.Names.Length]; parser.Names.CopyTo(names, 0); } if (parser.Id != null) { Oid = parser.Id; } if (parser.Description != null) { Description = parser.Description; } Obsolete = parser.Obsolete; if (parser.Required != null) { RequiredAttributes = new string[parser.Required.Length]; parser.Required.CopyTo(RequiredAttributes, 0); } if (parser.Optional != null) { OptionalAttributes = new string[parser.Optional.Length]; parser.Optional.CopyTo(OptionalAttributes, 0); } if (parser.Superiors != null) { Superiors = new string[parser.Superiors.Length]; parser.Superiors.CopyTo(Superiors, 0); } Type = parser.Type; var qualifiers = parser.Qualifiers; AttributeQualifier attrQualifier; while (qualifiers.MoveNext()) { attrQualifier = (AttributeQualifier)qualifiers.Current; SetQualifier(attrQualifier.Name, attrQualifier.Values); } Value = FormatString(); } catch (IOException ex) { Logger.Log.LogWarning("Exception swallowed", ex); } }
/// <summary> /// Constructs a DIT content rule from the raw string value returned from a /// schema query for dITContentRules. /// </summary> /// <param name="raw"> /// The raw string value returned from a schema query /// for content rules. /// </param> public LdapDitContentRuleSchema(string raw) : base(LdapSchema.SchemaTypeNames[LdapSchema.Ditcontent]) { Obsolete = false; var parser = new SchemaParser(raw); if (parser.Names != null) { Names = new string[parser.Names.Length]; parser.Names.CopyTo(Names, 0); } if (parser.Id != null) { Id = parser.Id; } if (parser.Description != null) { Description = parser.Description; } if (parser.Auxiliary != null) { AuxiliaryClasses = new string[parser.Auxiliary.Length]; parser.Auxiliary.CopyTo(AuxiliaryClasses, 0); } if (parser.Required != null) { RequiredAttributes = new string[parser.Required.Length]; parser.Required.CopyTo(RequiredAttributes, 0); } if (parser.Optional != null) { OptionalAttributes = new string[parser.Optional.Length]; parser.Optional.CopyTo(OptionalAttributes, 0); } if (parser.Precluded != null) { PrecludedAttributes = new string[parser.Precluded.Length]; parser.Precluded.CopyTo(PrecludedAttributes, 0); } Obsolete = parser.Obsolete; var qualifiers = parser.Qualifiers; AttributeQualifier attrQualifier; while (qualifiers.MoveNext()) { attrQualifier = qualifiers.Current; SetQualifier(attrQualifier.Name, attrQualifier.Values); } Value = FormatString(); }
/* * } * * /** * Constructs a Name Form from the raw string value returned on a * schema query for nameForms. * * @param raw The raw string value returned on a schema * query for nameForms. */ public LdapNameFormSchema(string raw) : base(LdapSchema.SchemaTypeNames[LdapSchema.NameForm]) { Obsolete = false; try { var parser = new SchemaParser(raw); if (parser.Names != null) { Names = new string[parser.Names.Length]; parser.Names.CopyTo(Names, 0); } if (parser.Id != null) { Id = parser.Id; } if (parser.Description != null) { Description = parser.Description; } if (parser.Required != null) { RequiredNamingAttributes = new string[parser.Required.Length]; parser.Required.CopyTo(RequiredNamingAttributes, 0); } if (parser.Optional != null) { OptionalNamingAttributes = new string[parser.Optional.Length]; parser.Optional.CopyTo(OptionalNamingAttributes, 0); } if (parser.ObjectClass != null) { ObjectClass = parser.ObjectClass; } Obsolete = parser.Obsolete; var qualifiers = parser.Qualifiers; AttributeQualifier attrQualifier; while (qualifiers.MoveNext()) { attrQualifier = qualifiers.Current; SetQualifier(attrQualifier.Name, attrQualifier.Values); } Value = FormatString(); } catch (IOException ex) { Logger.Log.LogWarning("Exception swallowed", ex); } }
protected void Page_Load(object sender, EventArgs e) { SchemaParser parser = new SchemaParser(); List <string> allSchemaInfo = parser.GenerateInfoForAllSchema(); foreach (string schema in allSchemaInfo) { Response.Write(schema); } }
static void Main(string[] args) { var dfdl = @"d:\dfdltests\dfdl.xsd"; var feed = @"d:\dfdltests\sampleinput2.txt"; var parser = new SchemaParser(dfdl); parser.Parse(feed); }
public void DoesNotAlterAst() { var schemaKitchenSink = TestUtils.SchemaKitchenSink.Value; var ast = SchemaParser.ParseSchema(schemaKitchenSink); var astCopy = SchemaParser.ParseSchema(schemaKitchenSink); var schemaPrinter = new SchemaPrinter(); schemaPrinter.VisitSchemaDocument(ast); ast.ShouldBeEquivalentToDeepDynamic(astCopy); }
static void Main(string[] args) { var dfdl = @"d:\dfdltests\dfdl.xsd"; var feed = @"d:\dfdltests\sampleinput2.txt"; var parser = new SchemaParser(dfdl); parser.Parse(feed); }
void ShowLdapSyntax(SchemaParser sp) { if (sp == null) { return; } synDescriptionEntry.Text = sp.Description; synOIDEntry.Text = sp.ID; }
/// <summary> /// Constructs a DIT content rule from the raw string value returned from a /// schema query for dITContentRules. /// </summary> /// <param name="raw"> /// The raw string value returned from a schema query /// for content rules. /// </param> public LdapDITContentRuleSchema(string raw) : base(LdapSchema.schemaTypeNames[LdapSchema.DITCONTENT]) { obsolete = false; try { var parser = new SchemaParser(raw); if (parser.Names != null) { names = new string[parser.Names.Length]; parser.Names.CopyTo(names, 0); } if ((object)parser.ID != null) { oid = parser.ID; } if ((object)parser.Description != null) { description = parser.Description; } if (parser.Auxiliary != null) { auxiliary = new string[parser.Auxiliary.Length]; parser.Auxiliary.CopyTo(auxiliary, 0); } if (parser.Required != null) { required = new string[parser.Required.Length]; parser.Required.CopyTo(required, 0); } if (parser.Optional != null) { optional = new string[parser.Optional.Length]; parser.Optional.CopyTo(optional, 0); } if (parser.Precluded != null) { precluded = new string[parser.Precluded.Length]; parser.Precluded.CopyTo(precluded, 0); } obsolete = parser.Obsolete; var qualifiers = parser.Qualifiers; AttributeQualifier attrQualifier; while (qualifiers.MoveNext()) { attrQualifier = (AttributeQualifier)qualifiers.Current; setQualifier(attrQualifier.Name, attrQualifier.Values); } Value = formatString(); } catch (IOException) { } }
public static void Main(string[] args) { string sourceFileName = String.Empty; string targetFileName = String.Empty; string rootNodeName = String.Empty; bool showHelp = false; List<string> nodesToSkip = new List<string>(); List<string> attributesToAdd = new List<string>(); var optionSet = new OptionSet() { { "s|source=", "The {SOURCE} xsd file to use to generate the XPaths (required).", v => sourceFileName = v }, { "t|target=", "The {TARGET} csv file containing the extracted XPaths (required).", v => targetFileName = v }, { "r|root:", "The {ROOT ELEMENT} to start from (optional). If not specified this defaults to the first root element found.", v => rootNodeName = v }, { "i|ignore:", "The {ELEMENT} to ignore when generating the XPaths (optional).", nodesToSkip.Add }, { "a|add:", "An additional {ATTRIBUTE} to extract from the element when generating the csv list (optional).", attributesToAdd.Add }, { "h|?|help", "Show this message and exit.", v => showHelp = v != null }, }; try { List<string> extraParameters = optionSet.Parse(args); if (extraParameters.Count > 0) { Console.WriteLine("XsdHelper: The following extra parameters are being ignored:\n {0}", String.Join("\n", extraParameters.ToArray())); } } catch (OptionException e) { Console.Write("XsdHelper: "); Console.WriteLine(e.Message); Console.WriteLine("Try `XsdHelper --help' for more information."); return; } showHelp |= String.IsNullOrEmpty(sourceFileName) || String.IsNullOrEmpty(targetFileName); if (showHelp) { ShowHelp(optionSet); return; } ValidateSuppliedFileArguments(sourceFileName, targetFileName); using (StreamWriter csvXPathFileWriter = new StreamWriter(targetFileName, false)) { Console.WriteLine("Loading schemas..."); SchemaParser parser = new SchemaParser(sourceFileName, csvXPathFileWriter); Console.WriteLine(String.Format("{0} files loaded", parser.LoadedSchemas.Count)); foreach (KeyValuePair<string, XmlSchema> loadedSchema in parser.LoadedSchemas.OrderBy(s => s.Key)) { Console.WriteLine(String.Format("File: {0}, Namespace: {1}", loadedSchema.Key, loadedSchema.Value.TargetNamespace)); } parser.ExtractXPaths(nodesToSkip, attributesToAdd, rootNodeName); csvXPathFileWriter.Close(); } }
/// <summary> /// Sets the Cassandra version in order to identify how to parse the metadata information /// </summary> /// <param name="version"></param> internal void SetCassandraVersion(Version version) { _schemaParser = SchemaParser.GetInstance(version, this, GetUdtDefinitionAsync, _schemaParser); }