Desenvolvimento Código Aberto

Trabalhar com o banco de dados SAP conectado aos componentes do Screen Painter é relativamente bem fácil, pois o engine do Screen Painter faz quase todo o trabalho para você, reconhecendo os componentes para cada tipo de campo do dicionário de dados e  quando é possível lhe questiona se deseja uma conversão de um componente básico para outro mais adequado ao tipo de campo usado, e além disso lhe da botões de chamadas para pesquisas de campos que contem uma chave estrangeira.

Trabalhar com os componentes desconectados do banco de dados é um pouco diferente, pois você precisa controlar e referenciar os componentes criados na janela de design direto de seu código Abap. Diferentemente de outras linguagens de programação onde você referencia o objeto diretamente pelo nome do componente ou pelo seu ID, o Abap não possui uma unidade de código para o design gerado, que normalmente contém o nome dos componentes e suas propriedades e eventos, deste modo não é possível referenciar automaticamente os componentes em um programa Abap.

Para resolver esta situação o Abap exige que o programador crie variáveis com o mesmo nome do componente criado no Screen Painter e possui uma Function Code que dispara o evento PAI chamada SY-UCOMM que contem as funções que você nomeou nas propriedades dos seus componentes. Mas em seus programas ABAP, você deve trabalhar com o campo OK_CODE em vez de usar diretamente o sy–ucomm, você deve sempre inicializar o campo OK_CODE em um programa ABAP pelo seguinte motivo,  é preciso limpar este campo para garantir que o código de função de uma tela não esteja preenchido no evento PBO, com um valor indesejado. Esta limpeza é importante quando o próximo evento PAI for disparado com um código de função vazia (por exemplo, usando ENTER).

Menu Painter/ Screen Painter

1. Na transação SE38 crie um programa chamado Z_ZVISUAL_CODIGO.
2. Na transação SE41 Crie um titulo chamado ZVISUAL_CODIGO, use a imagem abaixo para referencia:
3. Crie um menu com o nome de 100.
4. Coloque o nome do menu de “Visual + Código” e preencha os campos Code com o nome das funções dos botões que serão criados posteriormente: F_ACAO, F_LIMPAR, F_SAIR, use a imagem abaixo para referencia:
5. Salve e Ative o menu status 100.
6. Entre na transação SE51.
7. Na aba Flow Logic crie o PBO Module e salve o programa.
8. De volta na SE51 crie o seguinte design:
9. Na propriedade Name coloque TCAMPO1, e TCAMPO2 para os Input/Output Fields, TRADIO1 e TRADIO2 para os RadioButtons e TCHECK1 e TCHECK2 para os Checkbox.
10. Nomeie os botões de TACAO, TLIMPAR e TSAIR e para seus Function Codes nomeie como F_ACAO, F_LIMPAR e F_SAIR.
11. Salve e ative a tela de layout.
12. Entre na transação SE38 e complete o seu programa com o código abaixo, você deve obter o seguinte resultado:

Exemplo:

Neste exemplo criamos um programa Abap que chama um menu e uma tela visual, onde controlamos seus componentes via codificação.

Abap

*&---------------------------------------------------------------------*
*& Report  ZVISUAL_CODIGO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Visual + código
*&---------------------------------------------------------------------*

REPORT  ZVISUAL_CODIGO.

" Declara variaveis para os componetes
DATA TCAMPO1 TYPE string.
DATA TCAMPO2 TYPE string.

DATA TRADIO1 TYPE C LENGTH 1.
DATA TRADIO2 TYPE C LENGTH 1.

DATA TCHECK1 TYPE C LENGTH 1.
DATA TCHECK2 TYPE C LENGTH 1.

" Declara variaveis para os eventos
DATA OK_CODE LIKE SY-UCOMM.
DATA CLIQUE_OK LIKE SY-UCOMM.

" Chama tela visual
CALL SCREEN 100.

MODULE STATUS_0100 OUTPUT.

  " Chama o menu e o tilulo da tela
  SET PF-STATUS '100'.
  SET TITLEBAR 'ZVISUAL_CODIGO'.

" Limpa o evento contra possiveis sujeira PAI
CLIQUE_OK = OK_CODE.
CLEAR OK_CODE.

" Dedfine eventos dos botões
CASE CLIQUE_OK.
  WHEN 'F_ACAO'.

    " Verifica se o grupo foi clicado
    CASE 'RADIO'.
       IF TRADIO1 EQ 'X'.
         TCAMPO1 = 'Você selecionou o Radio Button numero 1'.
       ENDIF.

       IF TRADIO2 EQ 'X'.
         TCAMPO1 = 'Você selecionou o Radio Button numero 2'.
       ENDIF.
    ENDCASE.

    " Verifica CheckBoxes
    IF TCHECK1 EQ 'X'.
      TCAMPO1 = 'Você selecionou o CheckBox 1'.
    ENDIF.

    IF TCHECK2 EQ 'X'.
      TCAMPO2 = 'Você selecionou o CheckBox 2'.
    ENDIF.

  " Limpa campos
  WHEN 'F_LIMPAR'.
    CLEAR :
        TCAMPO1,
        TCAMPO2,
        TCHECK1,
        TCHECK2,
        TRADIO1,
        TRADIO2.

  " Sai do programa
  WHEN 'F_SAIR'.
    LEAVE PROGRAM.
ENDCASE.

ENDMODULE.                 " STATUS_0100  OUTPUT

ListBox

Em computação, uma caixa de combinação é um elemento de interface gráfica. Um ListBox em Abap é chamado de ComboBox em outras linguagens de programação e permite ao usuário escolher uma das várias opções, pode ter duas formas muito diferentes. A forma padrão é a caixa de combinação não editável, que conta com um botão e uma lista suspensa de valores. A segunda forma, chamada de caixa de combinação editável, possui um campo de texto com um pequeno botão confinando-o. O usuário pode digitar um valor no campo de texto ou clique no botão para exibir uma lista drop-down.

VRM_Set_Value

É um modulo de função Abap que adiciona dois valores a uma variável tipo tabela, esta tabela possui dois campos o primeiro chamado KEY do tipo inteiro e o segundo chamado TEXT do tipo string, esta função vincula-se a um componente através de seu parâmetro ID e adiciona os valores através do parâmetro Values .

VRM_Get_Value

É a mesma função acima, apenas ao invés de adicionar, retorna os valores  atrelados a um ID de um componente.

Vrm_VAlue

É um tipo associado a estrutura de chave e valores.

Screen Painter

Para criar uma tela visual para o programa relacionado ao código abaixo siga os seguintes passos:

