copperspice / cs_string

Header-only library providing unicode aware string support for C++

CopperSpice

Introduction

CopperSpice is a set of individual libraries which can be used to develop cross platform software applications in C++. It is a totally open source project released under the LGPL V2.1 license and was initially derived from the Qt framework. Over the last several years CopperSpice has completely diverged, with a goal of providing a first class GUI library to unite the C++ community.

Our motivation for developing CopperSpice was to change the fundamental design and turn the existing framework into a set of libraries for C++ developers. We are accomplishing this by leveraging modern C++ functionality, new technology, and modern tooling. CopperSpice currently requires C++17 or newer.

The libraries available in CopperSpice include:

• CsCore
• CsGui
• CsMultimedia
• CsNetwork
• CsOpenGL
• CsScript
• CsSql
• CsSvg
• CsVulkan
• CsWebKit
• CsXml
• CsXmlPatterns

There are also several open source BSD licensed libraries which are used by CopperSpice and available as stand alone libraries for anyone developing C++ applications.

• CsCrypto
• CsLibGuarded
• CsPaint
• CsPointer
• CsSignal
• CsString

System Requirements

To use the CopperSpice libraries a C++17 compiler and a C++17 standard library are required.

CopperSpice CMake build files are provided with the source distribution. We recommend your projects should also use CMake and Ninja for the build system.

For additional information about building from source, refer to our CopperSpice Overview Documentation or the KitchenSink demo application for sample CMake project files.

Building

The CopperSpice libraries are built using the CMake build system.

Using the CopperSpice Libraries

• Any C++ application using CopperSpice can be built with CMake or any build system which imports CMake files
• CopperSpice can be linked directly into any standard C++ application

Documentation

Overview

The CopperSpice Overview documentation includes information on building CopperSpice, downloading prebuilt binary files, package requirements, setting up an application which links with CopperSpice, migrating to CopperSpice, and general configuration information.

https://www.copperspice.com/docs/cs_overview/index.html

API

The API contains full class documentation and multiple tutorials for CopperSpice and is available directly on our website and from our download page.

https://www.copperspice.com/docs/cs_api/index.html

Offline

Both the CS Overview and API documentation can be downloaded for offline use. They are available in a compressed tar file or zip format.

https://download.copperspice.com/copperspice/documentation

Major Enhancements

• Reflection
  • No Meta-Object Compiler is required for generating meta data, all references were removed
  • The functionality provided by moc was replaced with compile time templates
  • CopperSpice automatically generates meta data for processing Signals/ Slots and Introspection
  • A template class can now inherit from QObject with no restrictions on types
  • Complex data types such as QMap<QString, int> can be used for signal or slot arguments

• Enhanced Functionality
  • CopperSpice makes extensive use of modern C++ features
    • constexpr, lambda expressions, templates, variadic templates, template variables
    • move semantics, structured bindings, tuple, decltype, SFINAE, and type traits
  • Redesigned all container classes to use the C++ standard library containers, iterators, and algorithms
  • Refactored all Mutex and Lock classes
  • CopperSpice includes a majority of the Qt 5 classes
  • Platform independent plugin system based on standard C++
  • High DPI Rendering Support
  • Redesigned pointer classes

• Integration of CsLibGuarded
  • Used to manage shared data

• Integration of CsSignal
  • Improved thread aware Signal/Slot delivery
  • Increased efficiency while maintaining the full Signal/Slot API
  • Deadlocks in Signal/Slot processing have been eliminated

• Integration of CsString
  • Improved storage to properly represent Unicode strings
  • QString8 (UTF-8) and QString16 (UTF-16) classes
  • Added QStringView, QStringParser, and QRegularExpression

Presentations

Our YouTube channel contains videos about C++, graphics, build systems, CopperSpice, DoxyPress, and other topics related to software development.

https://www.youtube.com/copperspice

Links to technical presentations recorded at CppCon, CppNow, embBO++, MeetingC++, and code::dive, can be found on our presentation page.

https://www.copperspice.com/presentations.html

Authors and Key Contributors

The CS team welcomes contributors of all skill levels. When submitting a pull request please observe our Coding Style Guidelines.

https://www.copperspice.com/style_guide/source_code_style.html

• Ansel Sermersheim
• Barbara Geller
• Jan Wilmans
• Tim van Deurzen
• Paul Bendixen
• Peter Bindels
• Mortaro Marcello
• Adam Mensel
• Robin Mills
• Ivailo Monev
• Adam Mensel
• Matan Nassaw
• Jeff Cohen
• Daniel Pfeifer
• Zbigniew Skowron
• Johan Förberg
• Dennis Menschel

License

This library is released under the LGPL V2.1 license. For more information refer to the LICENSE file provided with this project.

References

• Website: https://www.copperspice.com
• Twitter: https://twitter.com/copperspice_cpp
• Email: [email protected]

• Github: https://github.com/copperspice

• Forum: https://forum.copperspice.com
• Journal: https://journal.copperspice.com

cs_string's Issues

