processor.h

Go to the documentation of this file.

#pragma once
#include <map>
#include <vector>
#include "architecture_id.h"
#include "object.h"
#include "ustring.h"
 
namespace xtd {
  class processor final : public object {
  public:
    processor(xtd::architecture_id architecture, bool is_64_bit, uint32_t core_count) : architecture_(architecture), is_64_bit_(is_64_bit), core_count_(core_count) {}
 
    processor() = default;
    processor(const processor&) = default;
    processor& operator=(const processor&) = default;
    friend std::ostream& operator <<(std::ostream& os, const processor& processor) noexcept {return os << processor.to_string();}
    
    xtd::architecture_id architecture() const noexcept {return architecture_;}
 
    uint32_t core_count() const noexcept {return core_count_;}
 
    bool is_64_bit() const noexcept {return is_64_bit_;}
    
    xtd::ustring name() const noexcept {
      static std::map<xtd::architecture_id, xtd::ustring> processor_names {{architecture_id::x86, "Intel or AMD"}, {architecture_id::arm, "ARM"}, {architecture_id::unknown, "<Unknown>"}};
      return processor_names[architecture_];
    }
 
    xtd::ustring architecture_string() const noexcept {
      if (!architecture_string_.empty()) return architecture_string_;
      architecture_string_ = ustring::format("{}", architecture_);
      if (is_64_bit_) {
        if (architecture_ == architecture_id::x86) architecture_string_ += "_";
        architecture_string_ += "64";
      }
      return architecture_string_;
    }
    
    xtd::ustring to_string() const noexcept {return architecture_string();}
    
  private:
    xtd::architecture_id architecture_ = xtd::architecture_id::unknown;
    bool is_64_bit_ = false;
    uint32_t core_count_ = 1;
    mutable xtd::ustring architecture_string_;
  };
}