reference_guides/v0.1.1/property_8h_source.html

 #pragma once

 #include <ostream>

 #include "../../object.h"

 #include "../../ustring.h"


 namespace xtd {

   namespace web {

     namespace css {

       class property : public object{

       public:

         property() = default;

         explicit property(const xtd::ustring& value) : value_(value) {}

         operator xtd::ustring() {return value_;}


         static property from(bool value) {return property(ustring::format("{}", value));}

         static property from(double value) {return property(ustring::format("{}", value));}

         static property from(float value) {return property(ustring::format("{}", value));}

         static property from(int8_t value) {return property(ustring::format("{}", value));}

         static property from(int16_t value) {return property(ustring::format("{}", value));}

         static property from(int32_t value) {return property(ustring::format("{}", value));}

         static property from(int64_t value) {return property(ustring::format("{}", value));}

         static property from(const xtd::ustring& value) {return property(ustring::format("{}", value));}

         static property from(uint8_t value) {return property(ustring::format("{}", value));}

         static property from(uint16_t value) {return property(ustring::format("{}", value));}

         static property from(uint32_t value) {return property(ustring::format("{}", value));}

         static property from(uint64_t value) {return property(ustring::format("{}", value));}

         template<typename value_t>

         static property from(value_t value) {return property(ustring::format("{}", value));}


         const xtd::ustring& value() const {return value_;}

         template<typename value_t>

         uintptr_t value() const {return xtd::parse<value_t>(value_);}


         bool to_boolean() const {return xtd::parse<bool>(value_);}

         double to_double() const {return xtd::parse<double>(value_);}

         int8_t to_int8() const {return xtd::parse<int8_t>(value_);}

         int16_t to_int16() const {return xtd::parse<int16_t>(value_);}

         int32_t to_int32() const {return xtd::parse<int32_t>(value_);}

         int64_t to_int64() const {return xtd::parse<int64_t>(value_);}

         intptr_t to_intptr() const {return xtd::parse<intptr_t>(value_);}

         float to_single() const {return xtd::parse<float>(value_);}

         xtd::ustring to_string() const noexcept override {return value_;}

         uint8_t to_uint8() const {return xtd::parse<uint8_t>(value_);}

         uint16_t to_uint16() const {return xtd::parse<uint16_t>(value_);}

         uint32_t to_uint32() const {return xtd::parse<uint32_t>(value_);}

         uint64_t to_uint64() const {return xtd::parse<uint64_t>(value_);}

         uintptr_t to_uintptr() const {return xtd::parse<uintptr_t>(value_);}

         template<typename value_t>

         uintptr_t to() const {return xtd::parse<value_t>(value_);}


         friend std::ostream& operator <<(std::ostream& os, const property& property) noexcept {return os << property.to_string();}


       private:

         xtd::ustring value_;

       };

     }

   }

 }

xtd::object
Supports all classes in the xtd class hierarchy and provides low-level services to derived classes....
Definition: object.h:26

xtd::ustring
Represents text as a sequence of UTF-8 code units.
Definition: ustring.h:48

xtd::web::css::property
Definition: property.h:13

xtd::web::css::property::to_string
xtd::ustring to_string() const noexcept override
Returns a std::string that represents the current object.
Definition: property.h:46

xtd::ustring::format
static ustring format(const ustring &fmt, args_t &&... args)
Writes the text representation of the specified arguments list, to string using the specified format ...
Definition: ustring.h:689

xtd::parse< double >
double parse< double >(const std::string &str, number_styles styles)
Convert a type into a string.
Definition: parse.h:166

xtd::parse< int8_t >
int8_t parse< int8_t >(const std::string &str, number_styles styles)
Convert a type into a string.
Definition: parse.h:58

xtd::parse< bool >
bool parse< bool >(const std::string &str)
Convert a type into a string.
Definition: parse.h:310

xtd::parse< float >
float parse< float >(const std::string &str, number_styles styles)
Convert a type into a string.
Definition: parse.h:157

xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition: system_report.h:17