anchor.diff:    Result := AsString(',');
   end;
   
  +{ TDataParamsAsAggregate }
  +
  +constructor TDataParamsAsAggregate.Create(const AController: IInterface;
  +  Origin: IDataParams);
  +begin
  +  inherited Create(AController);
  +  FOrigin := Origin;
  +end;
  +
  +function TDataParamsAsAggregate.Add(Param: IDataParam): IDataParams;
  +begin
  +  Result := FOrigin.Add(Param);
  +end;
  +
  +function TDataParamsAsAggregate.Add(const ParamName: string; DataType: TFieldType;
  +  Value: Variant): IDataParams;
  +begin
  +  Result := FOrigin.Add(ParamName, DataType, Value);
  +end;
  +
  +function TDataParamsAsAggregate.Param(Index: Integer): IDataParam;
  +begin
  +  Result := FOrigin.Param(Index);
  +end;
  +
  +function TDataParamsAsAggregate.Param(const ParamName: string): IDataParam;
  +begin
  +  Result := FOrigin.Param(ParamName);
  +end;
  +
  +function TDataParamsAsAggregate.Count: Integer;
  +begin
  +  Result := FOrigin.Count;
  +end;
  +
  +function TDataParamsAsAggregate.AsString(const SeparatorChar: string): string;
  +begin
  +  Result := FOrigin.AsString(SeparatorChar);
  +end;
  +
  +function TDataParamsAsAggregate.AsString: string;
  +begin
  +  Result := FOrigin.AsString;
  +end;
  +
  +{ TDataResult }
  +
  +constructor TDataResult.Create(OK: Boolean; Infos: IDataInformations; Data: IDataParams);
  +begin
  +  inherited Create;
  +  FOK := OK;
  +  FData := Data;
  +  FInfos := Infos;
  +end;
  +
  +class function TDataResult.New(OK: Boolean; Infos: IDataInformations;
  +  Data: IDataParams): IDataResult;
  +begin
  +  Result := Create(OK, Infos, Data);
  +end;
  +
  +class function TDataResult.New(OK: Boolean; Infos: IDataInformations): IDataResult;
  +begin
  +  Result := Create(OK, Infos, TDataParams.New);
  +end;
  +
  +class function TDataResult.New(OK: Boolean; Info: IDataInformation): IDataResult;
  +begin
  +  Result := New(OK, TDataInformations.New.Add(Info));
  +end;
  +
  +class function TDataResult.New(OK: Boolean): IDataResult;
  +begin
  +  Result := New(OK, TDataInformation.New('RESULT'));
  +end;
  +
  +function TDataResult.OK: Boolean;
  +begin
  +  Result := FOK;
  +end;
  +
  +function TDataResult.Data: IDataParams;
  +begin
  +  Result := FData;
  +end;
  +
  +function TDataResult.Informations: IDataInformations;
  +begin
  +  Result := FInfos;
  +end;
  +
  +{ TDataConstraints }
  +
  +constructor TDataConstraints.Create;
  +begin
  +  inherited Create;
  +  FList := TInterfaceList.Create
  +end;
  +
  +class function TDataConstraints.New: IDataConstraints;
  +begin
  +  Result := Create;
  +end;
  +
  +function TDataConstraints.Add(C: IDataConstraint): IDataConstraints;
  +begin
  +  Result := Self;
  +  FList.Add(C);
  +end;
  +
  +function TDataConstraints.Get(Index: Integer): IDataConstraint;
  +begin
  +  Result := FList.Items[Index] as IDataConstraint;
  +end;
  +
  +function TDataConstraints.Count: Integer;
  +begin
  +  Result := FList.Count;
  +end;
  +
  +function TDataConstraints.Checked: IDataResult;
  +var
  +  I: Integer;
  +  OK: Boolean;
  +  R: IDataResult;
  +  Infos: IDataInformations;
  +begin
  +  OK := True;
  +  Infos := TDataInformations.New;
  +  for I := 0 to Count-1 do
  +  begin
  +    R := Get(I).Checked;
  +    if not R.OK then
  +      OK := False;
  +    Infos.Add(R.Informations);
  +  end;
  +  Result := TDataResult.New(OK, Infos);
  +end;
  +
   end.
   
  
positive.code:   Result := FOrigin.Size;
  end;
  
  { TDataResult }
  
  constructor TDataResult.Create(Value: Variant; const Message: string);
  begin
    inherited Create;
    FValue := Value;
    FMessage := Message;
  end;
  
  class function TDataResult.New(Value: Variant; const Message: string
    ): IDataResult;
  begin
    Result := Create(Value, Message);
  end;
  
  function TDataResult.Value: Variant;
  begin
    Result := FValue;
  end;
  
  function TDataResult.AsBoolean: Boolean;
  begin
    if VarIsNull(FValue) then
      Result := False
    else
      Result := FValue;
  end;
  
  function TDataResult.Message: string;
  begin
    Result := FMessage;
  end;
  
  { TDataParams }
  
negative.code: 
  destructor TDataParams.Destroy;
  begin
    FList.Free;
    inherited;
  end;
  
  function TDataParams.Add(Param: IDataParam): IDataParams;
  begin
    Result := Self;
    FList.Add(Param);
  end;
  
  function TDataParams.Add(const ParamName: string; DataType: TFieldType;
    Value: Variant): IDataParams;
  begin
    Result := Self;
    FList.Add(TDataParam.New(ParamName, DataType, Value));
  end;
  
  function TDataParams.Param(Index: Integer): IDataParam;
  begin
    Result := FList.Items[Index] as IDataParam;
  end;
  
  function TDataParams.Param(const ParamName: string): IDataParam;
  var
    I: Integer;
    P: IDataParam;
  begin
    P := nil;
    for I := 0 to FList.Count -1 do
    begin
      P := Param(I);
      if CompareText(P.Name, ParamName) = 0 then
      begin
        Result := P;
        Exit;
      end;
    end;
    if not Assigned(P) then
      raise EDataParams.CreateFmt('Param "%s" not found.', [ParamName]);
  end;
  
  function TDataParams.Count: Integer;
  begin
    Result := FList.Count;
  end;
  
  function TDataParams.AsString(const SeparatorChar: string): string;
  