System Namespace Reference

Namespaces

 BoxedValueDetail
 
 Collections
 
 ComponentModel
 
 Constraints
 
 Data
 
 Diagnostics
 
 Drawing
 
 Globalization
 
 IO
 
 Net
 
 Reflection
 
 Resources
 
 Runtime
 
 Security
 
 StringExtra
 
 TestPredicates
 
 TestToolsExt
 
 Text
 
 Threading
 
 Timers
 
 TimeZoneInfo
 
 TypeCodeHelper
 
 TypeInfo
 
 UriDetails
 
 Web
 
 Windows
 
 WithLambda
 
 Xml
 

Classes

class  Array
 
class  ArraySegment
 
class  AsposeCppLibrary
 
class  Attribute
 
struct  BasePointerType
 
struct  BasePointerType< WeakPtr< T > >
 
class  BaseTypesInfo
 
class  BaseTypesInfo< FirstType, BaseTypes... >
 
class  BaseTypesInfo<>
 
class  BitConverter
 
struct  Boolean
 
class  BoxedEnum
 
class  BoxedValue
 
class  BoxedValue< System::Collections::Generic::KeyValuePair< TKey, TValue > >
 
class  BoxedValue< System::Drawing::Color >
 
class  BoxedValue< System::Drawing::Point >
 
class  BoxedValue< System::Drawing::PointF >
 
class  BoxedValue< System::Drawing::Rectangle >
 
class  BoxedValue< System::Drawing::RectangleF >
 
class  BoxedValue< System::Drawing::Size >
 
class  BoxedValue< System::Drawing::SizeF >
 
class  BoxedValueBase
 
class  Buffer
 
struct  Byte
 
struct  CastResult
 
struct  CastResult< Array< TTo > >
 
struct  CastResult< MulticastDelegate< T > >
 
struct  CastResult< String >
 
class  Char
 
struct  CollectionAssertHelper
 
class  Comparison
 
class  Console
 
class  ConsoleOutput
 
struct  Convert
 
class  DateTime
 
class  DateTimeOffset
 
class  DBNull
 
class  Decimal
 
class  DefaultBoxedValue
 
class  Delegate
 
class  Delegate< ReturnType(ArgumentTypes...)>
 
class  Details_Exception
 
struct  Double
 
class  DynamicWeakPtr
 
struct  EmptyArrayInitializer
 
struct  Enum
 
struct  EnumGetNameHelper
 
struct  EnumParseHelper
 
class  EnumValues
 
class  EnumValuesBase
 
struct  Environment
 
class  EventArgs
 
class  EventHandler
 
class  ExceptionWrapper
 
class  ExceptionWrapper< Details_Exception >
 
class  ExceptionWrapperBase
 
class  ExceptionWrapperHelper
 
struct  ExceptionWrapperType
 
class  Func
 
class  GC
 
class  Guid
 
class  IAsyncResult
 
class  ICloneable
 
class  IComparable
 
class  IConvertible
 
class  ICustomFormatter
 
class  IDisposable
 
class  IEnumerableAdapter
 
class  IEnumerableDefaultAdapter
 
class  IEnumerableTupleAdapter
 
class  IEnumeratorIterator
 
class  IEquatable
 
class  IFormatProvider
 
class  IFormattable
 
struct  Int16
 
struct  Int32
 
struct  Int64
 
struct  IsBoxable
 
struct  IsBoxable< Collections::Generic::KeyValuePair< TKey, TValue > >
 
struct  IsBoxable< DateTime >
 
struct  IsBoxable< DateTimeOffset >
 
struct  IsBoxable< Decimal >
 
struct  IsBoxable< Drawing::Color >
 
struct  IsBoxable< Drawing::Point >
 
struct  IsBoxable< Drawing::PointF >
 
struct  IsBoxable< Drawing::Rectangle >
 
struct  IsBoxable< Drawing::RectangleF >
 
struct  IsBoxable< Drawing::Size >
 
struct  IsBoxable< Drawing::SizeF >
 
struct  IsBoxable< Guid >
 
struct  IsBoxable< Nullable< T > >
 
struct  IsBoxable< String >
 
struct  IsBoxable< System::Security::Cryptography::HashAlgorithmName >
 
struct  IsBoxable< TimeSpan >
 
struct  IsBoxable< ValueType >
 
struct  IsBoxedValue
 
struct  IsBoxedValue< BoxedValue< T > >
 