1. Crie um programa chamado ZCOMBO.
2. Na transação SE51, relacione o programa e insira o numero dela igual a 100.
3. Na aba Flow Logic , tire o comentário da linha “MODULE STATUS_0100.” e de um duplo clique na variável: “STATUS_0100“.
4. Crie o modulo PBO  selecionando a opção MAIN PROGRAM.
5. Salve o programa e volte para a transação SE51.
6. Clique no botão Layout e desenhe uma tela como na imagem acima.
7. No componente ListBox coloque seu nome de COMBO, seu Fct_Code de F_CODE e sua propriedade DropDown de LISTBOX.
8. No componente Pushbutton coloque seu nome de SAIR e seu Fct_Code de F_SAIR.
9. Salve e Ative as telas.
10. Na transação SE38 chame o programa ZCOMBO e insira o código abaixo, você deve obter um programa como na figura a seguir.

Exemplo:

No programa a seguir criamos um ListBox e o populamos com nomes de musicas da banda Rolling Stones, e usamos código Abap para  capturar o evento SelectedChange através de atributos do R/3.

Abap

*&---------------------------------------------------------------------*
*& Report  ZCOMBO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& ComboBox
*&---------------------------------------------------------------------*

REPORT  ZCOMBO.

* Cria um Pool tipo VRM
TYPE-POOLS vrm.

* Declara Variaveis
DATA: LISTBOX TYPE vrm_value OCCURS 0,
COMBO TYPE SY-UCOMM,
retorno TYPE VRM_VALUES,
texto TYPE string,
LCOMBO TYPE vrm_value,
TNOME TYPE vrm_value.

* Carrega Itens temporariamente
LOAD-OF-PROGRAM.

  LCOMBO-KEY = '1'.
  LCOMBO-TEXT = 'Satisfaction'.
  APPEND LCOMBO TO LISTBOX.

  LCOMBO-KEY = '2'.
  LCOMBO-TEXT = 'Paint it Black'.
  APPEND LCOMBO TO LISTBOX.

  LCOMBO-KEY = '3'.
  LCOMBO-TEXT = 'Wild Horses'.
  APPEND LCOMBO TO LISTBOX.

  LCOMBO-KEY = '4'.
  LCOMBO-TEXT = 'Brown Sugar'.
  APPEND LCOMBO TO LISTBOX.

  LCOMBO-KEY = '5'.
  LCOMBO-TEXT = 'Sympathy for the Devil'.
  APPEND LCOMBO TO LISTBOX.

  LCOMBO-KEY = '6'.
  LCOMBO-TEXT = 'Start Me Up'.
  APPEND LCOMBO TO LISTBOX.

START-OF-SELECTION.

* Chama a tela
CALL SCREEN 100.

* Inicio do Modulo 100
MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

* Popula o componente ListBox

  CALL FUNCTION 'VRM_SET_VALUES'
    EXPORTING
      id     = 'COMBO'
      values = LISTBOX[].

* Verifica ações dos componentes
  CASE SY-UCOMM.
    " Deixa o programa
    WHEN 'F_SAIR'.
      LEAVE PROGRAM.

    " Captura Item Selecionado
    WHEN 'F_COMBO'.

      " Retorna os valores dos componentes
      CALL FUNCTION 'VRM_GET_VALUES'
        EXPORTING
          ID     = 'COMBO'
        IMPORTING
          VALUES = RETORNO.

      " Lê variavel dentro do retorno tipo tabela pelo ID.
      READ TABLE RETORNO WITH KEY KEY = COMBO INTO TEXTO.

      " Adiciona item selecionado ao componente textbox
      TNOME = TEXTO.

  ENDCASE.

ENDMODULE.                 " STATUS_0100  OUTPUT

Menu Painter

É uma ferramenta com a qual você cria interfaces de usuário para seus programas ABAP. Os programas ABAP contem uma grande variedade de funções, que se enquadram em diferentes categorias dentro da interface do usuário. É importante que os usuários sejam capazes de diferenciar entre essas categorias para escolher a função certa facilmente. No sistema R/3, você organiza as funções usando o Painter Menu.

Uma instância da interface do usuário, que consiste em uma barra de menu, uma barra de ferramentas padrão, uma barra de ferramentas do aplicativo, e uma configuração de tecla de função, é chamada de GUI Status. O  GUI Status e GUI Title definem como a interface do usuário irá parecer e se comportar em um programa ABAP.

O objeto principal de uma interface de usuário é o GUI Status. Isso pode ser atribuído a qualquer tela (tela, tela de seleção, ou lista). Tecnicamente, trata-se de uma referência a uma barra de menu, uma barra de ferramentas padrão, e uma configuração de teclas de função.

GUI Status / GUI Title

Para  criar um Status e Title do GUI, siga os passos abaixo:

1. Entre na transação SE41
2. Entre com o nome do programa ZDESIGNFIRST e clique em Create.
3. Digite no campo STATUS, ZMENU.
4. No campo Short Text digite, Meu primeiro menu e clique OK.
5. Na tela Maintain Status, em Menu Bar, clique no primeiro icone com o sinal de mais.
6. Após expandir, em Display Standard, preencha o primeiro campo com a palavra: Reservas.
7. De um duplo clique no seu campo Reservas.
8. Apos expandir, em Code digite: F_Mostrar e em Text digite Mostrar.
9. Faça o mesmo procedimento acima adicionando os itens Limpar e Sair.
10. Salve e ative o Menu.
11. Digite /nse41 para voltar a tela inicial do  Menu Painter.
12. Selecione o programa ZDESIGNFIRST, o Status ZMENU, clique no botão de radio Title List e clique no botão Create.
13. Em Title Code digite o mesmo nome do programa e em Title digite: “Flight Model – Reservas de Voo.” e clique OK.
14. Para testar ative e pressione F8, coloque o status = ZMENU, Screen = 100, Title = ZDESIGNFIRST e clique em OK.
15. Entre na transação SE38 e modifique o programa ZDESIGNFIRST como mostra o código abaixo.

Exemplo:

Neste exemplo criamos um Menu Painter para um objeto de GUI Status e um Objeto GUI Title e o anexamos ao programa ZDESIGNFIRST que fizemos anteriormente no Screen Painter com o editor gráfico.

Abap

*&---------------------------------------------------------------------*
*& Report  ZDESIGNFIRST
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Screen Painter
*&---------------------------------------------------------------------*

REPORT  ZDESIGNFIRST.

TABLES SPFLI.

DATA  OK_CODE LIKE SY-UCOMM.

CALL SCREEN 100.

MODULE STATUS_0100 OUTPUT.

