Hippy项目源码分析补充（二）

最新推荐文章于 2021-12-27 20:37:28 发布
最新推荐文章于 2021-12-27 20:37:28 发布
阅读量127 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45870965/article/details/122179710
版权

C++17 string_view 性能优化 编码转换 字符串视图
关键词由CSDN通过智能技术生成

2021SC@SDUSC

#pragma once

#include <codecvt>
#include <locale>
#include <string>
#include <utility>

#include "base/logging.h"
#include "base/unicode_string_view.h"

#define EXTEND_LITERAL(ch) ch, ch, u##ch, U##ch

namespace hippy {
namespace base {

class StringViewUtils {
 public:
  using unicode_string_view = tdf::base::unicode_string_view;
  using u8string = unicode_string_view::u8string;
  using char8_t_ = unicode_string_view::char8_t_;

  inline static bool IsEmpty(const unicode_string_view& str_view) {
    unicode_string_view::Encoding encoding = str_view.encoding();
    switch (encoding) {
      case unicode_string_view::Encoding::Unkown: {
        return true;
      }
      case unicode_string_view::Encoding::Latin1: {
        return str_view.latin1_value().empty();
      }
      case unicode_string_view::Encoding::Utf16: {
        return str_view.utf16_value().empty();
      }
      case unicode_string_view::Encoding::Utf32: {
        return str_view.utf32_value().empty();
      }
      case unicode_string_view::Encoding::Utf8: {
        return str_view.utf8_value().empty();
      }
      default:
        break;
    }

    TDF_BASE_NOTREACHED();
  }

