JoinString.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    [[nodiscard]] String joinString(const String& s, const Vector<String>& values);
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> void toStringListPrimary(Vector<String>& list, const T& value) { list.push_back(value); }
 
    template<> void toStringListPrimary<std::size_t>(Vector<String>& list, const std::size_t& value);
 
    template<> void toStringListPrimary<int>(Vector<String>& list, const int& value);
 
    // Forward declaration (required for GCC and clang)
    template<typename... Args> void toStringList(Vector<String>& list, Args&&... args);
 
    template<typename Arg0, typename... ArgsN> void toStringListSecondary(Vector<String>& list, Arg0&& arg0, ArgsN&&... argsN) {
        toStringListPrimary(list, std::forward<Arg0>(arg0));
        toStringList(list, std::forward<ArgsN>(argsN)...);
    }
 
    template<typename... Args> void toStringList(Vector<String>& list, Args&&... args) { toStringListSecondary(list, std::forward<Args>(args)...); }
 
    template<> void toStringList(Vector<String>& list);
 
    template<typename Arg0> void toStringListSecondary(Vector<String>& list, Arg0&& arg0) { toStringListPrimary(list, std::forward<Arg0>(arg0)); }
 
    // ---------------------------------------------------------------------------------------------
 
    class JoinableString {
    public:
        JoinableString() = default;
        JoinableString(const char* s);
 
        JoinableString(const JoinableString&) = default;
        JoinableString& operator=(const JoinableString&) = default;
 
        // see JoinString
        [[nodiscard]] String join(const Vector<String>& values = {}) const;
 
        template<typename... Args> String operator()(Args&&... args) const {
            Vector<String> values;
            toStringList(values, std::forward<Args>(args)...);
            return join(values);
        }
 
        // Returns only the string without any transformation.
        [[nodiscard]] inline operator String() const { return join({}); }
 
        [[nodiscard]] inline operator std::string() const { return std::string(join({}).c_str()); }
 
    private:
        const char* mString = nullptr;
        bool mCanJoin = false;
    };
 
    // Returns lhs.join() + rhs
    inline String operator+(const JoinableString& lhs, const String& rhs) { return lhs.join() + rhs; }
 
    // Returns lhs + rhs.join()
    inline String operator+(const String& lhs, const JoinableString& rhs) { return lhs + rhs.join(); }
 
} // namespace CeresEngine::ShaderCompiler