* Adiciona o Menu e Titulo criados no Menu Painter
SET PF-STATUS 'ZMENU'.
SET TITLEBAR 'ZDESIGNFIRST'.

  CASE SY-UCOMM.
    WHEN 'F_SAIR'.
      LEAVE PROGRAM.

    WHEN 'F_MOSTRAR'.
      SELECT SINGLE *  FROM spfli INTO
             CORRESPONDING FIELDS OF spfli
      WHERE
             carrid = spfli-CARRID AND
             CONNID = spfli-CONNID.

    WHEN 'F_LIMPAR'.
      CLEAR SPFLI.

    WHEN 'F_GRAVAR'.
      INSERT INTO SPFLI VALUES SPFLI.
      MESSAGE 'Registro gravado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

    WHEN 'F_EXCLUIR'.
      DELETE FROM SPFLI CLIENT SPECIFIED
      WHERE
              mandt =  spfli-MANDT  AND
              carrid = spfli-CARRID AND
              CONNID = spfli-CONNID.
      MESSAGE 'Registro deletado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

  ENDCASE.
ENDMODULE.

Screen Painter Alphanumeric

O editor alfanumérico gráfico proporciona um ambiente amigável para projetar telas em todas as plataformas. Você pode iniciar o editor alfanumérico a partir da tela inicial do Screen Painter ou a partir do Navegador do repositório.

O editor alfanumérico contém as mesmas funções que o  editor gráfico. A diferença entre os dois está na maneira de criar elementos gráficos e como eles são exibidos na tela.

O sistema utiliza caracteres alfanuméricos para exibir elementos gráficos. O sistema distingue todos os elementos gráficos com cor.  Para garantir que você não possa substituir um, todos eles são protegidos contra gravação. Para alterar um elemento, você deve selecioná-lo e, em seguida, escolher uma função apropriada. Ao contrário do editor gráfico, você não pode escolher os elementos da paleta  de elemento. Em vez disso, você usa os menus.

 Aphanumeric Editor

Para criar uma tela no editor alfanumérico siga os seguintes passos:

1. Crie um programa chamado ZDF_Alpha.
2. Entre na transação SE51.
3. Crie uma Screen Painter para seu programa com o Screen Number 100.
4. Na aba Flow Logic, tire o comentario da linha: MODULE STATUS_0100.
5. Dê um duplo clique na variavel STATUS_0100 e crie um PBO Module, selecionando o programa MAIN e salve o ZDF_Alpha.
6. Volte para a transação SE51 e abra para modificação o seu Screen Painter ZDF_Alpha.
7. Clique no menu Utilities e em Settings.
8. Na aba Screen Painter, desmarque o Graphical Layout Editor e clique OK.
9. Clique em Layout para abrir o editor gráfico alfanumérico.
10. No Editor alfanumérico você pode usar os menus para criar componentes.
11. Posicione o cursos na primeira linha, clique no menu Edit, Create Element, Text Field e preencha a propriedade Text para: Reserva de Voo e clique em Transfer.
12. Posicione o cursor duas linha abaixo.
13. No menu Goto, Dictionary/Program Fields ou CTRL + F6.
14. Em Table/Field Name coloque SPFLI e clique em Get from Dict.
15. Selecione todos os campos e clique em Transfer.
16. No menu Edit clique em Select Block.
17. Clique no menu Edit, Create Element, Pushbutton e crie um botão chamado Mostrar com a propriedade Fct_CODE = F_MOSTRAR.
18. Crie mais 4 botões com o mesmo procedimento acima para SAIR, LIMPAR, GRAVAR e EXCLUIR.
19. Na aba Element List va para o elemento Tipo OK e o nomeie para OK_CODE.
20. Salve sua tela e clique em Activate.
21. volte para o progama ZDF_Alpha e escreva o codigo abaixo.

Para usar este programa, caso você não tenha usado o post anterior  você precisa rodar o programa ZDADOS para preencher as tabelas auxiliares para o Flight Model. Você obterá uma tela igual a figura abaixo:

Exemplo:

Neste programa usamos a tabela de reserva de  voo, SPFLI do Flight Model que não possui uma GUI de entrada de dados. O que vamos fazer é criar a GUI de entrada de dados apenas para esta tabela usando o Screen Painter e OPEN SQL, visto que temos que respeitar as Foreing Keys das tabelas transparentes,  é necessário rodar primeiramente o programa ZDADOS para preencher manualmente as tabelas auxiliares para nosso programa.

Abap

*&---------------------------------------------------------------------*
*& Report  ZDF_ALPHA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Screen Painter - Alphanumeric
*&---------------------------------------------------------------------*

REPORT  ZDF_ALPHA.
*&---------------------------------------------------------------------*
*&      Module  STATUS_0100  OUTPUT
*&---------------------------------------------------------------------*
*       text
*----------------------------------------------------------------------*

TABLES SPFLI.

DATA OK_CODE LIKE SY-UCOMM.
DATA PROG LIKE SY-REPID.
PROG = 'ZDF_ALPHA'.

CALL SCREEN 100.

MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.

 SET TITLEBAR 'Screen Painter Alpha - Reserva de Voo' OF PROGRAM PROG.

  CASE SY-UCOMM.
    WHEN 'F_SAIR'.
      LEAVE PROGRAM.

    WHEN 'F_MOSTRAR'.
      SELECT SINGLE *  FROM spfli INTO
             CORRESPONDING FIELDS OF spfli
      WHERE
             carrid = spfli-CARRID AND
             CONNID = spfli-CONNID.

    WHEN 'F_LIMPAR'.
      CLEAR SPFLI.

    WHEN 'F_GRAVAR'.
      INSERT INTO SPFLI VALUES SPFLI.
      MESSAGE 'Registro gravado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

    WHEN 'F_EXCLUIR'.
      DELETE FROM SPFLI CLIENT SPECIFIED
      WHERE
              mandt =  spfli-MANDT  AND
              carrid = spfli-CARRID AND
              CONNID = spfli-CONNID.
      MESSAGE 'Registro deletado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

  ENDCASE.

ENDMODULE.                 " STATUS_0100  OUTPUT

Screen Painter

É uma ferramenta do ABAP Workbench que permite a criação de telas para suas transações. Você pode usá-lo tanto para criar a própria tela, com campos e outros elementos gráficos, e para escrever a lógica do fluxo atrás da tela.

O Screen Painter tem um editor de layout que você usa para criar seu layout de tela. Ele funciona no modo gráfico e  no modo alfanumérico.  Ambos os modos oferecem as mesmas funções, mas usam diferentes interfaces. No modo gráfico, você usa uma interface de arrastar semelhante a uma ferramenta de desenho. No modo alfanumérico, você usa seu teclado e menus.

