Reassemble arrays from data returned from a
read-property-multiple.

For each object-identifier, check if a property is present is
present more than once. If it is, we are most probably dealing with
a segmented array... just concat them together.

Return true if the raw data returned by a read property is part of
an array.

Inverse of 'expand-obj-prop-ref'.

Ask the remote device what is the length of the BACnet array and
return as many object-property-identifiers. If object is not an
array (or any other error), return nil.

An array length can be provided to avoid a request to a remote device.

Take a normal object-property-references, such as

[ [[:analog-input 0] :description :object-name] ...]

and separate the properties into individual references to obtain:
[ [[:analog-input 0] :description]
  [[:analog-input 0] :object-name] ...]

Return true if the object-property-references is an expanded array
Example :
[[[:device 123] [:object-list 1]]
 [[:device 123] [:object-list 2]]]

Read the partitioned arrays in chunks and then assemble them back
together.

Read a BACnet array one time at the time and re-assemble the result
afterward.

Given a list of object-property-references, return a list of object properties maps.

[[[:analog-input 0] :description]
 [[:analog-input 1] :object-name]
 [[:device 1234] [:object-list 2]]] <---- with array index

---->

({:description "ANALOG INPUT 0", :object-identifier [:analog-input 0]}
 {:object-name "ANALOG INPUT 1", :object-identifier [:analog-input 1]}
 {[:object-list 2] [:analog-input 0], :object-identifier [:device 1234]})

Retrieve the property values form a remote device.
 Format for object-property-references should be:

 [ [[:analog-input 0] :description :object-name]   <--- multiple properties
   [[:device 1234] [:object-list 0]]                <--- array access
   [[:analog-ouput 1] :present-value]  ...]

The result will be a collection of objects properties map.

Example:

({:object-identifier [analog-input 1], :present-value 12.23}
 {:object-identifier [analog-input 2], :present-value 24.53, object-name "Analog Input 2"})

A convenience function to retrieve properties for multiple
objects.

read-access-specification should be of the form:
 [[object-identifier property-references]
  [object-identifier property-references]]

In case of an error (example :unknown-object), will fallback to
reading everything individually in order to be able to know which
property-reference is problematic.

read-access-specification should be of the form:
[[object-identifier property-references]
 [object-identifier property-references]]

Create a read-property-multiple request.
[[object-identifier property-references]
 [object-identifier property-references]]

Create a read-property request.

[:analog-input 0] :description
[:analog-input 0] [:description 0] <--- with array index

'by-what?' can be :sequence, :time, or position (the default if
none is provided).

'by-what?' can be :sequence, :time, or :position (the default if none is provided).

Read a single property.

Read a single property. If there's a size-related APDU error, will
try to read the BACnet arrays one item at the time.

For devices that don't support the special identifiers
(i.e. :all, :required and :optional), return a list of properties.

The :all won't be as the one defined by the BACnet standard,
because we can't know for sure what are the properties. (Especially
in the case of proprietary objects.)

True if the abort reason is size related.

Apply function 'f' to coll only if it really is a collection.
Return nil otherwise.