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: constructor TDataParams.Create;
  begin
    inherited Create;
    FParams := TParams.Create;
  end;
  
  class function TDataParams.New: IDataParams;
  
negative.code:   Result := FOrigin.Size;
  end;
  
  { TDataInformation }
  
  constructor TDataInformation.Create(const Id, Text, Metadata: string);
  begin
    inherited Create;
    FId := Id;
    FText := Text;
    FMetadata := Metadata;
  end;
  
  class function TDataInformation.New(const Id, Text, Metadata: string): IDataInformation;
  begin
    Result := Create(Id, Text, Metadata);
  end;
  
  class function TDataInformation.New(const Id, Text: string): IDataInformation;
  begin
    Result := Create(Id, Text, Text);
  end;
  
  class function TDataInformation.New(const Id: string): IDataInformation;
  begin
    Result := New(Id, '');
  end;
  
  function TDataInformation.Id: string;
  begin
    Result := FId;
  end;
  
  function TDataInformation.Text: string;
  begin
    Result := FText;
  end;
  
  function TDataInformation.Metadata: string;
  begin
    Result := FMetadata;
  end;
  
  { TDataInformations }
  
  constructor TDataInformations.Create;
  begin
    inherited Create;
    FList := TInterfaceList.Create;
  end;
  
  class function TDataInformations.New: IDataInformations;
  begin
    Result := Create;
  end;
  
  function TDataInformations.Add(Info: IDataInformation): IDataInformations;
  begin
    Result := Self;
    FList.Add(Info);
  end;
  
  function TDataInformations.Add(Infos: IDataInformations): IDataInformations;
  var
    I: Integer;
  begin
    Result := Self;
    for I := 0 to Infos.Count -1 do
      Add(Infos.Get(I));
  end;
  
  function TDataInformations.Get(Index: Integer): IDataInformation;
  begin
    Result := FList.Items[Index] as IDataInformation;
  end;
  
  function TDataInformations.Count: Integer;
  begin
    Result := FList.Count;
  end;
  
  function TDataInformations.Text: string;
  var
    I: Integer;
    Info: IDataInformation;
  begin
    Result := '';
    for I := 0 to Count -1 do
    begin
      Info := Get(I);
      Result := Result + Info.Id + ': ' + Info.Text + #13;
    end;
  end;
  
  { TDataParam }
  
  constructor TDataParam.Create(const Name: string; DataType: TFieldType; Value: Variant);
  begin
    inherited Create;
    FParam := TParam.Create(nil);
    FParam.Name := Name;
    FParam.DataType := DataType;
    FParam.Value := Value;
  end;
  
  class function TDataParam.New(const Name: string; DataType: TFieldType; Value: Variant): IDataParam;
  begin
    Result := Create(Name, DataType, Value);
  end;
  
  destructor TDataParam.Destroy;
  begin
    FParam.Free;
    inherited;
  end;
  
  function TDataParam.Name: string;
  begin
    Result := FParam.Name;
  end;
  
  function TDataParam.Value: Variant;
  begin
    Result := FParam.Value;
  end;
  
  function TDataParam.IsNull: Boolean;
  begin
    Result := FParam.IsNull;
  end;
  
  function TDataParam.AsParam: TParam;
  begin
    Result := FParam;
  end;
  
  function TDataParam.AsBCD: Currency;
  begin
    Result := FParam.AsBCD;
  end;
  
  function TDataParam.AsBlob: TBlobData;
  begin
    Result := FParam.AsBlob;
  end;
  
  function TDataParam.AsBoolean: Boolean;
  begin
    Result := FParam.AsBoolean;
  end;
  
  function TDataParam.AsCurrency: Currency;
  begin
    Result := FParam.AsCurrency;
  end;
  
  function TDataParam.AsDate: TDateTime;
  begin
    Result := FParam.AsDate;
  end;
  
  function TDataParam.AsDateTime: TDateTime;
  begin
    Result := FParam.AsDateTime;
  end;
  
  function TDataParam.AsFloat: Double;
  begin
    Result := FParam.AsFloat;
  end;
  
  function TDataParam.AsInteger: LongInt;
  begin
    Result := FParam.AsInteger;
  end;
  
  function TDataParam.AsSmallInt: LongInt;
  begin
    Result := FParam.AsSmallInt;
  end;
  
  function TDataParam.AsMemo: string;
  begin
    Result := FParam.AsMemo;
  end;
  
  function TDataParam.AsString: string;
  begin
    Result := FParam.AsString;
  end;
  
  function TDataParam.AsTime: TDateTime;
  begin
    Result := FParam.AsTime;
  end;
  
  function TDataParam.AsWord: LongInt;
  begin
    Result := FParam.AsWord;
  end;
  
  { TDataParams }
  