Design First, Code Later

O editor de layout gráfico fornece um ambiente amigável para projetar telas. Você pode iniciar o editor de layout a partir da tela inicial do Screen Painter ou a partir do Navegador do repositório. O editor de layout possui dependências com o SAP GUI e você precisa estar usando versões compatíveis com o Graphical Layout Editor.

Depois de adicionar um elemento na sua tela, você pode convertê-lo para um outro tipo de elemento usando o menu Editar. Você também pode usar a paleta de elementos para selecionar e colocar os elementos da tela sem primeiro identificar seus campos ou você pode importar os campos e criar componentes automaticamente direto de uma tabela transparente.

Screen Painter Layout Editor

1. Entre na transação SE38 e crie um programa chamado ZDesignFirst.
2. Entre na transação SE51
3. Adicione no campo Program, o nome do programa criado anteriormente e no campo Screen Number escreva o numero: 100 e clique em Create.
4. No campo Short Description coloque : Desenvolvimento Aberto.
5. Na aba Flow Logic, apague o caractere de comentario “*”, deixando a linha: “MODULE STATUS_0100.” compilavel.
6. De um duplo clique na variável “STATUS_0100“.
7. Em Create PBO Module escolha: MAIN PROGRAM, clique em Ok e salve.
8. Digite a transação /nSE51, para voltar no Screen Painter, selecione modificar e clique em Layout.
9. No editor de Layout clique no icone Dictionary ou aperte a tecla F6.
10. Na tela seguinte, no campo Table/Field Name escolha a tabela SPFLI e clique no botão GET FROM DICTIONARY.
11. Selecione todos os campos, clique em OK e solte os componentes na tela (não converta nenhum componente).
12. Coloque um componente BOX na tela e de um duplo clique, na janela de propriedades, mude a  propriedade Text para: Reserva de Voo.
13. Coloque um PushButton na tela e preencha as propriedades: Name = Mostrar, Text = Mostrar e FctCode = F_MOSTRAR.
14. Crie mais quatro botões e repita os mesmos procedimentos acima, o primeiro com o nome de limpar e segundo com o nome de Sair, Gravar e Excluir.
15. Alinhe o Desing da tela como na figura abaixo.
16. Clique em Save, Activate e pressione Flow Logic.
17. Na aba Element List, no elemento tipo OK nomeie para OK_CODE.
18. Na aba Attributes em Cursor Position escolha: SPFLI_CARRID
19. Clique em Activate e volte para a transação SE38  e abra o seu programa ZDesignFirst.
20. Use os dois códigos abaixo.

Programa Abap

O programa com a tela totalmente funcional, deve ficar como na imagem abaixo, deve ser capaz de pesquisar, gravar e excluir uma tabela transparente:

Exemplo:

Neste programa usamos a tabela de reserva de  voo, SPFLI do Flight Model que não possui uma GUI de entrada de dados. O que vamos fazer é criar a GUI de entrada de dados apenas para esta tabela usando o Screen Painter e OPEN SQL, visto que temos que respeitar as Foreing Keys das tabelas transparentes,  é necessário rodar primeiramente o programa Zdados para preencher manualmente as tabelas auxiliares para nosso programa. Vale ressaltar que neste ponto só nos interessa o Screen Painter e não como manipular dados consistentemente, o que veremos mais tarde.

Abap

Zdados -Rode este programa para gravar dados nas tabelas transparentes.

*&---------------------------------------------------------------------*
*& Report  ZDADOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Insere Dados manualmente no Flight Model
*&---------------------------------------------------------------------*

REPORT  ZDADOS.

* Define tabelas do Banco de dados
TABLES SCARR.
TABLES SGEOCITY.
TABLES SAIRPORT.
TABLES SPFLI.

* Apaga dados existentes
DELETE FROM SCARR.
DELETE FROM SGEOCITY.
DELETE FROM SAIRPORT.
DELETE FROM SPFLI.

* Cria MATRIZs de dados (rows)
DATA MATRIZ1 TYPE SCARR.
DATA MATRIZ2 TYPE SGEOCITY.
DATA MATRIZ3 TYPE SAIRPORT.
DATA MATRIZ4 TYPE SPFLI.

* Insere dados.

MATRIZ1-CARRID = '001'.
MATRIZ1-CARRNAME = 'DA LINNHAS AEREAS'.
MATRIZ1-CURRCODE = 'REAL'.
MATRIZ1-MANDT = '001'.
MATRIZ1-URL  = 'https://desenvolvimentoaberto.wordpress.com'.

INSERT INTO SCARR VALUES MATRIZ1.

MATRIZ2-CITY = 'SAO PAULO'.
MATRIZ2-COUNTRY = 'BRA'.
MATRIZ2-LATITUDE = '23'.
MATRIZ2-LONGITUDE = '46'.
MATRIZ2-MANDT = '001'.

INSERT INTO SGEOCITY VALUES MATRIZ2.

MATRIZ2-CITY = 'RIO DE JANEIRO'.
MATRIZ2-COUNTRY = 'BRA'.
MATRIZ2-LATITUDE = '22'.
MATRIZ2-LONGITUDE = '43'.
MATRIZ2-MANDT = '001'.

INSERT INTO SGEOCITY VALUES MATRIZ2.

MATRIZ3-ID ='001'.
MATRIZ3-MANDT ='001'.
MATRIZ3-NAME = 'AEROPORTO DE CONGONHAS'.
MATRIZ3-TIME_ZONE = 'GMT-3'.

INSERT INTO SAIRPORT VALUES MATRIZ3.

MATRIZ3-ID ='002'.
MATRIZ3-MANDT ='001'.
MATRIZ3-NAME = 'AERO PORTO SANTOS DUMONT'.
MATRIZ3-TIME_ZONE = 'GMT-3'.

INSERT INTO SAIRPORT VALUES MATRIZ3.

MATRIZ4-AIRPFROM = '001'.
MATRIZ4-AIRPTO = '002'.
MATRIZ4-ARRTIME = '170000'.
MATRIZ4-CARRID = '001'.
MATRIZ4-CITYFROM = 'SAO PAULO'.
MATRIZ4-CITYTO = 'RIO DE JANEIRO'.
MATRIZ4-CONNID = '001'.
MATRIZ4-COUNTRYFR = 'BRA'.
MATRIZ4-COUNTRYTO = 'BRA'.
MATRIZ4-DEPTIME = '181500'.
MATRIZ4-DISTANCE = '500'.
MATRIZ4-DISTID = 'KM'.
MATRIZ4-FLTIME = '75'.
MATRIZ4-FLTYPE = 'X'.
MATRIZ4-MANDT = '001'.
MATRIZ4-PERIOD = '1'.

