AND and OR for multiple arguments

[ahocevar]

No description provided.

[ahocevar]

Closing, as discussed in the hangout. Instead, we create a function in filter encoding that detects constructs like (foo && (bar && (baz && bam))) and turns them into a filter with multiple ANDs.

[tschaub]

Also note that in the meantime, we can focus on reading/writing FE without round-tripping exactly.

So this ol.expr.parse('foo && bar && baz && bam') produces a tree that roughly looks like this:

{
  type: ol.expr.Logical
  left: {
    type: ol.expr.Logical,
    left: {
      type: ol.expr.Logical,
      left: {
        type: ol.expr.Identifier,
        name: 'foo'
      },
      operator: '&&',
      right: {
        type: ol.expr.Identifier,
        name: 'bar'      
      }
    },
    operator: '&&',
    right: {
      type: ol.expr.Identifier,
      name: 'baz'    
    }
  },
  operator: '&&',
  right: {
    type: ol.expr.Identifier,
    name: 'bam'
  }
}

If you serialize this blindly, you'll create nested filter:And elements with two children each instead of one filter:And element with four children. The logic is the same. And when you are deserializing, and you encounter filter:And you create one ol.expr.Logical for the first pair of children as left/right, another ol.expr.Logical with left created above and right the next child, and so forth.

Yes, this results in more verbose FE than necessary. But I don't think the parser should block on getting the round-tripped doc.