def _ok_coordinate_arrays(meta, axis, overlap, contiguous, info):
    """Return True iff the aggregating 1-d coordinates of the aggregating
    axis are all aggregatable.

    It is assumed that the input metadata objects have already been
    sorted by the canonical first values of their 1-d coordinates.

    :Parameters:

        meta: `list` of `_Meta`

        axis: `str`
            Find the canonical identity of the aggregating axis.

        overlap: `bool`
            See the `cf.aggregate` function for details.

        contiguous: `bool`
            See the `cf.aggregate` function for details.

        info: `int`
            See the `cf.aggregate` function for details.

    :Returns:

        `bool`

    **Examples:**

    >>> if not _ok_coordinate_arrays(meta, 'latitude', True, False)
    ...     print("Don't aggregate")

    """
    m = meta[0]
    dim_coord_index = m.axis[axis]['dim_coord_index']
    if dim_coord_index is not None:
        dim_coord_index0 = dim_coord_index
        for m0, m1 in zip(meta[:-1], meta[1:]):
            dim_coord_index1 = m1.axis[axis]['dim_coord_index']
            if m0.last_values[axis][dim_coord_index0] >= m1.first_values[axis][
                dim_coord_index1]:
                if info:
                    meta[0].message = (
                        '{0!r} dimension coordinate values overlap ({1} >= {2})'
                        .format(m.axis[axis]['ids'][dim_coord_index], m0.
                        last_values[axis][dim_coord_index0], m1.
                        first_values[axis][dim_coord_index1]))
                return False
            dim_coord_index0 = dim_coord_index1
        if axis in m.first_bounds:
            if not overlap:
                for m0, m1 in zip(meta[:-1], meta[1:]):
                    if m1.first_bounds[axis][0] < m0.last_bounds[axis][1]:
                        if info:
                            meta[0].message = (
                                'overlap={0} and {1!r} dimension coordinate bounds values overlap ({2} < {3})'
                                .format(m.axis[axis]['ids'][dim_coord_index
                                ], overlap, m1.first_bounds[axis][0], m0.
                                last_bounds[axis][1]))
                        return
            if contiguous:
                for m0, m1 in zip(meta[:-1], meta[1:]):
                    if m0.last_bounds[axis][1] < m1.first_bounds[axis][0]:
                        if info:
                            meta[0].message = (
                                'contiguous={0} and {1!r} dimension coordinate cells are not contiguous ({2} < {3})'
                                .format(m.axis[axis]['ids'][dim_coord_index
                                ], contiguous, m0.last_bounds[axis][1], m1.
                                first_bounds[axis][0]))
                        return
    else:
        for i, identity in enumerate(meta[0].axis[axis]['ids']):
            set_of_1d_aux_coord_values = set()
            number_of_1d_aux_coord_values = 0
            for m in meta:
                aux = m.axis[axis]['keys'][i]
                array = m.field.item(aux).array
                set_of_1d_aux_coord_values.update(array)
                number_of_1d_aux_coord_values += array.size
                if len(set_of_1d_aux_coord_values
                    ) != number_of_1d_aux_coord_values:
                    if info:
                        meta[0].message = (
                            'no {0!r} dimension coordinates and {0!r} auxiliary coordinates have duplicate values'
                            .format(identity))
                    return
    return True