INSERT INTO SPFLI VALUES MATRIZ4.

* Exibe imagem
WRITE : / 'Dados inseridos'.

ZDesignFirst – Screen Painter

*&---------------------------------------------------------------------*
*& Report  ZDESIGNFIRST
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Screen Painter
*&---------------------------------------------------------------------*

REPORT  ZDESIGNFIRST.

* Define tabela de Reserva de Voo
TABLES SPFLI.

* Define variaveis do programa
DATA : OK_CODE    LIKE   SY-UCOMM.

* chama tela numero 100
CALL SCREEN 100.

MODULE STATUS_0100 OUTPUT.

* verifica ação dos botões
  CASE SY-UCOMM.
    WHEN 'F_SAIR'.
      LEAVE PROGRAM.

    WHEN 'F_MOSTRAR'.
      SELECT SINGLE *  FROM spfli INTO
             CORRESPONDING FIELDS OF spfli
      WHERE
             carrid = spfli-CARRID AND
             CONNID = spfli-CONNID.

    WHEN 'F_LIMPAR'.
      CLEAR SPFLI.

    WHEN 'F_GRAVAR'.
      INSERT INTO SPFLI VALUES SPFLI.
      MESSAGE 'Registro gravado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

    WHEN 'F_EXCLUIR'.
      DELETE FROM SPFLI CLIENT SPECIFIED
      WHERE
              mandt =  spfli-MANDT  AND
              carrid = spfli-CARRID AND
              CONNID = spfli-CONNID.
      MESSAGE 'Registro deletado com Sucesso' TYPE 'S'.
      CLEAR SPFLI.

  ENDCASE.
ENDMODULE.

Function Modules 

Módulos de função são rotinas ABAP que são armazenados em uma biblioteca de função central. Elas não são específicas do aplicativo, mas disponível em todo o sistema. O ABAP Workbench vem com um grande número de módulos de função padrão.

Como rotinas de formulários, módulos de função podem encapsular o código do programa e fornecer uma interface para troca de dados. Os Módulos de função devem pertencer a um grupo chamado de um grupo de funções.

Eles possuem uma interface fixa para troca de dados. Isso torna mais fácil para você passar parâmetros de entrada e saída para o módulo de função. Por exemplo, você pode atribuir valores padrão para os parâmetros de entrada. A interface também suporta manipulação de exceção. Isto permite-lhe detectar erros e passá-los de volta para o programa de chamada para o manuseio.

Os módulos usam a sua própria área de memória. O programa de chamada e do módulo de função não pode trocar dados usando uma área de memória compartilhada – devem usar a interface do módulo de função. Isso evita efeitos colaterais desagradáveis, como a substituição de dados acidentalmente. Você chama um módulo de função pelo seu nome (que deve ser único) em um comunicado de função de chamada usando a palavra chave CALL FUNCTION.

Function Builder

O Function Builder permite desenvolver, testar e documentar novos módulos de função. Você também pode usá-lo para exibir informações sobre os módulos de função existentes.

Criando uma Função

1.  Entre na transação SE37.
2.  No menu Goto, Function Groups, Create Group, crie um novo Grupo de função chamado ZDEVA.
3.  Digite a transação SE80, no ABAP WorkBench escolha grupo de função e o seu grupo, clique com o botão direito em cima do nome do seu grupo e escolha Activate.
4. Volte para a transação SE37.
5. Em Function Module, escreva ZF_FUNCAO_DA e clique em Create.
6. 
7. Na aba Import, nos campos respectivos digite: Parameter name = TEXTO1, Typing = TYPE, Associated Type = String.
8. No segundo registro digite: Parameter name = TEXTO2, Typing = TYPE, Associated Type = String.
9. Na Aba Export, nos campos respectivos digite: Parameter name = RESULTADO, Typing = TYPE, Associated Type = String.
10. Na Aba Exceptions nos campos respectivos digite: Exception = DA_ERRO, ShortText = Erro na função Dev Aberto.
11. Na aba Source Code, você pode ver o código gerado automaticamente, preencha de acordo com a imagem abaixo.
12. Clique em Activate para ativar a função.

 Call Function

Para chamar um módulo de função, use a instrução de função de chamada  CALL FUNCTION.

Exemplo:

Neste exemplo criamos um modulo de função no Function Builder e usamos um programa para chamar esta função.

Abap

Função

FUNCTION ZF_FUNCAO_DA.
*"----------------------------------------------------------------------
*"*"Local Interface:
*"  IMPORTING
*"     REFERENCE(TEXTO1) TYPE  STRING
*"     REFERENCE(TEXTO2) TYPE  STRING
*"  EXPORTING
*"     REFERENCE(RESULTADO) TYPE  STRING
*"  EXCEPTIONS
*"      DA_ERRO
*"----------------------------------------------------------------------

IF TEXTO1 NE 'ERRO'.

  CONCATENATE TEXTO1 TEXTO2 INTO RESULTADO SEPARATED BY ' '.

ELSE.

  RAISE DA_ERRO.

ENDIF.

ENDFUNCTION.

Programa

*&---------------------------------------------------------------------*
*& Report  ZFUNCAO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Modulo de Função
*&---------------------------------------------------------------------*

REPORT  ZFUNCAO.

DATA R_FUNCAO TYPE STRING.

* Chama função

CALL FUNCTION 'ZF_FUNCAO_DA'
  exporting
    TEXTO1    = 'Desenvolvimento'
    TEXTO2    = 'Aberto'
  importing
    RESULTADO = R_FUNCAO.

WRITE : / 'Retorno da função:', R_FUNCAO.

No post anterior aprendemos como montar telas gráficas dinamicamente, continuaremos criando uma tela gráfica de seleção mesclando tabelas internas e o banco de dados SAP, usando comandos OPEN SQL, para preencher as tabelas transparentes do Flight Model. Para quem não se lembra, o Flight Model é o principal exemplo do NetWeavear 7  e suas tabelas transparentes por default no mandante 001 não possui dados, por isto vamos inserir os dados manualmente, temos que ter cuidado para não esquecer de preencher as outras tabelas que fazem referencia (Foreign Key) a nossa tabela de voo, veja a imagem abaixo:

Flight Model:

https://desenvolvimentoaberto.wordpress.com/2014/02/20/netweaver-flight-model-introducao-ao-database-mini-sap/

Foreign Key

