procedure TCallContextWrapper.Bind<T>(name: String; value: T);
var
  v: TValue;
begin
  case PTypeInfo(TypeInfo(T))^.Kind of
    tkInterface:
      begin
        TValue.Make(@value, TypeInfo(T), v);
        BindIntf(Name, v.AsInterface, v);
      end;
    tkClass:
      begin
        v := TValue.From<T>(value);
        BindObject(Name, v.AsObject, v);
      end;
    tkInteger, tkChar, tkFloat, tkString, tkSet, tkWChar, tkLString, tkWString,
      tkVariant, tkInt64, tkUString, tkPointer:
      begin
        v := TValue.From<T>(value);
        Bind(Name, v.AsVariant)
      end
  else
    begin
      TValue.Make(@value, TypeInfo(T), v);
      BindOtherType(Name, v);
    end;
  end;
end;

function TCallContextWrapper.Get<T>(name: String): T;
begin
  case PTypeInfo(TypeInfo(T))^.Kind of
    tkInterface, tkClass:
      begin
        if not FCallContext.InputObjects.FindParam(name) then
          raise Exception.Create
            (string.Format
            ('Parameter [{0}] with type {1} not found in CallContext.',
            [name, PTypeInfo(TypeInfo(T))^.name]));

        Result := FCallContext.InputObjects[name].AsItem.Get<T>;
      end
  else
    begin
      if not FCallContext.InputParams.FindParam(name) then
        raise Exception.Create
          (string.Format
          ('Parameter [{0}] with type {1} not found in CallContext.',
          [name, PTypeInfo(TypeInfo(T))^.name]));
      Result := FCallContext.InputParams[name].AsItem.Get<T>;
    end;
  end;

procedure TCallContextWrapper.BindIntf(name: String; value: IInterface;
  v: TValue);
var
  prm: IModuleCallParam;
begin
  prm := FCallContext.InputObjects[name];
  prm.AsRTTIValue := v;
  prm.AsInterface := value;
end;

procedure TCallContextWrapper.BindObject(name: String; value: TObject;
  v: TValue);
var
  prm: IModuleCallParam;
begin
  prm := FCallContext.InputObjects[name];
  prm.AsRTTIValue := v;
  prm.AsObject := value;
end;

procedure TCallContextWrapper.BindOtherType(name: String; v: TValue);
begin
  FCallContext.InputParams[name].AsRTTIValue := v;
end;

procedure TCallContextWrapper.BindOutputIntf(name: String; value: IInterface;
  v: TValue);
var
  prm: IModuleCallParam;
begin
  prm := FCallContext.OutputObjects[name];
  prm.AsRTTIValue := v;
  prm.AsInterface := value;
end;

procedure TCallContextWrapper.BindOutputObject(name: String; value: TObject;
  v: TValue);
var
  prm: IModuleCallParam;
begin
  prm := FCallContext.OutputObjects[name];
  prm.AsRTTIValue := v;
  prm.AsObject := value;
end;

procedure TCallContextWrapper.BindOutputOtherType(name: String; v: TValue);
begin
  FCallContext.OutputParams[name].AsRTTIValue := v;
end;

l_Object := TObject(l_Interface);

l_Object := l_Interface as TObject; 

unit _ClassSmartPointer;

interface

uses
  SysUtils;

type
  TLifetimeWatcher = class(TInterfacedObject)
  private
    FWhenDone: TProc;
  public
    constructor Create(const AWhenDone: TProc);
    destructor Destroy; override;
  end;

  TSmartPointer<T: class> = record
  strict private
    FValue: T;
    FLifetime: IInterface;
  public
    constructor Create(const AValue: T); overload;
    class operator Implicit(const AValue: T): TSmartPointer<T>;
    class operator Implicit(const AValue: TSmartPointer<T>): T;

    property Value: T read FValue;
  end;

{ TLifetimeWatcher }
implementation

constructor TLifetimeWatcher.Create(const AWhenDone: TProc);
begin
  FWhenDone := AWhenDone;
end;

destructor TLifetimeWatcher.Destroy;
begin
  if Assigned(FWhenDone) then
    FWhenDone;
  inherited;
end;

{ TSmartPointer<T> }

constructor TSmartPointer<T>.Create(const AValue: T);
begin
  FValue := AValue;
  FLifetime := TLifetimeWatcher.Create(procedure
  begin
    if Assigned(AValue) then
      AValue.Free;
  end);
end;

