System
Contents
[
Hide
]Classes
| Class | Description |
|---|---|
| Activator | Contains methods to create types of objects. |
| Array | Class that represents an array data structure. Objects of this class should only be allocated using System::MakeArray() and System::MakeObject() functions. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| ArraySegment | Represents a segment of the one-dimensional array. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Attribute | A base class for custom attributes. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| BitConverter | Contains methods that perform conversions of sequence of bytes to a value type and vice-versa. This is a static type with no instance services. You should never create instances of it by any means. |
| Boolean | Class that keeps static members of System.Boolean .Net type. |
| BoxedEnum | Represents boxed enumeration value. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| BoxedValue | Represents a boxed value. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| BoxedValueBase | A base class that defines an interface and implements some fundamental methods of a descendant class that represents a boxed value. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Buffer | Contains methods that manipulate raw byte arrays. This is a static type with no instance services. You should never create instances of it by any means. |
| Byte | Contains methods to work with the unsigned 8-bit integer. |
| Char | Provides methods for manipulation of characters represented as UTF-16 code units. This is a static type with no instance services. You should never create instances of it by any means. |
| Comparison | Represents a pointer to the method that compares two objects of the same type. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Console | Provides methods for outputting data to the standard output stream. This is a static type with no instance services. You should never create instances of it by any means. |
| ConsoleOutput | Represents the standard output stream. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| DateTime | Represents a specific date and time value on the time continuum. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| DateTimeOffset | Contains the date and time of day relative to Coordinated Universal Time. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| DBNull | Represents a non-existing value. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Decimal | Represents a decimal number. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| DefaultBoxedValue | BoxedValue class implementation. Allows it BoxingValue specializations to be declared without duplicating common code. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Delegate< ReturnType(ArgumentTypes…)> | Represents a pointer to a function, method or a function object. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Details_ApplicationException | A base class for classes that represent application (rather than system) exceptions. Never create instances of this class manually. Use the ApplicationException class instead. Never wrap the ApplicationException class instances into System::SmartPtr. |
| Details_ArgumentException | ArgumentException is thrown when an argument passed to a method being invoked is invalid. Never create instances of this class manually. Use the ArgumentException class instead. Never wrap the ArgumentException class instances into System::SmartPtr. |
| Details_ArgumentNullException | |
| Details_ArgumentOutOfRangeException | ArgumentOutOfRangeException is thrown when a method being invoked is passed an argument that falls out of the expected range of values for that argument. Never create instances of this class manually. Use the ArgumentOutOfRangeException class instead. Never wrap the ArgumentOutOfRangeException class instances into System::SmartPtr. |
| Details_ArithmeticException | ArithmeticException is throw when an error occurs during execution of arithmetic, conversion of casting operations. Never create instances of this class manually. Use the ArithmeticException class instead. Never wrap the ArithmeticException class instances into System::SmartPtr. |
| Details_BadImageFormatException | The exception that is thrown when the file image of a dynamic link library (DLL) or an executable program is invalid. Never create instances of this class manually. Use the BadImageFormatException class instead. Never wrap the BadImageFormatException class instances into System::SmartPtr. |
| Details_DataMisalignedException | |
| Details_DivideByZeroException | DivideByZeroException is thrown when division by 0 is attempted in an arithmetic operation. Never create instances of this class manually. Use the DivideByZeroException class instead. Never wrap the DivideByZeroException class instances into System::SmartPtr. |
| Details_Exception | Represents an exception. Never create instances of this class manually. Use the Exception class instead. Never wrap the Exception class instances into System::SmartPtr. |
| Details_ExceptionWithErrorCode | The template class for an exception with an error code. |
| Details_ExceptionWithFilename | The template class for an exception with a file name. |
| Details_ExecutionEngineException | ExecutionEngineException is present for compatibility reasons only. |
| Details_FormatException | FormatException is thrown when the format of the method’s argument is not valid. Never create instances of this class manually. Use the FormatException class instead. Never wrap the FormatException class instances into System::SmartPtr. |
| Details_IndexOutOfRangeException | IndexOutOfRangeException is thrown when an access to an element of a collection is attempted using an index that is outside its bounds. Never create instances of this class manually. Use the IndexOutOfRangeException class instead. Never wrap the IndexOutOfRangeException class instances into System::SmartPtr. |
| Details_InvalidCastException | InvalidCastException is thrown when invalid casting operation of invalid explicit conversion is attempted. Never create instances of this class manually. Use the InvalidCastException class instead. Never wrap the InvalidCastException class instances into System::SmartPtr. |
| Details_InvalidOperationException | The exception that is thrown when a method is invoked on an object which is in the state inconsistent with this call. Never create instances of this class manually. Use the InvalidOperationException class instead. Never wrap the InvalidOperationException class instances into System::SmartPtr. |
| Details_InvalidProgramException | InvalidProgramException is present for compatibility reasons only. Never create instances of this class manually. Use the InvalidProgramException class instead. Never wrap the InvalidProgramException class instances into System::SmartPtr. |
| Details_InvalidTimeZoneException | InvalidTimeZoneException is thrown when time zone information is invalid. Never create instances of this class manually. Use the InvalidTimeZoneException class instead. Never wrap the InvalidTimeZoneException class instances into System::SmartPtr. |
| Details_MemberAccessException | MemberAccessException is thrown when access to non-existent class’ member is attempted or when access to the member is not permitted. Never create instances of this class manually. Use the MemberAccessException class instead. Never wrap the MemberAccessException class instances into System::SmartPtr. |
| Details_MethodAccessException | MemberAccessException is thrown when access to non-existent method is attempted or when access to the method is not permitted. Never create instances of this class manually. Use the MethodAccessException class instead. Never wrap the MethodAccessException class instances into System::SmartPtr. |
| Details_NotImplementedException | NotImplementedException is thrown when a method that is not implemented and serves as a stub. Never create instances of this class manually. Use the NotImplementedException class instead. Never wrap the NotImplementedException class instances into System::SmartPtr. |
| Details_NotSupportedException | NotSupportedException is thrown when a method being invoked is not supported or when an operation attempted on a stream is not supported. Never create instances of this class manually. Use the NotSupportedException class instead. Never wrap the NotSupportedException class instances into System::SmartPtr. |
| Details_NullReferenceException | NullReferenceException is thrown when dereferencing of a null-reference is attempted. Never create instances of this class manually. Use the NullReferenceException class instead. Never wrap the NullReferenceException class instances into System::SmartPtr. |
| Details_ObjectDisposedException | ObjectDisposedException is thrown when a method is invoked on a disposed object. Never create instances of this class manually. Use the ObjectDisposedException class instead. Never wrap the ObjectDisposedException class instances into System::SmartPtr. |
| Details_OperationCanceledException | OperationCanceledException is thrown in a thread upon cancellation of an operation that the thread was executing. CancellationToken member is not implemented. Never create instances of this class manually. Use the OperationCanceledException class instead. Never wrap the OperationCanceledException class instances into System::SmartPtr. |
| Details_OutOfMemoryException | |
| Details_OverflowException | OverflowException is thrown when an operation results in an overflow. Never create instances of this class manually. Use the OverflowException class instead. Never wrap the OverflowException class instances into System::SmartPtr. |
| Details_PlatformNotSupportedException | PlatformNotSupportedException is thrown when a feature does not run on a particular platform. Never create instances of this class manually. Use the PlatformNotSupportedException class instead. Never wrap the PlatformNotSupportedException class instances into System::SmartPtr. |
| Details_RankException | RankException is thrown when an array argument with the number of dimensions different from the expected is passed to a method. Never create instances of this class manually. Use the RankException class instead. Never wrap the RankException class instances into System::SmartPtr. |
| Details_StackOverflowException | StackOverflowException is thrown when the thread’s execution stack overflows. Never create instances of this class manually. Use the StackOverflowException class instead. Never wrap the StackOverflowException class instances into System::SmartPtr. |
| Details_SystemException | A base class for classes that represent system (rather than application) exceptions. Never create instances of this class manually. Use the SystemException class instead. Never wrap the SystemException class instances into System::SmartPtr. |
| Details_TimeoutException | TimeoutException indicates if the time that is allotted for a process or operation is expired. Never create instances of this class manually. Use the TimeoutException class instead. Never wrap the TimeoutException class instances into System::SmartPtr. |
| Details_TimeZoneNotFoundException | TimeZoneNotFoundException is thrown when time zone information is not found. Never create instances of this class manually. Use the TimeZoneNotFoundException class instead. Never wrap the TimeZoneNotFoundException class instances into System::SmartPtr. |
| Details_TypeInitializationException | |
| Details_UnauthorizedAccessException | UnauthorizedAccessException is thrown when access is denied by the operating system because of an I/O error or a security error. Never create instances of this class manually. Use the UnauthorizedAccessException class instead. Never wrap the UnauthorizedAccessException class instances into System::SmartPtr. |
| Details_UriFormatException | UriFormatException is thrown when the format of URI is not valid. Never create instances of this class manually. Use the UriFormatException class instead. Never wrap the UriFormatException class instances into System::SmartPtr. |
| DynamicWeakPtr | Smart pointer class which tracks pointer modes of template arguments of stored object and updates them after each assignment. This type is a pointer to manage other object’s deletion. It should be allocated on stack and passed to functions either by value or by const reference. |
| EnumValues | Provides meta information about enumeration constants of enum type E. |
| EnumValuesBase | A base class for a class that represents meta information of enumeration type. |
| EventArgs | The base class for classes that represent a context that is passed to the event subscribers when an event is triggered. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| ExceptionWrapper | Template that represents wrapper of exceptions that are derived from Exception class. |
| Func | Function delegate. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| GC | Represents an emulated Garbage Collection which acts more like a stub which effectively does nothing. This is a static type with no instance services. You should never create instances of it by any means. |
| Guid | Represents a Globally Unique IDentifier This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| IAsyncResult | Represents the status of asynchronous operation. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| ICloneable | Defies a method that enables object cloning - creating a copy of an object. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IComparable | Defines a method that compares two objects. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IConvertible | Defines methods that convert the value of the implementing reference or value type to a common language runtime type that has an equivalent value. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| ICustomFormatter | Defines a method that performs custom formatting of a string representation of a value represented by the specified object. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IDisposable | Defines method that releases resources owned by the current object. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IEquatable | Defines a method that determines the equality of two objects. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IFormatProvider | Defines a method that provides formatting information. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| IFormattable | Defines a method that formats the value of the current object using the specified format string and format provider. |
| Int16 | Contains methods to work with the 16-bit integer. |
| Int32 | Contains methods to work with the 32-bit integer. |
| Int64 | Contains methods to work with the 64-bit integer. |
| LockContext | Guard object implementing C# lock() statement. |
| MarshalByRefObject | Provides access to objects across application domain boundaries in remoting-enabled applications. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| MulticastDelegate< ReturnType(ArgumentTypes…)> | Represents a collection of delegates. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Nullable | Forward declaration. |
| Object | Base class that enables using methods available for System.Object class in C#. All non-trivial classes used with translated environment should inherit it. |
| ObjectExt | Provides static methods that emulate C# Object methods called for non-Object C++ types (strings, numbers, etc.). This is a static type with no instance services. You should never create instances of it by any means. |
| ObjectType | Provides static methods that implement object type getters. This is a static type with no instance services. You should never create instances of it by any means. |
| OperatingSystem | Represents a particular operating system and provides information about it. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Random | Represents a pseudo-random number generator. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| ScopedCulture | Represents a culture used within the scope. |
| SmartPtr | Pointer class to wrap types being allocated on heap. Use it to manage memory for classes inheriting Object. This pointer type follows intrusive pointer semantics. Reference counter is stored either in Object itself or in counter structure which is tied to Object instance tightly. In any case, all SmartPtr instances form single ownership group regardless how they were created which is unlike how std::shared_ptr class behaves. Converting raw pointer to SmartPtr is safe given there are other SmartPtr instances holding shared references to the same object. SmartPtr class instance can be in one of two states: shared pointer and weak pointer. To keep object alive, one should have count of shared references to it positive. Both weak and shared pointers can be used to access pointed object (to call methods, read or write fields, etc.), but weak pointers do not participate to shared pointer reference counting. Object is being deleted when the last ‘shared’ SmartPtr pointer to it is being destroyed. So, make sure that this doesn’t happen when no other shared SmartPtr pointers to object exist, e. g. during object construction or destruction. Use System::Object::ThisProtector sentry objects (in C++ code) or CppCTORSelfReference or CppSelfReference attribute (in C# code being translated) to fix this issue. Similarily, make sure to break loop references by using System::WeakPtr pointer class or System::SmartPtrMode::Weak pointer mode (in C++ code) or CppWeakPtr attribute (in C# code being translated). If two or more objects reference each other using ‘shared’ pointers, they will never be deleted. If pointer type (weak or shared) should be switched in runtime, use System::SmartPtr |
| SmartPtrInfo | Service class to test and alter SmartPtr’s contents without knowing final type. Used for garbage collection and loop references detection, etc. Think of it as of ‘pointer to pointer’. We can’t use SmartPtr’s basetype as it doesn’t have any; instead, we use this ‘info’ class. |
| String | String class used across the library. Is a substitute for C# System.String when translating code. For optimization reasons, isn’t considered an Object subclass. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| StringComparer | Compares strings using different comparison modes. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| StringHashCompiletime | A helper class that generates a hash value from a c-string. |
| TimeSpan | Represents a time interval. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| TimeZone | Represents a time zone. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| TimeZoneInfo | Represents an information destribing a particular time zone. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| Tuple | Class that represents a tuple data structure. Maximum number of items is 8. |
| TupleFactory | Provides static methods for creating tuple objects. |
| TypeInfo | Represents a particular type and provides information about it. |
| Uri | Unified resource identifier. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| UriBuilder | Provides methods to construct and modify universial resource identifiers (URIs). Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| UriParser | Used to parse a new URI scheme. Objects of this class should only be allocated using System::MakeObject() function. Never create instance of this type on stack or using operator new, as it will result in runtime errors and/or assertion faults. Always wrap this class into System::SmartPtr pointer and use this pointer to pass it to functions as argument. |
| UriShim | Service class. |
| ValueType | Baseclass for value types with Object inheritance being truncated for performance reasons. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Version | Represents a version number. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Void | |
| WeakPtr | Subclass of System::SmartPtr which sets itself to weak mode at construction. Please note that this class doesn’t guarantee that its instance will always remain in weak mode as set_Mode() is still accessible. This type is a pointer to manage other object’s deletion. It should be allocated on stack and passed to functions either by value or by const reference. |
| WeakReference< T > | Represents a weak reference, which references an object while still allowing that object to be deleted. |
| WeakReference<> | Represents a weak reference, which references an object while still allowing that object to be deleted. |
Structures
| Struct | Description |
|---|---|
| CastResult | Template magic to deduce cast results. |
| CollectionAssertHelper | Heler API for collection-related operations. |
| Convert | The structure that contains methods performing conversion of values of one type to the values of another type. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| Double | Contains methods to work with the double-precision floating-point number. |
| Enum | Provides methods that perform some operations on values of enum type. This is a static type with no instance services. You should never create instances of it by any means. |
| EnumGetNameHelper | Helper class that provides functionality of geting the strting name of enum constant. |
| EnumParseHelper | Helper class that provides functionality of converting a string representation of enum consnant into equivalent enum value. |
| Environment | Environment services. This is a static type with no instance services. You should never create instances of it by any means. |
| HolderInitializer | This class used to get persistent reference to the object instance, whatever it is lvalue or rvalue. To ubtain such reference, use ‘HoldIfTemporary’ method, that has there overloads. Two of them take rvalue as a parameter, and just return the reference to it. The third one, in opposite, takes lvalue as a parameter, makes a pointer copy, then return reference to that copy. Also, class has ‘Hold’ method to hold passed value unconditionally (used to copy values of a local on-stack variables or it’s child references) |
| HolderInitializer< T, false > | HolderInitializer specialization for the case when T is a value type., The usage context allow to return reference to temporary objects, as it is guaranteed, that the instance will be copied by caller. So, this specialization is used just as a stub, and do nothing. |
| IsBoxable | Template predicate that checks if boxing of the specified type is supported. |
| IsExceptionWrapper | A template predicate that determines if the specified type is a Exception class or its descendant. |
| IsNullable | A template predicate that determines if its template argument T in Nullable or its subclass. |
| IsSmartPtr | Trait class to check if a type is a specialization of SmartPtr class. |
| IsStringByteSequence | Template magic to check if a type is a sequence of string characters. |
| IsStringLiteral | Template magic to check if a type is a string literal. |
| IsStringPointer | Template magic to check if a type is a pointer to character string. |
| IsWeakPtr | Traits class to check if specific class is a specialization of System::WeakPtr. Doesn’t check if instance is actually in weak mode. |
| MakeConstRef | Trait to make generic type "const reference" if it is String or a SmartPtr<> type. |
| Math | Contains math functions. This is a static type with no instance services. You should never create instances of it by any means. |
| MethodArgumentTuple< R(*)(Args…)> | Defines tuple to store method arguments. |
| MethodArgumentTuple< R(C::*)(Args…) const > | Defines tuple to store method arguments. |
| MethodArgumentTuple< R(C::*)(Args…)> | Defines tuple to store method arguments. |
| MulticastDelegateTypeInfo | Represents a pointer to TypeInfo object that contains information about MulticastDelegate class. |
| RemoveShared | Trait structs to remove SharedPtr/WeakPtr from argument type. |
| SByte | Contains methods to work with the 8-bit integer. |
| ScopeGuard | The service class that provides services for running a particular function object when an instance of the class goes out of scope. |
| Single | Contains methods to work with the single-precision floating-point number. |
| TestCompare | Service structure providing interface to compare collections. |
| TestTools | Provides a set of useful methods that check some basic properties of different types and functions. |
| TestToolsExt | Common functions to be used by testing translation. |
| TypeInfoPtr | Wrapper for a pointer to an instance of TypeInfo class. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| UInt16 | Contains methods to work with the unsigned 16-bit integer. |
| UInt32 | Contains methods to work with the unsigned 32-bit integer. |
| UInt64 | Contains methods to work with the unsigned 64-bit integer. |
| WeakPtrFromTypeParameter | Trait struct to convert argument type to a weak-pointer, if it is a pointer type. |
Functions
| Function | Description |
|---|---|
| ArrayPtr<T> MakeArray(std::initializer_list<T>) | A factory function that constructs a new Array object, fills it with the elements from the specified initialization list and returns a smart pointer pointing to the Array object. |
| ArrayPtr<T> MakeArray(Args&&…) | A factory function that constructs a new Array object passing the specified arguments to its constructor. |
| std::enable_if<std::is_integral<Integral>::value, ArrayPtr<T>>::type MakeArray(Integral, Args&&…) | A factory function that constructs a new Array object passing the specified arguments to its constructor. |
| bool operator==(ArraySegment<T>, ArraySegment<T>) | |
| constexpr bool operator==(std::nullptr_t, DateTime) | |
| constexpr bool operator==(std::nullptr_t, const DateTimeOffset&) | |
| bool operator==(std::nullptr_t, const Nullable<T>&) | Determines if the specified Nullable object represents a value that is equal to null. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator==(const T1&, const Nullable<T2>&) | Determines if the specified value is equal to the value represented by the specified Nullable object by applying operator==() to these values. |
| bool operator==(const SmartPtr<X>&, const SmartPtr<Y>&) | Equal-compares two smart pointers. |
| bool operator==(std::nullptr_t, SmartPtr<X> const&) | Checks if smart pointer is null. |
| std::enable_if<std::is_base_of<Object, Y>::value&&detail::has_no_operator_equal<X, Y>::value, bool>::type operator==(const SmartPtr<X>&, const Y *) | Equality comparison smart pointer against simple (C) pointer. |
| std::enable_if<std::is_base_of<Object, X>::value&&detail::has_no_operator_equal<X, Y>::value, bool>::type operator==(const X *, const SmartPtr<Y>&) | Equality comparison smart pointer against simple (C) pointer. |
| std::enable_if<!std::is_scalar<T>::value&&!std::is_pointer<T>::value&&!std::is_array<T>::value&&detail::has_method_is_null<T>::value, bool>::type operator==(T const&, std::nullptr_t) | Checks if value type object (translated C# structure, etc.) is null. |
| std::enable_if<!std::is_scalar<T>::value&&!std::is_pointer<T>::value&&!std::is_array<T>::value&&detail::has_method_is_null<T>::value, bool>::type operator==(std::nullptr_t, T const&) | Checks if value type object (translated C# structure, etc.) is null. |
| bool operator==(Chars&, const String&) | String comparison. |
| bool operator==(T&, const String&) | String comparison. |
| bool operator==(const SharedPtr<Object>&, const String&) | Object and string comparison. |
| bool operator==(std::nullptr_t, const String&) | Checks if string is null. |
| constexpr bool operator==(std::nullptr_t, TimeSpan) | |
| bool operator==(const SharedPtr<Uri>&, const SharedPtr<Uri>&) | Determines if the URIs represented by the current and specified objects are equal. |
| bool operator!=(ArraySegment<T>, ArraySegment<T>) | |
| constexpr bool operator!=(std::nullptr_t, DateTime) | |
| constexpr bool operator!=(std::nullptr_t, const DateTimeOffset&) | |
| bool operator!=(std::nullptr_t, const Nullable<T>&) | Determines if the specified Nullable object represents a value that is not equal to null. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator!=(const T1&, const Nullable<T2>&) | Determines if the specified value is not equal to the value represented by the specified Nullable object by applying operator!=() to these values. |
| bool operator!=(const SmartPtr<X>&, const SmartPtr<Y>&) | Non-equal-compares two smart pointers. |
| bool operator!=(SmartPtr<X> const&, std::nullptr_t) | Checks if smart pointer is not null. |
| bool operator!=(std::nullptr_t, SmartPtr<X> const&) | Checks if smart pointer is not null. |
| std::enable_if<std::is_base_of<Object, Y>::value&&detail::has_no_operator_equal<X, Y>::value, bool>::type operator!=(const SmartPtr<X>&, const Y *) | Inequality comparison smart pointer against simple (C) pointer. |
| std::enable_if<std::is_base_of<Object, X>::value&&detail::has_no_operator_equal<X, Y>::value, bool>::type operator!=(const X *, const SmartPtr<Y>&) | Equality comparison smart pointer against simple (C) pointer. |
| bool operator!=(Chars&, const String&) | String comparison. |
| bool operator!=(T&, const String&) | String comparison. |
| bool operator!=(const SharedPtr<Object>&, const String&) | Object and string comparison. |
| bool operator!=(std::nullptr_t, const String&) | Checks if string is null. |
| constexpr bool operator!=(std::nullptr_t, TimeSpan) | |
| bool operator!=(const SharedPtr<Uri>&, const SharedPtr<Uri>&) | Determines if the URIs represented by the current and specified objects are not equal. |
| static bool IsEnumMetaInfoDefined(T) | |
| static bool IsEnumMetaInfoDefined(T) | |
| static System::String EnumGetName(T) | |
| static System::String EnumGetName(T) | |
| constexpr bool operator<(std::nullptr_t, DateTime) | |
| constexpr bool operator<(std::nullptr_t, const DateTimeOffset&) | |
| bool operator<(std::nullptr_t, const Nullable<T>&) | Always returns false. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator<(const T1&, const Nullable<T2>&) | Determines if the specified value is less than the value represented by the specified Nullable object by applying operator<() to these values. |
| constexpr bool operator<(std::nullptr_t, TimeSpan) | |
| constexpr bool operator<=(std::nullptr_t, DateTime) | |
| constexpr bool operator<=(std::nullptr_t, const DateTimeOffset&) | |
| bool operator<=(std::nullptr_t, const Nullable<T>&) | Always returns false. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator<=(const T1&, const Nullable<T2>&) | Determines if the specified value is less or equal to the value represented by the specified Nullable object by applying operator<=() to these values. |
| constexpr bool operator<=(std::nullptr_t, TimeSpan) | |
| constexpr bool operator>(std::nullptr_t, DateTime) | |
| constexpr bool operator>(std::nullptr_t, const DateTimeOffset&) | |
| bool operator>(std::nullptr_t, const Nullable<T>&) | Always returns false. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator>(const T1&, const Nullable<T2>&) | Determines if the specified value is greater than the value represented by the specified Nullable object by applying operator>() to these values. |
| constexpr bool operator>(std::nullptr_t, TimeSpan) | |
| constexpr bool operator>=(std::nullptr_t, DateTime) | |
| constexpr bool operator>=(std::nullptr_t, const DateTimeOffset&) | |
| bool operator>=(std::nullptr_t, const Nullable<T>&) | Always returns false. |
| std::enable_if<!IsNullable<T1>::value, bool>::type operator>=(const T1&, const Nullable<T2>&) | Determines if the specified value is greater or equal to the value represented by the specified Nullable object by applying operator>=() to these values. |
| constexpr bool operator>=(std::nullptr_t, TimeSpan) | |
| void PrintTo(DateTime, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(DateTimeOffset, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const Decimal&, ::std::ostream *) | Writes the value represented by the specified object to the specified output stream. |
| void PrintTo(const Details_Exception&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const ExceptionWrapper<T>&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const Guid&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const Nullable<T>&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const System::Object&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| std::enable_if_t<detail::has_print_to_function<T>::value, void> PrintTo(const SmartPtr<T>&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| std::enable_if_t<!detail::has_print_to_function<T>::value, void> PrintTo(const SmartPtr<T>&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const System::String&, std::ostream *) | Prints string to ostream. Mostly used for debug. |
| void PrintTo(TimeSpan, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| void PrintTo(const WeakPtr<T>&, std::ostream *) | Prints value to ostream. Mostly used for debug. |
| std::ostream& operator«(std::ostream&, DateTime) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, DateTime) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, DateTimeOffset) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, DateTimeOffset) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const Decimal&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const Decimal&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const Exception&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const Exception&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const Guid&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const Guid&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const Nullable<T>&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const Nullable<T>&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const System::Object&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const System::Object&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const OperatingSystem&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const OperatingSystem&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const SharedPtr<T>&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const SharedPtr<T>&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const String&) | Outputs a string to the output stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const String&) | Outputs a string to the output stream. |
| std::ostream& operator«(std::ostream&, TimeSpan) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, TimeSpan) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const TypeInfo&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const TypeInfo&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const Version&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const Version&) | Insert data into the stream. |
| std::ostream& operator«(std::ostream&, const WeakPtr<T>&) | Insert data into the stream using UTF-8 encoding. |
| std::wostream& operator«(std::wostream&, const WeakPtr<T>&) | Insert data into the stream. |
| auto operator-(DayOfWeek, DayOfWeek) | Calculates the number of days between two days of week. |
| Decimal operator-(const T&, const Decimal&) | Returns a new instance of Decimal class that represents a value that is the result of subtraction of the value represented by the specified Decimal object from the specified value. |
| MulticastDelegate<T> operator-(MulticastDelegate<T>, MulticastDelegate<T>) | Disconnects all callbacks in right hand delegate from the end of left hand delegate callback list. |
| auto operator-(const T1&, const Nullable<T2>&) | Subtracts non-nullable and nullable values. |
| Decimal operator+(const T&, const Decimal&) | Returns a new instance of Decimal class that represents a value that is a sum of the specified value and the value represented by the specified Decimal object. |
| MulticastDelegate<T> operator+(MulticastDelegate<T>, MulticastDelegate<T>) | Connects all callbacks from right hand delegate to the end of left hand delegate callback list. |
| auto operator+(const T1&, const Nullable<T2>&) | Sums non-nullable and nullable values. |
| std::enable_if<IsStringLiteral<T, char_t>::value, String>::type operator+(T&, const String&) | String concatenation. |
| std::enable_if<IsStringPointer<T, char_t>::value, String>::type operator+(T&, const String&) | String concatenation. |
| String operator+(const char_t, const String&) | String concatenation. |
| Decimal operator*(const T&, const Decimal&) | Returns a new instance of Decimal class that represents a value that is a result of multiplication of the specified value and the value represented by the specified Decimal object. |
| Decimal operator/(const T&, const Decimal&) | Returns a new instance of Decimal class that represents a value that is a result of division of the specified value and the value represented by the specified Decimal object. |
| std::enable_if<IsExceptionWrapper<T>::value, constT&>::type Default() | Returns the default-constructed instance of the specified type. |
| std::enable_if<!IsExceptionWrapper<T>::value, constT&>::type Default() | Returns the default-constructed instance of the specified type. |
| std::enable_if_t<Details::is_lambda_void_void<T>::value> DoTryFinally(T&&, F&&) | The sigle function that emulates behavior of C#’s try[-catch]-finally statement. During translation of C#’s try[-catch]-finally statement with translator’s option finally_statement_as_lambda set to true, the statement is translated into the invocation of this method. |
| std::enable_if_t<Details::is_lambda_void_boolref<T>::value, bool> DoTryFinally(T&&, F&&) | The sigle function that emulates behavior of C#’s try[-catch]-finally statement. During translation of C#’s try[-catch]-finally statement with translator’s option finally_statement_as_lambda set to true, the statement is translated into the invocation of this method. This overload handles the case in which the return value of the function object that implements the try[-catch] part of the try[-catch]-finally statement is bool. |
| std::enable_if_t<Details::is_lambda_nonovoid_boolref<T>::value, std::optional<Details::ResultOf<T, bool&>>> DoTryFinally(T&&, F&&) | The sigle function that emulates behavior of C#’s try[-catch]-finally statement. During translation of C#’s try[-catch]-finally statement with translator’s option finally_statement_as_lambda set to true, the statement is translated into the invocation of this method. This overload handles the case in which the return value of the function object that implements the try[-catch] part of the try[-catch]-finally statement is bool&. |
| DynamicWeakPtr<T, trunkMode, weakLeafs…>::Reference Ref(DynamicWeakPtr<T, trunkMode, weakLeafs…>&) | Creates reference to DynamicWeakPtr object. Used by translator when passing function arguments by reference. |
| T& Ref(T&) | Helper function to acquire references to objects. Used to guarantee that System::DynamicWeakPtr updates referenced object after assignments. |
| std::enable_if_t<!Details::IsIterable<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, T>> IterateOver(System::SmartPtr<Enumerable>) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable without begin(), end() methods with target type argument for (auto& value : IterateOver |
| std::enable_if_t<!Details::IsIterable<Enumerable>::value, Details::EnumeratorAdapter<Enumerable>> IterateOver(System::SmartPtr<Enumerable>) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable without begin(), end() methods with default target type argument for (auto& value : IterateOver(enumerable)) analog to the following C# code foreach (var value in enumerable) |
| std::enable_if_t<Details::IsIterable<Enumerable>::value, System::SmartPtr<Enumerable>> IterateOver(System::SmartPtr<Enumerable>) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable with begin(), end() methods with default target type argument for (auto& value : IterateOver(enumerable)) |
| std::enable_if_t<Details::IsIterable<Enumerable>::value&&std::is_same<typename Details::ReturnTypeTrait<T>::ReturnType, Details::IterableValueType<Enumerable>>::value, System::SmartPtr<Enumerable>> IterateOver(System::SmartPtr<Enumerable>) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable with begin(), end() methods with target type same as original value_type of iterator. |
| std::enable_if_t<Details::IsIterable<Enumerable>::value&&!std::is_same<typename Details::ReturnTypeTrait<T>::ReturnType, Details::IterableValueType<Enumerable>>::value, Details::CppIteratorAdapter<Enumerable, T>> IterateOver(System::SmartPtr<Enumerable>) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable with begin(), end() methods with different target type and original value_type of iterator. |
| std::enable_if_t<!IsSmartPtr<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, Details::ValueTypeOfEnumerable<Enumerable>, Enumerable *>> IterateOver(const Enumerable *) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable this with default target type. |
| std::enable_if_t<!IsSmartPtr<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, T, Enumerable *>> IterateOver(const Enumerable *) | This function property wraps enumerable (or iterable) object so it can be used with range-based for loop This overload for Enumerable without begin(), end() methods with target type argument for (auto& value : IterateOver |
| std::enable_if<std::is_scalar<T>::value, int>::type GetHashCode(const T&) | Returns a hash code for the specified scalar value. |
| std::enable_if<!std::is_scalar<T>::value&&System::IsSmartPtr<T>::value, int>::type GetHashCode(const T&) | Returns a hash code for the specified object. |
| std::enable_if<System::IsExceptionWrapper<T>::value, int>::type GetHashCode(const T&) | Returns a hash code for the specified object which is exception. |
| std::enable_if<!std::is_scalar<T>::value&&!System::IsSmartPtr<T>::value&&!System::IsExceptionWrapper<T>::value, int>::type GetHashCode(const T&) | Returns a hash code for the specified object which is not a smart pointer nor exception. |
| int GetHashCode(const std::thread::id&) | Specialization for std::thread::id; Returns the hash code for the specified thread object. |
| std::enable_if<!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type Cast_noexcept(SmartPtr<TFrom> const&) | Performs cast on SmartPtr objects. |
| std::enable_if<!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type Cast(SmartPtr<TFrom> const&) | Performs cast on SmartPtr objects. |
| std::enable_if<IsExceptionWrapper<TFrom>::value&&IsExceptionWrapper<TTo>::value&&(std::is_convertible<TTo, TFrom>::value | |
| std::enable_if<!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type DynamicCast_noexcept(SmartPtr<TFrom> const&) | Performs dynamic cast on SmartPtr objects. |
| std::enable_if<std::is_same<System::Object, TFrom>::value&&IsExceptionWrapper<TTo>::value, TTo>::type DynamicCast_noexcept(SmartPtr<TFrom>) | Performs dynamic cast on Objects to Exception objects. |
| std::enable_if<IsExceptionWrapper<TFrom>::value&&IsExceptionWrapper<TTo>::value&&(std::is_convertible<TTo, TFrom>::value | |
| std::enable_if<!std::is_enum<TTo>::value&&!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type DynamicCast(SmartPtr<TFrom> const&) | Performs dynamic cast on SmartPtr objects. |
| std::enable_if<std::is_enum<TTo>::value, TTo>::type DynamicCast(SmartPtr<TFrom>) | Unboxes boxed enum via cast. |
| CastResult<TTo>::type DynamicCast(std::nullptr_t) | Performs dynamic cast of null objects. |
| std::enable_if<!IsExceptionWrapper<TFrom>::value&&!IsSmartPtr<TFrom>::value&&std::is_convertible<TTo, TFrom>::value, TTo>::type DynamicCast(TFrom&) | Performs dynamic cast on non-pointer objects. |
| std::enable_if<std::is_same<System::Object, TFrom>::value&&IsExceptionWrapper<TTo>::value, TTo>::type DynamicCast(SmartPtr<TFrom>) | Performs dynamic cast on Objects to Exception objects. |
| std::enable_if<std::is_pointer<TTo>::value&&std::is_same<IntPtr, TFrom>::value, TTo>::type DynamicCast(TFrom) | Performs dynamic cast from IntPtr to pointer. |
| std::enable_if<!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type StaticCast_noexcept(SmartPtr<TFrom> const&) | Performs static cast on SmartPtr objects. |
| CastResult<TTo>::type StaticCast_noexcept(WeakPtr<TFrom> const&) | Performs static cast on WeakPtr objects. |
| std::enable_if<IsExceptionWrapper<TFrom>::value&&IsExceptionWrapper<TTo>::value&&(std::is_convertible<TTo, TFrom>::value | |
| std::enable_if<std::is_same<System::Object, TFrom>::value&&IsExceptionWrapper<TTo>::value, TTo>::type StaticCast_noexcept(SmartPtr<TFrom>) | Performs static cast on Objects to Exception objects. |
| std::enable_if<!IsExceptionWrapper<TTo>::value, typenameCastResult<TTo>::type>::type StaticCast(SmartPtr<TFrom> const&) | Performs static cast on SmartPtr objects. |
| CastResult<TTo>::type StaticCast(WeakPtr<TFrom> const&) | Performs static cast on WeakPtr objects. |
| CastResult<TTo>::type StaticCast(std::nullptr_t) | Performs static cast of null objects. |
| std::enable_if<std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(TFrom) | Specialization for arithmetic types. |
| std::enable_if<std::is_same<TTo, System::String>::value, TTo>::type StaticCast(TTo) | Process cast from String to String. |
| std::enable_if<std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(const TFrom *) | Specialization for arithmetic types. |
| std::enable_if<!std::is_same<TFrom, System::String>::value&&!IsExceptionWrapper<TFrom>::value&&!IsSmartPtr<TFrom>::value&&!std::is_arithmetic<TFrom>::value, TTo>::type StaticCast(const TFrom&) | Performs static cast on non-pointer objects. |
| std::enable_if<IsExceptionWrapper<TFrom>::value&&IsExceptionWrapper<TTo>::value&&(std::is_convertible<TTo, TFrom>::value | |
| std::enable_if<std::is_same<System::Object, TFrom>::value&&IsExceptionWrapper<TTo>::value, TTo>::type StaticCast(SmartPtr<TFrom>) | Performs static cast on Objects to Exception objects. |
| CastResult<TTo>::type ConstCast(const SmartPtr<TFrom>&) | End of deprecated casts. |
| CastResult<TTo>::type ForceStaticCast(SmartPtr<TFrom> const&) | Performs real static cast on SmartPtr objects. |
| SmartPtr<Object> MemberwiseClone(T *) | Performs memberwise cloning using copy constructor. |
| std::enable_if_t<Details::CastType<Source, Result>::None, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used when the source and the result types are the same. |
| std::enable_if_t<Details::CastType<Source, Result>::Static, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used when simple constructor-like cast is needed. |
| std::enable_if_t<Details::CastType<Source, Result>::Exception, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for exception wrappers. |
| std::enable_if_t<Details::CastType<Source, Result>::ObjectToException, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for casting object to exception. |
| std::enable_if_t<Details::CastType<Source, Result>::Pointer, typename CastResult<Result>::type> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used when the source and result both are smart pointers (without expicit SmartPtr<…> in result type). |
| std::enable_if_t<Details::CastType<Source, Result>::RawPointer, typename CastResult<std::remove_pointer_t<Result>>::type> ExplicitCast(Source) | Casts the source type to the result type using explicit cast. Used when the casting raw pointer to smart pointer. |
| std::enable_if_t<Details::CastType<Source, Result>::PointerToPointer, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used when the source and result both are smart pointers (with expicit SmartPtr<…> in result type). |
| std::enable_if_t<Details::CastType<Source, Result>::UnboxingToNullable, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for unboxing object to nullable. |
| std::enable_if_t<Details::CastType<Source, Result>::NullableBoxing, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used to box nullable. |
| std::enable_if_t<Details::CastType<Source, Result>::NullableUnboxing, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for unboxing nullable object. |
| std::enable_if_t<Details::CastType<Source, Result>::EnumBoxing, SmartPtr<BoxedValueBase>> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for enum boxing. |
| std::enable_if_t<Details::CastType<Source, Result>::Boxing, typename CastResult<Result>::type> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for common boxing. |
| std::enable_if_t<Details::CastType<Source, Result>::StringBoxing, typename CastResult<Result>::type> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for System::String boxing. |
| std::enable_if_t<Details::CastType<Source, Result>::Unboxing, Result> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for common unboxing. |
| std::enable_if_t<Details::CastType<Source, Result>::Null, typename CastResult<Result>::type> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for nullptr casting. |
| std::enable_if_t<Details::CastType<Source, Result>::Array, typename CastResult<Result>::type> ExplicitCast(const Source&) | Casts the source type to the result type using explicit cast. Used for casting between arrays. |
| std::enable_if_t<Details::CastType<Source, Result>::Static, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used when simple constructor-like cast is needed. |
| std::enable_if_t<Details::CastType<Source, Result>::None, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used when the source and the result types are the same. |
| std::enable_if_t<Details::CastType<Source, Result>::Exception, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for exception wrappers. |
| std::enable_if_t<Details::CastType<Source, Result>::ObjectToException, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for casting object to exception. |
| std::enable_if_t<Details::CastType<Source, Result>::Pointer, typename CastResult<Result>::type> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used when the source and result both are smart pointers. |
| std::enable_if_t<Details::CastType<Source, Result>::PointerToPointer, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used when the source and result both are smart pointers (with expicit SmartPtr<…> in result type). |
| std::enable_if_t<Details::CastType<Source, Result>::UnboxingToNullable, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for unboxing object to nullable. |
| std::enable_if_t<Details::CastType<Source, Result>::NullableBoxing, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for boxing nullable object. |
| std::enable_if_t<Details::CastType<Source, Result>::Boxing, typename CastResult<Result>::type> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for boxing common object. |
| std::enable_if_t<Details::CastType<Source, Result>::UnboxingToString, Result> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for string unboxing. |
| std::enable_if_t<Details::CastType<Source, Result>::Null, typename CastResult<Result>::type> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used for nullptr casing. |
| std::enable_if_t<Details::CastType<Source, Result>::Array, typename CastResult<Result>::type> AsCast(const Source&) | Casts the source type to the result type using ‘as’ operator cast. Used to cast between arrays. |
| const System::TypeInfo& ObjectType::GetType< System::String >() | Implements typeof() translation. Overload for String. |
| const System::TypeInfo& ObjectType::GetType< System::DateTime >() | Implements typeof() translation. Overload for DateTime. |
| bool Equals(const TA&, const TB&) | Determines the equality of two values applying operator==() to them. |
| bool Equals< float, float >(const float&, const float&) | Specialization for single-precision floating point values. Although two floating point NaNs are defined by IEC 60559:1989 to always compare as unequal, the contract for System.Object.Equals, requires that overrides must satisfy the requirements for an equivalence operator. Therefore, System.Double.Equals and System.Single.Equals return True when comparing two NaNs, while the equality operator returns False in that case, as required by the standard. |
| bool Equals< double, double >(const double&, const double&) | Specialization for double-precision floating point values. |
| std::enable_if_t<!std::is_floating_point<TA>::value&&!std::is_floating_point<TB>::value, int> Compare(const TA&, const TB&) | Compares two values. |
| std::enable_if_t<std::is_floating_point<TA>::value&&std::is_floating_point<TB>::value, int> Compare(const TA&, const TB&) | Compares two floating point values. |
| bool IsNaN(const T&) | Determines if the specified value is Not-A-Number value. |
| bool IsInfinity(const T&) | Determines if the specified value represents infinity. |
| bool IsPositiveInfinity(const T&) | Determines if the specified value represents positive infinity. |
| bool IsNegativeInfinity(const T&) | Determines if the specified value represents negative infinity. |
| TTo CheckedCast(TFrom) | Determines if the specified value falls into the range of values of type TTo and if it does casts it to the type TTo. |
| ScopeGuard<F> MakeScopeGuard(F) | A factory function that creates instances of ScopedGuard class. |
| T setter_wrap(void(*)(T2), T) | Overload for static setter functions with type conversion. |
| std::enable_if<std::is_base_of<HostSet, Host>::value, T>::type setter_wrap(Host const, void(HostSet::)(T2), T) | Overload for instance setter functions with type conversion. |
| T setter_increment_wrap(T()(), void()(T)) | Translator translates C#’s increment expressions targeting class’ property that has setter and getter defined, into invocation of this function. |
| std::enable_if<std::is_base_of<HostGet, Host>::value&&std::is_base_of<HostSet, Host>::value, T>::type setter_increment_wrap(Host const, T(HostGet::)(), void(HostSet::*)(T)) | Translator translates C#’s increment expressions targeting class’ property that has setter and getter defined, into invocation of this function. |
| T setter_post_increment_wrap(T()(), void()(T)) | Translator translates C#’s post-increment expressions targeting class’ property that has setter and getter defined, into invocation of this function. |
| 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, T(HostGet::)(), void(HostSet::*)(T)) | Translator translates C#’s post-increment expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for non-const getter). |
| 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, T(HostConstGet::)() const, void(HostSet::*)(T)) | Translator translates C#’s post-increment expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for const getter). |
| T setter_decrement_wrap(T()(), void()(T)) | Translator translates C#’s pre-decrement expressions targeting class’ property that has setter and getter defined, into invocation of this function. |
| std::enable_if<std::is_base_of<HostGet, Host>::value&&std::is_base_of<HostSet, Host>::value, T>::type setter_decrement_wrap(Host const, T(HostGet::)(), void(HostSet::*)(T)) | Translator translates C#’s pre-decrement expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for non-const getter). |
| std::enable_if<std::is_base_of<HostConstGet, Host>::value&&std::is_base_of<HostSet, Host>::value, T>::type setter_decrement_wrap(Host const, T(HostConstGet::)() const, void(HostSet::*)(T)) | Translator translates C#’s pre-decrement expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for const getter). |
| T setter_post_decrement_wrap(T()(), void()(T)) | Translator translates C#’s post-decrement expressions targeting class’ property that has setter and getter defined, into invocation of this function. |
| 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, T(HostGet::)(), void(HostSet::*)(T)) | Translator translates C#’s post-decrement expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for non-const getter). |
| 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, T(HostConstGet::)() const, void(HostSet::*)(T)) | Translator translates C#’s post-decrement expressions targeting instance’s property that has setter and getter defined, into invocation of this function (overload for const getter). |
| std::enable_if<!IsSmartPtr<T>::value, SmartPtr<T>>::type MakeObject(Args&&…) | Creates object on heap and returns shared pointer to it. |
| std::enable_if<IsSmartPtr<T>::value, T>::type MakeObject(Args&&…) | Creates object on heap and returns shared pointer to it. |
| SmartPtr<X> MakeSharedPtr(X *) | Converts raw pointer to smart pointer. |
| SmartPtr<X> MakeSharedPtr(const X *) | Converts raw pointer to smart pointer. Overload for const pointers. Useful e. g. when using ’this’ variable in C# methods translated as const. |
| SmartPtr<Y> static_pointer_cast(SmartPtr<X> const&) | Casts smart pointers using static_cast. |
| SmartPtr<Y> dynamic_pointer_cast(SmartPtr<X> const&) | Casts smart pointers using dynamic_cast. |
| SmartPtr<Y> const_pointer_cast(SmartPtr<X> const&) | Casts smart pointers using const_cast. |
| T * get_pointer(System::SmartPtr<T> const&) | Gets referenced object of smart pointer. |
| std::enable_if<!System::detail::has_method_get_Count<From>::value, Collections::Generic::ListPtr<To>>::type CastEnumerableTo(const From&) | Performs the explicit casting of elements of the specified enumerable object to different type. |
| std::enable_if<System::detail::has_method_get_Count<From>::value, Collections::Generic::ListPtr<To>>::type CastEnumerableTo(const From&) | Performs the explicit casting of elements of the specified enumerable object to different type. |
| std::enable_if_t<System::IsSmartPtr<From>::value, System::SharedPtr<System::Array<To>>> StaticCastArray(const System::SharedPtr<System::Array<From>>&) | Performs casting of elements of the specified array to different type. Override for cases then From is SmartPtr obj. |
| std::enable_if_t<!System::IsSmartPtr<From>::value&&System::IsBoxable<From>::value&&std::is_same<To, System::SharedPtr<Object>>::value, System::SharedPtr<System::Array<To>>> StaticCastArray(const System::SharedPtr<System::Array<From>>&) | Performs casting of elements of the specified array to different type. Override for cases then From is Boxable and To is Object[]. |
| SharedPtr<Array<To>> DynamicCastArray(const SharedPtr<Array<From>>&) | Performs casting of elements of the specified array to different type. |
| std::istream& operator»(std::istream&, String&) | Gets a string from the input streamusing UTF-8 encoding. |
| std::wistream& operator»(std::wistream&, String&) | Gets a string from the input stream. |
| bool is_vp_test(const ::testing::TestInfo *) | |
| std::string ForEachMemberGVName() |
Enums
| Enum | Description |
|---|---|
| Base64FormattingOptions | Enumeration containing values that represent different formats of base-64 encoded data. |
| DateTimeKind | Enumeration values of which represent the kinds of date and time. |
| DayOfWeek | Enumeration that represents a day of week. |
| EnvironmentVariableTarget | Specifies the environment variable location. |
| MidpointRounding | Specifies the behavior of rounding functions. |
| PlatformID | Represents an operating system platform. |
| SmartPtrMode | SmartPtr pointer type: weak or shared. Defines whether pointer is being counted when it is being decided whether to delete object or not. |
| StringSplitOptions | Determines string splitting behavior. |
| StringComparison | Defines string comparison style. |
| TypeCode | Represents the type of an object. |
| UriKind | Represents the kinds of URIs. |
| UriComponents | Represents URI components. |
| UriFormat | Specifies how the URI is escaped. |
| UriHostNameType | Represents the type of host name. |
| UriPartial | Represents the parts of a URI for the Uri.GetLeftPart method. |
Typedefs
| Typedef | Description |
|---|---|
| IFormatProviderPtr | An alias for a smart pointer that points to an instance of System::IFormatProvider class. |
| DecoderFallbackPtr | An alias for a smart pointer that points to an instance of System::Text::DecoderFallback class. |
| DecoderFallbackBufferPtr | An alias for a smart pointer that points to an instance of System::Text::DecoderFallbackBuffer class. |
| DecoderReplacementFallbackPtr | An alias for a smart pointer that points to an instance of System::Text::DecoderReplacementFallback class. |
| EncoderFallbackPtr | An alias for a smart pointer that points to an instance of System::Text::EncoderFallback class. |
| EncoderFallbackBufferPtr | An alias for a smart pointer that points to an instance of System::Text::EncoderFallbackBuffer class. |
| EncoderPtr | An alias for a smart pointer that points to an instance of System::Text::Encoder class. |
| DecoderPtr | An alias for a smart pointer that points to an instance of System::Text::Decoder class. |
| EncoderReplacementFallbackBufferPtr | An alias for a smart pointer that points to an instance of System::Text::EncoderReplacementFallbackBuffer class. |
| EncoderReplacementFallbackPtr | An alias for a smart pointer that points to an instance of System::Text::EncoderReplacementFallback class. |
| EncodingPtr | An alias for a smart pointer that points to an instance of System::Text::Encoding class. |
| EncodingInfoPtr | An alias for a smart pointer that points to an instance of System::Text::EncodingInfo class. |
| StreamPtr | An alias for a smart pointer that points to an instance of System::IO::Stream class. |
| FileStreamPtr | An alias for a smart pointer that points to an instance of System::IO::FileStream class. |
| MemoryStreamPtr | An alias for a smart pointer that points to an instance of System::IO::MemoryStream class. |
| StreamReaderPtr | An alias for a smart pointer that points to an instance of System::IO::StreamReader class. |
| StreamWriterPtr | An alias for a smart pointer that points to an instance of System::IO::StreamWriter class. |
| FileInfoPtr | An alias for a smart pointer that points to an instance of System::IO::FileInfo class. |
| FileSystemInfoPtr | An alias for a smart pointer that points to an instance of System::IO::FileSystemInfo class. |
| DirectoryInfoPtr | An alias for a smart pointer that points to an instance of System::IO::DirectoryInfo class. |
| Action | Delegate type that references methods that have no return value. |
| ByteArrayPtr | An alias for a smart pointer object that points to an array of unsigned 8-bit integers. |
| AsyncCallback | A delegate type that represents a method to be called when asynchronous operation completes. |
| BadImageFormatException | The exception that is thrown when the file image of a dynamic link library (DLL) or an executable program is invalid. Never wrap the BadImageFormatException class instances into System::SmartPtr. |
| Converter | Represents a pointer to the invokable entity that accepts a single argument of the TInput type and returns a value of the TOutput type. |
| Event | Represents an event - a mechanism through which subscribers are notified about an occurence of interest by means of a delegate invocation. |
| EventArgsPtr | Shared pointer to an instance of EventArgs class. |
| EventHandler | Represents a method that reacts to and processes an event. This type should be allocated on stack and passed to functions by value or by reference. Never use System::SmartPtr class to manage objects of this type. |
| ExceptionPtr | Type alias used by exception wrappers. |
| Exception | Alias to be used instead of Details::Exception. |
| SystemException | |
| ApplicationException | |
| InvalidOperationException | |
| InvalidProgramException | |
| InvalidTimeZoneException | |
| TimeZoneNotFoundException | |
| ObjectDisposedException | |
| NotImplementedException | |
| NotSupportedException | |
| PlatformNotSupportedException | |
| ArgumentException | |
| ArgumentNullException | |
| ArgumentOutOfRangeException | |
| FormatException | |
| UriFormatException | |
| ArithmeticException | |
| OverflowException | |
| DivideByZeroException | |
| OutOfMemoryException | |
| IndexOutOfRangeException | |
| RankException | |
| InvalidCastException | |
| NullReferenceException | |
| UnauthorizedAccessException | |
| MemberAccessException | |
| MethodAccessException | |
| OperationCanceledException | |
| StackOverflowException | |
| TimeoutException | |
| ExecutionEngineException | |
| TypeInitializationException | |
| DataMisalignedException | |
| IAsyncResultPtr | Shared pointer to IAsyncResult. |
| MakeConstRef_t | Helper type for MakeConstRef modifier. |
| Predicate | Represents a pointer to a predicate - an invokable entity that accepts a single argument and returns a bool value. |
| ArrayPtr | Alias for ‘pointer to array’ type. |
| SharedPtr | Alias for smart pointer widely used in the library. |
| StringComparerPtr | An alias for a shared pointer to an instance of StringComparer class. |
| TimeZonePtr | Shared pointer to an instance of TimeZone class. |
| TimeZoneInfoPtr | Alias for shared pointer to an instance of TimeZoneInfo class. |