Uma chave externa ou estrangeira é um atributo ou uma combinação de atributos numa relação, cujos valores são necessários para equivaler à chave primária de uma relação. O conceito de Chave estrangeira em uso de banco de dados se refere ao tipo de relacionamento entre distintas tabelas de dados do banco de dados. Uma chave estrangeira é chamada quando há o relacionamento entre duas tabelas. Sempre em chave estrangeira vai haver relacionamentos entre tabelas, por exemplo, uma tabela que possui relação com a chave primaria de outra tabela.

Validação de Parâmetros

A validação de entrada da tela pode ser feita no evento da instrução:

AT SELECTION-SCREEN

Útil se quiser exigir a entrada de dados do usuário antes de processamento principal.

Usando AT SELECTION-SCREEN ON nome do campo:

• Disparado se nome do campo foi submetido.
• Se um erro ou aviso é emitido, o campo é realçado.

EM AT SELECTION-SCREEN ON RADIOBUTTON GROUP nome do grupo:

• Se um erro ou aviso é emitido, o grupo é realçado.

Range of Values

Permite que o usuário selecione um intervalo de valores, criando o componente na tela já com botões e tabelas relacionadas.

Sintaxe:

SELECT-OPTIONS itabname FOR dataobject.

Exemplo:

Neste exemplo temos dois programas distintos o primeiro preenche os dados do Flight Model, preenchendo a tabela de voo e as tabelas que fazem relação e possuem uma chave estrangeira na tabela voo. O segundo é nossa tela de seleção que busca todos os voos de uma agencia de viagem, também como fazer a validação em um campo de parâmetros.

Abap – Programa #1

*&---------------------------------------------------------------------*
*& Report  ZDADOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Insere Dados manualmente no Flight Model
*&---------------------------------------------------------------------*

REPORT  ZDADOS.

* Define tabelas do Banco de dados
TABLES SCARR.
TABLES SGEOCITY.
TABLES SAIRPORT.
TABLES SPFLI.

* Apaga dados existentes
DELETE FROM SCARR.
DELETE FROM SGEOCITY.
DELETE FROM SAIRPORT.
DELETE FROM SPFLI.

* Cria MATRIZs de dados (rows)
DATA MATRIZ1 TYPE SCARR.
DATA MATRIZ2 TYPE SGEOCITY.
DATA MATRIZ3 TYPE SAIRPORT.
DATA MATRIZ4 TYPE SPFLI.

* Insere dados.

MATRIZ1-CARRID = '001'.
MATRIZ1-CARRNAME = 'DA Airlines'.
MATRIZ1-CURRCODE = 'REAL'.
MATRIZ1-MANDT = '001'.
MATRIZ1-URL  = 'https://desenvolvimentoaberto.wordpress.com'.

INSERT INTO SCARR VALUES MATRIZ1.

MATRIZ2-CITY = 'São Paulo'.
MATRIZ2-COUNTRY = 'Bra'.
MATRIZ2-LATITUDE = '23'.
MATRIZ2-LONGITUDE = '46'.
MATRIZ2-MANDT = '001'.

INSERT INTO SGEOCITY VALUES MATRIZ2.

MATRIZ2-CITY = 'Rio de Janeiro'.
MATRIZ2-COUNTRY = 'Bra'.
MATRIZ2-LATITUDE = '22'.
MATRIZ2-LONGITUDE = '43'.
MATRIZ2-MANDT = '001'.

INSERT INTO SGEOCITY VALUES MATRIZ2.

MATRIZ3-ID ='001'.
MATRIZ3-MANDT ='001'.
MATRIZ3-NAME = 'Aeroporto de Congonhas'.
MATRIZ3-TIME_ZONE = 'GMT-3'.

INSERT INTO SAIRPORT VALUES MATRIZ3.

MATRIZ3-ID ='002'.
MATRIZ3-MANDT ='001'.
MATRIZ3-NAME = 'Aeroporto Santos Dumont'.
MATRIZ3-TIME_ZONE = 'GMT-3'.

INSERT INTO SAIRPORT VALUES MATRIZ3.

MATRIZ4-AIRPFROM = '001'.
MATRIZ4-AIRPTO = '002'.
MATRIZ4-ARRTIME = '170000'.
MATRIZ4-CARRID = '001'.
MATRIZ4-CITYFROM = 'São Paulo'.
MATRIZ4-CITYTO = 'Rio de Janeiro'.
MATRIZ4-CONNID = '001'.
MATRIZ4-COUNTRYFR = 'Bra'.
MATRIZ4-COUNTRYTO = 'Bra'.
MATRIZ4-DEPTIME = '181500'.
MATRIZ4-DISTANCE = '500'.
MATRIZ4-DISTID = 'KM'.
MATRIZ4-FLTIME = '75'.
MATRIZ4-FLTYPE = 'D'.
MATRIZ4-MANDT = '001'.
MATRIZ4-PERIOD = '1'.

INSERT INTO SPFLI VALUES MATRIZ4.

* Exibe imagem
WRITE : / 'Dados inseridos'.

Abap – Programa #2

*&---------------------------------------------------------------------*
*& Report  ZVISUAL_D
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Selection Screen - Database
*&---------------------------------------------------------------------*

REPORT  ZVISUAL_D.

* Define internal Table
DATA str TYPE spfli.

* Monta tela
SELECTION-SCREEN BEGIN OF BLOCK bloco1 WITH FRAME
  TITLE titulo.

   SELECTION-SCREEN BEGIN OF LINE.

      SELECTION-SCREEN COMMENT 1(22) com.
      SELECT-OPTIONS userair FOR str-carrid.

   SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco1.

SELECTION-SCREEN BEGIN OF BLOCK bloco2 WITH FRAME
  TITLE titulo1.

    SELECTION-SCREEN COMMENT 1(40) com1.
    PARAMETER valor TYPE string.

SELECTION-SCREEN END OF BLOCK bloco2.

* Carrega rotulos da tela
LOAD-OF-PROGRAM.

Titulo = 'Modelo de Voo (Flight Model - NetWeaver 7'.
titulo1 = 'Evento de validação'.
com = 'Selecione Linha Aerea'.
com1 = 'Experimente digitar a palavra: VALIDA'.

* Evento de validação
AT SELECTION-SCREEN ON valor.
  IF valor = 'VALIDA'.
    MESSAGE 'Você digitou uma palavra Invalida' TYPE 'W'.
  ENDIF.

* Inicia o Programa
START-OF-SELECTION.

* Seleciona os dados do banco de dados e coloca na tabela interna
SELECT carrid connid countryfr cityfrom cityto arrtime deptime distance distid  FROM spfli INTO
CORRESPONDING FIELDS OF str WHERE carrid IN userair.

WRITE: / str-carrid, str-connid, str-countryfr, str-cityfrom, str-cityto,
         str-arrtime, str-deptime, str-distance, str-distid.

