reference_guides/latest/property_8hpp_source.html

#pragma once

#include "../../object.hpp"

#include "../../string.hpp"

#include "../../single.hpp"

#include <ostream>


namespace xtd {

  namespace web {

    namespace css {


      class property : public object {

      public:


        property() = default;

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

        property(const property&) = default;

        property& operator =(const property&) = default;

        property(property&&) = default;

        property& operator =(property&&) = default;


        operator xtd::string() noexcept {return value_;}


        [[nodiscard]] auto value() const noexcept -> const xtd::string& {return value_;}

        template<class value_t>

        [[nodiscard]] auto value() const noexcept -> value_t {return xtd::parse<value_t>(value_);}


        [[nodiscard]] auto to_boolean() const -> bool {return xtd::parse<bool>(value_);}

        [[nodiscard]] auto to_double() const -> double {return xtd::parse<double>(value_);}

        [[nodiscard]] auto to_int8() const -> xtd::sbyte  {return xtd::parse<xtd::sbyte>(value_);}

        [[nodiscard]] auto to_int16() const -> xtd::int16 {return xtd::parse<xtd::int16>(value_);}

        [[nodiscard]] auto to_int32() const -> xtd::int32 {return xtd::parse<xtd::int32>(value_);}

        [[nodiscard]] auto to_int64() const -> xtd::int64 {return xtd::parse<xtd::int64>(value_);}

        [[nodiscard]] auto to_intptr() const -> xtd::intptr {return xtd::parse<xtd::intptr>(value_);}

        [[nodiscard]] auto to_single() const -> xtd::single {return xtd::parse<float>(value_);}

        [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return value_;}

        [[nodiscard]] auto to_uint8() const -> xtd::byte {return xtd::parse<xtd::byte>(value_);}

        [[nodiscard]] auto to_uint16() const -> xtd::uint16 {return xtd::parse<xtd::uint16>(value_);}

        [[nodiscard]] auto to_uint32() const -> xtd::uint32 {return xtd::parse<xtd::uint32>(value_);}

        [[nodiscard]] auto to_uint64() const -> xtd::uint64 {return xtd::parse<xtd::uint64>(value_);}

        [[nodiscard]] auto to_uintptr() const -> xtd::uintptr {return xtd::parse<xtd::uintptr>(value_);}

        template<class value_t>

        [[nodiscard]] auto to() const -> value_t {return xtd::parse<value_t>(value_);}


        static auto from(bool value) -> property {return property(string::format("{}", value));}

        static auto from(double value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::single value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::sbyte value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::int16 value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::int32 value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::int64 value) -> property {return property(string::format("{}", value));}

        static auto from(const xtd::string& value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::byte value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::uint16 value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::uint32 value) -> property {return property(string::format("{}", value));}

        static auto from(xtd::uint64 value) -> property {return property(string::format("{}", value));}

        static auto from(const auto& value) -> property {return property(string::format("{}", value));}


      private:

        xtd::string value_;

      };


    }

  }

}

xtd::object::object
object()=default
Create a new instance of the ultimate base class object.

xtd::web::css::property::to_string
auto to_string() const noexcept -> xtd::string override
Returns a xtd::string that represents the current object.
Definition property.hpp:52

xtd::basic_string< char >::format
static auto format(const basic_string< char > &fmt, args_t &&... args) -> basic_string

xtd::string
xtd::basic_string< char > string
Represents text as a sequence of UTF-8 code units.
Definition __string_definitions.hpp:43

xtd::int64
std::int64_t int64
Represents a 64-bit signed integer.
Definition int64.hpp:23

xtd::uint32
std::uint32_t uint32
Represents a 32-bit unsigned integer.
Definition uint32.hpp:23

xtd::sbyte
std::int8_t sbyte
Represents a 8-bit signed integer.
Definition sbyte.hpp:23

xtd::intptr
std::intmax_t intptr
Represent a pointer or a handle.
Definition intptr.hpp:23

xtd::uintptr
uintmax_t uintptr
Represent a pointer or a handle.
Definition uintptr.hpp:23

xtd::uint16
std::uint16_t uint16
Represents a 16-bit unsigned integer.
Definition uint16.hpp:23

xtd::int32
std::int32_t int32
Represents a 32-bit signed integer.
Definition int32.hpp:23

xtd::int16
std::int16_t int16
Represents a 16-bit signed integer.
Definition int16.hpp:23

xtd::uint64
std::uint64_t uint64
Represents a 64-bit unsigned integer.
Definition uint64.hpp:23

xtd::byte
std::uint8_t byte
Represents a 8-bit unsigned integer.
Definition byte.hpp:23

xtd::single
float single
Represents a single-precision floating-point number.
Definition single.hpp:23

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

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

xtd::parse< xtd::sbyte >
xtd::sbyte parse< xtd::sbyte >(const std::string &str, number_styles styles)
Convert a string into a type.
Definition parse.hpp:91

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

xtd::parse
value_t parse(const std::string &str)
Convert a string into a type.
Definition parse.hpp:34

xtd::web
Contains classes and interfaces that enable browser-server communication. This namespace includes the...
Definition css_reader.hpp:14

xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition abstract_object.hpp:8

object.hpp
Contains xtd::object class.

single.hpp
Contains xtd::single type.

string.hpp
Contains xtd::string alias.