// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements.  See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership.  The ASF licenses this file

// to you 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.

// This file is copied from

// https://github.com/facebookincubator/velox/blob/main/velox/type/StringView.h

// And modified by Doris

#pragma once

#include <glog/logging.h>

#include <cstddef>

#include <cstdint>

#include <cstring>

#include <string>

#include "core/string_ref.h"

namespace doris {

// Variable length string or binary type for use in vectors. This has

// semantics similar to std::string_view or folly::StringPiece and

// exposes a subset of the interface. If the string is 12 characters

// or less, it is inlined and no reference is held. If it is longer, a

// reference to the string is held and the 4 first characters are

// cached in the StringView. This allows failing comparisons early and

// reduces the CPU cache working set when dealing with short strings.

class StringView {

public:

    using value_type = char;

    static constexpr size_t kPrefixSize = 4 * sizeof(char);

    static constexpr size_t kInlineSize = 12;

    StringView() {

        static_assert(sizeof(StringView) == 16);

        memset(this, 0, sizeof(StringView));

    }

    StringView(const char* data, uint32_t len) : size_(len) {

        DCHECK_GE(len, 0);

        DCHECK(data || len == 0);

        if (isInline()) {

            // Zero the inline part.

            // this makes sure that inline strings can be compared for equality with 2

            // int64 compares.

            memset(prefix_, 0, kPrefixSize);

            if (size_ == 0) {

                return;

            }

            // small string: inlined. Zero the last 8 bytes first to allow for whole

            // word comparison.

            value_.data = nullptr;

            memcpy(prefix_, data, size_);

        } else {

            // large string: store pointer

            memcpy(prefix_, data, kPrefixSize);

            value_.data = data;

        }

    }

    StringView(unsigned char* data, uint32_t len)

            : StringView(reinterpret_cast<const char*>(data), len) {}

    bool isInline() const { return isInline(size_); }

    ALWAYS_INLINE static constexpr bool isInline(uint32_t size) { return size <= kInlineSize; }

    explicit StringView(std::string&& value) = delete;

    explicit StringView(const std::string& value)

            : StringView(value.data(), cast_set<uint32_t>(value.size())) {}

    explicit StringView(std::string_view value)

            : StringView(value.data(), cast_set<uint32_t>(value.size())) {}

    /* implicit */ StringView(const char* data)

            : StringView(data, cast_set<uint32_t>(strlen(data))) {}

    doris::StringRef to_string_ref() const { return {data(), size()}; }

    operator std::string_view() && = delete;

    explicit operator std::string_view() const& { return {data(), size()}; }

    operator std::string() const { return std::string(data(), size()); }

    std::string str() const { return *this; }

    const char* data() && = delete;

    const char* data() const& { return isInline() ? prefix_ : value_.data; }

    uint32_t size() const { return size_; }

    bool empty() const { return size() == 0; }

    void set_size(uint32_t size) { size_ = size; }

    bool operator==(const StringView& other) const;

    friend std::ostream& operator<<(std::ostream& os, const StringView& stringView) {

        os.write(stringView.data(), stringView.size());

        return os;

    }

    auto operator<=>(const StringView& other) const {

        const auto cmp = compare(other);

        return cmp < 0   ? std::strong_ordering::less

               : cmp > 0 ? std::strong_ordering::greater

                         : std::strong_ordering::equal;

    }

    // Returns 0, if this == other

    //       < 0, if this < other

    //       > 0, if this > other

    int32_t compare(const StringView& other) const;

    const char* begin() && = delete;

    const char* begin() const& { return data(); }

    const char* end() && = delete;

    const char* end() const& { return data() + size(); }

    std::string dump_hex() const {

        static const char* kHex = "0123456789ABCDEF";

        std::string out;

        out.reserve(size_ * 2 + 2);

        out.push_back('0');

        out.push_back('x');

        const char* ptr = data();

        for (uint32_t i = 0; i < size_; ++i) {

            auto c = static_cast<unsigned char>(ptr[i]);

            out.push_back(kHex[c >> 4]);

            out.push_back(kHex[c & 0x0F]);

        }

        return out;

    }

private:

    inline int64_t size_and_prefix_as_int64() const {

        return reinterpret_cast<const int64_t*>(this)[0];

    }

    inline int64_t inlined_as_int64() const { return reinterpret_cast<const int64_t*>(this)[1]; }

    int32_t prefix_as_int() const { return *reinterpret_cast<const int32_t*>(&prefix_); }

    uint32_t size_;

    char prefix_[4];

    union {

        char inlined[8];

        const char* data;

    } value_;

};

} // namespace doris