Spring Unit

Declares the fundamental types for the Spring4D Framework.

Classes

EFormatException
EIndexOutOfRangeException
EInvalidEnumArgumentException
EKeyNotFoundException
ERttiException
ManagedAttribute

This attribute marks automatically initialized interface or object fields inside of classes that inherit from TManagedObject or are using the mechanism provided by TInitTable.

TArray
TBaseAttribute
TEnum

Provides static methods to manipulate an enumeration type.

TEventArgs
TInitTable
TInterfaceBase

Provides a non-reference-counted spring4d.api/!:system.iinterface implementation.

TInterfacedCriticalSection
TManagedInterfacedObject
TManagedObject
TNotificationHandler
TPropertyChangedEventArgs
TRefCountedObject

Provides an abstract implementation for any interface implementing class without already implementing IInterface to avoid unnecessary waste of instance space for its VMT. If you inherit from this class you implement an interface that is not IInterface and thus would just waste this space.

TType
Tuple

Records

Event<T>
Guard

Provides static methods to check arguments and raise argument exceptions.

Int24
Lazy
Lazy<T>

Provides support for lazy initialization.

Lock

Provides an easy to use wrapper around TCriticalSection. It automatically initializes the TCriticalSection instance when required and destroys it when the Lock goes out of scope.

Nullable
Nullable<T>

A nullable type can represent the normal range of values for its underlying value type, plus an additional Null value.

Pointer<T>
RaiseHelper
ReadWriteLock
Shared
Shared<T>
TActivator
TArgument
TArrayEnumerator<T>
TLazyInitializer

Provides lazy initialization routines.

TNamedValue

A record type that stores a TValue and a name.

TNullableHelper

Helper record for fast access to nullable value via RTTI.

TTimSort
TTypeInfo<T>
TTypedValue

A record type that stores a TValue and a typeinfo.

Tuple<T1,T2,T3,T4>
Tuple<T1,T2,T3>
Tuple<T1,T2>
Vector<T>
VectorHelper
Weak
Weak<T>

Interfaces

IClonable

Supports cloning, which creates a new instance of a class with the same value as an existing instance.

IComparable

Defines a generalized type-specific comparison method that a class implements to order or sort its instances.

IComparerRef
ICountable

Base interface for anything that has a countable quantity.

ICriticalSection
IEnumerable

Exposes an enumerator, which supports a simple iteration over a non-generic collection.

IEnumerator

Supports a simple iteration over a non-generic collection.

IEvent
IEvent<T>

Represents a multicast event that provides adding and removing event handlers.

IEventArgs
IInvokableEvent<T>

Represents a multicast event that can be invoked.

IInvokableNotifyEvent
IInvokableNotifyEvent<T>
ILazy

Provides support for lazy initialization.

ILazy<T>

Provides support for lazy initialization.

INotifyEvent<T>
INotifyPropertyChanged
IObjectActivator
IPropertyChangedEventArgs

Enumerations

ExceptionArgument
ExceptionResource
TCollectionChangedAction

Describes the action that caused a CollectionChanged event.

TLazyKind

Specifies the kind of a lazy type.

Delegates

Action

Encapsulates a method that has no parameters and does not return a value.

Action<T1,T2,T3,T4>

Encapsulates a method that has four parameters and does not return a value.

Action<T1,T2,T3>

Encapsulates a method that has three parameters and does not return a value.

Action<T1,T2>

Encapsulates a method that has two parameters and does not return a value.

Action<T>

Encapsulates a method that has a single parameter and does not return a value.

Func<T,TResult>

Encapsulates a method that has one parameter and returns a value of the type specified by the TResult parameter.

Func<T1,T2,T3,T4,TResult>

Encapsulates a method that has four parameters and returns a value of the type specified by the TResult parameter.

Func<T1,T2,T3,TResult>

Encapsulates a method that has three parameters and returns a value of the type specified by the TResult parameter.

Func<T1,T2,TResult>

Encapsulates a method that has two parameters and returns a value of the type specified by the TResult parameter.

Func<TResult>

Encapsulates a method that has no parameters and returns a value of the type specified by the TResult parameter.

IShared<T>
Predicate<T>

Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

TActionMethod<T>

Represents a instance method that has a single parameter and does not return a value.

TActionProc<T>

Represents a procedure that has a single parameter and does not return a value.

TConstructor
TEventHandler<T>
TFieldInitializer
TMethodPointer
TNotificationEvent
TNotifyEvent<T>

An event type like TNotifyEvent that also has a generic item parameter.

TNotifyProc

Represents a anonymous method that has the same signature as TNotifyEvent.

