emoticon.h

Go to the documentation of this file.

#pragma once
#include "../forms_export.h"
#include <xtd/object.h>
#include <xtd/static.h>
#include <xtd/ustring.h>
#include <ostream>
#include <vector>
 
namespace xtd {
  namespace forms {
    class forms_export_ emoticon : public object {
    public:
      static const emoticon empty();
      
      emoticon(const xtd::ustring& name, std::initializer_list<char32_t> codepoints) : name_(name), codepoints_(codepoints) {}
      
      emoticon(const xtd::ustring& name, const std::vector<char32_t>& codepoints) : name_(name), codepoints_(codepoints) {}
      
      emoticon(const xtd::ustring& name, char32_t codepoint) : name_(name), codepoints_({codepoint}) {}
      
      emoticon(std::initializer_list<char32_t> codepoints) : codepoints_(codepoints) {}
      
      emoticon(const std::vector<char32_t>& codepoints) : codepoints_(codepoints) {}
      
      emoticon(char32_t codepoint) : codepoints_({codepoint}) {}
      
      template<typename type_t>
      emoticon(const xtd::ustring& name, std::initializer_list<type_t> codepoints) : name_(name) {
        for(auto codepoint : codepoints)
          codepoints_.push_back(static_cast<char32_t>(codepoint));
      }
      
      template<typename type_t>
      emoticon(const xtd::ustring& name, const std::vector<type_t>& codepoints) : name_(name) {
        for(auto codepoint : codepoints)
          codepoints_.push_back(static_cast<char32_t>(codepoint));
      }
      
      template<typename type_t>
      emoticon(const xtd::ustring& name, type_t codepoint) : name_(name), codepoints_({static_cast<char32_t>(codepoint)}) {}
      
      template<typename type_t>
      emoticon(std::initializer_list<type_t> codepoints) {
        for(auto codepoint : codepoints)
          codepoints_.push_back(static_cast<char32_t>(codepoint));
      }
      
      template<typename type_t>
      emoticon(const std::vector<type_t>& codepoints) {
        for(auto codepoint : codepoints)
          codepoints_.push_back(static_cast<char32_t>(codepoint));
      }
 
      template<typename type_t>
      emoticon(type_t codepoint) : codepoints_({static_cast<char32_t>(codepoint)}) {}
 
      emoticon() = default;
      emoticon(const emoticon&) = default;
      emoticon& operator=(const emoticon&) = default;
      bool operator==(const emoticon& value) {return name_ == value.name_ && codepoints_ == value.codepoints_;}
      bool operator!=(const emoticon& value) {return !operator==(value);}
      friend std::ostream& operator<<(std::ostream& os, const xtd::forms::emoticon& emoticon) noexcept {
        return os << emoticon.to_string();
      }
      
      const xtd::ustring& name() const {return name_;}
      
      const std::vector<char32_t>& codepoints() const {return codepoints_;}
 
      xtd::ustring to_string() const noexcept override {
        std::string result;
        for (auto codepoint : codepoints_) {
          if (codepoint < 0x80) {
            result.push_back(static_cast<char>(codepoint));
          } else  if (codepoint < 0x800) {
            result.push_back(static_cast<char>((codepoint >> 6) | 0xc0));
            result.push_back(static_cast<char>((codepoint & 0x3f) | 0x80));
          } else if (codepoint < 0x10000) {
            result.push_back(static_cast<char>((codepoint >> 12) | 0xe0));
            result.push_back(static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80));
            result.push_back(static_cast<char>((codepoint & 0x3f) | 0x80));
          } else {
            result.push_back(static_cast<char>((codepoint >> 18) | 0xf0));
            result.push_back(static_cast<char>(((codepoint >> 12) & 0x3f) | 0x80));
            result.push_back(static_cast<char>(((codepoint >> 6) & 0x3f) | 0x80));
            result.push_back(static_cast<char>((codepoint & 0x3f) | 0x80));
          }
        }
        return result;
      }
      
    private:
      xtd::ustring name_;
      std::vector<char32_t> codepoints_;
    };
  }
}
 
inline xtd::ustring operator+(const xtd::forms::emoticon& value_a, const xtd::forms::emoticon& value_b) {
  return value_a.to_string() + value_b.to_string();
}
 
inline xtd::ustring operator+(const xtd::forms::emoticon& value_a, const char* value_b) {
  return value_a.to_string() + value_b;
}
 
inline xtd::ustring operator+(const xtd::forms::emoticon& value_a, const xtd::ustring& value_b) {
  return value_a.to_string() + value_b;
}
 
inline xtd::ustring operator+(const xtd::ustring& value_a, const xtd::forms::emoticon& value_b) {
  return value_a + value_b.to_string();
}
 
inline xtd::ustring operator+(const char* value_a, const xtd::forms::emoticon& value_b) {
  return xtd::ustring(value_a) + value_b.to_string();
}