sol-str-slice.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include <sol-macros.h>
#include <sol-types.h>

#ifdef __cplusplus
extern "C" {
#endif

#define SOL_STR_STATIC_ASSERT_LITERAL(_s) ("" _s)

#define SOL_STR_SLICE_LITERAL(_s) { (sizeof(SOL_STR_STATIC_ASSERT_LITERAL(_s)) - 1), (_s) }

#define SOL_STR_SLICE_STR(_s, _len) (struct sol_str_slice){.len = (_len), .data = (_s) }

#define SOL_STR_SLICE_EMPTY { .len = 0, .data = "" }

#define SOL_STR_SLICE_PRINT(_s) (int)(_s).len, (_s).data

typedef struct sol_str_slice {
    size_t len; 
    const char *data; 
} sol_str_slice;

static inline bool
sol_str_slice_str_eq(const struct sol_str_slice a, const char *b)
{
    return b && a.len == strlen(b) && (memcmp(a.data, b, a.len) == 0);
}

static inline bool
sol_str_slice_eq(const struct sol_str_slice a, const struct sol_str_slice b)
{
    return a.len == b.len && (memcmp(a.data, b.data, a.len) == 0);
}

static inline bool
sol_str_slice_str_case_eq(const struct sol_str_slice a, const char *b)
{
    return b && a.len == strlen(b) && (strncasecmp(a.data, b, a.len) == 0);
}

static inline bool
sol_str_slice_case_eq(const struct sol_str_slice a, const struct sol_str_slice b)
{
    return a.len == b.len && (strncasecmp(a.data, b.data, a.len) == 0);
}

char *sol_str_slice_contains(const struct sol_str_slice haystack, const struct sol_str_slice needle);

static inline char *
sol_str_slice_str_contains(const struct sol_str_slice haystack, const char *needle)
{
    return sol_str_slice_contains(haystack, SOL_STR_SLICE_STR(needle, strlen(needle)));
}

static inline void
sol_str_slice_copy(char *dst, const struct sol_str_slice src)
{
    memcpy(dst, src.data, src.len);
    dst[src.len] = 0;
}

static inline bool
sol_str_slice_starts_with(const struct sol_str_slice slice, const struct sol_str_slice prefix)
{
    return slice.len >= prefix.len && strncmp(slice.data, prefix.data, prefix.len) == 0;
}

static inline bool
sol_str_slice_str_starts_with(const struct sol_str_slice slice, const char *prefix)
{
    size_t len = strlen(prefix);

    return slice.len >= len && strncmp(slice.data, prefix, len) == 0;
}

static
#ifndef DOXYGEN_RUN
    SOL_ATTR_NON_NULL(1)
#endif
inline struct sol_str_slice
sol_str_slice_from_str(const char *s)
{
    return SOL_STR_SLICE_STR(s, strlen(s));
}

static
#ifndef DOXYGEN_RUN
    SOL_ATTR_NON_NULL(1)
#endif
inline struct sol_str_slice
sol_str_slice_from_blob(const struct sol_blob *blob)
{
    return SOL_STR_SLICE_STR((char *)blob->mem, blob->size);
}

static inline struct sol_blob *
sol_str_slice_to_blob(const struct sol_str_slice slice)
{
    void *blob_mem;
    struct sol_blob *blob;

    blob_mem = malloc(slice.len);
    if (!blob_mem)
        return NULL;

    memcpy(blob_mem, slice.data, slice.len);

    blob = sol_blob_new(&SOL_BLOB_TYPE_DEFAULT, NULL,
        blob_mem, slice.len);

    if (!blob) {
        free(blob_mem);
        return NULL;
    }

    return blob;
}

int sol_str_slice_to_int(const struct sol_str_slice s, long int *value);

static inline char *
sol_str_slice_to_str(const struct sol_str_slice slice)
{
    return strndup(slice.data, slice.len);
}

static inline struct sol_str_slice
sol_str_slice_remove_leading_whitespace(struct sol_str_slice slice)
{
    struct sol_str_slice copy = slice;

    while (copy.len && isspace((uint8_t)*copy.data)) {
        copy.data++;
        copy.len--;
    }

    return copy;
}

static inline struct sol_str_slice
sol_str_slice_remove_trailing_whitespace(struct sol_str_slice slice)
{
    struct sol_str_slice copy = slice;

    while (copy.len != 0) {
        uint8_t c = copy.data[copy.len - 1];
        if (isspace(c))
            copy.len--;
        else
            break;
    }

    if (slice.len - copy.len)
        return copy;

    return slice;
}

static inline struct sol_str_slice
sol_str_slice_trim(struct sol_str_slice slice)
{
    return sol_str_slice_remove_trailing_whitespace
               (sol_str_slice_remove_leading_whitespace(slice));
}

struct sol_vector sol_str_slice_split(const struct sol_str_slice slice, const char *delim, size_t maxsplit);

bool sol_str_slice_split_iterate(const struct sol_str_slice slice, struct sol_str_slice *token, const char **itr, const struct sol_str_slice delim);

static inline bool
sol_str_slice_str_split_iterate(const struct sol_str_slice slice, struct sol_str_slice *token, const char **itr, const char *delim)
{
    return sol_str_slice_split_iterate(slice, token, itr, sol_str_slice_from_str(delim));
}

#ifdef __cplusplus
}
#endif