struct  IsExceptionWrapper
 
struct  IsForwardingOf
 
struct  IsForwardingOf< T, U >
 
struct  IsNonConstStringArray
 
struct  IsNullable
 
struct  IsSmartPtr
 
struct  IsStringByteSequence
 
struct  IsStringLiteral
 
struct  IsStringPointer
 
struct  IsWeakPtr
 
class  LockContext
 
class  MarshalByRefObject
 
struct  Math
 
struct  MethodArgumentTuple
 
struct  MethodArgumentTuple< R(*)(Args...)>
 
struct  MethodArgumentTuple< R(C::*)(Args...) const >
 
struct  MethodArgumentTuple< R(C::*)(Args...)>
 
class  MulticastDelegate
 
class  MulticastDelegate< ReturnType(ArgumentTypes...)>
 
class  Nullable
 
class  Object
 
class  ObjectExt
 
class  OperatingSystem
 
class  Random
 
struct  SByte
 
class  ScopedCulture
 
struct  ScopeGuard
 
struct  Single
 
class  SmartPtr
 
class  SmartPtrInfo
 
struct  static_holder
 
class  String
 
class  StringComparer
 
class  StringHashCompiletime
 
class  StringHashCompiletime< 0 >
 
struct  TestCompare
 
struct  TestTools
 
struct  TestToolsExt
 
class  TimeSpan
 
class  TimeZone
 
class  TimeZoneInfo
 
class  TypeInfo
 
struct  TypeInfoPtr
 
struct  UInt16
 
struct  UInt32
 
struct  UInt64
 
class  Uri
 
class  UriBuilder
 
class  UriParser
 
class  UriShim
 
class  ValueType
 
class  Version
 
class  WeakPtr
 
class  WeakReference
 

Typedefs

typedef MulticastDelegate< void(Args...)> Action
 
typedef SmartPtr< Array< T > > ArrayPtr
 
typedef std::function< void(SharedPtr< IAsyncResult >)> AsyncCallback
 
typedef ArrayPtr< uint8_t > ByteArrayPtr
 
typedef MulticastDelegate< TOutput(TInput)> Converter
 
typedef MulticastDelegate< Args... > Event
 
typedef SharedPtr< EventArgsEventArgsPtr
 
typedef ExceptionWrapper< Details_ExceptionException
 
typedef SmartPtr< Details_ExceptionExceptionPtr
 
typedef SharedPtr< IAsyncResultIAsyncResultPtr
 
typedef MulticastDelegate< bool(T)> Predicate
 
typedef SmartPtr< T > SharedPtr
 
typedef SharedPtr< StringComparerStringComparerPtr
 
typedef SharedPtr< TimeZoneInfoTimeZoneInfoPtr
 
typedef SharedPtr< TimeZoneTimeZonePtr
 

Enumerations

enum  Base64FormattingOptions
 
enum  DateTimeKind
 
enum  DayOfWeek
 
enum  EnvironmentVariableTarget
 
enum  MidpointRounding
 
enum  PlatformID
 
enum  SmartPtrMode
 
enum  StringComparison
 
enum  StringSplitOptions
 
enum  TypeCode
 
enum  UriComponents
 
enum  UriFormat
 
enum  UriHostNameType
 
enum  UriKind
 
enum  UriPartial
 

Functions

std::enable_if<!System::detail::has_method_get_Count< From >::value, ListPtr< To > >::type CastEnumerableTo (const From &enumerable)
 
TTo CheckedCast (TFrom value)
 
std::enable_if_t<!std::is_floating_point< TA >::value &&!std::is_floating_point< TB >::value, int > Compare (const TA &a, const TB &b)
 
SmartPtr< Y > const_pointer_cast (SmartPtr< X > const &x)
 
static CastResult< TTo >::type ConstCast (const SmartPtr< TFrom > &obj)
 
 DECLARE_ENUM_OPERATORS (UriComponents)
 
 DECLARE_ENUM_OPERATORS (UriFormat)
 
const std::enable_if< IsBoxable< T >::value &&!IsExceptionWrapper< T >::value, T & >::type Default ()
 
std::enable_if_t< Details::is_lambda_void_void< T >::value > DoTryFinally (T &&tryBlock, F &&finallyBlock)
 
SmartPtr< Y > dynamic_pointer_cast (SmartPtr< X > const &x)
 