ENDSELECT.

Quando você precisa que o usuário forneça dados de entrada para algum tipo de processamento, você pode montar uma tela com parâmetros de seleção usando componentes visuais que são criados em tempo de execução, você pode usar rótulos (COMMENT), campos de edição, botões de cheque, botões de radio, botões comuns e eventos para realizar uma interação com a resposta do usuário.

PARAMETERS

Os parâmetros são os componentes de uma tela de seleção que são atribuídos a um objeto de dados elementar global no programa ABAP e um campo de entrada na tela de seleção. Parameters é o tipo mais básico de aceitação de entrada. Usando os parâmetros você pode gerar uma tela de tela de seleção padrão.

EVENT BLOCK

Um programa ABAP é uma coleção de blocos de processamento, chamados pelo ambiente de tempo de execução quando relacionados a eventos é acionado através do fluxo natural do programa de controle ou quando provocado por uma ação do usuário.

LOAD-OF-PROGRAM

Esta palavra-chave define um bloco de evento cujo evento é acionado pelo ambiente ABAP-runtime quando um programa executável, um pool de módulo, um grupo de funções ou uma pool de sub-rotina é carregado na sessão interna.

START-OF-SELECTION

Esta palavra-chave define o bloco de processamento padrão de um programa executável. O evento associado é acionado pelo ambiente de tempo de execução ABAP durante a execução de um programa executável após quaisquer telas de seleção padrão serem processadas.

SELECTION-SCREEN

Telas de seleção são telas especiais que não são criadas no Screen Painter, mas são geradas a partir de declarações ABAP. Você pode usá-las sempre que quiser que o usuário digite um único valor para um campo ou campos, ou para introduzir critérios de seleção.

AT SELECTION-SCREEN

Define uma forma básica de toda uma série de eventos que ocorrem enquanto a tela de seleção está sendo processada.

A tela de seleção standard, em um programa executável ou no banco de dados lógico ligado a ela, é chamada automaticamente entre os eventos da inicialização e o inicio da selecão. Quando você chama a tela de seleção e, quando os usuários interagem com ela, o ambiente de tempo de execução ABAP gera eventos de tela de seleção, que ocorrem entre os comandos INITIALIZATION e START-OF-SELECTION.

Exemplo:
Neste exemplo desenvolvemos uma tela de seleção usando frames e vários componentes de seleção, usamos também o eventos de seleção.

Abap

*&---------------------------------------------------------------------*
*& Report  ZVISUAL
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Selection Screen - List process events
*&---------------------------------------------------------------------*

REPORT  ZVISUAL.

* Define tabela ucommcomponent para o fcode do botão
TABLES sscrfields.

* Define variaveis
DATA evento TYPE i VALUE 0.

* Define bloco do frame 1
SELECTION-SCREEN BEGIN OF BLOCK bloco1 WITH FRAME

  TITLE titulo1.

  SELECTION-SCREEN BEGIN OF LINE.

    SELECTION-SCREEN COMMENT 1(10) com1.
    PARAMETERS: var1 TYPE i,
                var2 TYPE i,
                var3 TYPE i.
    SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco1.

* Define bloco do frame 2
SELECTION-SCREEN BEGIN OF BLOCK bloco2 WITH FRAME

  TITLE titulo2.

  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(12) com2.
    PARAMETERS data LIKE sy-datum.
  SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco2.

* Define bloco do frame 3
SELECTION-SCREEN BEGIN OF BLOCK bloco3 WITH FRAME

  TITLE titulo3.

  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(9) com3.
    PARAMETERS masc AS CHECKBOX.
    SELECTION-SCREEN COMMENT 18(8) com4.
    PARAMETERS fem AS CHECKBOX.
  SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco3.

* Define bloco do frame 4
SELECTION-SCREEN BEGIN OF BLOCK bloco4 WITH FRAME

  TITLE titulo4.

  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN COMMENT 1(10) com5.
    PARAMETERS: variavel AS CHECKBOX.
  SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco4.

* Define bloco do frame 5
SELECTION-SCREEN BEGIN OF BLOCK bloco5 WITH FRAME

  TITLE titulo5.

  SELECTION-SCREEN BEGIN OF LINE.
    SELECTION-SCREEN PUSHBUTTON 2(10) but1 USER-COMMAND CLIQUE1.
  SELECTION-SCREEN END OF LINE.

SELECTION-SCREEN END OF BLOCK bloco5.

* Usa componente sem frame

SELECTION-SCREEN COMMENT 1(15) com6.
PARAMETERS : escolha1 RADIOBUTTON GROUP grpa,
escolha2 RADIOBUTTON GROUP grpa,
escolha3 RADIOBUTTON GROUP grpa.

* Carrega variaveis da selecão de tela
LOAD-OF-PROGRAM.

  titulo1 = 'Entre campos numericos (Parameters)'.
  titulo2 = 'Data (Data - Calendario)'.
  titulo3 = 'Sexo (Checkbox)'.
  titulo4 = 'Variave (Checkbox)'.
  titulo5 = 'Botão (PushButton)'.

  but1 = 'OK'.

  com1 = 'Numeros '.
  com2 = 'Data de hoje'.
  com3 = 'Masculino'.
  com4 = 'Feminino'.
  com5 = 'Variavel'.
  com6 = 'RadioButton'.

* Evento do botão
AT SELECTION-SCREEN.

  CASE sscrfields.
    WHEN 'CLIQUE1'.
      evento = 1.
  ENDCASE.

* Inicio do processamento da seleção de tela
START-OF-SELECTION.

* Imprime campo data
  WRITE : / 'Data:', data.
  .
* Imprime campo sexo
  IF masc = 'X'.
    WRITE / 'Você é do sexo masculino!'.
  ENDIF.
  IF fem = 'X'.
    WRITE / 'Você é do sexo feminino!'.
  ENDIF.

* Imprime resultado do Checkbox
  IF variavel = 'X'.
    WRITE / 'Você clicou no checkbox'.
  ELSE.
    WRITE / 'Você não clicou no checkbox'.
  ENDIF.

* Imprime resultado do Radiobutton
  CASE 'X'.
    WHEN escolha1.
      WRITE / 'Você fez a primeira escolha'.
    WHEN escolha2.
      WRITE / 'Você fez a segunda escolha'.
    WHEN escolha3.
      WRITE / 'Você fez a terceira escolha'.
    WHEN OTHERS.
      WRITE / 'Você não fez nenhuma escolha'.
  ENDCASE.

* Captura resultado do evento
  CASE evento.
    WHEN 1.
      WRITE : / 'Você clicou no botão'.
    WHEN 0.
      WRITE : / 'Você não clicou no botão'.
  ENDCASE.

