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);
}
