reference_guides/v0.1.0/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