static std::enable_if< IsExceptionWrapper< TFrom >::value &&IsExceptionWrapper< TTo >::value &&(std::is_convertible< TTo, TFrom >::value||std::is_base_of< TTo, TFrom >::value), TTo >::type DynamicCast (const TFrom &obj)
 
static std::enable_if<!std::is_enum< TTo >::value &&!IsExceptionWrapper< TTo >::value, typename CastResult< TTo >::type >::type DynamicCast (SmartPtr< TFrom > obj)
 
static std::enable_if< !IsExceptionWrapper< TFrom >::value &&!IsSmartPtr< TFrom >::value &&std::is_convertible< TTo, TFrom >::value, TTo >::type DynamicCast (TFrom &obj)
 
static std::enable_if< IsExceptionWrapper< TFrom >::value &&IsExceptionWrapper< TTo >::value &&(std::is_convertible< TTo, TFrom >::value||std::is_base_of< TTo, TFrom >::value), TTo >::type DynamicCast_noexcept (const TFrom &obj) noexcept
 
static std::enable_if<!IsExceptionWrapper< TTo >::value, typename CastResult< TTo >::type >::type DynamicCast_noexcept (SmartPtr< TFrom > obj) noexcept
 
SharedPtr< Array< To > > DynamicCastArray (const SharedPtr< Array< From >> &from)
 
std::enable_if< IsSmartPtr< To >::value &&System::detail::has_method_get_Count< From >::value, ListPtr< To > >::type DynamicCastEnumerableTo (const From &enumerable)
 
static String EnumGetName (T value)
 
bool Equals (const TA &a, const TB &b)
 
bool Equals< double, double > (const double &a, const double &b)
 
bool Equals< float, float > (const float &a, const float &b)
 
T * get_pointer (SmartPtr< T > const &x)
 
int GetHashCode (const std::thread::id &id)
 
std::enable_if< std::is_scalar< T >::value, int >::type GetHashCode (const T &obj)
 
static bool IsEnumMetaInfoDefined (T value)
 
bool IsInfinity (const T &value)
 
bool IsNaN (const T &value)
 
bool IsNegativeInfinity (const T &value)
 
bool IsPositiveInfinity (const T &value)
 
std::enable_if_t<!IsSmartPtr< Enumerable >::value, Details::EnumeratorAdapter< Enumerable, Details::ValueTypeOfEnumerable< Enumerable >, Enumerable * > > IterateOver (Enumerable *enumerable)
 
std::enable_if_t<!Details::IsIterable< Enumerable >::value, Details::EnumeratorAdapter< Enumerable, T > > IterateOver (SmartPtr< Enumerable > enumerable)
 
ArrayPtr< T > MakeArray (Args &&... args)
 
std::enable_if< std::is_integral< Integral >::value, ArrayPtr< T > >::type MakeArray (Integral size, Args &&... args)
 
ArrayPtr< T > MakeArray (std::initializer_list< T > init)
 
std::enable_if<!IsSmartPtr< T >::value, SmartPtr< T > >::type MakeObject (Args &&... args)
 
ScopeGuard< F > MakeScopeGuard (F f)
 
SmartPtr< X > MakeSharedPtr (const X *p)
 
SmartPtr< X > MakeSharedPtr (X *p)
 
SmartPtr< ObjectMemberwiseClone (T *ptr)
 
bool operator!= (ArraySegment< T > a, ArraySegment< T > b)
 
bool operator!= (Chars &left, const String &right)
 
ASPOSECPP_SHARED_API bool operator!= (const SharedPtr< Object > &left, const String &right)
 
ASPOSECPP_SHARED_API bool operator!= (const SharedPtr< Uri > &uri1, const SharedPtr< Uri > &uri2)
 
bool operator!= (const SmartPtr< X > &x, const SmartPtr< Y > &y)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator!= (const T1 &some, const T2 &other)
 
bool operator!= (SmartPtr< X > const &x, std::nullptr_t)
 
constexpr bool operator!= (std::nullptr_t, const DateTimeOffset &)
 
ASPOSECPP_SHARED_API bool operator!= (std::nullptr_t, const String &str)
 
std::enable_if< IsNullable< T >::value, bool >::type operator!= (std::nullptr_t, const T &other)
 
constexpr bool operator!= (std::nullptr_t, DateTime)
 
bool operator!= (std::nullptr_t, SmartPtr< X > const &x)
 
constexpr bool operator!= (std::nullptr_t, TimeSpan)
 
bool operator!= (T &left, const String &right)
 
