emoticon.hpp

Go to the documentation of this file.

#pragma once
#include "../forms_export.hpp"
#include <xtd/collections/generic/list>
#include <xtd/icomparable>
#include <xtd/iequatable>
#include <xtd/object>
#include <xtd/static>
#include <xtd/string>
#include <ostream>
#include <vector>

namespace xtd {
  namespace forms {
    class forms_export_ emoticon : public xtd::object, public xtd::iequatable<emoticon>, public xtd::icomparable<emoticon> {
      struct data;
    public:
      
      static auto empty() -> emoticon;
      
      
      emoticon(const xtd::string& name, std::initializer_list<xtd::char32> codepoints);
      
      emoticon(const xtd::string& name, const xtd::array<xtd::char32>& codepoints);
      
      emoticon(const xtd::string& name, xtd::char32 codepoint);
      
      explicit emoticon(std::initializer_list<xtd::char32> codepoints);
      
      explicit emoticon(const xtd::array<xtd::char32>& codepoints);
      
      explicit emoticon(xtd::char32 codepoint);
      
      template<typename type_t>
      emoticon(const xtd::string& name, std::initializer_list<type_t> codepoints) {
        create_data();
        name_(name);
        for (const auto& codepoint : codepoints)
          codepoints_().add(static_cast<char32>(codepoint));
      }
      
      template<typename type_t>
      emoticon(const xtd::string& name, const xtd::array<type_t>& codepoints) {
        create_data();
        name_(name);
        for (const auto& codepoint : codepoints)
          codepoints_().add(static_cast<char32>(codepoint));
      }
      
      template<typename type_t>
      emoticon(const xtd::string& name, type_t codepoint) {
        create_data();
        name_(name);
        codepoints_({static_cast<xtd::char32>(codepoint)});
      }
      
      template<typename type_t>
      explicit emoticon(std::initializer_list<type_t> codepoints) {
        create_data();
        for (auto codepoint : codepoints)
          codepoints_().add(static_cast<xtd::char32>(codepoint));
      }
      
      template<typename type_t>
      explicit emoticon(const xtd::array<type_t>& codepoints) {
        create_data();
        for (auto codepoint : codepoints)
          codepoints_().add(static_cast<xtd::char32>(codepoint));
      }
      
      template<typename type_t>
      explicit emoticon(type_t codepoint) {
        create_data();
        codepoints_({static_cast<xtd::char32>(codepoint)});
      }
      
      emoticon();
      emoticon(const emoticon& other);
      auto operator =(const emoticon& other) -> emoticon&;
      
      
      [[nodiscard]] auto name() const noexcept -> const xtd::string&;
      
      [[nodiscard]] auto codepoints() const noexcept -> xtd::array<xtd::char32>;
      
      
      [[nodiscard]] auto compare_to(const emoticon &obj) const noexcept -> xtd::int32 override;
      
      [[nodiscard]] auto equals(const xtd::object& obj) const noexcept -> bool override;
      [[nodiscard]] auto equals(const emoticon& other) const noexcept -> bool override;
      
      [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override;
      
      [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
      
    private:
      auto create_data() -> void;
      auto name_(const xtd::string& name) -> void;
      [[nodiscard]] auto codepoints_() -> xtd::collections::generic::list<xtd::char32>&;
      auto codepoints_(xtd::array<xtd::char32>&& codepoints) -> void;
      
      xtd::sptr<data> data_;
    };
  }

  inline auto operator +(const xtd::forms::emoticon& value_a, const xtd::forms::emoticon& value_b) -> xtd::string {
    return value_a.to_string() + value_b.to_string();
  }
  
  inline auto operator +(const xtd::forms::emoticon& value_a, const char* value_b) -> xtd::string {
    return value_a.to_string() + value_b;
  }
  
  inline auto operator +(const xtd::forms::emoticon& value_a, const xtd::string& value_b) -> xtd::string {
    return value_a.to_string() + value_b;
  }
  
  inline auto operator +(const xtd::string& value_a, const xtd::forms::emoticon& value_b) -> xtd::string {
    return value_a + value_b.to_string();
  }
  
  inline auto operator +(const char* value_a, const xtd::forms::emoticon& value_b) -> xtd::string {
    return xtd::string(value_a) + value_b.to_string();
  }
}