Exibir código-fonte para Tiny Types

'''Tiny Types''' é um padrão que basicamente propõe encapsular tipos simples dentro classes específicas de domínio. Parece simples, mas o uso de Tiny Types, além de proporcionar o enriquecimento do domain model, favorece a manutenibilidade e legibilidade do código.

Vamos usar como exemplo códigos fictícios, porém muito comum de encontrar em diversos projetos:


  TPessoa = class
  public
    property Nome: string read FNome write FNome;
    property CNPJ: string read FCNPJ write FCNPJ;
    // ...
  end;

Com essa classe em mãos conseguimos usar o código normalmente.


  var
    Pessoa: TPessoa;
  begin
    // ...
    Pessoa.Nome := 'Tecsystem';
    Pessoa.CNPJ := '99.999.999/0001-91';
  end;

O problema aparece quando queremos adicionar mais utilidade ao codigo, como por exemplo validação, formatação, entre várias outras possibilidades. Nesse caso poderiamos incluir essas utilidades na classe TPessoa, o que tornaria difícil do reuso do código.

Uma alternativa, que é a mais usada, seria uma classe utilitária onde teremos diversas funções para resolver esses pequenos problemas.


  TClasseUtils = class
  public
    class function ValidaCNPJ(const CNPJ: string): string;
    class function GetCNPJFormatado(const CNPJ: string): string;
  end;


Dessa forma podemos validar o CNPJ em qualquer lugar do sistema, porém criamos dependência dessa TClasseUtils.


  if TClasseUtils.ValidaCNPJ(Pessoa.CNPJ) then
    // ...

Usando o Tiny Types

Uma outra alternativa, que na minha opinião deixa o código mais elegante e expressivo, é através do uso de Tiny Types. Então, que tal isso:


  TPessoaNova = class
  public
    property Nome: string read FNome write FNome;
    property CNPJ: TCNPJ read FCNPJ write FCNPJ;
  end;
 
  var
    Pessoa: TPessoaNova;
  begin
    Pessoa.Nome := 'Tecsystem';
    Pessoa.CNPJ := '99.999.999/0001-91';
    if Pessoa.CNPJ.EhValido() then
      // ...
  end;

Isso pode ser possível através do uso de Tiny Types. O padrão indica o uso de uma classe para resolver o problema, mas o Delphi oferece um tipo de dados mais interessante nesse caso que é o record type. A interface do record seria basicamente isso:


  TCNPJ = record
  private
    FValor: string;
  public
    class operator Implicit(const CNPJ: string): TCNPJ;
    class operator Implicit(const CNPJ: TCNPJ): string;
    function EhValido(): Boolean;
    // ...
  end;

A implementação é normal, com exceção do operator overloading class operator implicit que resolve um erro em tempo de compilação ao tentar atribuir um valor a uma property do tipo record.

Segue abaixo a unit de exemplo com o código completo das funcionalidades para consulta:

unit DocsBR;

interface

type

  TCNPJ = record
  private
    FUnformatted: string;
    function GetFormatted: string;

  public
    class operator Implicit(const CNPJ: string): TCNPJ;
    class operator Implicit(const CNPJ: TCNPJ): string;

    function IsValid(): Boolean;

    property Unformatted: string read FUnformatted;
    property Formatted: string read GetFormatted;

  end;

  TCPF = record
  private
    FUnformatted: string;
  
    function GetFormatted: string;
  public
    class operator Implicit(const CPF: string): TCPF;
    class operator Implicit(const CPF: TCPF): string;

    function IsValid(): Boolean;

    property Unformatted: string read FUnformatted;
    property Formatted: string read GetFormatted;

  end;

implementation

uses
  MaskUtils, StrUtils, SysUtils;

function Clear(const Doc: string): string;
var
  Letter: Char;
begin

  Result := '';

  for Letter in Doc do
  begin

    if Letter in ['0'..'9'] then
      Result := Result + Letter;

  end;

end;

{ TCNPJ }