MSVC linker warning:

LINK : warning LNK4044: unrecognized option '/Wl,--no-undefined'; ignored

In cmake the compiler ID is the most robust way to identify the compiler used.
E.g.
<$<CXX_COMPILER_ID:MSVC>:/wd4715>

Request for Discussions Section

Hi I know you by my teacher I am happy to know you are there

Could you please open a Discussion Section as a quick and safe solution for learning your projects ?

See you there

size_t and int usage and other issue

CsString has some inconsistent use of int and size_t. E.g. here:
int walk(int len, std::vector<storage_unit>::const_iterator iter)

What is the idea behind using the namespace CsString?
Does the statement
using namespace CsString;
not lead to name conflicts with the class?

CsChar is not exported on Windows.
class CsChar { ... };
in file cs_char.h

Does the statement below create a temp. CsString?
CsString::CsStringView text{ "hello" };
If yes then any further use of 'text' will cause problems.

Cmake
Visual Studio C++ does not have the option -wl

The header files are not included in the project, but
this is helpful for IDEs that support header files in
the project (e.g. CLion, Visual Studio).

Best regards
Thomas Krenn

Compile failure on storage on OSX build

Not sure where else to put this information, feel free to just close it if its in the wrong place.

---

Here's what's installed

12:10:13 doolin@inventium:~/src/cs_string (git:master:bf347f4) ruby-2.4.1
$ g++ --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 8.0.0 (clang-800.0.42.1)
Target: x86_64-apple-darwin16.6.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

---

Here's the build output

$ make check
/Applications/Xcode.app/Contents/Developer/usr/bin/make check-am
/Applications/Xcode.app/Contents/Developer/usr/bin/make bin/test
g++ -DPACKAGE_NAME="cs_string" -DPACKAGE_TARNAME="cs_string" -DPACKAGE_VERSION="1.0.0" -DPACKAGE_STRING="cs_string\ 1.0.0" -DPACKAGE_BUGREPORT="[email protected]" -DPACKAGE_URL="" -DPACKAGE="cs_string" -DVERSION="1.0.0" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_DLFCN_H=1 -DLT_OBJDIR=".libs/" -DSIZEOF_SIZE_T=8 -DQT_SHARED -I./src -DCS_STRING_ALLOW_UNSAFE -g -O2 -std=c++11 -MT test/bin_test-main.o -MD -MP -MF test/.deps/bin_test-main.Tpo -c -o test/bin_test-main.o test -f 'test/main.cpp' || echo './'test/main.cpp
test/main.cpp:100:28: error: character too large for enclosing character literal type
CsString::CsChar c127 = '¿';
^
test/main.cpp:104:28: error: character too large for enclosing character literal type
CsString::CsChar c256 = '↴';
^
test/main.cpp:110:26: error: character too large for enclosing character literal type
CsString::CsChar cX = '𝅘𝅥𝅮';
^
3 errors generated.
make[2]: *** [test/bin_test-main.o] Error 1
make[1]: *** [check-am] Error 2
make: *** [check] Error 2

---

Remarks

Given the structure of test_o2, it might be worthwhile separating these cases (CsString::CsChar c127 = '¿';) from the CsString::CsChar u127 = UCHAR('¿');. That is, collect the known bogosity into its own test.

cmake - include header files

For users with an IDE (CLion or MSVC) it is helpful to include the header to the project.

Inconsistent 'size_type' and 'int' usage

MSVC warnings:
'argument': conversion from 'CsString::CsStringIterator<E,A>::size_type' to 'int'

'walk' takes an int as first argument.
E.g. here:
template <typename E, typename A> CsStringIterator<E,A> &CsStringIterator<E,A>::operator+=(size_type n) { m_iter += E::walk(n, m_iter); return *this; }

in

walk(int len, std::vector<storage_unit>::const_iterator iter)

Encodings do not check iterator limits

This seems implicitly to violate the boundaries of the data structure you're iterating over, which would lead to invalid inputs causing crashes. For example, seeking 3 characters forward in a 3-code unit / 1 code point string would exceed the string length & read undefined memory.

string 1.3.1

Current cmake file indicates 1.3.1 but there is no tag on this repository
Do you expect to release a new version of string at some point ?

CsStringView dangling pointer?

Over here:
https://en.cppreference.com/w/cpp/string/basic_string_view
they say:

std::string_view good("a string literal"); // OK: "good" points to a static array std::string_view bad("a temporary string"s); // "bad" holds a dangling pointer
The first example is not working with CsStringView.

Documentation for constData() wrong?

There seems to be an error in the documentation of the constData() method: it should have return type "const typename E::storage_unit *" and not "void".

From https://www.copperspice.com/docs/cs_string/class_csstring_1_1csbasicstring.html#ac353b4a5bfcdfde79571314d373fbd04

template<typename E, typename A = std::allocator>
void CsString::CsBasicString< E, A >::constData() const

Returns a pointer to the null terminated data stored in this CsBasicString. The pointer is valid until the string is modified.