Podemos ver muitos posts por ai dizendo que Abap não possui Arrays em vez disto possui Internal Tables e que são melhores que Arrays pela sua facilidade de manipulação.

Bem isto não é de inteira verdade, o Abap possui sim Arrays, como vimos em nosso post anterior, criamos uma Lista de Arrays contendo objetos usando a classe de coleção standart (CL_OBJECT_COLLECTION) e vamos usar agora outra forma de array para guardar objetos, mas desta vez teremos um pouco mais de controle sobre eles.

Map é um objeto que mapeia chaves e valores. Um mapa não pode conter chaves duplicadas, cada chave pode mapear , no máximo, um valor. Em algumas linguagens de programação um MAP chama-se Dictionary.

A interface Map fornece três visualizações de coleta, que permitem que o conteúdo de um mapa seja visto como um conjunto de chaves, cobrança de valores, ou um conjunto de mapeamentos chave-valor. A ordem de um mapa é definida como a ordem em que os iteradores em exibições de coleta do mapa devolver os seus elementos.

Em ABAP um MAP pertence a classe: CL_OBJECT_MAP

Exemplo: Neste exemplo criamos um simples programa que guarda objetos dentro de um objeto MAP e usa sua chave para remover um objeto do mapa, para dar ênfase nos mapas usamos um estilo de programação hibrida.

Abap

*&---------------------------------------------------------------------*
*& Report  ZCOLLECTION
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Collection - MAP
*&---------------------------------------------------------------------*

REPORT  ZCOLLECTION.

* Classe MAPA

CLASS MAPA DEFINITION.

PUBLIC SECTION.

     DATA CHAVE TYPE STRING.
     DATA VALOR TYPE STRING.

METHODS: CONSTRUCTOR  IMPORTING  CHAVE TYPE STRING OPTIONAL
                                 VALOR TYPE STRING OPTIONAL.

ENDCLASS.

CLASS MAPA IMPLEMENTATION.

  METHOD constructor.
    me->CHAVE = CHAVE.
    me->VALOR = VALOR.
  ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Declara e instancia objeto MAP

DATA MAP TYPE REF TO CL_OBJECT_MAP.
CREATE OBJECT MAP.

* cria Objeto MAPA

DATA MAPA TYPE REF TO MAPA.

* Adiciona CHAVE e VALOR no MAP

WRITE : / 'Lista de musicas do Beatles'.

PERFORM ADD USING '01' 'Let it be'.
PERFORM ADD USING '02' 'Dont let me down'.
PERFORM ADD USING '03' 'Come togheter'.
PERFORM ADD USING '04' 'Hey Jude'.
PERFORM ADD USING '05' 'Twist and shout'.

* Declara Iterador

DATA ITERADOR TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.
ITERADOR ?= MAP->GET_VALUES_ITERATOR( ).

PERFORM MOSTRAMAPA.

WRITE : / , / .
WRITE : / 'Remove musica 04 da lista'.
MAP->REMOVE( '04' ).

* Lembre-se que com o  Iterador podemos fazer
* uma alusão ao result de um banco de dados

ITERADOR ?= MAP->GET_VALUES_ITERATOR( ).

PERFORM MOSTRAMAPA.

* Retorna conteudo do mapa usando o Iterador

FORM MOSTRAMAPA.

  WHILE  ITERADOR->HAS_NEXT( ) IS NOT INITIAL.
    MAPA ?= ITERADOR->GET_NEXT( ).
    WRITE : / 'Chave:', MAPA->CHAVE,'Valor:', MAPA->VALOR.
  ENDWHILE.

ENDFORM.

* Adiciona objeto no objeto MAP

FORM ADD USING VALUE(C) TYPE STRING
   VALUE(V) TYPE STRING.

   CREATE OBJECT MAPA
       exporting
            CHAVE = C
            VALOR = V.

   MAP->PUT( exporting KEY  = MAPA->CHAVE  VALUE = MAPA ).

ENDFORM.

Iterator

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente(container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

As Classes ABAP:

A SAP fornece por padrão duas classes para manipular objetos usando coleções e iteradores:

• CL_OBJECT_COLLECTION – para a coleta de objetos.
• CL_OBJECT_COLLECTION_ITERATOR para Iterator.

As interfaces subjacentes não são genéricas o suficiente para distribuir outros tipos de opções de coleta, métodos obrigatórios, como, adicionar, remover, etc,  não fazem parte da interface. Portanto, você precisa criar interfaces de usuário semelhantes as da implementação da classes Standard e que podem ser usadas ​​em diferentes coleções e implementação de iterador.

A partir das classes Standards é possível criar uma classe Z para as coleções e iteradores, para que se assemelhe ao framework de coleções do java que possui muito mais  flexibilidade para colecionar e iterar objetos.

Exemplo:

neste exemplo mostramos como se usa uma Collection(coleções) para guardar uma lista de objetos (Array), e navegar pela lista de objetos usando o seu Iterator(iterador).

Abap

*&---------------------------------------------------------------------*
*& Report  ZITERADOR
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Coleções e Iteradores
*&---------------------------------------------------------------------*

REPORT  ZITERADOR.

* Classe Item

CLASS ITEM DEFINITION.
    PUBLIC SECTION.

    DATA: ITENS TYPE STRING READ-ONLY.

    METHODS: CONSTRUCTOR IMPORTING ITENS TYPE STRING.

ENDCLASS.

CLASS ITEM IMPLEMENTATION.

   METHOD constructor.
      me->ITENS = ITENS.
   ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Define collection LIST

DATA LIST TYPE REF TO CL_OBJECT_COLLECTION.
CREATE OBJECT LIST.

* Cria Objeto Item
DATA ITEM TYPE REF TO ITEM.

* musicas dos Beatles

PERFORM ADD USING 'Let it be'.
PERFORM ADD USING 'Dont let me down'.
PERFORM ADD USING 'Come togheter'.
PERFORM ADD USING 'Hey Jude'.
PERFORM ADD USING 'Twist and shout'.

* Cria Iterador

DATA ITERADOR TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.
ITERADOR = LIST->GET_ITERATOR( ).

* Usa iterator como um cursor de banco de dados

WHILE  ITERADOR->HAS_NEXT( ) IS NOT INITIAL.
   ITEM ?= ITERADOR->GET_NEXT( ).
   WRITE : / ITEM->ITENS.
ENDWHILE.

* Adiciona Itens na lista

FORM ADD USING VALUE(S) TYPE STRING.
   CREATE OBJECT ITEM
         exporting
             ITENS = S.
   LIST->ADD( ITEM ) .
ENDFORM.