Decimal operator* (const T &x, const Decimal &d)
 
String operator+ (const char_t left, const String &right)
 
std::enable_if<!IsNullable< T >::value &&std::is_class< T >::value, Nullable< T > >::type operator+ (const T &, std::nullptr_t)
 
Decimal operator+ (const T &x, const Decimal &d)
 
auto operator+ (const T1 &some, const Nullable< T2 > &other) -> Nullable< decltype(some+other.get_Value())>
 
std::enable_if<!IsNullable< T >::value &&std::is_class< T >::value, Nullable< T > >::type operator+ (std::nullptr_t, const T &)
 
std::enable_if< IsStringLiteral< T, char_t >::value, String >::type operator+ (T &left, const String &right)
 
Decimal operator- (const T &x, const Decimal &d)
 
auto operator- (const T1 &some, const Nullable< T2 > &other) -> Nullable< decltype(some - other.get_Value())>
 
auto operator- (DayOfWeek a, DayOfWeek b)
 
Decimal operator/ (const T &x, const Decimal &d)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator< (const T1 &some, const T2 &other)
 
constexpr bool operator< (std::nullptr_t, const DateTimeOffset &)
 
std::enable_if< IsNullable< T >::value, bool >::type operator< (std::nullptr_t, const T &)
 
constexpr bool operator< (std::nullptr_t, DateTime)
 
constexpr bool operator< (std::nullptr_t, TimeSpan)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator<= (const T1 &some, const T2 &other)
 
constexpr bool operator<= (std::nullptr_t, const DateTimeOffset &)
 
std::enable_if< IsNullable< T >::value, bool >::type operator<= (std::nullptr_t, const T &)
 
constexpr bool operator<= (std::nullptr_t, DateTime)
 
constexpr bool operator<= (std::nullptr_t, TimeSpan)
 
bool operator== (ArraySegment< T > a, ArraySegment< T > b)
 
bool operator== (Chars &left, const String &right)
 
ASPOSECPP_SHARED_API bool operator== (const SharedPtr< Object > &left, const String &right)
 
ASPOSECPP_SHARED_API bool operator== (const SharedPtr< Uri > &uri1, const SharedPtr< Uri > &uri2)
 
bool operator== (const SmartPtr< X > &x, const SmartPtr< Y > &y)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator== (const T1 &some, const T2 &other)
 
constexpr bool operator== (std::nullptr_t, const DateTimeOffset &)
 
ASPOSECPP_SHARED_API bool operator== (std::nullptr_t, const String &str)
 
constexpr bool operator== (std::nullptr_t, DateTime)
 
bool operator== (std::nullptr_t, SmartPtr< X > const &x)
 
std::enable_if<!std::is_scalar< T >::value &&!std::is_pointer< T >::value &&!std::is_array< T >::value, bool >::type operator== (std::nullptr_t, T const &x)
 
constexpr bool operator== (std::nullptr_t, TimeSpan)
 
bool operator== (T &left, const String &right)
 
std::enable_if<!std::is_scalar< T >::value &&!std::is_pointer< T >::value &&!std::is_array< T >::value, bool >::type operator== (T const &x, std::nullptr_t)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator> (const T1 &some, const T2 &other)
 
constexpr bool operator> (std::nullptr_t, const DateTimeOffset &)
 
std::enable_if< IsNullable< T >::value, bool >::type operator> (std::nullptr_t, const T &)
 
constexpr bool operator> (std::nullptr_t, DateTime)
 
constexpr bool operator> (std::nullptr_t, TimeSpan)
 
std::enable_if<!IsNullable< T1 >::value &&IsNullable< T2 >::value, bool >::type operator>= (const T1 &some, const T2 &other)
 
constexpr bool operator>= (std::nullptr_t, const DateTimeOffset &)
 
std::enable_if< IsNullable< T >::value, bool >::type operator>= (std::nullptr_t, const T &)
 
constexpr bool operator>= (std::nullptr_t, DateTime)
 
constexpr bool operator>= (std::nullptr_t, TimeSpan)
 
ASPOSECPP_SHARED_API void PrintTo (const Decimal &d, ::std::ostream *os)
 
void PrintTo (const DateTime &value, std::ostream *stream)
 
ASPOSECPP_SHARED_API void PrintTo (const String &value, std::ostream *os)
 
void PrintTo (const TimeSpan &value, std::ostream *stream)
 
