I'm looking to construct a predicate which checks if a list of strings in CloudKit contains any element in an array of strings. I know I can check if a string is in a list in CloudKit by using the CONTAINS predicate, and I also know I can check if a string field is in an array using the IN predicate, however due to using an array/list of strings on both sides of the predicate I need form a CONTAINS IN predicate. anyone know how?
Use ANY array IN otherArray within the predicate
Related
I was just wondering if there is a shorter way of writing an XPath query to find all HREF values containing at least one of many search values?
What I currently have is the following:
//a[contains(#href, 'value1') or contains(#href, 'value2')]
But it seems quite ugly, especially if I were to have more values.
First of all, in many cases you have to live with the "ugliness" or long-windedness of expressions if only XPath 1.0 is at your disposal. Elegance is something introduced with version 2.0, I'd daresay.
But there might be ways to improve your expression: Is there a regularity to the href attributes you'd like to find? For instance, if it is sufficient as a rule to say that the said href attribute values must start with "value", then the expression could be
//a[starts-with(#href,'value')]
I know that "value1" and "value2" are most probably not your actual attribute values but there might be something else that uniquely identifies the group of a elements you're after. Post your HTML input if this is something you want us to help you with.
Personally, I do not find your expression ugly. There is just one or operator and the expression is quite short and readable. I take
if I were to have more values.
to mean that currently, there are only two attribute values you are interested in and that your question therefore is a theoretical one.
In case you're using XPath 2 and would like to have exact matches instead of also matches only containing part of a search value, you can shorten with
//a[#href = ('value1', 'value2')]
For contains() this syntax wouldn't work as the second argument of contains() is only allowed to be 0 or 1 value.
In XPath 2 you could also use
//a[some $s in ('value1', 'value2') satisfies contains(#href, $s)]
or
//a[matches(#href, "value1|value2")]
I have an NSSearchField bound to an NSDictionaryController. In my search field's predicate format, I have a code like this key contains $value and what does it mean? What other alternatives are there for the predicate format (lines of code)? Thanks!
A quick search of the docs turns up this chapter in the Predicate Programming Guide:
Variables are denoted with a $ (for example $VARIABLE_NAME).
I don't see anywhere where it's explicitly mentioned, but the implication is that identifiers not prefixed by a $ are treated as keys—i.e., retrieved by Key-Value Coding. The predicate will match those objects from the dictionary controller whose value for key …
CONTAINS
The left-hand expression contains the right-hand expression.
… contains the value of $value.
So what's $value, then? The Cocoa Bindings Reference explains:
The multiple-value predicate binding allows you to create a search field pop-up menu that is pre populated with menu items that correspond to predicate filters. Each of the predicate bindings correspond to an entry in the search field pop-up menu. This multiple-value binding is used by the NSSearchField predicate binding.
The display name string is used as the menu item title. The predicate format is string that specifies the predicate for that menu item using the predicate format described in Predicate Programming Guide. Any occurrences of the string $value in the predicate format string are replaced with the contents of the search field.
In other words, an NSSearchField predefines the variable value for its predicates as holding whatever text is currently in the field—i.e., the text the user is searching for.
So, for example, if you create a predicate with the format name contains $value, and the user searches for “Emily”, that predicate will match those objects whose name contains (as a substring) the string “Emily”.
key stands for the Key of the dictionary and $value stands for the entered value in the NSSearchField.
For searching from more fields you can use || and && in the Predicate Format.
I somehow found out!
I for the predicate format, I just need to type
value contains $value
for it to work. Now I understand! Thank you all for your help!!!
foreach (var item in dictionary) {
cellValue.Text = item.Value.ToString();
}
I am developing an application that accepts user-defined XPath expressions and employs them as part of its runtime operation.
However, I would like to be able to infer some additional data by programmatically manipulating the expression, and I am curious to know whether there are any situations in which this approach might fail.
Given any user-defined XPath expression that returns a node set, is it safe to wrap it in the XPath count() function to determine the number of nodes in the set:
count(user_defined_expression)
Similarly, is it safe to append an array index to the expression to extract one of the nodes in the set:
user_defined_expression[1]
Well an XPath expression (in XPath 1.0) can yield a node-set or a string or a number or a boolean and doing count(expression) only makes sense on any expression yielding a node-set.
As for adding a positional predicate, I think you might want to use parentheses around your expression i.e. to change /root/foo/bar into (/root/foo/bar)[1] as that way you select the first bar element in the node-set selected by /root/foo/bar while without them you would get /root/foo/bar[1] which would select the first bar child element of any foo child element of the root element.
Are you checking that such user-defined expressions always evaluate to node-set?
If yes, first Expr is ok. Datatype will be correct for fn:count
Second one is a lot trickier, with a lot of situations there predicate will overweight axis, for example. Check this answer for a simple analysis. It will be difficult to say, what a user really meant.
A more robust approach would be to convert the XPath expression to XQueryX, which is an XML representation of the abstract syntax tree; you can then do XQuery or XSLT transformations on this XML representation, and then convert back to a modified XPath (or XQuery) for evaluation.
However, this will still only give you the syntactic structure of the expression; if you want semantic information, such as the inferred static type of the result, you will probably have to poke inside an XPath process that exposes this information.
<bits>
<thing>Match this please</thing>
<thing>Don't match this</thing>
<thing>Match <b>this</b> please</thing>
</bits>
An expression like this:
//thing[text()='Match this please']
will locate the first 'thing' but not the third, because the phrase is distributed through a child node.
Is there an expression that would match the first and the third 'thing' in my example?
Try:
//thing[string()='Match this please']
jsfiddle:
http://jsfiddle.net/ZG9n3/2/
Please check the reference to see if this is going to work for you:
http://www.w3.org/TR/xpath/#function-string
Is there an expression that would
match the first and the third 'thing'
in my example?
You mean: Is there an expression that would select the first and the third element named thing, based on their string value.
Use:
/*/thing[. = 'Match this please']
The predicate compares the string value of the context node to the string "Match this please".
By definition the string value of an element is the concatenation (in document order) of all of its text-nodes descendents.
Note: Always try to avoid the // abbreviation because its use may incur big inefficiency. Whenever the structure of an XML document is known, use a chain of specific location steps.
Using apricot, it is pretty easy to see how I can extract all elements with a given id or class using a CSS Selector. Is it possible to extract elements from a document based on whether some attribute of those elements matches against some regular expression?
If you mean do something like:
doc.search("//div[#id=/regex/]")
then I don't think it can be done. The alternative is to find all elements and then iterate through the results deleting those that don't match a regex.
result = doc.search("//div")
result.delete_if (|x| x.to_s !~ /regex/)
There are lots of alternative approaches. This thread has two other suggestions: Hpricot and Regular Expression.
Note, depending on exactly what it is you are trying to match you may be able to use the "Supported, but different" syntaxes available on the Hpricot Wiki, e.g:
E[#foo$=“bar”]
Matches an E element whose “foo”
attribute value ends exactly with the
string “bar”