string.hpp

Go to the documentation of this file.

#pragma once
#define __XTD_CORE_INTERNAL__
#include "internal/__string_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#include "basic_string.hpp"
#include "character.hpp"
#include "index.hpp"
#include "stringable.hpp"
#include "collections/generic/enumerable_generator.hpp"
#include "collections/generic/key_value_pair.hpp"
#include "linq/enumerable_.hpp"

namespace xtd {
  using string = xtd::basic_string<char>;
  
  using ustring [[deprecated("Replaced by xtd::string - Will be removed in version 1.2.0.")]] = xtd::string;
  
  [[nodiscard]] auto to_string(int val) -> xtd::string;
  [[nodiscard]] auto to_string(unsigned val) -> xtd::string;
  [[nodiscard]] auto to_string(long val) -> xtd::string;
  [[nodiscard]] auto to_string(unsigned long val) -> xtd::string;
  [[nodiscard]] auto to_string(long long val) -> xtd::string;
  [[nodiscard]] auto to_string(unsigned long long val) -> xtd::string;
  [[nodiscard]] auto to_string(float val) -> xtd::string;
  [[nodiscard]] auto to_string(double val) -> xtd::string;
  [[nodiscard]] auto to_string(long double val) -> xtd::string;
  template<typename type_t>
  [[nodiscard]] inline auto to_string(type_t val) -> xtd::string {
    return string::format("{}", val);
  }
  
  template<typename type_t>
  [[deprecated("Replaced by xtd::to_string - Will be removed in version 1.2.0.")]]
  [[nodiscard]] inline auto to_ustring(type_t val) -> xtd::string {
    return to_string(val);
  }

  namespace collections {
    namespace generic {
      template<typename type_t>
      auto enumerable_generator<type_t>::to_string() const -> xtd::string {
        auto result = xtd::string {"["};
        for (auto item : self_)
          result += xtd::string::format("{}{}", result != "[" ? ", " : "", item);
        return result + "]";
      }
    }
  }
  template<typename char_t, typename other_t>
  requires (xtd::stringable<other_t> && !xtd::textual<other_t> && !xtd::character<other_t>)
  auto operator +=(xtd::basic_string<char_t>& first, const other_t& second) -> xtd::basic_string<char_t>& {
    first += xtd::string::format("{}", second);
    return first;
  }
  
  template<typename char_t, typename other_t>
  requires (xtd::stringable<other_t> && !xtd::textual<other_t> && !xtd::character<other_t>)
  auto operator +(const xtd::basic_string<char_t>& first, const other_t& second) -> xtd::basic_string<char_t> {
    return xtd::string::format("{}{}", first, second);
  }
 
  template<typename char_t, typename other_t>
  requires (xtd::stringable<other_t> && !xtd::textual<other_t> && !xtd::character<other_t>)
  auto operator +(const char_t* first, const other_t& second) -> xtd::basic_string<char_t> {
    return xtd::string::format("{}{}", first, second);
  }
 
  template<typename char_t, typename other_t>
  requires (xtd::stringable<other_t> && !xtd::textual<other_t> && !xtd::character<other_t>)
  auto operator +(const other_t& first, const xtd::basic_string<char_t>& second) -> xtd::basic_string<char_t> {
    return xtd::string::format("{}{}", first, second);
  }
 
  template<typename char_t, typename other_t>
  requires (xtd::stringable<other_t> && !xtd::textual<other_t> && !xtd::character<other_t>)
  auto operator +(const other_t& first, const char_t* second) -> xtd::basic_string<char_t> {
    return xtd::string::format("{}{}", first, second);
  }
}

template<typename char_t, typename traits_t, typename allocator_t>
auto xtd::basic_string<char_t, traits_t, allocator_t>::operator [](const xtd::index& index) const -> const_reference {return operator [](index.get_offset(length()));}
 
template<typename char_t, typename traits_t, typename allocator_t>
auto xtd::basic_string<char_t, traits_t, allocator_t>::operator ()(const xtd::index& index) const -> const_reference {return operator [](index);}
 
template<typename type_t>
[[nodiscard]] inline auto __to_string_istringable_to_string(const xtd::istringable<type_t>* obj) -> std::string {
  return obj->to_string();
}
 
template<typename key_t, typename value_t>
[[nodiscard]] inline auto xtd::collections::generic::key_value_pair<key_t, value_t>::to_string() const noexcept -> xtd::string {return xtd::string::format("({}, {})", first, second);}
 
inline auto xtd::linq::enumerable::repeat(const char* element, xtd::usize count) -> xtd::collections::generic::enumerable_generator<xtd::string> {
  for (auto index = xtd::usize {}; index < count; ++index)
    co_yield element;
}
 
inline auto xtd::linq::enumerable::repeat(const xtd::char16* element, xtd::usize count) -> xtd::collections::generic::enumerable_generator<xtd::string> {
  for (auto index = xtd::usize {}; index < count; ++index)
    co_yield element;
}
 
inline auto xtd::linq::enumerable::repeat(const xtd::char32* element, xtd::usize count) -> xtd::collections::generic::enumerable_generator<xtd::string> {
  for (auto index = xtd::usize {}; index < count; ++index)
    co_yield element;
}
 
inline auto xtd::linq::enumerable::repeat(const xtd::char8* element, xtd::usize count) -> xtd::collections::generic::enumerable_generator<xtd::string> {
  for (auto index = xtd::usize {}; index < count; ++index)
    co_yield element;
}
 
inline auto xtd::linq::enumerable::repeat(const xtd::wchar* element, xtd::usize count) -> xtd::collections::generic::enumerable_generator<xtd::string> {
  for (auto index = xtd::usize {}; index < count; ++index)
    co_yield element;
}
 
template<typename type_t>
[[nodiscard]] inline auto __opaque_xtd_linq_enumerable_collection__<type_t>::to_string() const -> xtd::string {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
 
template<typename type_t, typename param_t>
[[nodiscard]] inline auto __opaque_xtd_linq_lazy_enumerable__<type_t, param_t>::to_string() const -> xtd::string {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
 
template<typename type_t>
[[nodiscard]] inline auto xtd::reference_wrapper_object<type_t>::to_string() const noexcept -> xtd::string {return xtd::string::format("{} [value={}]", xtd::object::to_string(), !ref_.has_value() ? "(null)" : string::format("{}", get()));}
 
template<typename type_t>
[[nodiscard]] inline auto xtd::shared_ptr_object<type_t>::to_string() const noexcept -> xtd::string {return xtd::string::format("{} [pointer={}]", xtd::object::to_string(), ptr_ == xtd::null ? "null"  : string::format("0x{:X16}, use_count={}", get(), use_count()));}
 
template<typename type_t, typename deleter_t>
[[nodiscard]] inline auto xtd::unique_ptr_object<type_t, deleter_t>::to_string() const noexcept -> xtd::string {return xtd::string::format("{} [pointer={}]", xtd::object::to_string(), ptr_ == xtd::null ? "null"  : string::format("0x{:X16}", get()));}
 
#include "literals/string.hpp"
#define __XTD_CORE_INTERNAL__
#include "internal/__xtd_std_format.hpp"
#undef __XTD_CORE_INTERNAL__