anchor.diff:    Result := FStaticInstance;
   end;
   
  +function TDefaultsMap.GetValue(DefValAttribClass : TDefaultValueAttributeClass) : TValue;
  +begin
  +  Result := FInternalMap.Items[DefValAttribClass];
  +end;
  +
  +function TDefaultsMap.HasValue(DefValAttribClass : TDefaultValueAttributeClass) : Boolean;
  +begin
  +  Result := FInternalMap.ContainsKey(DefValAttribClass);
  +end;
  +
   { TDefaultValueAttribute }
   
  -constructor TDefaultValueAttribute.Create(AValue : TValue);
  +constructor TDefaultValueAttribute.Create(AValueType : TDefaultValueKind);
   begin
     inherited Create;
   
  -  FValue := AValue;
  -  FValueKind := dvkData;
  -end;
  -
  -constructor TDefaultValueAttribute.Create;
  -begin
  -  inherited Create;
  -
  -  FValue := TValue.Empty;
  -  FValueKind := dvkCalculated;
  -end;
  -
  -function TDefaultValueAttribute.CalculateValue : TValue;
  -begin
  -  with TDefaultsMap.StaticInstance do
  -    if ContainsKey(Self.GetClassType) then
  -      Result := Items[Self.GetClassType]
  -    else
  -      Result := TValue.Empty;
  +  FValueType := AValueType;
   end;
   
   function TDefaultValueAttribute.GetClassType : TDefaultValueAttributeClass;
  
positive.code:   Pointer(Result) := PPointer(Self)^;
  end;
  
  function TDefaultValueAttribute.GetValue : TValue;
  begin
    Result := TValue.Empty;
  
    case ValueKind of
      dvkData:
  
negative.code: interface
  
  uses
    System.Generics.Collections, System.Rtti,
    FIToolkit.Config.Types;
  
  type
  
    { Base classes }
  
    TDefaultValueAttributeClass = class of TDefaultValueAttribute;
  
    TDefaultValueAttribute = class abstract (TCustomAttribute)
      strict private
        FValueType : TDefaultValueKind;
      private
        function GetClassType : TDefaultValueAttributeClass;
      protected
        constructor Create(AValueType : TDefaultValueKind);
      public
        property ValueKind : TDefaultValueKind read FValueType;
    end;
  
    TDefaultValueAttribute<T> = class abstract (TDefaultValueAttribute)
      strict private
        FValue : T;
      private
        function GetValue : T;
      protected
        function CalculateValue : T; virtual;
      public
        constructor Create(const AValue : T); overload;
        constructor Create; overload;
  
        property Value : T read GetValue;
    end;
  
    TDefaultsMap = class
      strict private
        type
          TInternalMap = class (TDictionary<TDefaultValueAttributeClass, TValue>);
      strict private
        class var FStaticInstance : TDefaultsMap;
  
        FInternalMap : TInternalMap;
      private
        class procedure FreeStaticInstance; static;
        class function  GetStaticInstance : TDefaultsMap; static;
      public
        class property StaticInstance : TDefaultsMap read GetStaticInstance;
  
        constructor Create;
        destructor Destroy; override;
  
        procedure AddValue(DefValAttribClass : TDefaultValueAttributeClass; Value : TValue);
        function  GetValue(DefValAttribClass : TDefaultValueAttributeClass) : TValue;
        function  HasValue(DefValAttribClass : TDefaultValueAttributeClass) : Boolean;
    end;
  
    procedure RegisterDefaultValue(DefValAttribClass : TDefaultValueAttributeClass; Value : TValue);
  
  implementation
  
  uses
    System.SysUtils;
  
  { Utils }
  
  procedure RegisterDefaultValue(DefValAttribClass : TDefaultValueAttributeClass; Value : TValue);
  begin
    TDefaultsMap.StaticInstance.AddValue(DefValAttribClass, Value);
  end;
  
  { TDefaultsMap }
  
  procedure TDefaultsMap.AddValue(DefValAttribClass : TDefaultValueAttributeClass; Value : TValue);
  begin
    FInternalMap.Add(DefValAttribClass, Value);
  end;
  
  constructor TDefaultsMap.Create;
  begin
    inherited Create;
  
    FInternalMap := TInternalMap.Create;
  end;
  
  destructor TDefaultsMap.Destroy;
  begin
    FreeAndNil(FInternalMap);
  
    inherited Destroy;
  end;
  
  class procedure TDefaultsMap.FreeStaticInstance;
  begin
  