Tiny Types - Histórico de revisão

Adm em 13h13min de 7 de janeiro de 2015

2015-01-07T13:13:03Z

Adm em 13h12min de 7 de janeiro de 2015

2015-01-07T13:12:30Z

Adm em 13h11min de 7 de janeiro de 2015

2015-01-07T13:11:10Z

Adm em 13h10min de 7 de janeiro de 2015

2015-01-07T13:10:24Z

Mostrar alterações

Adm em 12h53min de 7 de janeiro de 2015

2015-01-07T12:53:50Z

Adm em 12h38min de 7 de janeiro de 2015

2015-01-07T12:38:01Z

Adm em 12h36min de 7 de janeiro de 2015

2015-01-07T12:36:10Z

Mostrar alterações

Adm em 12h33min de 7 de janeiro de 2015

2015-01-07T12:33:21Z

Adm em 12h32min de 7 de janeiro de 2015

2015-01-07T12:32:15Z

Adm: Criou página com ''''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 prop...'

2015-01-07T12:31:30Z

Criou página com ''''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 prop...'

Página nova

'''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.

@@ Linha 79: / Linha 79: @@
      TCNPJ = record
-      private
+    private
        FUnformatted: string;
        function GetFormatted: string;

@@ Linha 99: / Linha 99: @@
        function GetFormatted: string;
      public
        class operator Implicit(const CPF: string): TCPF;
@@ Linha 113: / Linha 114: @@
    uses
-      MaskUtils, StrUtils, SysUtils;
+    MaskUtils, StrUtils, SysUtils;
    function Clear(const Doc: string): string;
@@ Linha 136: / Linha 137: @@
    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;
@@ Linha 226: / Linha 221: @@
    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;

@@ Linha 91: / Linha 91: @@
        property Unformatted: string read FUnformatted;
        property Formatted: string read GetFormatted;
-−
      end;
-−
      TCPF = record
      private

@@ Linha 2: / Linha 2: @@
 Vamos usar como exemplo códigos fictícios, porém muito comum de encontrar em diversos projetos:
    TPessoa = class
@@ Linha 12: / Linha 11: @@
 Com essa classe em mãos conseguimos usar o código normalmente.
    var
@@ Linha 25: / Linha 23: @@
 Uma alternativa, que é a mais usada, seria uma classe utilitária onde teremos diversas funções para resolver esses pequenos problemas.
    TClasseUtils = class
@@ Linha 35: / Linha 32: @@
 Dessa forma podemos validar o CNPJ em qualquer lugar do sistema, porém criamos dependência dessa TClasseUtils.
    if TClasseUtils.ValidaCNPJ(Pessoa.CNPJ) then
@@ Linha 43: / Linha 39: @@
 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
@@ Linha 50: / Linha 45: @@
      property CNPJ: TCNPJ read FCNPJ write FCNPJ;
    end;
-−
    var
      Pessoa: TPessoaNova;

@@ Linha 227: / Linha 227: @@
    end;
-{ TCPF }
+  { TCPF }
-class operator TCPF.Implicit(const CPF: string): TCPF;
+  class operator TCPF.Implicit(const CPF: string): TCPF;
-begin
+  begin
-  Result.FUnformatted := Clear(CPF);
+    Result.FUnformatted := Clear(CPF);
-end;
+  end;
-function TCPF.GetFormatted: string;
+  function TCPF.GetFormatted: string;
-begin
+  begin
-  Result := MaskUtils.FormatMaskText('000.000.000-00;0; ', FUnformatted);
+    Result := MaskUtils.FormatMaskText('000.000.000-00;0; ', FUnformatted);
-end;
+  end;
-class operator TCPF.Implicit(const CPF: TCPF): string;
+  class operator TCPF.Implicit(const CPF: TCPF): string;
-begin
+  begin
-  Result := CPF.FUnformatted;
+    Result := CPF.FUnformatted;
-end;
+  end;
-function TCPF.IsValid: Boolean;
+  function TCPF.IsValid: Boolean;
-const
+  const
-  BLACKLIST: array[0..9] of string = ('00000000000',
+    BLACKLIST: array[0..9] of string = ('00000000000',
-                                      '11111111111',
+                                        '11111111111',
-                                      '22222222222',
+                                        '22222222222',
-                                      '33333333333',
+                                        '33333333333',
-                                      '44444444444',
+                                        '44444444444',
-                                      '55555555555',
+                                        '55555555555',
-                                      '66666666666',
+                                        '66666666666',
-                                      '77777777777',
+                                        '77777777777',
-                                      '88888888888',
+                                        '88888888888',
-                                      '99999999999');
+                                        '99999999999');
-var
+  var
-  IsInvalidSize: Boolean;
+    IsInvalidSize: Boolean;
-  IsBlacklisted: Boolean;
+    IsBlacklisted: Boolean;
-  I: Integer;
+    I: Integer;
-  D1, D2: Integer;
+    D1, D2: Integer;
-begin
+  begin
-  IsInvalidSize := Length(FUnformatted) <> 11;
+    IsInvalidSize := Length(FUnformatted) <> 11;
-  IsBlacklisted := AnsiIndexStr(FUnformatted, BLACKLIST) >= 0;
+    IsBlacklisted := AnsiIndexStr(FUnformatted, BLACKLIST) >= 0;
-  if IsInvalidSize or IsBlacklisted then
+    if IsInvalidSize or IsBlacklisted then
-  begin
+    begin
-    Result := False;
+      Result := False;
-  end
+    end
-  else
+    else
-  begin
+    begin
-    D1 := 0;
+      D1 := 0;
-    for I := 1 to 9 do
+      for I := 1 to 9 do
-      D1 := D1 + (StrToInt(FUnformatted[I]) * (11 - I));
+        D1 := D1 + (StrToInt(FUnformatted[I]) * (11 - I));
-    D1 := 11 - (D1 mod 11);
+      D1 := 11 - (D1 mod 11);
-    if D1 >= 10 then
+      if D1 >= 10 then
-    D1 := 0;
+      D1 := 0;
-    D2 := D1 * 2;
+      D2 := D1 * 2;
-    for I := 1 to 9 do
+      for I := 1 to 9 do
-      D2 := D2 + (StrToInt(FUnformatted[I]) * (12 - I));
+        D2 := D2 + (StrToInt(FUnformatted[I]) * (12 - I));
-    D2 := 11 - (D2 mod 11);
+      D2 := 11 - (D2 mod 11);
-    if D2 >= 10 then
+      if D2 >= 10 then
-      D2 :=0;
+        D2 :=0;
-    Result := (IntToStr(D1) + IntToStr(D2)) = Copy(FUnformatted, 10, 2);
+      Result := (IntToStr(D1) + IntToStr(D2)) = Copy(FUnformatted, 10, 2);
-  end;
+    end;
-end;
+  end;
-end.
+  end.

@@ Linha 14: / Linha 14: @@
-var
+  var
-  Pessoa: TPessoa;
+    Pessoa: TPessoa;
-begin
+  begin
-  // ...
+    // ...
-  Pessoa.Nome := 'Tecsystem';
+    Pessoa.Nome := 'Tecsystem';
-  Pessoa.CNPJ := '99.999.999/0001-91';
+    Pessoa.CNPJ := '99.999.999/0001-91';
-end;
+  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.
@@ Linha 27: / Linha 27: @@
-TClasseUtils = class
+  TClasseUtils = class
-public
+  public
-  class function ValidaCNPJ(const CNPJ: string): string;
+    class function ValidaCNPJ(const CNPJ: string): string;
-  class function GetCNPJFormatado(const CNPJ: string): string;
+    class function GetCNPJFormatado(const CNPJ: string): string;
-end;
+  end;
@@ Linha 37: / Linha 37: @@
-if TClasseUtils.ValidaCNPJ(Pessoa.CNPJ) then
+  if TClasseUtils.ValidaCNPJ(Pessoa.CNPJ) then
-  // ...
+    // ...
 Usando o Tiny Types
@@ Linha 45: / Linha 45: @@
-TPessoaNova = class
+  TPessoaNova = class
-public
+  public
-  property Nome: string read FNome write FNome;
+    property Nome: string read FNome write FNome;
-  property CNPJ: TCNPJ read FCNPJ write FCNPJ;
+    property CNPJ: TCNPJ read FCNPJ write FCNPJ;
-end;
+  end;
-var
+  var
-  Pessoa: TPessoaNova;
+    Pessoa: TPessoaNova;
-begin
+  begin
-  Pessoa.Nome := 'Tecsystem';
+    Pessoa.Nome := 'Tecsystem';
-  Pessoa.CNPJ := '99.999.999/0001-91';
+    Pessoa.CNPJ := '99.999.999/0001-91';
-  if Pessoa.CNPJ.EhValido() then
+    if Pessoa.CNPJ.EhValido() then
-    // ...
+      // ...
-end;
+  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
+  TCNPJ = record
-private
+  private
-  FValor: string;
+    FValor: string;
-public
+  public
-  class operator Implicit(const CNPJ: string): TCNPJ;
+    class operator Implicit(const CNPJ: string): TCNPJ;
-  class operator Implicit(const CNPJ: TCNPJ): string;
+    class operator Implicit(const CNPJ: TCNPJ): string;
-  function EhValido(): Boolean;
+    function EhValido(): Boolean;
-  // ...
+    // ...
-end;
+  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.