TPropertyChangedEvent
TValueConverterCallback

Types

Helpers

Constants

EmptyValue
FieldVisibility
ISO8601FormatSettings
InvokableEvent
ObjCastGUID
caAdded

An item was added to the collection.

caChanged

An item in the collection was changed.

caExtracted

An item was removed from the collection without considering ownership.

caMoved

An item was moved within the collection.

caRemoved

An item was removed from the collection.

caReplaced

An item was replaced in the collection.

caReset

The content of the collection changed dramatically.

caReseted
doOwnsKeys

Objects stored as key are being destroyed when removed

doOwnsValues

Objects stored as value are being destroyed when removed

lkFunc

Type is Func<TResult> .

lkInterface

Type is ILazy<T> .

lkNone

Not a lazy type.

lkRecord

Type is Lazy<T> .

Routines

AtomicExchangeAdd(Int64, Int64)
AtomicLoad(Int64)
AtomicStore(Int64, Int64)
BinarySwap(Pointer, Pointer, NativeInt)
CheckArgumentNotNull(IInterface, string)

Raises an EArgumentNilException if the value is nil.

CheckArgumentNotNull(Pointer, string)

Raises an EArgumentNilException if the value is nil.

CheckIndex(Integer, Integer)
CheckRange(Integer, Integer, Integer)
CompareValue(TValue, TValue)

Compares two TValue instances.

CreateFieldTable(TClass)
DynArrayHigh(Pointer)
DynArrayLength(Pointer)
FormatValue(TValue)
GetAbstractError
GetEqualsOperator(PTypeInfo)
GetGenericTypeParameters(string)
GetInitTable(TClass)

Returns the field table for the given class that contains all fields that have Default or Managed attribute annotations.

GetInterfaceByTypeInfo(TObject, PTypeInfo, Void)
GetLazyKind(PTypeInfo)

Returns the TLazyKind of the typeInfo.

GetLazyType(PTypeInfo)

Returns the underlying type of the lazy type.

GetLazyTypeName(PTypeInfo)

Returns the underlying type name of the lazy type.

GetQualifiedClassName(TClass)
GetQualifiedClassName(TObject)
GetSetSize(PTypeInfo)

Returns the size of the passed set type

GetTypeInfoHashCode(PTypeInfo)
GetTypeSize(PTypeInfo)

Returns the size that is needed in order to pass an argument of the given type.

GetUnderlyingType(PTypeInfo)

Returns the underlying type argument of the specified nullable type.

GetVirtualMethod(TClass, Integer)
GrowCapacity(Integer)
GrowCapacity(Integer, Integer)
HasMethodInfo(PTypeInfo)
IncUnchecked(Integer, Integer)
InterfaceToMethodPointer(Void, Integer)
IntfAssign(IInterface, IInterface)
IsAssignableFrom(PTypeInfo, PTypeInfo)

Determines whether an instance of leftType can be assigned from an instance of rightType .

IsAssignableFrom(array of PTypeInfo, array of PTypeInfo)
IsAssignableFromRelaxed(PTypeInfo, PTypeInfo)

Determines whether an instance of leftType can be assigned from an instance of rightType using an equality check of the typeinfo.

IsLazyType(PTypeInfo)

Returns True if the type is a lazy type.

IsMethodReference(PTypeInfo)
IsNullable(PTypeInfo)

Returns True if the type is a nullable type.

IsPowerOf2(NativeInt)
MethodPointerToMethodReference(TMethodPointer)
MethodReferenceToMethod(Void)
MethodReferenceToMethodPointer(Void)
MethodToMethodReference(TMethod)
MoveManaged(Pointer, Pointer, Pointer, NativeInt)
NextPowerOf2(NativeInt)
NopQueryInterface(Pointer, TGuid, Void)
NopRef(Pointer)
PassByRef(PTypeInfo, TCallConv, Boolean)
PlatformNotImplemented
RecAddRef(Pointer)
RegisterWeakRef(Pointer, TObject)
SameTypeInfo(PTypeInfo, PTypeInfo)
SameValue(Variant, Variant)

Indicates whether two Variant values are equal. Unlike using the equals operator this function also supports variant arrays.

SkipShortString(PByte)
StreamToVariant(TStream)
SwapPtr(PPointer, Integer, Integer)
TypesOf(array of TValue)

Returns the types of the values.

UTF8IdentIdentCompare(PByte, PByte)
UnregisterWeakRef(Pointer, TObject)
VarArrayLength(Variant, Integer)

Returns the length of the variant array for the specified dimension.

VarIsNullOrEmpty(Variant)

Determines whether a variant value is null or empty.

__SuppressWarning(Void)