class operator TCNPJ.Implicit(const CNPJ: string): TCNPJ;
begin

  Result.FUnformatted := Clear(CNPJ);

end;

function TCNPJ.GetFormatted: string;
begin

  Result := MaskUtils.FormatMaskText('00.000.000/0000-00;0; ', FUnformatted);

end;

class operator TCNPJ.Implicit(const CNPJ: TCNPJ): string;
begin

  Result := CNPJ.FUnformatted;

end;

function TCNPJ.IsValid: Boolean;
const
  BLACKLIST: array[0..9] of string = ('00000000000000',
                                      '11111111111111',
                                      '22222222222222',
                                      '33333333333333',
                                      '44444444444444',
                                      '55555555555555',
                                      '66666666666666',
                                      '77777777777777',
                                      '88888888888888',
                                      '99999999999999');
var
  IsInvalidSize: Boolean;
  IsBlacklisted: Boolean;
  I: Integer;
  D1, D2: Integer;
begin
  
  IsInvalidSize := Length(FUnformatted) <> 14;
  IsBlacklisted := AnsiIndexStr(FUnformatted, BLACKLIST) >= 0;
  if IsInvalidSize or IsBlacklisted then
  begin
    Result := False;
  end
  else 
  begin

    D1 := 0;

    for I := 1 to 12 do
    begin

      if I < 5 then
        D1 := D1 + (StrToInt(FUnformatted[I]) * (6 - I))
      else
        D1 := D1 + (StrToInt(FUnformatted[I]) * (14 - I));

    end;

    D1 := 11 - (D1 mod 11);

    if D1 >= 10 then
      D1 := 0;
    
    D2:= D1 * 2;
    for I := 1 to 12 do
    begin

      if I < 6 then
        D2 := D2 + (StrToInt(FUnformatted[I]) * (7 - I))
      else
        D2 := D2 + (StrToInt(FUnformatted[I]) * (15 - I));

    end;

    D2 := 11 - (D2 mod 11);
    
    if D2 >= 10 then D2 :=0;

    Result := (IntToStr(D1) + IntToStr(D2)) = Copy(FUnformatted, 13, 2);

  end;

end;

{ TCPF }
class operator TCPF.Implicit(const CPF: string): TCPF;
begin

  Result.FUnformatted := Clear(CPF);

end;

function TCPF.GetFormatted: string;
begin

  Result := MaskUtils.FormatMaskText('000.000.000-00;0; ', FUnformatted);

end;

class operator TCPF.Implicit(const CPF: TCPF): string;
begin

  Result := CPF.FUnformatted;

end;

function TCPF.IsValid: Boolean;
const
  BLACKLIST: array[0..9] of string = ('00000000000',
                                      '11111111111',
                                      '22222222222',
                                      '33333333333',
                                      '44444444444',
                                      '55555555555',
                                      '66666666666',
                                      '77777777777',
                                      '88888888888',
                                      '99999999999');
var
  IsInvalidSize: Boolean;
  IsBlacklisted: Boolean;
  I: Integer;
  D1, D2: Integer;
begin
  
  IsInvalidSize := Length(FUnformatted) <> 11;
  IsBlacklisted := AnsiIndexStr(FUnformatted, BLACKLIST) >= 0;
  
  if IsInvalidSize or IsBlacklisted then
  begin
    Result := False;
  end
  else 
  begin

    D1 := 0;

    for I := 1 to 9 do
      D1 := D1 + (StrToInt(FUnformatted[I]) * (11 - I));
    
    D1 := 11 - (D1 mod 11);
    
    if D1 >= 10 then

    D1 := 0;
    
    D2 := D1 * 2;
    
    for I := 1 to 9 do
      D2 := D2 + (StrToInt(FUnformatted[I]) * (12 - I));

    D2 := 11 - (D2 mod 11);
    
    if D2 >= 10 then
      D2 :=0;

    Result := (IntToStr(D1) + IntToStr(D2)) = Copy(FUnformatted, 10, 2);

  end;

end;

end.