DeleteAction, DeleteVersionAction:
					return -1
				}
				switch b.Action {
				case DeleteAllVersionsAction, DelMarkerDeleteAllVersionsAction,
					DeleteAction, DeleteVersionAction:
					return 1
				}
				return -1
			}

			// Prefer earlier occurring event
			if a.Due.Before(b.Due) {
				return -1
			}
			return 1
		})
		return events[0]
	}

	return Event{

    arraycopy(second, 0, result, first.length, second.length);
    return result;
  }

  /**
   * Returns a new array that prepends {@code element} to {@code array}.
   *
   * @param element the element to prepend to the front of {@code array}
   * @param array the array of elements to append
   * @return an array whose size is one larger than {@code array}, with {@code element} occupying

 */
@Experimental
public interface VersionConstraint {
    /**
     * Returns the range of this constraint, or {@code null} if none.
     * <p>
     * Note: only one, this method or {@link #getRecommendedVersion()} method must return non-{@code null} value.
     */
    @Nullable
    VersionRange getVersionRange();

    /**
     * Returns the recommended version of this constraint, or {@code null} if none.
     * <p>

			return false, fmt.Errorf("kms: incomplete configuration for MinIO KMS: missing '%s'", EnvKMSDefaultKey)
		}
		if !isPresent(EnvKMSAPIKey) {
			return false, fmt.Errorf("kms: incomplete configuration for MinIO KMS: missing '%s'", EnvKMSAPIKey)
		}
		return true, nil
	case staticKeyPresent:
		if isPresent(EnvKMSSecretKey) && isPresent(EnvKMSSecretKeyFile) {

	switch mt {
	case CounterMT:
		return "counter"
	case GaugeMT:
		return "gauge"
	case HistogramMT:
		return "histogram"
	default:
		return "*unknown*"
	}
}

func (mt MetricType) toProm() prometheus.ValueType {
	switch mt {
	case CounterMT:
		return prometheus.CounterValue
	case GaugeMT:
		return prometheus.GaugeValue
	case HistogramMT:
		return prometheus.CounterValue
	default:

	return target.id
}

// Name - returns the Name of the target.
func (target *MQTTTarget) Name() string {
	return target.ID().String()
}

// Store returns any underlying store if set.
func (target *MQTTTarget) Store() event.TargetStore {
	return target.store
}

// IsActive - Return true if target is up and active
func (target *MQTTTarget) IsActive() (bool, error) {

	if h.Get(xhttp.AmzServerSideEncryption) != xhttp.AmzEncryptionAES {
		return ErrInvalidEncryptionMethod
	}
	return nil
}

// IsEncrypted returns true if the object metadata indicates
// that the object was uploaded using SSE-S3.
func (sses3) IsEncrypted(metadata map[string]string) bool {
	if _, ok := metadata[MetaSealedKeyS3]; ok {
		return true
	}
	return false
}

	if e == nil && other == nil {
		return nil, true
	}
	if e == nil {
		return other, false
	}
	if other == nil {
		return e, false
	}

	// Name should match...
	if e.name != other.name {
		if e.name < other.name {
			return e, false
		}
		return other, false
	}

	if other.isDir() || e.isDir() {
		if e.isDir() {
			return e, other.isDir() == e.isDir()
		}
		return other, other.isDir() == e.isDir()
	}

			return n, BadDigest{
				ExpectedMD5:   v.Expected.String(),
				CalculatedMD5: v.Computed.String(),
			}
		}
	}
	return n, err
}

// Size returns the absolute number of bytes the Reader
// will return during reading. It returns -1 for unlimited
// data.
func (r *Reader) Size() int64 { return r.size }

// ActualSize returns the pre-modified size of the object.

			if err != nil {
				return nil, fmt.Errorf("column %v not found", name)
			}
			// The position count starts at 1.
			idx--
			if idx >= len(r.csvRecord) || idx < 0 {
				// If field index > number of columns, return null
				return sql.FromNull(), nil
			}
			return sql.FromBytes([]byte(r.csvRecord[idx])), nil
		}
		// TODO: Return Missing?
		return nil, fmt.Errorf("column %v not found", name)
	}