DynamicWeakPtr< T, trunkMode, weakLeafs... >::Reference Ref (DynamicWeakPtr< T, trunkMode, weakLeafs... > &ptr)
 
T & Ref (T &value)
 
std::enable_if< std::is_base_of< HostConstGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_decrement_wrap (Host *const host, T(HostConstGet::*pGetter)() const, void(HostSet::*pSetter)(T))
 
std::enable_if< std::is_base_of< HostGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_decrement_wrap (Host *const host, T(HostGet::*pGetter)(), void(HostSet::*pSetter)(T))
 
setter_decrement_wrap (T(*pGetter)(), void(*pSetter)(T))
 
std::enable_if< std::is_base_of< HostGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_increment_wrap (Host *const host, T(HostGet::*pGetter)(), void(HostSet::*pSetter)(T))
 
setter_increment_wrap (T(*pGetter)(), void(*pSetter)(T))
 
std::enable_if< std::is_base_of< HostConstGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_post_decrement_wrap (Host *const host, T(HostConstGet::*pGetter)() const, void(HostSet::*pSetter)(T))
 
std::enable_if< std::is_base_of< HostGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_post_decrement_wrap (Host *const host, T(HostGet::*pGetter)(), void(HostSet::*pSetter)(T))
 
setter_post_decrement_wrap (T(*pGetter)(), void(*pSetter)(T))
 
std::enable_if< std::is_base_of< HostConstGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_post_increment_wrap (Host *const host, T(HostConstGet::*pGetter)() const, void(HostSet::*pSetter)(T))
 
std::enable_if< std::is_base_of< HostGet, Host >::value &&std::is_base_of< HostSet, Host >::value, T >::type setter_post_increment_wrap (Host *const host, T(HostGet::*pGetter)(), void(HostSet::*pSetter)(T))
 
setter_post_increment_wrap (T(*pGetter)(), void(*pSetter)(T))
 
std::enable_if< std::is_base_of< HostSet, Host >::value, T >::type setter_wrap (Host *const host, void(HostSet::*pSetter)(T2), T value)
 
setter_wrap (void(*pSetter)(T2), T value)
 
SmartPtr< Y > static_pointer_cast (SmartPtr< X > const &x)
 
static std::enable_if< IsExceptionWrapper< TFrom >::value &&IsExceptionWrapper< TTo >::value &&(std::is_convertible< TTo, TFrom >::value||std::is_base_of< TTo, TFrom >::value), TTo >::type StaticCast (const TFrom &obj)
 
static std::enable_if< std::is_arithmetic< TFrom >::value, TTo >::type StaticCast (const TFrom *value)
 
static std::enable_if<!IsExceptionWrapper< TTo >::value, typename CastResult< TTo >::type >::type StaticCast (SmartPtr< TFrom > obj)
 
static std::enable_if<!std::is_same< TFrom, String >::value &&!IsExceptionWrapper< TFrom >::value &&!IsSmartPtr< TFrom >::value &&!std::is_arithmetic< TFrom >::value, TTo >::type StaticCast (TFrom &obj)
 
static std::enable_if< std::is_arithmetic< TFrom >::value, TTo >::type StaticCast (TFrom value)
 
static std::enable_if< std::is_same< TTo, String >::value, TTo >::type StaticCast (TTo value)
 
static CastResult< TTo >::type StaticCast (WeakPtr< TFrom > obj)
 
static std::enable_if< IsExceptionWrapper< TFrom >::value &&IsExceptionWrapper< TTo >::value &&(std::is_convertible< TTo, TFrom >::value||std::is_base_of< TTo, TFrom >::value), TTo >::type StaticCast_noexcept (const TFrom &obj)
 
static std::enable_if<!IsExceptionWrapper< TTo >::value, typename CastResult< TTo >::type >::type StaticCast_noexcept (SmartPtr< TFrom > obj)
 
static CastResult< TTo >::type StaticCast_noexcept (WeakPtr< TFrom > obj)
 
std::enable_if_t< IsSmartPtr< From >::value, SharedPtr< Array< To > > > StaticCastArray (const SharedPtr< Array< From >> &from)
 

Variables

static CastResult< TTo >::type DynamicCast (std::nullptr_t) noexcept
 
 Machine
 
 Process
 
decltype(Ref(std::declval< T & >())) Ref (const std::reference_wrapper< T > &wrapper)
 
static CastResult< TTo >::type StaticCast (std::nullptr_t)
 
 User