class operator TSmartPointer<T>.Implicit(const AValue: T): TSmartPointer<T>;
begin
  Result := TSmartPointer<T>.Create(AValue);
end;

class operator TSmartPointer<T>.Implicit(const AValue: TSmartPointer<T>): T;
begin
  Result := AValue.Value;
end;

End.

procedure TBlotterModel_BrokerReport.InternalRefresh;
begin
  _entities.AddRangeItems(TDbCtx.New<TBrokerReportListItem>(
   procedure(var p: TParams)
    begin
      p.CreateParam(ftFloat, 'par_file_group_id', ptInput).Value := _currentGroupId;
    end).Value.Query());
end;

TBlotterModel_F405.GetLocalSet(const data: ISetListItem<TF405ListItem>)
var dbctx: TSmartPointer<TDbContext<TF405ListItem>>;
begin
   dbctx := TDbContext<TF405ListItem>.Create;
   data.AddRangeItems(dbCtx.Value.Query()); 
end;

TBlotterModel_F405.GetLocalSet(const data: ISetListItem<TF405ListItem>)
var dbctx: TDbContext<TF405ListItem>;
begin
   dbctx := TDbContext<TF405ListItem>.Create;
   try
      data.AddRangeItems(dbCtx.Query());
   finally
      data.Free;
   end; 
end;

unit SummaryForBookListItem;

interface

uses  _ClassListItem, _EngineNullable, cxStyles, _EngineImages, _style;

Type
    TSummaryForBookListItem = Class (TListItem)
    strict private
      class Var
        styleRedBold: TStyle;
    private
      FIsRedRow: BooleanNull;
      FSTATE_TXT: StringNull;
      FINV_QNTY: IntNull;
      FRBS_QNTY: IntNull;
      FQNTY: IntNull;
    public
      function GetStyleForRow(): TCxStyle;
      property IsRedRow: BooleanNull read FIsRedRow write FIsRedRow;
      property STATE_TXT: StringNull read FSTATE_TXT;
      property INV_QNTY: IntNull read FINV_QNTY;
      property RBS_QNTY: IntNull read FRBS_QNTY;
      property QNTY: IntNull read FQNTY;
    end;

implementation

uses UITypes;

{ TSummaryForBookListItem }

function TSummaryForBookListItem.GetStyleForRow: TCxStyle;
begin
  Result := nil;
  if (FIsRedRow.HasValue and  FIsRedRow.Value) then
      Result := styleRedBold.Create(TColors.Red).FontStyle([TFontStyle.fsBold]);
end;

end.

unit _style;

interface

uses Graphics, cxStyles;

Type
  TStyle = record
  strict private
    FStyle: TCxStyle;
    FLifetime: IInterface;
  public
    Constructor Create(Color: TColor; TextColor: TColor = clBlack);
    Function FontStyle(Style: TFontStyles): TStyle;
    Function FontSize(Size: Cardinal): TStyle;
    Function FontColor(color: TColor): TStyle;
    Function FontName(Name: TFontName): TStyle;

    class operator Implicit(const Value: TStyle): Pointer;
    class operator Implicit(const Value: TStyle): TCxStyle;
  end;


implementation

uses _ClassSmartPointer;

constructor TStyle.Create(Color, TextColor: TColor);
var style: TcxStyle;
begin
  if Assigned(FStyle) then
    Exit;
  FStyle := TCxStyle.Create(nil);
  FStyle.Color := Color;
  FStyle.TextColor := TextColor;
  Style:=FStyle;
  FLifetime := TLifetimeWatcher.Create(procedure
  begin
    if Assigned(Style) then
      Style.Free;
  end);
end;

function TStyle.FontColor(color: TColor): TStyle;
begin
  if Assigned(FStyle) then
    FStyle.Font.Color := Color;
  Result := Self;
end;

function TStyle.FontName(Name: TFontName): TStyle;
begin
  if Assigned(FStyle) then
    FStyle.Font.Name := Name;
  Result := Self;
end;

function TStyle.FontSize(Size: Cardinal): TStyle;
begin
  if Assigned(FStyle) then
    FStyle.Font.Size := Size;
  Result := Self;
end;

function TStyle.FontStyle(Style: TFontStyles): TStyle;
begin
  if Assigned(FStyle) then
    FStyle.Font.Style := Style;
  Result := Self;
end;

class operator TStyle.Implicit(const Value: TStyle): TCxStyle;
begin
  Result := Value.FStyle;
end;

class operator TStyle.Implicit(const Value: TStyle): Pointer;
begin
  Result := Value.FStyle;
end;


end.