private void ByAttribute()
{
TokenQueue cq = new TokenQueue(tq.ChompBalanced('[', ']')); // content queue
string key = cq.ConsumeToAny("=", "!=", "^=", "$=", "*=", "~="); // eq, not, start, end, contain, match, (no val)
if (key.Length == 0)
{
throw Failure.EmptyString("key");
}
cq.ConsumeWhitespace();
if (cq.IsEmpty)
{
if (key.StartsWith("^", StringComparison.Ordinal))
{
evals.Add(new Evaluator.AttributeStarting(key.Substring(1)));
}
else
{
evals.Add(new Evaluator.Attribute(key));
}
}
else
{
if (cq.MatchChomp("="))
{
evals.Add(new Evaluator.AttributeWithValue(key, cq.Remainder()));
}
else if (cq.MatchChomp("!="))
{
evals.Add(new Evaluator.AttributeWithValueNot(key, cq.Remainder()));
}
else if (cq.MatchChomp("^="))
{
evals.Add(new Evaluator.AttributeWithValueStarting(key, cq.Remainder()));
}
else if (cq.MatchChomp("$="))
{
evals.Add(new Evaluator.AttributeWithValueEnding(key, cq.Remainder()));
}
else if (cq.MatchChomp("*="))
{
evals.Add(new Evaluator.AttributeWithValueContaining(key, cq.Remainder()));
}
else if (cq.MatchChomp("~="))
{
evals.Add(new Evaluator.AttributeWithValueMatching(key, new Regex(cq.Remainder())));
}
else
{
throw DomFailure.CannotParseAttributeQuery(query, cq.Remainder());
}
}
}
static Exception _TryParse(string text, out ArrayDimension result)
{
result = default(ArrayDimension);
if (text == null)
{
return(new ArgumentNullException("text"));
}
text = text.Trim();
if (text.Length == 0)
{
return(Failure.EmptyString("text"));
}
Match m = PATTERN.Match(text);
if (!m.Success)
{
return(Failure.NotParsable("text", typeof(ArrayDimension)));
}
int?lowerBound = GetInt32(m.Groups["LowerBound"].Value);
int?upperBound = GetInt32(m.Groups["UpperBound"].Value);
if (lowerBound.HasValue || upperBound.HasValue)
{
result = new ArrayDimension(lowerBound, upperBound);
return(null);
}
return(Failure.NotParsable("text", typeof(ArrayDimension)));
}
public string this[string property] {
get {
if (property == null)
{
throw new ArgumentNullException("property");
}
if (string.IsNullOrEmpty(property))
{
throw Failure.EmptyString("property");
}
return(values.GetValueOrDefault(property));
}
set {
if (property == null)
{
throw new ArgumentNullException("property");
}
if (string.IsNullOrEmpty(property))
{
throw Failure.EmptyString("property");
}
values[property] = value;
}
}
public HxlDirective Create(string directive)
{
if (directive == null)
{
throw new ArgumentNullException("directive");
}
if (directive.Length == 0)
{
throw Failure.EmptyString("directive");
}
var items = HxlDirective.Parse(directive).ToArray();
if (items == null)
{
return(HxlDirective.Null);
}
Type type = GetDirectiveType(items[0].Key);
if (type == null)
{
return(null);
}
throw new NotImplementedException();
// return CreateDirectiveCore(type, items.Skip(1));
}
private void VerifyPrefix(string prefix, string argumentName)
{
if (prefix == null)
{
throw new ArgumentNullException(argumentName);
}
if (string.IsNullOrEmpty(prefix))
{
throw Failure.EmptyString(argumentName);
}
if (this.map.ContainsKey(prefix))
{
throw HxlFailure.PrefixAlreadyDefined("prefix", prefix);
}
switch (prefix)
{
case "hxl":
case "c":
case "xml":
case "xmlns":
throw HxlFailure.CannotUseBuiltinPrefixes(argumentName);
}
}
static Exception _TryParse(string text, IHxlNamespaceResolver namespaceResolver, out HxlQualifiedName result)
{
result = null;
if (text == null)
{
return(new ArgumentNullException("text"));
}
if (string.IsNullOrEmpty(text))
{
return(Failure.EmptyString("text"));
}
var helper = HxlQualifiedNameHelper.Parse(text);
Uri ns = null;
if (!string.IsNullOrEmpty(helper.Prefix))
{
ns = namespaceResolver.LookupNamespace(helper.Prefix);
}
result = helper.ToName(ns);
return(null);
}
public override void WriteStartTree(string localName, string ns)
{
if (localName == null)
{
throw new ArgumentNullException("localName");
}
if (string.IsNullOrEmpty(localName))
{
throw Failure.EmptyString("localName");
}
StartImplicitly();
PropertyTree newTree = new PropertyTree(localName, ns);
CopyLineInfo(newTree);
if (this.root == null)
{
this.root = newTree;
this.currentParent = newTree;
}
else
{
PushParent(newTree);
}
}
public MethodName GetMethod(string name, TypeName returnType, IEnumerable <string> typeParameters, IEnumerable <TypeName> parameters)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw Failure.EmptyString(nameof(name));
}
if (returnType == null)
{
throw new ArgumentNullException("returnType");
}
typeParameters = typeParameters ?? Array.Empty <string>();
parameters = parameters ?? Array.Empty <TypeName>();
if (typeParameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("typeParameters");
}
if (parameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("parameters");
}
return(new DefaultMethodName(
this,
name,
DefaultMethodName.SetGenericParameters(typeParameters),
DefaultMethodName.SetParameters(parameters),
DefaultMethodName.SetReturnType(returnType)
));
}
public MethodName GetMethod(string name, params TypeName[] parameters)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw Failure.EmptyString(nameof(name));
}
parameters = parameters ?? Array.Empty <TypeName>();
if (parameters.Any(t => t == null))
{
throw Failure.CollectionContainsNullElement("parameters");
}
int mangle;
var method = TypeName.StripMangle(name, out mangle);
return(new DefaultMethodName(
this,
method,
DefaultMethodName.SetGenericMangle(mangle),
DefaultMethodName.SetParameters(parameters)
));
}
private static ArrayDimensionCollection _TryParse(string text, bool throwOnError)
{
if (text == null)
{
if (throwOnError)
{
throw new ArgumentNullException("text");
}
else
{
return(null);
}
}
if (text.Length == 0)
{
if (throwOnError)
{
throw Failure.EmptyString("text");
}
else
{
return(null);
}
}
string[] items = text.Split(',');
int index = 0;
ArrayDimension[] result = new ArrayDimension[items.Length];
foreach (var m in items)
{
string dim = m.Trim();
if (dim.Length == 0)
{
result[index++] = new ArrayDimension();
}
else
{
ArrayDimension ad;
if (!ArrayDimension.TryParse(dim, out ad))
{
if (throwOnError)
{
throw Failure.NotParsable("text", typeof(ArrayDimensionCollection));
}
else
{
return(null);
}
}
result[index++] = ad;
}
}
return(new ArrayDimensionCollection(result));
}
public override bool MoveToSibling(string name) {
if (name == null) {
throw new ArgumentNullException("name");
}
if (string.IsNullOrEmpty(name)) {
throw Failure.EmptyString("name");
}
return MoveToSibling(node => node.Name == name);
}
private void ByClass()
{
string className = tq.ConsumeCssIdentifier();
if (className.Length == 0)
{
throw Failure.EmptyString("className");
}
evals.Add(new Evaluator.Class(className.Trim().ToLower()));
}
private void ById()
{
string id = tq.ConsumeCssIdentifier();
if (id.Length == 0)
{
throw Failure.EmptyString("id");
}
evals.Add(new Evaluator.Id(id));
}
public override bool MoveToChild(string ns, string name) {
if (name == null) {
throw new ArgumentNullException("name");
}
if (string.IsNullOrEmpty(name)) {
throw Failure.EmptyString("name");
}
ns = ns ?? string.Empty;
return MoveToChild(node => node.Name == name && node.Namespace == ns);
}
private static void CheckRole(string role)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.Length == 0)
{
throw Failure.EmptyString(nameof(role));
}
}
public CompareToAttribute(string propertyName)
{
if (propertyName == null)
{
throw new ArgumentNullException("propertyName"); // $NON-NLS-1
}
if (propertyName.Trim().Length == 0)
{
throw Failure.EmptyString("propertyName"); // $NON-NLS-1
}
_otherProperty = propertyName;
}
public TargetArchitecture(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (string.IsNullOrEmpty(name))
{
throw Failure.EmptyString("name");
}
_name = name;
}
public virtual DomName WithLocalName(string value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.Length == 0)
{
throw Failure.EmptyString(nameof(value));
}
return(Namespace + value);
}
public IEnumerable <HxlCompiledTemplateInfo> FindTemplates(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (string.IsNullOrEmpty(name))
{
throw Failure.EmptyString("name");
}
return(_templates[name]);
}
public FieldName GetField(string name, TypeName fieldType)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (name.Length == 0)
{
throw Failure.EmptyString(nameof(name));
}
return(new FieldName(this, name, SafeCloneBind(fieldType)));
}
public static Logger FromName(string name) {
if (name == null)
throw new ArgumentNullException("name");
if (name.Length == 0)
throw Failure.EmptyString("name");
if (name == System.Name)
return System;
Init();
LoggerBuilder lb = InstrumentationConfiguration.Current.Loggers[name];
return BuildLoggerSafe(lb, name);
}
protected internal DomProcessingInstruction(string target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (string.IsNullOrEmpty(target))
{
throw Failure.EmptyString(nameof(target));
}
_target = target;
}
public static PropertyTreeSchema FromFile(string file)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (string.IsNullOrEmpty(file))
{
throw Failure.EmptyString("file");
}
return(FromStreamContext(StreamContext.FromFile(file)));
}
public PropertyTreeDefinition DefineType(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (string.IsNullOrEmpty(name))
{
throw Failure.EmptyString("name");
}
throw new NotImplementedException();
}
public TypeName GetType(string ns, string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw Failure.EmptyString("name");
}
return(DefaultTypeName.FromFullName(ns, name, this));
}
public ParameterName this[string name] {
get {
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (string.IsNullOrEmpty(nameof(name)))
{
throw Failure.EmptyString(nameof(name));
}
return(this.FirstOrDefault(t => t.Name == name));
}
}
public bool Contains(string name, string ns)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw Failure.EmptyString("name");
}
return(Contains(QualifiedName.Create(ns ?? string.Empty, name)));
}
public bool Contains(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw Failure.EmptyString("name");
}
return(this.items.Keys.Any(t => string.Equals(t.LocalName, name, StringComparison.OrdinalIgnoreCase)));
}
public IEnumerable <T> GetByLocalName(string name)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw Failure.EmptyString("name");
}
return(this.items.Values.Where(t => t.Name == name));
}
protected internal DomDocumentType(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (string.IsNullOrEmpty(name))
{
throw Failure.EmptyString(nameof(name));
}
_name = name;
}