  static unicode_string_view CovertToLatin(
      const unicode_string_view& str_view,
      unicode_string_view::Encoding src_encoding) {
    switch (src_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return unicode_string_view(str_view.latin1_value());
      }
      case unicode_string_view::Encoding::Utf16:
      case unicode_string_view::Encoding::Utf32:
      case unicode_string_view::Encoding::Utf8:
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  static unicode_string_view CovertToUtf16(
      const unicode_string_view& str_view,
      unicode_string_view::Encoding src_encoding) {
    switch (src_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return unicode_string_view(
            CopyChars<char, char16_t>(str_view.latin1_value()));
      }
      case unicode_string_view::Encoding::Utf16: {
        return unicode_string_view(str_view.utf16_value());
      }
      case unicode_string_view::Encoding::Utf32: {
        return unicode_string_view(U32ToU16(str_view.utf32_value()));
      }
      case unicode_string_view::Encoding::Utf8: {
        return unicode_string_view(U8ToU16(str_view.utf8_value()));
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  static unicode_string_view CovertToUtf32(
      const unicode_string_view& str_view,
      unicode_string_view::Encoding src_encoding) {
    switch (src_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return unicode_string_view(
            CopyChars<char, char32_t>(str_view.latin1_value()));
      }
      case unicode_string_view::Encoding::Utf16: {
        return unicode_string_view(U16ToU32(str_view.utf16_value()));
      }
      case unicode_string_view::Encoding::Utf32: {
        return unicode_string_view(str_view.utf32_value());
      }
      case unicode_string_view::Encoding::Utf8: {
        return unicode_string_view(U8ToU32(str_view.utf8_value()));
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  static unicode_string_view CovertToUtf8(
      const unicode_string_view& str_view,
      unicode_string_view::Encoding src_encoding) {
    switch (src_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        const auto& str = str_view.latin1_value();
        auto ptr =
            reinterpret_cast<const unicode_string_view::char8_t_*>(str.c_str());
        return unicode_string_view(ptr, str.length());
      }
      case unicode_string_view::Encoding::Utf16: {
        return unicode_string_view(U16ToU8(str_view.utf16_value()));
      }
      case unicode_string_view::Encoding::Utf32: {
        return unicode_string_view(U32ToU8(str_view.utf32_value()));
      }
      case unicode_string_view::Encoding::Utf8: {
        return unicode_string_view(str_view.utf8_value());
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  static unicode_string_view Convert(
      const unicode_string_view& str_view,
      unicode_string_view::Encoding dst_encoding) {
    unicode_string_view::Encoding src_encoding = str_view.encoding();
    switch (dst_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return CovertToLatin(str_view, src_encoding);
      }
      case unicode_string_view::Encoding::Utf16: {
        return CovertToUtf16(str_view, src_encoding);
      }
      case unicode_string_view::Encoding::Utf32: {
        return CovertToUtf32(str_view, src_encoding);
      }
      case unicode_string_view::Encoding::Utf8: {
        return CovertToUtf8(str_view, src_encoding);
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  inline static const char* U8ToConstCharPointer(
      const unicode_string_view::char8_t_* p) {
    return reinterpret_cast<const char*>(p);
  }

  inline static const unicode_string_view::char8_t_* ToU8Pointer(
      const char* p) {
    return reinterpret_cast<const unicode_string_view::char8_t_*>(p);
  }

  inline static const char* ToConstCharPointer(
      const unicode_string_view& str_view,
      unicode_string_view& view_owner) {
    TDF_BASE_DCHECK(view_owner.encoding() ==
                    unicode_string_view::Encoding::Utf8);
    unicode_string_view::Encoding encoding = str_view.encoding();
    switch (encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return str_view.latin1_value().c_str();
      }
      case unicode_string_view::Encoding::Utf8: {
        return U8ToConstCharPointer(str_view.utf8_value().c_str());
      }
      case unicode_string_view::Encoding::Utf16:
      case unicode_string_view::Encoding::Utf32: {
        unicode_string_view::u8string& ref = view_owner.utf8_value();
        ref =
            Convert(str_view, unicode_string_view::Encoding::Utf8).utf8_value();
        return U8ToConstCharPointer(ref.c_str());
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
    TDF_BASE_NOTREACHED();
  }

  inline static unicode_string_view ConstCharPointerToStrView(const char* p,
                                                              size_t len = -1) {
    size_t length;
    if (len == -1) {
      length = strlen(p);
    } else {
      length = len;
    }
    return unicode_string_view(
        reinterpret_cast<const unicode_string_view::char8_t_*>(p), length);
  }

  inline static std::string ToU8StdStr(const unicode_string_view& str_view) {
    unicode_string_view::u8string str =
        Convert(str_view, unicode_string_view::Encoding::Utf8).utf8_value();
    return std::string(U8ToConstCharPointer(str.c_str()), str.length());
  }

  inline static size_t FindLastOf(const unicode_string_view& str_view,
                                  unicode_string_view::char8_t_ u8_ch,
                                  char ch,
                                  char16_t u16_ch,
                                  char32_t u32_ch) {
    unicode_string_view::Encoding encoding = str_view.encoding();
    switch (encoding) {
      case unicode_string_view::Encoding::Latin1: {
        const std::string& str = str_view.latin1_value();
        return str.find_last_of(ch);
      }
      case unicode_string_view::Encoding::Utf16: {
        const std::u16string& str = str_view.utf16_value();
        return str.find_last_of(u16_ch);
      }
      case unicode_string_view::Encoding::Utf32: {
        const std::u32string& str = str_view.utf32_value();
        return str.find_last_of(u32_ch);
      }
      case unicode_string_view::Encoding::Utf8: {
        const unicode_string_view::u8string& str = str_view.utf8_value();
        return str.find_last_of(u8_ch);
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }

    TDF_BASE_NOTREACHED();
  }

  inline static unicode_string_view SubStr(const unicode_string_view& str_view,
                                           size_t pos,
                                           size_t n) {
    unicode_string_view::Encoding encoding = str_view.encoding();
    switch (encoding) {
      case unicode_string_view::Encoding::Latin1: {
        const std::string& str = str_view.latin1_value();
        return unicode_string_view(str.substr(pos, n));
      }
      case unicode_string_view::Encoding::Utf16: {
        const std::u16string& str = str_view.utf16_value();
        return unicode_string_view(str.substr(pos, n));
      }
      case unicode_string_view::Encoding::Utf32: {
        const std::u32string& str = str_view.utf32_value();
        return unicode_string_view(str.substr(pos, n));
      }
      case unicode_string_view::Encoding::Utf8: {
        const unicode_string_view::u8string& str = str_view.utf8_value();
        return unicode_string_view(str.substr(pos, n));
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }

    TDF_BASE_NOTREACHED();
  }

  inline static size_t GetLength(const unicode_string_view& str_view) {
    unicode_string_view::Encoding encoding = str_view.encoding();
    switch (encoding) {
      case unicode_string_view::Encoding::Latin1: {
        const std::string& str = str_view.latin1_value();
        return str.length();
      }
      case unicode_string_view::Encoding::Utf16: {
        const std::u16string& str = str_view.utf16_value();
        return str.length();
      }
      case unicode_string_view::Encoding::Utf32: {
        const std::u32string& str = str_view.utf32_value();
        return str.length();
      }
      case unicode_string_view::Encoding::Utf8: {
        const unicode_string_view::u8string& str = str_view.utf8_value();
        return str.length();
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }

    TDF_BASE_NOTREACHED();
  }

 private:
  template <typename SrcChar, typename DstChar>
  inline static std::basic_string<DstChar> CopyChars(
      const std::basic_string<SrcChar>& src) {
    static_assert(sizeof(SrcChar) <= sizeof(DstChar), "copy downgrade");

    size_t len = src.length();
    std::basic_string<DstChar> dst;
    dst.resize(len);
    std::copy_n(src.c_str(), len, &dst[0]);
    return dst;
  }

  inline static unicode_string_view::u8string U32ToU8(
      const std::u32string& str) {
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
    std::string bytes = conv.to_bytes(str);
    const unicode_string_view::char8_t_* ptr =
        reinterpret_cast<const unicode_string_view::char8_t_*>(bytes.data());
    return unicode_string_view::u8string(ptr, bytes.length());
  }

  inline static std::u32string U8ToU32(
      const unicode_string_view::u8string& str) {
    const char* ptr = reinterpret_cast<const char*>(str.c_str());
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
    return conv.from_bytes(ptr, ptr + str.length());
  }

  inline static unicode_string_view::u8string U16ToU8(
      const std::u16string& str) {
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    std::string bytes = convert.to_bytes(str);
    const unicode_string_view::char8_t_* ptr =
        reinterpret_cast<const unicode_string_view::char8_t_*>(bytes.data());
    return unicode_string_view::u8string(ptr, bytes.length());
  }

  inline static std::u16string U8ToU16(
      const unicode_string_view::u8string& str) {
    const char* ptr = reinterpret_cast<const char*>(str.c_str());
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
    return convert.from_bytes(ptr, ptr + str.length());
  }

  inline static std::u16string U32ToU16(const std::u32string& str) {
    std::wstring_convert<std::codecvt_utf16<char32_t>, char32_t> convert;
    std::string bytes = convert.to_bytes(str);
    return std::u16string(reinterpret_cast<const char16_t*>(bytes.c_str()),
                          bytes.length() / sizeof(char16_t));
  }

  inline static std::u32string U16ToU32(const std::u16string& str) {
    const char16_t* ptr = str.c_str();
    std::wstring_convert<std::codecvt_utf16<char32_t>, char32_t> convert;
    return convert.from_bytes(
        reinterpret_cast<const char*>(ptr),
        reinterpret_cast<const char*>(ptr + str.length()));
  }
};

}  // namespace base
}  // namespace hippy

namespace tdf {
namespace base {

inline unicode_string_view operator+(const unicode_string_view& lhs,
                                     const unicode_string_view& rhs) {
  using StringViewUtils = hippy::base::StringViewUtils;
  unicode_string_view::unicode_string_view::Encoding lhs_encoding =
      lhs.encoding();
  unicode_string_view::Encoding rhs_encoding = rhs.encoding();
  if (lhs_encoding <= rhs_encoding) {
    switch (rhs_encoding) {
      case unicode_string_view::Encoding::Latin1: {
        return unicode_string_view(
            StringViewUtils::Convert(lhs, rhs_encoding).latin1_value() +
            rhs.latin1_value());
      }
      case unicode_string_view::Encoding::Utf16: {
        return unicode_string_view(
            StringViewUtils::Convert(lhs, rhs_encoding).utf16_value() +
            rhs.utf16_value());
      }
      case unicode_string_view::Encoding::Utf32: {
        return unicode_string_view(
            StringViewUtils::Convert(lhs, rhs_encoding).utf32_value() +
            rhs.utf32_value());
      }
      case unicode_string_view::Encoding::Utf8: {
        return unicode_string_view(
            StringViewUtils::Convert(lhs, rhs_encoding).utf8_value() +
            rhs.utf8_value());
      }
      default: {
        TDF_BASE_NOTREACHED();
      }
    }
  }

  switch (lhs_encoding) {
    case unicode_string_view::Encoding::Latin1: {
      return unicode_string_view(
          lhs.latin1_value() +
          StringViewUtils::Convert(rhs, lhs_encoding).latin1_value());
    }
    case unicode_string_view::Encoding::Utf16: {
      return unicode_string_view(
          lhs.utf16_value() +
          StringViewUtils::Convert(rhs, lhs_encoding).utf16_value());
    }
    case unicode_string_view::Encoding::Utf32: {
      return unicode_string_view(
          lhs.utf32_value() +
          StringViewUtils::Convert(rhs, lhs_encoding).utf32_value());
    }
    case unicode_string_view::Encoding::Utf8: {
      return unicode_string_view(
          lhs.utf8_value() +
          StringViewUtils::Convert(rhs, lhs_encoding).utf8_value());
    }
    default: {
      TDF_BASE_NOTREACHED();
    }
  }
  TDF_BASE_NOTREACHED();
}

}  // namespace base
}  // namespace tdf

C++17 string_view简析：

string_view是c++17标准库提供的一个类，它提供一个字符串的视图，即可以通过这个类以各种方法“观测”字符串，但不允许修改字符串。

构造和求substr都是O(1)的复杂度

std的string的构造不可避免的会设计内存分配和拷贝。而string_view只是一个字符串的视图，构造函数可以避免拷贝，做到O(1)复杂度。

const std::basic_string<char, std::char_traits<char>, Allocator>& str) noexcept 
    : ptr_(str.data()), length_(CheckLengthInternal(str.size())) {}

从上面的代码可以看出，string_view的构造函数，仅仅是记录的字符串的指针地址和字符串长度，并未进行拷贝。

string_view::substr的原理类似，只是指针移动操作，返回一个子string_view。

有效性：

在string_view面世之前，一个接受const char*的函数， 加入想要传入string， 还需要把string使用c_str()转换才行。而现在，string_view可以完全兼容两者。

注意事项：

1.string_view并没有尾0 （'\0），所以在输出的时候，要注意边界。
2.因为string_view并不拷贝内存，所以要特别注意它所指向的字符串的生命周期。string_view指向的字符串，不能再string_view死亡之前被回收。



 

countryrain
关注
基于Java语言的HappyRun跑步软件设计源码下载
10-12
本项目提供HappyRun跑步软件的Java源码下载，包含262个文件，涵盖84个Java源文件、80个XML配置文件、73个PNG图片文件、10个JPG图片文件、3个Gradle构建文件、2个Git忽略文件、2个JAR包文件以及少量其他文件类型，...
Hippy项目源码分析 （一）
weixin_45870965的博客
10-11 269
2021SC@SDUSC 上篇文章已说明我的分工：Core全部内容 Core： C++ 实现的 JS 模块，通过 Binding 方式运行在 JS 引擎中。 include： include\core\base\base_time.h include\core\base\common.h include\core\base\file.h include\core\base\hash.h include\core\base\js_value_wrapper.h 小结：以上为..
Hippy项目源码分析Week3
B1uePoi的博客
10-24 2361
2021SC@SDUSC Hippy项目源码分析第三周FlexAlignFlexGrowFlexShrinkFlexOverflowFlexPositionType 本篇内容接上周分析 FlexAlign Flex项目在容器侧轴对齐方式，类似于FlexJustify，只不过不是水平方向，而是纵向，这个属性可以设置所有Flex项目对齐方式，并且包括匿名元素 STRETCH Flex项目沿着Flex容器侧轴方向填满整个Flex容器高度（或宽度） FLEX_START Flex项目并列在Flex容器侧轴开始
Hippy项目源码分析Week1
B1uePoi的博客
10-10 211
2021SC@SDUSC Hippy项目源码分析第一周layout\android\java\flexflex\FlexAlign.javaFlexConstants.javaFlexCSSDirction.javaFlexDirection.javaFlexJustify.javaFlexMeasureMode.javaFlexNodeAPI.javaFlexOutput.javaFlexOverflow.javaFlexPositionType.javaFlexSpacing.javaFlexWrap.
Hippy项目源码分析总结
weixin_45870965的博客
12-27 551
2021SC@SDUSC #include <memory> #include <string> #include <vector> #include "base/unicode_string_view.h" namespace hippy { namespace base { class UriLoader { public: using unicode_string_view = tdf::base::unicode_string_view; u
Hippy项目源码分析（六）
weixin_45870965的博客
12-27 312
2021SC@SDUSC 首篇文章已说明我的分工：Core全部内容 include\core\napi\jcs\js_native_jsc_helper.h #pragma once #include <JavaScriptCore/JavaScriptCore.h> #include <string> #include "core/napi/js_native_api_types.h" #include "core/napi/jsc/js_native_api
基于Java的Happy Captcha设计源码验证码软件包
最新发布
09-29
Happy Captcha是一个简洁高效的Java验证码软件包，它通过最小化代码量，帮助开发者快速实现Web站点验证码功能。该软件包包含20个文件，其中12个为Java源文件，4个为字体文件（ttf），并提供Apache 2.0开源许可，使...
Bubble Shooter 松鼠泡泡射手Unity游戏项目源码C#
02-16
Bubble Shooter 松鼠泡泡射手Unity游戏项目源码C# 支持Unity版本2020.1.14f1及以上 商品描述 怎么玩？ • 在屏幕上滑动手指，将球射向气球并粘在最近的球上。 • 当您看到3 个相同颜色的球在一起时，您可以添加更多...
表情识别源码二分类happy——disgust
11-06
happy表情识别率
HappyGo项目.zip
11-04
培训机构里的JAVA课程项目，项目使用HTML5+CSS3设计页面，使用的是JSP+Servlet实现，数据库用MySQL，应用了Bootstrap v4、JQuery等框架。 包含完整的静态页面和数据库脚本文件
Hippy项目源码分析（二）
weixin_45870965的博客
10-19 295
2021SC@SDUSC 首篇文章已说明我的分工：Core全部内容 目录 include\core\base\macros.h include\core\base\string_view_utils.h include\core\base\task.h include\core\base\task_runner.h include\core\base\thread.h 小结 include\core\base\macros.h #pragma once #include &l.
Hippy项目源码分析（三）
weixin_45870965的博客
12-16 4592
2021SC@SDUSC 首篇文章已说明我的分工：Core全部内容 目录 include\core\base\thread_id.h include\core\base\uri_loader.h include\core\base\thread_id.h #pragma once #include <pthread.h> #include <stdint.h> namespace hippy { namespace base { class Th...
Hippy项目源码分析Week8
B1uePoi的博客
11-28 114
2021SC@SDUSC Hippy项目源码分析第八周layout/engineHippy.hHippy.cppHPLayoutCache.hHPLayoutCache.cppHPNode.hHPNode.cpp layout/engine Hippy.h 预定义了若干函数，引用了HPNode.h，被Hippy.cpp引用，将其中预定义的函数进行实现 具体代码不再列出 Hippy.cpp 实现了Node的各项参数的setter和getter方法，具体代码不再列出 HPLayoutCache.h 定义了一个结
Hippy项目源码分析补充（一）
weixin_45870965的博客
12-27 406
2021SC@SDUSC #pragma once #include <cstdlib> #include <string> #include <unordered_map> #include <vector> namespace hippy { namespace base { class JSValueWrapper final { public: using JSObjectType = typename std::unordered_ma
Hippy项目源码分析（五）
weixin_45870965的博客
12-27 333
2021SC@SDUSC 首篇文章已说明我的分工：Core全部内容 include\core\modules\timer_module.h #pragma once #include <memory> #include <unordered_map> #include <utility> #include "core/base/task.h" #include "core/modules/module_base.h" #include "core/napi
Hippy项目源码分析（四）
weixin_45870965的博客
12-16 753
2021SC@SDUSC 首篇文章已说明我的分工：Core全部内容 目录 include\core\modules\console_module.h include\core\modules\contextify_module.h include\core\modules\module_base.h include\core\modules\module_register.h include\core\modules\console_module.h #pragma once ...
Hippy项目源码分析Week12
B1uePoi的博客
12-26 1213
2021SC@SDUSC Hippy项目源码分析第十二周examples/android-demo/javaMyActivityTiny.javaMyAPIProvider.java examples/android-demo/java MyActivityTiny.java @SuppressWarnings({"unused"}) public class MyActivityTiny extends Activity { private HippyEngine mHippyEngine; priv
Hippy项目源码分析Week4
B1uePoi的博客
10-31 1466
2021SC@SDUSC Hippy项目源码分析第四周layout/android/jniJNI是什么？FlexNode.h layout/android/jni JNI是什么？ JNI是Java Native Interface的缩写，通过使用Java本地接口书写程序，可以确保代码在不同的平台上方便移植，从java1.1开始，JNI标准成为java平台的一部分，它允许java代码和其他语言写的代码进行交互，JNI一开始是为了与本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其它编程语言，只要
Hippy项目源码分析Week11
B1uePoi的博客
12-19 2396
2021SC@SDUSC Hippy项目源码分析第十一周examples/android-demo/javaMyActivity.java layout文件下的源码基本分析完毕，开始分析examples目录下的android-demo文件夹 examples/android-demo/java 该文件夹下是Hippy项目在安卓的一些演示实例，供开发者参考 MyActivity.java public class MyActivity extends Activity { private HippyEngi
Happy Captcha验证码简易版v1.0.1源码发布
资源摘要信息:"Happy Captcha简易验证码 v1.0.1-源码.zip" 标题分析: - "Happy Captcha"：这可能是验证码服务的名称或者验证码组件的名称。在互联网应用中，验证码被广泛用于区分人类用户和自动化脚本，以增强网站...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值