├── zdp_memento.abap ├── zdp_composite2.abap ├── zdp_abstractfactory2.abap ├── zdp_singletonfactory.abap ├── README.md ├── .project ├── zdp_visitor.abap ├── zdp_adapter.abap ├── zdp_singleton.abap ├── zdp_facade.abap ├── zdp_prototype.abap ├── zdp_observer.abap ├── zdp_proxy.abap ├── zdp_strategy.abap ├── zdp_templatemethod.abap ├── zdp_state.abap ├── zdp_command.abap ├── zdp_bridge.abap ├── zdp_interpreter.abap ├── zdp_factorymethod.abap ├── zdp_builder.abap ├── zdp_flyweight.abap ├── zdp_abstractfactory.abap ├── zdp_factorymethod2.abap ├── zdp_mediator.abap ├── zdp_decorator.abap ├── zdp_composite.abap ├── zdp_chainofresp.abap ├── zdp_state2.abap ├── zdp_factorymethod3.abap └── zdp_iterator.abap /zdp_memento.abap: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /zdp_composite2.abap: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /zdp_abstractfactory2.abap: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /zdp_singletonfactory.abap: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 23 Design Patterns in ABAP 2 | ================= 3 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | ABAPDesignPattern 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /zdp_visitor.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_VISITOR 3 | *& Tight Coupled Visitor 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_visitor. 9 | 10 | INTERFACE lif_visitable. 11 | METHODS: accept IMPORTING visitor. 12 | ENDINTERFACE. 13 | 14 | INTERFACE lif_visitor. 15 | METHODS: visit IMPORTING visitable. 16 | ENDINTERFACE. 17 | 18 | CLASS simple_visitable DEFINITION. 19 | PUBLIC SECTION. 20 | INTERFACES: lif_visitable. 21 | ENDCLASS. 22 | 23 | CLASS simple_visitable IMPLEMENTATION. 24 | METHOD lif_visitable~accept. 25 | visitor.visit(me). 26 | ENDMETHOD. 27 | ENDCLASS. 28 | 29 | CLASS simple_visitor DEFINITION. 30 | PUBLIC SECTION. 31 | INTERFACES: lif_visitor. 32 | ENDCLASS. 33 | 34 | CLASS simple_visitor IMPLEMENTATION. 35 | METHOD lif_visitor~visit. 36 | visitable.accept( ). 37 | ENDMETHOD. 38 | ENDCLASS. 39 | 40 | 41 | START-OF-SELECTION. 42 | 43 | -------------------------------------------------------------------------------- /zdp_adapter.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_ADAPTER 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_adapter. 9 | 10 | INTERFACE lif_output. 11 | METHODS: generate_output. 12 | ENDINTERFACE. 13 | 14 | CLASS simple_op DEFINITION. 15 | PUBLIC SECTION. 16 | INTERFACES: lif_output. 17 | ENDCLASS. 18 | 19 | CLASS simple_op IMPLEMENTATION. 20 | METHOD lif_output~generate_output. 21 | WRITE: / 'Simple Output - just using write.'. 22 | ENDMETHOD. 23 | ENDCLASS. 24 | 25 | CLASS tree_output DEFINITION. 26 | PUBLIC SECTION. 27 | METHODS: generate_tree. 28 | ENDCLASS. 29 | 30 | CLASS tree_output IMPLEMENTATION. 31 | METHOD generate_tree. 32 | WRITE: / 'Creating Tree ... using CL_GUI_ALV_TREE'. 33 | ENDMETHOD. 34 | ENDCLASS. 35 | 36 | CLASS new_complex_op DEFINITION. 37 | PUBLIC SECTION. 38 | INTERFACES: lif_output. 39 | ENDCLASS. 40 | 41 | CLASS new_complex_op IMPLEMENTATION. 42 | METHOD lif_output~generate_output. 43 | DATA: o_tree_op TYPE REF TO tree_output. 44 | CREATE OBJECT o_tree_op. 45 | o_tree_op->generate_tree( ). 46 | ENDMETHOD. 47 | ENDCLASS. 48 | 49 | START-OF-SELECTION. 50 | DATA: o_op TYPE REF TO lif_output. 51 | CREATE OBJECT o_op TYPE simple_op. 52 | o_op->generate_output( ). 53 | 54 | CREATE OBJECT o_op TYPE new_complex_op. 55 | o_op->generate_output( ). -------------------------------------------------------------------------------- /zdp_singleton.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_SINGLETON 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_singleton. 9 | 10 | 11 | CLASS lcl_application DEFINITION CREATE PRIVATE. 12 | PUBLIC SECTION. 13 | CLASS-METHODS: 14 | get_instance 15 | RETURNING VALUE(ro_instance) TYPE REF TO lcl_application. 16 | 17 | METHODS: 18 | set_name IMPORTING iv_name TYPE char30, 19 | get_name RETURNING VALUE(rv_name) TYPE char30. 20 | 21 | PRIVATE SECTION. 22 | CLASS-DATA: lo_apps TYPE REF TO lcl_application. 23 | DATA: v_name TYPE char30. 24 | ENDCLASS. 25 | 26 | CLASS lcl_application IMPLEMENTATION. 27 | METHOD get_instance. 28 | IF lo_apps IS INITIAL. 29 | CREATE OBJECT lo_apps. 30 | ENDIF. 31 | 32 | ro_instance = lo_apps. 33 | ENDMETHOD. 34 | 35 | METHOD set_name. 36 | me->v_name = iv_name. 37 | ENDMETHOD. 38 | 39 | METHOD get_name. 40 | rv_name = me->v_name. 41 | ENDMETHOD. 42 | ENDCLASS. 43 | 44 | START-OF-SELECTION. 45 | DATA: lo_application TYPE REF TO lcl_application. 46 | DATA: lv_result TYPE char30. 47 | 48 | WRITE: / 'LO_APPLICATION'. 49 | 50 | lo_application = lcl_application=>get_instance( ). 51 | lo_application->set_name( ' This is first object' ). 52 | 53 | lv_result = lo_application->get_name( ). 54 | WRITE: / lv_result. 55 | CLEAR lv_result. 56 | 57 | DATA: lo_2nd_apps TYPE REF TO lcl_application. 58 | SKIP 2. 59 | WRITE: / 'LO_2ND_APPS : '. 60 | lo_2nd_apps = lcl_application=>get_instance( ). 61 | lv_result = lo_2nd_apps->get_name( ). 62 | WRITE: / lv_result. 63 | CLEAR lv_result. -------------------------------------------------------------------------------- /zdp_facade.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_FACADE 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_facade. 9 | 10 | CLASS lcl_data DEFINITION. 11 | PUBLIC SECTION. 12 | METHODS: constructor. 13 | ENDCLASS. 14 | 15 | INTERFACE lif_write. 16 | METHODS: write_data. 17 | ENDINTERFACE. 18 | 19 | CLASS lcl_write_alv DEFINITION. 20 | PUBLIC SECTION. 21 | INTERFACES: lif_write. 22 | ENDCLASS. 23 | 24 | CLASS lcl_write_log DEFINITION. 25 | PUBLIC SECTION. 26 | INTERFACES: lif_write. 27 | ENDCLASS. 28 | 29 | CLASS lcl_facade DEFINITION. 30 | PUBLIC SECTION. 31 | METHODS: process_report IMPORTING iv_write_type TYPE char1. 32 | ENDCLASS. 33 | 34 | CLASS lcl_data IMPLEMENTATION. 35 | METHOD constructor. 36 | WRITE: / 'Getting Data'. 37 | ENDMETHOD. 38 | ENDCLASS. 39 | 40 | CLASS lcl_write_alv IMPLEMENTATION. 41 | METHOD lif_write~write_data. 42 | WRITE: / 'Writing data in ALV'. 43 | ENDMETHOD. 44 | ENDCLASS. 45 | 46 | CLASS lcl_write_log IMPLEMENTATION. 47 | METHOD lif_write~write_data. 48 | WRITE: / 'Wring data in Log'. 49 | ENDMETHOD. 50 | ENDCLASS. 51 | 52 | CLASS lcl_facade IMPLEMENTATION. 53 | METHOD process_report. 54 | DATA: lo_data TYPE REF TO lcl_data. 55 | CREATE OBJECT lo_data. 56 | 57 | DATA: lo_write TYPE REF TO lif_write. 58 | IF iv_write_type = 'A'. 59 | CREATE OBJECT lo_write TYPE lcl_write_alv. 60 | ELSE. 61 | CREATE OBJECT lo_write TYPE lcl_write_log. 62 | ENDIF. 63 | lo_write->write_data( ). 64 | ENDMETHOD. 65 | ENDCLASS. 66 | 67 | START-OF-SELECTION. 68 | DATA: lo_facade TYPE REF TO lcl_facade. 69 | CREATE OBJECT lo_facade. 70 | lo_facade->process_report( iv_write_type = 'A' ). -------------------------------------------------------------------------------- /zdp_prototype.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_PROTOTYPE 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_prototype. 9 | 10 | 11 | CLASS prototype DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: 14 | constructor IMPORTING iv_id TYPE string 15 | ,get_id RETURNING VALUE(rv_id) TYPE string 16 | ,clone ABSTRACT RETURNING VALUE(ro_prototype) TYPE REF TO prototype. 17 | 18 | PRIVATE SECTION. 19 | DATA: id TYPE string. 20 | ENDCLASS. 21 | 22 | CLASS prototype IMPLEMENTATION. 23 | METHOD constructor. 24 | me->id = iv_id. 25 | ENDMETHOD. 26 | 27 | METHOD get_id. 28 | rv_id = me->id. 29 | ENDMETHOD. 30 | ENDCLASS. 31 | 32 | CLASS concrete_prototype1 DEFINITION INHERITING FROM prototype. 33 | PUBLIC SECTION. 34 | METHODS: 35 | clone REDEFINITION. 36 | ENDCLASS. 37 | 38 | CLASS concrete_prototype1 IMPLEMENTATION. 39 | METHOD clone. 40 | ro_prototype = me. 41 | ENDMETHOD. 42 | ENDCLASS. 43 | 44 | CLASS concrete_prototype2 DEFINITION INHERITING FROM prototype. 45 | PUBLIC SECTION. 46 | METHODS: 47 | clone REDEFINITION. 48 | ENDCLASS. 49 | 50 | CLASS concrete_prototype2 IMPLEMENTATION. 51 | METHOD clone. 52 | ro_prototype = me. 53 | ENDMETHOD. 54 | ENDCLASS. 55 | 56 | CLASS mainapp DEFINITION. 57 | PUBLIC SECTION. 58 | CLASS-METHODS: 59 | main. 60 | ENDCLASS. 61 | 62 | CLASS mainapp IMPLEMENTATION. 63 | METHOD main. 64 | DATA: p1 TYPE REF TO concrete_prototype1 65 | ,c1 TYPE REF TO concrete_prototype1 66 | , p2 TYPE REF TO concrete_prototype2 67 | , c2 TYPE REF TO concrete_prototype2 68 | , id TYPE string. 69 | 70 | FIELD-SYMBOLS TYPE REF TO prototype. 71 | 72 | CREATE OBJECT p1 EXPORTING iv_id = 'I'. 73 | 74 | c1 ?= p1->clone( ). 75 | 76 | id = c1->get_id( ). 77 | WRITE: / 'Cloned: {0}', id. 78 | 79 | CREATE OBJECT p2 EXPORTING iv_id = 'II'. 80 | c2 ?= p2->clone( ). 81 | id = c2->get_id( ). 82 | WRITE: / 'Cloned: {0}', id. 83 | ENDMETHOD. 84 | 85 | ENDCLASS. 86 | 87 | START-OF-SELECTION. 88 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_observer.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_OBSERVER 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | PROGRAM zdp_observer. 9 | 10 | 11 | CLASS main_process DEFINITION. 12 | PUBLIC SECTION. 13 | METHODS: set_state IMPORTING iv_state TYPE char1. 14 | EVENTS: state_changed EXPORTING VALUE(new_state) TYPE char1. 15 | PRIVATE SECTION. 16 | DATA: current_state TYPE char1. 17 | ENDCLASS. 18 | 19 | CLASS main_process IMPLEMENTATION. 20 | METHOD set_state. 21 | current_state = iv_state. 22 | SKIP 2. 23 | WRITE: / 'Main Process new state', current_state. 24 | RAISE EVENT state_changed EXPORTING new_state = current_state. 25 | ENDMETHOD. 26 | ENDCLASS. 27 | 28 | CLASS myfunction DEFINITION ABSTRACT. 29 | PUBLIC SECTION. 30 | METHODS: on_state_changed ABSTRACT 31 | FOR EVENT state_changed OF main_process 32 | IMPORTING new_state. 33 | ENDCLASS. 34 | 35 | CLASS myalv DEFINITION INHERITING FROM myfunction. 36 | PUBLIC SECTION. 37 | METHODS: on_state_changed REDEFINITION. 38 | ENDCLASS. 39 | 40 | 41 | CLASS myalv IMPLEMENTATION. 42 | METHOD on_state_changed. 43 | WRITE: / 'New state in ALV processing', new_state. 44 | ENDMETHOD. 45 | ENDCLASS. 46 | 47 | CLASS mydb DEFINITION INHERITING FROM myfunction. 48 | PUBLIC SECTION. 49 | METHODS: on_state_changed REDEFINITION. 50 | ENDCLASS. 51 | 52 | CLASS mydb IMPLEMENTATION. 53 | METHOD on_state_changed. 54 | WRITE: / 'New State in DB processing', new_state. 55 | ENDMETHOD. 56 | ENDCLASS. 57 | 58 | CLASS main_app DEFINITION. 59 | PUBLIC SECTION. 60 | CLASS-METHODS: run. 61 | ENDCLASS. 62 | 63 | CLASS main_app IMPLEMENTATION. 64 | METHOD run. 65 | DATA: lo_process TYPE REF TO main_process. 66 | DATA: lo_alv TYPE REF TO myalv. 67 | DATA: lo_db TYPE REF TO mydb. 68 | 69 | CREATE OBJECT lo_process. 70 | CREATE OBJECT: lo_alv, lo_db. 71 | 72 | SET HANDLER lo_alv->on_state_changed FOR lo_process. 73 | SET HANDLER lo_db->on_state_changed FOR lo_process. 74 | 75 | lo_process->set_state( 'A' ). 76 | lo_process->set_state( 'B' ). 77 | lo_process->set_state( 'C' ). 78 | ENDMETHOD. 79 | ENDCLASS. 80 | 81 | START-OF-SELECTION. 82 | main_app=>run( ). -------------------------------------------------------------------------------- /zdp_proxy.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_PROXY 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_proxy. 9 | 10 | 11 | INTERFACE lif_data. 12 | DATA: t_t100 TYPE tt_t100. 13 | METHODS: get_data IMPORTING iv_spras TYPE spras OPTIONAL 14 | CHANGING ct_data TYPE tt_t100. 15 | METHODS: write_data. 16 | ENDINTERFACE. 17 | 18 | CLASS lcl_proxy_data DEFINITION. 19 | PUBLIC SECTION. 20 | INTERFACES: lif_data. 21 | PRIVATE SECTION. 22 | DATA: o_t100_data TYPE REF TO lif_data. 23 | ENDCLASS. 24 | 25 | CLASS lcl_t100_data DEFINITION. 26 | PUBLIC SECTION. 27 | INTERFACES: lif_data. 28 | ENDCLASS. 29 | 30 | CLASS lcl_proxy_data IMPLEMENTATION. 31 | METHOD lif_data~get_data. 32 | IF iv_spras NE sy-langu. 33 | EXIT. 34 | ENDIF. 35 | 36 | CREATE OBJECT o_t100_data TYPE lcl_t100_data. 37 | o_t100_data->get_data( 38 | EXPORTING 39 | iv_spras = iv_spras 40 | CHANGING 41 | ct_data = ct_data 42 | ). 43 | ENDMETHOD. 44 | 45 | METHOD lif_data~write_data. 46 | IF o_t100_data IS NOT BOUND. 47 | WRITE: / 'No data to display'. 48 | ELSE. 49 | o_t100_data->write_data( ). 50 | ENDIF. 51 | ENDMETHOD. 52 | ENDCLASS. 53 | 54 | CLASS lcl_t100_data IMPLEMENTATION. 55 | METHOD lif_data~get_data. 56 | SELECT * FROM t100 INTO TABLE lif_data~t_t100 57 | UP TO 200000000 ROWS WHERE sprsl = iv_spras. 58 | ct_data = lif_data~t_t100. 59 | ENDMETHOD. 60 | 61 | METHOD lif_data~write_data. 62 | DATA: lv_lines TYPE i. 63 | lv_lines = lines( lif_data~t_t100 ). 64 | WRITE: / 'Total lines', lv_lines. 65 | ENDMETHOD. 66 | ENDCLASS. 67 | 68 | CLASS lcl_main_app DEFINITION. 69 | PUBLIC SECTION. 70 | CLASS-METHODS:run. 71 | ENDCLASS. 72 | 73 | CLASS lcl_main_app IMPLEMENTATION. 74 | METHOD run. 75 | DATA: lo_proxy TYPE REF TO lif_data. 76 | DATA: lt_data TYPE tt_t100. 77 | 78 | CREATE OBJECT lo_proxy TYPE lcl_proxy_data. 79 | lo_proxy->get_data( 80 | EXPORTING 81 | iv_spras = 'E' 82 | CHANGING 83 | ct_data = lt_data 84 | ). 85 | 86 | lo_proxy->write_data( ). 87 | ENDMETHOD. 88 | ENDCLASS. 89 | 90 | START-OF-SELECTION. 91 | lcl_main_app=>run( ). -------------------------------------------------------------------------------- /zdp_strategy.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_STRATEGY 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_strategy. 9 | 10 | 11 | INTERFACE strategy. 12 | METHODS: algorithm. 13 | ENDINTERFACE. 14 | 15 | CLASS concrete_strategya DEFINITION. 16 | PUBLIC SECTION. 17 | INTERFACES: strategy. 18 | ENDCLASS. 19 | 20 | CLASS concrete_strategya IMPLEMENTATION. 21 | METHOD strategy~algorithm. 22 | WRITE: / 'Called Concreate Strategy A Algorithm Interface.'. 23 | ENDMETHOD. 24 | ENDCLASS. 25 | 26 | CLASS concrete_strategyb DEFINITION. 27 | PUBLIC SECTION. 28 | INTERFACES: strategy. 29 | ENDCLASS. 30 | 31 | CLASS concrete_strategyb IMPLEMENTATION. 32 | METHOD strategy~algorithm. 33 | WRITE: / 'Called Concreate Strategy B Algorithm Interface.'. 34 | ENDMETHOD. 35 | ENDCLASS. 36 | 37 | CLASS concrete_strategyc DEFINITION. 38 | PUBLIC SECTION. 39 | INTERFACES: strategy. 40 | ENDCLASS. 41 | 42 | CLASS concrete_strategyc IMPLEMENTATION. 43 | METHOD strategy~algorithm. 44 | WRITE: / 'Called Concreate Strategy C Algorithm Interface.'. 45 | ENDMETHOD. 46 | ENDCLASS. 47 | 48 | CLASS context DEFINITION. 49 | PUBLIC SECTION. 50 | METHODS: constructor IMPORTING io_instance TYPE REF TO strategy 51 | , context_interface. 52 | PRIVATE SECTION. 53 | DATA: mstrategy TYPE REF TO strategy. 54 | ENDCLASS. 55 | 56 | CLASS context IMPLEMENTATION. 57 | METHOD constructor. 58 | mstrategy = io_instance. 59 | ENDMETHOD. 60 | 61 | METHOD context_interface. 62 | me->mstrategy->algorithm( ). 63 | ENDMETHOD. 64 | ENDCLASS. 65 | 66 | CLASS mainapp DEFINITION. 67 | PUBLIC SECTION. 68 | CLASS-METHODS: main. 69 | ENDCLASS. 70 | 71 | CLASS mainapp IMPLEMENTATION. 72 | METHOD main. 73 | DATA: o_context TYPE REF TO context. 74 | DATA: o_strategy TYPE REF TO strategy. 75 | 76 | CREATE OBJECT o_strategy TYPE concrete_strategya. 77 | CREATE OBJECT o_context EXPORTING io_instance = o_strategy. 78 | o_context->context_interface( ). 79 | 80 | CREATE OBJECT o_strategy TYPE concrete_strategyb. 81 | CREATE OBJECT o_context EXPORTING io_instance = o_strategy. 82 | o_context->context_interface( ). 83 | 84 | CREATE OBJECT o_strategy TYPE concrete_strategyc. 85 | CREATE OBJECT o_context EXPORTING io_instance = o_strategy. 86 | o_context->context_interface( ). 87 | 88 | ENDMETHOD. 89 | ENDCLASS. 90 | 91 | 92 | START-OF-SELECTION. 93 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_templatemethod.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_TEMPLATEMETHOD 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_templatemethod. 9 | 10 | CLASS template_sandwich DEFINITION ABSTRACT. 11 | PUBLIC SECTION. 12 | METHODS: prepare_sandwich FINAL. 13 | 14 | PROTECTED SECTION. 15 | METHODS: add_butter. 16 | METHODS: add_extra ABSTRACT. 17 | METHODS: add_veggetables ABSTRACT. 18 | PRIVATE SECTION. 19 | METHODS: slice_break. 20 | ENDCLASS. 21 | 22 | CLASS template_sandwich IMPLEMENTATION. 23 | METHOD add_butter. 24 | WRITE: / 'Add thin layer of butter'. 25 | ENDMETHOD. 26 | 27 | METHOD slice_break. 28 | WRITE: / 'Slice Break.'. 29 | ENDMETHOD. 30 | 31 | METHOD prepare_sandwich. 32 | slice_break( ). 33 | add_butter( ). 34 | add_extra( ). 35 | add_veggetables( ). 36 | ENDMETHOD. 37 | ENDCLASS. 38 | 39 | CLASS cheese_sandwich DEFINITION INHERITING FROM template_sandwich. 40 | PUBLIC SECTION. 41 | PROTECTED SECTION. 42 | METHODS: add_extra REDEFINITION. 43 | METHODS: add_veggetables REDEFINITION. 44 | METHODS: add_butter REDEFINITION. 45 | PRIVATE SECTION. 46 | ENDCLASS. 47 | 48 | CLASS cheese_sandwich IMPLEMENTATION. 49 | METHOD add_butter. 50 | WRITE: / 'Add thick layer of butter'. 51 | ENDMETHOD. 52 | 53 | METHOD add_extra. 54 | WRITE:/ 'Add slices of camenbert'. 55 | ENDMETHOD. 56 | 57 | METHOD add_veggetables. 58 | WRITE:/ 'Add tomato slices'. 59 | ENDMETHOD. 60 | ENDCLASS. 61 | 62 | CLASS ham_sandwich DEFINITION INHERITING FROM template_sandwich. 63 | PUBLIC SECTION. 64 | PROTECTED SECTION. 65 | METHODS: add_extra REDEFINITION. 66 | METHODS: add_veggetables REDEFINITION. 67 | PRIVATE SECTION. 68 | ENDCLASS. 69 | 70 | CLASS ham_sandwich IMPLEMENTATION. 71 | METHOD add_extra. 72 | WRITE: / 'Add slice of ham'. 73 | ENDMETHOD. 74 | 75 | METHOD add_veggetables. 76 | WRITE: / 'Add salad leaves'. 77 | WRITE: / 'Add onions'. 78 | ENDMETHOD. 79 | ENDCLASS. 80 | 81 | CLASS mainapp DEFINITION. 82 | PUBLIC SECTION. 83 | CLASS-METHODS: 84 | main. 85 | ENDCLASS. 86 | 87 | CLASS mainapp IMPLEMENTATION. 88 | METHOD main. 89 | DATA: sandwich TYPE REF TO template_sandwich. 90 | CREATE OBJECT sandwich TYPE cheese_sandwich. 91 | 92 | sandwich->prepare_sandwich( ). 93 | 94 | CREATE OBJECT sandwich TYPE ham_sandwich. 95 | sandwich->prepare_sandwich( ). 96 | ENDMETHOD. 97 | ENDCLASS. 98 | 99 | START-OF-SELECTION. 100 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_state.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_STATE 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_state. 9 | 10 | CLASS context DEFINITION DEFERRED. 11 | CLASS cl_abap_typedescr DEFINITION LOAD. 12 | 13 | DATA: moff TYPE i 14 | , slen TYPE i 15 | , mlen TYPE i. 16 | 17 | DEFINE get_clazz_name. 18 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 19 | FIND REGEX 'CLASS=' IN &2 MATCH OFFSET moff match LENGTH mlen. 20 | slen = moff + mlen. 21 | SHIFT &2 BY slen PLACES LEFT. 22 | END-OF-DEFINITION. 23 | 24 | CLASS state DEFINITION ABSTRACT. 25 | PUBLIC SECTION. 26 | METHODS: 27 | handle ABSTRACT IMPORTING io_context TYPE REF TO context. 28 | ENDCLASS. 29 | 30 | CLASS context DEFINITION. 31 | PUBLIC SECTION. 32 | METHODS: constructor IMPORTING io_state TYPE REF TO state, 33 | request. 34 | DATA: mo_state TYPE REF TO state. 35 | ENDCLASS. 36 | 37 | CLASS context IMPLEMENTATION. 38 | METHOD constructor. 39 | me->mo_state = io_state. 40 | ENDMETHOD. 41 | 42 | METHOD request. 43 | me->mo_state->handle( io_context = me ). 44 | ENDMETHOD. 45 | ENDCLASS. 46 | 47 | CLASS concrete_statea DEFINITION INHERITING FROM state. 48 | PUBLIC SECTION. 49 | METHODS: 50 | handle REDEFINITION. 51 | ENDCLASS. 52 | 53 | CLASS concrete_stateb DEFINITION INHERITING FROM state. 54 | PUBLIC SECTION. 55 | METHODS: 56 | handle REDEFINITION. 57 | ENDCLASS. 58 | 59 | CLASS concrete_statea IMPLEMENTATION. 60 | METHOD handle. 61 | DATA: stateb TYPE REF TO state. 62 | DATA: class_name TYPE abap_abstypename. 63 | CREATE OBJECT stateb TYPE concrete_stateb. 64 | io_context->mo_state = stateb. 65 | get_clazz_name stateb class_name. 66 | WRITE: / 'State:', class_name. 67 | ENDMETHOD. 68 | ENDCLASS. 69 | 70 | CLASS concrete_stateb IMPLEMENTATION. 71 | METHOD handle. 72 | DATA: statea TYPE REF TO state. 73 | DATA: class_name TYPE abap_abstypename. 74 | CREATE OBJECT statea TYPE concrete_statea. 75 | io_context->mo_state = statea. 76 | get_clazz_name statea class_name. 77 | WRITE: / 'State:', class_name. 78 | ENDMETHOD. 79 | ENDCLASS. 80 | 81 | CLASS mainapp DEFINITION. 82 | PUBLIC SECTION. 83 | CLASS-METHODS: main. 84 | ENDCLASS. 85 | 86 | CLASS mainapp IMPLEMENTATION. 87 | METHOD: main. 88 | DATA: context TYPE REF TO context. 89 | DATA: state TYPE REF TO concrete_statea. 90 | CREATE OBJECT state. 91 | CREATE OBJECT context EXPORTING io_state = state. 92 | 93 | context->request( ). 94 | context->request( ). 95 | context->request( ). 96 | context->request( ). 97 | 98 | ENDMETHOD. 99 | ENDCLASS. 100 | 101 | START-OF-SELECTION. 102 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_command.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_COMMAND 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_command. 9 | 10 | 11 | CLASS receiver DEFINITION. 12 | PUBLIC SECTION. 13 | METHODS: 14 | action. 15 | ENDCLASS. 16 | 17 | CLASS receiver IMPLEMENTATION. 18 | METHOD action. 19 | WRITE: / 'Console.WriteLine(Called Receiver.Action()'. 20 | ENDMETHOD. 21 | ENDCLASS. 22 | 23 | CLASS command DEFINITION ABSTRACT. 24 | PUBLIC SECTION. 25 | METHODS: 26 | constructor IMPORTING io_receiver TYPE REF TO receiver 27 | , execute ABSTRACT. 28 | 29 | PROTECTED SECTION. 30 | DATA: mo_receiver TYPE REF TO receiver. 31 | ENDCLASS. 32 | 33 | 34 | CLASS command IMPLEMENTATION. 35 | METHOD constructor. 36 | me->mo_receiver = io_receiver. 37 | ENDMETHOD. 38 | ENDCLASS. 39 | 40 | CLASS concrete_command DEFINITION INHERITING FROM command. 41 | PUBLIC SECTION. 42 | METHODS: 43 | execute REDEFINITION. 44 | ENDCLASS. 45 | 46 | 47 | CLASS concrete_command IMPLEMENTATION. 48 | METHOD execute. 49 | me->mo_receiver->action( ). 50 | ENDMETHOD. 51 | ENDCLASS. 52 | 53 | CLASS invoker DEFINITION. 54 | PUBLIC SECTION. 55 | METHODS: 56 | set_command IMPORTING io_command TYPE REF TO command 57 | , execute_command. 58 | PRIVATE SECTION. 59 | DATA: mo_command TYPE REF TO command. 60 | ENDCLASS. 61 | 62 | CLASS invoker IMPLEMENTATION. 63 | METHOD set_command. 64 | me->mo_command = io_command. 65 | ENDMETHOD. 66 | 67 | METHOD execute_command. 68 | me->mo_command->execute( ). 69 | ENDMETHOD. 70 | ENDCLASS. 71 | 72 | CLASS lcl_application DEFINITION CREATE PRIVATE. 73 | PUBLIC SECTION. 74 | CLASS-METHODS:run. 75 | METHODS: constructor. 76 | PRIVATE SECTION. 77 | CLASS-DATA: so_application TYPE REF TO lcl_application. 78 | ENDCLASS. 79 | 80 | CLASS lcl_application IMPLEMENTATION. 81 | METHOD run. 82 | DATA: exc_ref TYPE REF TO cx_root 83 | , exc_text TYPE string. 84 | 85 | IF lcl_application=>so_application IS INITIAL. 86 | TRY . 87 | CREATE OBJECT lcl_application=>so_application. 88 | CATCH cx_sy_create_object_error INTO exc_ref. 89 | exc_text = exc_ref->get_text( ). 90 | MESSAGE exc_text TYPE 'I'. 91 | ENDTRY. 92 | ENDIF. 93 | ENDMETHOD. 94 | 95 | METHOD constructor. 96 | DATA: receiver TYPE REF TO receiver, 97 | command TYPE REF TO concrete_command 98 | , invoker TYPE REF TO invoker. 99 | 100 | CREATE OBJECT receiver. 101 | CREATE OBJECT command EXPORTING io_receiver = receiver. 102 | 103 | CREATE OBJECT invoker. 104 | 105 | invoker->set_command( command ). 106 | invoker->execute_command( ). 107 | ENDMETHOD. 108 | ENDCLASS. 109 | 110 | START-OF-SELECTION. 111 | lcl_application=>run( ). -------------------------------------------------------------------------------- /zdp_bridge.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_BRIDGE 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_bridge. 9 | CLASS abstract_car DEFINITION DEFERRED. 10 | CLASS cl_abap_typedescr DEFINITION LOAD. 11 | 12 | DATA: moff TYPE i 13 | , slen TYPE i 14 | , mlen TYPE i. 15 | 16 | DEFINE get_clazz_name. 17 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 18 | FIND REGEX 'CLASS=' IN &2 MATCH OFFSET moff match LENGTH mlen. 19 | slen = moff + mlen. 20 | SHIFT &2 BY slen PLACES LEFT. 21 | END-OF-DEFINITION. 22 | 23 | CLASS abstract_road DEFINITION ABSTRACT. 24 | PUBLIC SECTION. 25 | METHODS: 26 | set_car IMPORTING io_car TYPE REF TO abstract_car, 27 | run ABSTRACT. 28 | PROTECTED SECTION. 29 | DATA: mo_car TYPE REF TO abstract_car. 30 | ENDCLASS. 31 | 32 | CLASS abstract_road IMPLEMENTATION. 33 | METHOD set_car. 34 | me->mo_car = io_car. 35 | DATA: name TYPE string. 36 | get_clazz_name me->mo_car name. 37 | WRITE: / name. 38 | ENDMETHOD. 39 | ENDCLASS. 40 | 41 | CLASS abstract_car DEFINITION ABSTRACT. 42 | PUBLIC SECTION. 43 | METHODS: 44 | run ABSTRACT. 45 | ENDCLASS. 46 | 47 | CLASS speed_way DEFINITION INHERITING FROM abstract_road. 48 | PUBLIC SECTION. 49 | METHODS: 50 | run REDEFINITION. 51 | ENDCLASS. 52 | 53 | CLASS speed_way IMPLEMENTATION. 54 | METHOD run. 55 | WRITE: ' run on the speed way.'. 56 | me->mo_car->run( ). 57 | ENDMETHOD. 58 | ENDCLASS. 59 | 60 | CLASS street DEFINITION INHERITING FROM abstract_road. 61 | PUBLIC SECTION. 62 | METHODS: 63 | run REDEFINITION. 64 | ENDCLASS. 65 | 66 | CLASS street IMPLEMENTATION. 67 | METHOD run. 68 | WRITE: ' run on the streen.'. 69 | me->mo_car->run( ). 70 | ENDMETHOD. 71 | ENDCLASS. 72 | 73 | CLASS car DEFINITION INHERITING FROM abstract_car. 74 | PUBLIC SECTION. 75 | METHODS: 76 | run REDEFINITION. 77 | ENDCLASS. 78 | 79 | CLASS car IMPLEMENTATION. 80 | METHOD run. 81 | WRITE: / 'this is car runing on '. 82 | ENDMETHOD. 83 | ENDCLASS. 84 | 85 | CLASS bus DEFINITION INHERITING FROM abstract_car. 86 | PUBLIC SECTION. 87 | METHODS: 88 | run REDEFINITION. 89 | ENDCLASS. 90 | 91 | CLASS bus IMPLEMENTATION. 92 | METHOD run. 93 | WRITE: / 'this is bus running on '. 94 | ENDMETHOD. 95 | ENDCLASS. 96 | 97 | CLASS mainapp DEFINITION. 98 | PUBLIC SECTION. 99 | CLASS-METHODS: main. 100 | ENDCLASS. 101 | 102 | CLASS mainapp IMPLEMENTATION. 103 | METHOD main. 104 | DATA: road1 TYPE REF TO speed_way 105 | , road2 TYPE REF TO street. 106 | CREATE OBJECT road1. 107 | CREATE OBJECT road2. 108 | 109 | road1->set_car( NEW car( ) ). 110 | road1->run( ). 111 | road2->set_car( NEW bus( ) ). 112 | road2->run( ). 113 | ENDMETHOD. 114 | ENDCLASS. 115 | 116 | START-OF-SELECTION. 117 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_interpreter.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_INTERPRETER 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_interpreter. 9 | CLASS context DEFINITION DEFERRED. 10 | 11 | CLASS abstract_expression DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: 14 | interpret ABSTRACT IMPORTING io_context TYPE REF TO context. 15 | ENDCLASS. 16 | 17 | CLASS context DEFINITION. 18 | PUBLIC SECTION. 19 | METHODS: constructor IMPORTING iv_input TYPE string 20 | , get_input RETURNING VALUE(rv_input) TYPE string 21 | , set_input IMPORTING iv_input TYPE string 22 | , get_output RETURNING VALUE(rv_output) TYPE string 23 | , set_output IMPORTING iv_output TYPE string. 24 | PRIVATE SECTION. 25 | DATA: mv_input TYPE string 26 | , mv_output TYPE i. 27 | ENDCLASS. 28 | 29 | CLASS context IMPLEMENTATION. 30 | METHOD constructor. 31 | me->mv_input = iv_input. 32 | ENDMETHOD. 33 | METHOD get_input. 34 | rv_input = me->mv_input. 35 | ENDMETHOD. 36 | METHOD set_input. 37 | me->mv_input = iv_input. 38 | ENDMETHOD. 39 | METHOD get_output. 40 | rv_output = me->mv_output. 41 | ENDMETHOD. 42 | METHOD set_output. 43 | me->mv_output = iv_output. 44 | ENDMETHOD. 45 | ENDCLASS. 46 | 47 | CLASS plus_expression DEFINITION INHERITING FROM abstract_expression. 48 | PUBLIC SECTION. 49 | METHODS: 50 | interpret REDEFINITION. 51 | ENDCLASS. 52 | 53 | CLASS plus_expression IMPLEMENTATION. 54 | METHOD interpret. 55 | WRITE: / 'PlusExpression++'. 56 | DATA: input TYPE string. 57 | input = io_context->get_input( ). 58 | 59 | ENDMETHOD. 60 | ENDCLASS. 61 | 62 | 63 | CLASS minus_expression DEFINITION INHERITING FROM abstract_expression. 64 | PUBLIC SECTION. 65 | METHODS: 66 | interpret REDEFINITION. 67 | ENDCLASS. 68 | 69 | CLASS minus_expression IMPLEMENTATION. 70 | METHOD interpret. 71 | WRITE: / 'MinusExpression--'. 72 | DATA: input TYPE string. 73 | input = io_context->get_input( ). 74 | ENDMETHOD. 75 | ENDCLASS. 76 | 77 | CLASS mainapp DEFINITION. 78 | PUBLIC SECTION. 79 | CLASS-METHODS: 80 | main. 81 | ENDCLASS. 82 | 83 | CLASS mainapp IMPLEMENTATION. 84 | METHOD main. 85 | DATA: inputexpr TYPE string. 86 | inputexpr = '10'. 87 | 88 | DATA: context TYPE REF TO context. 89 | CREATE OBJECT context EXPORTING iv_input = inputexpr. 90 | 91 | DATA: list TYPE STANDARD TABLE OF REF TO abstract_expression. 92 | 93 | APPEND NEW plus_expression( ) TO list. 94 | APPEND NEW plus_expression( ) TO list. 95 | 96 | APPEND NEW minus_expression( ) TO list. 97 | APPEND NEW minus_expression( ) TO list. 98 | APPEND NEW minus_expression( ) TO list. 99 | 100 | FIELD-SYMBOLS TYPE REF TO abstract_expression. 101 | 102 | LOOP AT list ASSIGNING . 103 | ->interpret( context ). 104 | ENDLOOP. 105 | ENDMETHOD. 106 | ENDCLASS. 107 | 108 | START-OF-SELECTION. 109 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_factorymethod.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_FACTORYMETHOD 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_factorymethod. 9 | 10 | CLASS product DEFINITION DEFERRED. 11 | CLASS concrete_producta DEFINITION DEFERRED. 12 | CLASS concrete_productb DEFINITION DEFERRED. 13 | 14 | CLASS creator DEFINITION DEFERRED. 15 | CLASS concrete_creatora DEFINITION DEFERRED. 16 | CLASS concrete_creatorb DEFINITION DEFERRED. 17 | 18 | CLASS cl_abap_typedescr DEFINITION LOAD. 19 | 20 | DATA: moff TYPE i 21 | , slen TYPE i 22 | , mlen TYPE i. 23 | 24 | DEFINE get_clazz_name. 25 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 26 | find REGEX 'CLASS=' in &2 MATCH OFFSET moff MATCH LENGTH mlen. 27 | slen = moff + mlen. 28 | SHIFT &2 by slen PLACES LEFT. 29 | END-OF-DEFINITION. 30 | 31 | CLASS product DEFINITION ABSTRACT. 32 | ENDCLASS. 33 | 34 | CLASS concrete_producta DEFINITION INHERITING FROM product. 35 | ENDCLASS. 36 | 37 | CLASS concrete_productb DEFINITION INHERITING FROM product. 38 | ENDCLASS. 39 | 40 | CLASS creator DEFINITION ABSTRACT. 41 | PUBLIC SECTION. 42 | METHODS: 43 | factorymethod ABSTRACT RETURNING VALUE(product) TYPE REF TO product. 44 | ENDCLASS. 45 | 46 | CLASS concrete_creatora DEFINITION INHERITING FROM creator. 47 | PUBLIC SECTION. 48 | METHODS: 49 | factorymethod REDEFINITION. 50 | ENDCLASS. 51 | 52 | CLASS concrete_creatora IMPLEMENTATION. 53 | METHOD factorymethod. 54 | CREATE OBJECT product TYPE concrete_producta. 55 | ENDMETHOD. 56 | ENDCLASS. 57 | 58 | CLASS concrete_creatorb DEFINITION INHERITING FROM creator. 59 | PUBLIC SECTION. 60 | METHODS: 61 | factorymethod REDEFINITION. 62 | ENDCLASS. 63 | 64 | CLASS concrete_creatorb IMPLEMENTATION. 65 | METHOD factorymethod. 66 | CREATE OBJECT product TYPE concrete_productb. 67 | ENDMETHOD. 68 | ENDCLASS. 69 | 70 | CLASS main_app DEFINITION. 71 | PUBLIC SECTION. 72 | CLASS-DATA: oa_creator_coll TYPE TABLE OF REF TO creator. 73 | CLASS-METHODS: main. 74 | ENDCLASS. 75 | 76 | CLASS main_app IMPLEMENTATION. 77 | METHOD main. 78 | DATA: creator TYPE REF TO creator 79 | , concretecreatora TYPE REF TO concrete_creatora 80 | , concretecreatorb TYPE REF TO concrete_creatorb 81 | , product TYPE REF TO product 82 | , class_name TYPE abap_abstypename. 83 | 84 | FIELD-SYMBOLS TYPE any. 85 | 86 | CREATE OBJECT concretecreatora. 87 | APPEND concretecreatora TO oa_creator_coll. 88 | 89 | CREATE OBJECT concretecreatorb. 90 | APPEND concretecreatorb TO oa_creator_coll. 91 | 92 | LOOP AT oa_creator_coll ASSIGNING . 93 | get_clazz_name class_name. 94 | CASE class_name. 95 | WHEN 'CONCRETE_CREATORA'. 96 | WRITE: / 'ConcreteCreatorA Creates Product A'. 97 | WHEN 'CONCRETE_CREATORB'. 98 | WRITE: / 'ConcreteCreatorB Creates Product B'. 99 | ENDCASE. 100 | 101 | creator = . 102 | product = creator->factorymethod( ). 103 | 104 | get_clazz_name product class_name. 105 | WRITE: / 'Product = ', class_name. 106 | ENDLOOP. 107 | ENDMETHOD. 108 | ENDCLASS. 109 | 110 | START-OF-SELECTION. 111 | main_app=>main( ). -------------------------------------------------------------------------------- /zdp_builder.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_BUILDER 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_builder. 9 | 10 | 11 | INTERFACE lif_pizza. 12 | DATA: dough TYPE string, 13 | sauce TYPE string, 14 | topping TYPE string. 15 | ENDINTERFACE. 16 | 17 | CLASS lcl_pizza DEFINITION. 18 | PUBLIC SECTION. 19 | INTERFACES: lif_pizza. 20 | ENDCLASS. 21 | 22 | CLASS pizza_builder DEFINITION ABSTRACT. 23 | PUBLIC SECTION. 24 | METHODS: create_new_pizza 25 | RETURNING VALUE(ro_pizza) TYPE REF TO lif_pizza. 26 | METHODS: build_dough ABSTRACT, 27 | build_sauce ABSTRACT, 28 | build_topping ABSTRACT. 29 | 30 | PROTECTED SECTION. 31 | DATA: pizza TYPE REF TO lif_pizza. 32 | ENDCLASS. 33 | 34 | CLASS pizza_builder IMPLEMENTATION. 35 | METHOD create_new_pizza. 36 | CREATE OBJECT pizza TYPE lcl_pizza. 37 | ro_pizza = pizza. 38 | ENDMETHOD. 39 | ENDCLASS. 40 | 41 | CLASS veg_pizza_builder DEFINITION INHERITING FROM pizza_builder. 42 | PUBLIC SECTION. 43 | METHODS: build_dough REDEFINITION, 44 | build_sauce REDEFINITION, 45 | build_topping REDEFINITION. 46 | ENDCLASS. 47 | 48 | CLASS veg_pizza_builder IMPLEMENTATION. 49 | METHOD build_dough. 50 | pizza->dough = 'Thin Crust'. 51 | ENDMETHOD. 52 | 53 | METHOD build_sauce. 54 | pizza->sauce = 'Mild'. 55 | ENDMETHOD. 56 | 57 | METHOD build_topping. 58 | pizza->topping = 'Olives, Pineapples, Jalapenos'. 59 | ENDMETHOD. 60 | ENDCLASS. 61 | 62 | CLASS cheese_pizza_builder DEFINITION INHERITING FROM pizza_builder. 63 | PUBLIC SECTION. 64 | METHODS: build_dough REDEFINITION, 65 | build_sauce REDEFINITION, 66 | build_topping REDEFINITION. 67 | ENDCLASS. 68 | 69 | 70 | CLASS cheese_pizza_builder IMPLEMENTATION. 71 | METHOD build_dough. 72 | pizza->dough = 'Thick Crust'. 73 | ENDMETHOD. 74 | 75 | METHOD build_sauce. 76 | pizza->sauce = 'Mild Hot'. 77 | ENDMETHOD. 78 | 79 | METHOD build_topping. 80 | pizza->topping = 'Cheese, Cheese, Cheese, more Cheese'. 81 | ENDMETHOD. 82 | ENDCLASS. 83 | 84 | CLASS cook DEFINITION. 85 | PUBLIC SECTION. 86 | METHODS: construct_pizza IMPORTING io_builder TYPE REF TO pizza_builder 87 | RETURNING VALUE(ro_pizza) TYPE REF TO lif_pizza. 88 | PRIVATE SECTION. 89 | DATA: pizzabuilder TYPE REF TO pizza_builder. 90 | ENDCLASS. 91 | 92 | CLASS cook IMPLEMENTATION. 93 | METHOD construct_pizza. 94 | pizzabuilder = io_builder. 95 | ro_pizza = pizzabuilder->create_new_pizza( ). 96 | 97 | pizzabuilder->build_dough( ). 98 | pizzabuilder->build_sauce( ). 99 | pizzabuilder->build_topping( ). 100 | ENDMETHOD. 101 | ENDCLASS. 102 | 103 | 104 | START-OF-SELECTION. 105 | DATA: o_cook TYPE REF TO cook, 106 | o_pizza_builder TYPE REF TO pizza_builder, 107 | o_pizza TYPE REF TO lif_pizza. 108 | CREATE OBJECT o_cook. 109 | 110 | CREATE OBJECT o_pizza_builder TYPE veg_pizza_builder. 111 | o_pizza = o_cook->construct_pizza( o_pizza_builder ). 112 | WRITE: / o_pizza->dough, o_pizza->sauce, o_pizza->topping. 113 | 114 | CREATE OBJECT o_pizza_builder TYPE cheese_pizza_builder. 115 | o_pizza = o_cook->construct_pizza( o_pizza_builder ). 116 | WRITE: / o_pizza->dough, o_pizza->sauce, o_pizza->topping. -------------------------------------------------------------------------------- /zdp_flyweight.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_FLYWEIGHT 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_flyweight. 9 | 10 | 11 | CLASS flyweight DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: 14 | operation ABSTRACT IMPORTING iv_extrincicstate TYPE i. 15 | ENDCLASS. 16 | 17 | CLASS concrete_flyweight DEFINITION INHERITING FROM flyweight. 18 | PUBLIC SECTION. 19 | METHODS: 20 | operation REDEFINITION. 21 | ENDCLASS. 22 | 23 | CLASS concrete_flyweight IMPLEMENTATION. 24 | METHOD operation. 25 | WRITE: /5(20) 'ConcreteFlyweight', iv_extrincicstate. 26 | ENDMETHOD. 27 | ENDCLASS. 28 | 29 | CLASS unshared_concrete_flyweight DEFINITION INHERITING FROM flyweight. 30 | PUBLIC SECTION. 31 | METHODS: 32 | operation REDEFINITION. 33 | ENDCLASS. 34 | 35 | CLASS unshared_concrete_flyweight IMPLEMENTATION. 36 | METHOD operation. 37 | WRITE: /5(20) 'Unshared Concrete Flyweight', iv_extrincicstate. 38 | ENDMETHOD. 39 | ENDCLASS. 40 | 41 | CLASS flyweight_factory DEFINITION. 42 | PUBLIC SECTION. 43 | TYPES: BEGIN OF ty_flyweight, 44 | key(1) TYPE c 45 | , value TYPE REF TO concrete_flyweight 46 | , END OF ty_flyweight. 47 | 48 | METHODS: 49 | constructor 50 | , getflyweight IMPORTING iv_key TYPE c 51 | RETURNING VALUE(ro_value) TYPE REF TO flyweight. 52 | 53 | PRIVATE SECTION. 54 | DATA flyweights TYPE HASHED TABLE OF ty_flyweight WITH UNIQUE KEY key. 55 | ENDCLASS. 56 | 57 | CLASS flyweight_factory IMPLEMENTATION. 58 | METHOD constructor. 59 | DATA: cf TYPE REF TO concrete_flyweight 60 | ,buffer TYPE ty_flyweight . 61 | 62 | CREATE OBJECT cf. 63 | buffer-key = 'X'. 64 | buffer-value = cf. 65 | INSERT buffer INTO TABLE flyweights. 66 | 67 | CREATE OBJECT cf. 68 | buffer-key = 'Y'. 69 | buffer-value = cf. 70 | INSERT buffer INTO TABLE flyweights. 71 | 72 | CREATE OBJECT cf. 73 | buffer-key = 'Z'. 74 | buffer-value = cf. 75 | INSERT buffer INTO TABLE flyweights. 76 | ENDMETHOD. 77 | 78 | METHOD getflyweight. 79 | DATA buffer TYPE ty_flyweight. 80 | READ TABLE flyweights WITH TABLE KEY key = iv_key INTO buffer. 81 | ro_value = buffer-value. 82 | ENDMETHOD. 83 | ENDCLASS. 84 | 85 | CLASS mainapp DEFINITION. 86 | PUBLIC SECTION. 87 | CLASS-METHODS: 88 | main. 89 | ENDCLASS. 90 | 91 | CLASS mainapp IMPLEMENTATION. 92 | METHOD main. 93 | DATA: extrincicstate TYPE i 94 | ,f TYPE REF TO flyweight_factory 95 | ,fx TYPE REF TO flyweight 96 | ,fy TYPE REF TO flyweight 97 | ,fz TYPE REF TO flyweight 98 | ,uf TYPE REF TO unshared_concrete_flyweight 99 | . 100 | extrincicstate = 22. 101 | 102 | CREATE OBJECT f. 103 | fx = f->getflyweight( 'X' ). 104 | SUBTRACT 1 FROM extrincicstate. 105 | fx->operation( extrincicstate ). 106 | 107 | SUBTRACT 1 FROM extrincicstate. 108 | fy = f->getflyweight( 'Y' ). 109 | fy->operation( extrincicstate ). 110 | 111 | SUBTRACT 1 FROM extrincicstate. 112 | fz = f->getflyweight( 'Z' ). 113 | fz->operation( extrincicstate ). 114 | 115 | SUBTRACT 1 FROM extrincicstate. 116 | CREATE OBJECT uf. 117 | uf->operation( extrincicstate ). 118 | ENDMETHOD. 119 | ENDCLASS. 120 | 121 | START-OF-SELECTION. 122 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_abstractfactory.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_ABSTRACTFACTORY 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_abstractfactory. 9 | 10 | 11 | CLASS abs_data DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: read_data ABSTRACT. 14 | ENDCLASS. 15 | 16 | CLASS data_from_file DEFINITION INHERITING FROM abs_data. 17 | PUBLIC SECTION. 18 | METHODS: read_data REDEFINITION. 19 | ENDCLASS. 20 | 21 | 22 | CLASS data_from_file IMPLEMENTATION. 23 | METHOD read_data. 24 | WRITE: / 'Reading data from file'. 25 | ENDMETHOD. 26 | ENDCLASS. 27 | 28 | CLASS data_from_db DEFINITION INHERITING FROM abs_data. 29 | PUBLIC SECTION. 30 | METHODS: read_data REDEFINITION. 31 | ENDCLASS. 32 | 33 | CLASS data_from_db IMPLEMENTATION. 34 | METHOD read_data. 35 | WRITE: / 'Reading data from Database Table'. 36 | ENDMETHOD. 37 | ENDCLASS. 38 | 39 | CLASS abs_print DEFINITION ABSTRACT. 40 | PUBLIC SECTION. 41 | METHODS: write_data ABSTRACT. 42 | ENDCLASS. 43 | 44 | CLASS print_alv DEFINITION INHERITING FROM abs_print. 45 | PUBLIC SECTION. 46 | METHODS: write_data REDEFINITION. 47 | ENDCLASS. 48 | 49 | CLASS print_alv IMPLEMENTATION. 50 | METHOD write_data. 51 | WRITE: / 'Writing data into ALV'. 52 | ENDMETHOD. 53 | ENDCLASS. 54 | 55 | CLASS print_simple DEFINITION INHERITING FROM abs_print. 56 | PUBLIC SECTION. 57 | METHODS: write_data REDEFINITION. 58 | ENDCLASS. 59 | 60 | 61 | CLASS print_simple IMPLEMENTATION. 62 | METHOD write_data. 63 | WRITE: / 'Writing data in classic - This is actually classic'. 64 | ENDMETHOD. 65 | ENDCLASS. 66 | 67 | CLASS REPORT DEFINITION ABSTRACT. 68 | PUBLIC SECTION. 69 | METHODS: get_data ABSTRACT, 70 | print_data ABSTRACT. 71 | ENDCLASS. 72 | 73 | 74 | CLASS simple_report DEFINITION INHERITING FROM REPORT. 75 | PUBLIC SECTION. 76 | METHODS: get_data REDEFINITION. 77 | METHODS: print_data REDEFINITION. 78 | ENDCLASS. 79 | 80 | CLASS simple_report IMPLEMENTATION. 81 | METHOD get_data. 82 | DATA: lo_data TYPE REF TO data_from_file. 83 | CREATE OBJECT lo_data. 84 | lo_data->read_data( ). 85 | ENDMETHOD. 86 | 87 | METHOD print_data. 88 | DATA: lo_print TYPE REF TO print_simple. 89 | CREATE OBJECT lo_print. 90 | lo_print->write_data( ). 91 | ENDMETHOD. 92 | ENDCLASS. 93 | 94 | CLASS complex_report DEFINITION INHERITING FROM REPORT. 95 | PUBLIC SECTION. 96 | METHODS: get_data REDEFINITION. 97 | METHODS: print_data REDEFINITION. 98 | ENDCLASS. 99 | 100 | CLASS complex_report IMPLEMENTATION. 101 | METHOD get_data. 102 | DATA: lo_data TYPE REF TO data_from_db. 103 | CREATE OBJECT lo_data. 104 | lo_data->read_data( ). 105 | ENDMETHOD. 106 | 107 | METHOD print_data. 108 | DATA: lo_print TYPE REF TO print_alv. 109 | CREATE OBJECT lo_print. 110 | lo_print->write_data( ). 111 | ENDMETHOD. 112 | ENDCLASS. 113 | 114 | CLASS lcl_main_app DEFINITION. 115 | PUBLIC SECTION. 116 | CLASS-METHODS: RUN. 117 | ENDCLASS. 118 | 119 | CLASS lcl_main_app IMPLEMENTATION. 120 | METHOD RUN. 121 | DATA: lo_report TYPE REF TO REPORT. 122 | CREATE OBJECT lo_report TYPE simple_report. 123 | lo_report->get_data( ). 124 | lo_report->print_data( ). 125 | 126 | CREATE OBJECT lo_report TYPE complex_report. 127 | lo_report->get_data( ). 128 | lo_report->print_data( ). 129 | ENDMETHOD. 130 | ENDCLASS. 131 | 132 | START-OF-SELECTION. 133 | lcl_main_app=>run( ). -------------------------------------------------------------------------------- /zdp_factorymethod2.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_FACTORYMETHOD2 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_factorymethod2 NO STANDARD PAGE HEADING LINE-SIZE 80. 9 | 10 | CLASS cl_abap_typedescr DEFINITION LOAD. 11 | 12 | DATA: moff TYPE i 13 | , slen TYPE i 14 | , mlen TYPE i. 15 | 16 | DEFINE get_clazz_name. 17 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 18 | find REGEX 'CLASS=' in &2 MATCH OFFSET moff MATCH LENGTH mlen. 19 | slen = moff + mlen. 20 | SHIFT &2 by slen PLACES LEFT. 21 | END-OF-DEFINITION. 22 | 23 | INTERFACE product. 24 | TYPES ty_productname(30) TYPE c. 25 | DATA: name TYPE ty_productname. 26 | 27 | METHODS: 28 | get_name RETURNING VALUE(name) TYPE ty_productname. 29 | ENDINTERFACE. 30 | 31 | CLASS concrete_producta DEFINITION. 32 | PUBLIC SECTION. 33 | INTERFACES: 34 | product. 35 | ENDCLASS. 36 | 37 | CLASS concrete_producta IMPLEMENTATION. 38 | METHOD product~get_name. 39 | name = 'ConcreteProductA'. 40 | ENDMETHOD. 41 | ENDCLASS. 42 | 43 | CLASS concrete_productb DEFINITION. 44 | PUBLIC SECTION. 45 | INTERFACES: 46 | product. 47 | ENDCLASS. 48 | 49 | CLASS concrete_productb IMPLEMENTATION. 50 | METHOD product~get_name. 51 | name = 'ConCreteProductB'. 52 | ENDMETHOD. 53 | ENDCLASS. 54 | 55 | INTERFACE creator. 56 | METHODS: 57 | factorymethod RETURNING VALUE(product) TYPE REF TO product. 58 | ENDINTERFACE. 59 | 60 | CLASS concrete_creatora DEFINITION. 61 | PUBLIC SECTION. 62 | INTERFACES: 63 | creator. 64 | ENDCLASS. 65 | 66 | CLASS concrete_creatora IMPLEMENTATION. 67 | METHOD creator~factorymethod. 68 | CREATE OBJECT product TYPE concrete_producta. 69 | ENDMETHOD. 70 | ENDCLASS. 71 | 72 | CLASS concrete_creatorb DEFINITION. 73 | PUBLIC SECTION. 74 | INTERFACES: 75 | creator. 76 | ENDCLASS. 77 | 78 | CLASS concrete_creatorb IMPLEMENTATION. 79 | METHOD creator~factorymethod. 80 | CREATE OBJECT product TYPE concrete_productb. 81 | ENDMETHOD. 82 | ENDCLASS. 83 | 84 | CLASS main_app DEFINITION. 85 | PUBLIC SECTION. 86 | CLASS-DATA: oa_creator_coll TYPE TABLE OF REF TO creator. 87 | CLASS-METHODS: main. 88 | ENDCLASS. 89 | 90 | CLASS main_app IMPLEMENTATION. 91 | METHOD main. 92 | 93 | DATA: concrete_creatora TYPE REF TO concrete_creatora 94 | , concrete_creatorb TYPE REF TO concrete_creatorb 95 | , product TYPE REF TO product 96 | , product_name(30) TYPE c 97 | , class_name TYPE abap_abstypename. 98 | 99 | FIELD-SYMBOLS TYPE REF TO creator. 100 | 101 | CREATE OBJECT concrete_creatora. 102 | APPEND concrete_creatora TO oa_creator_coll. 103 | 104 | CREATE OBJECT concrete_creatorb. 105 | APPEND concrete_creatorb TO oa_creator_coll. 106 | 107 | LOOP AT oa_creator_coll ASSIGNING . 108 | get_clazz_name class_name. 109 | CASE class_name. 110 | WHEN 'CONCRETE_CREATORA'. 111 | WRITE: / 'ConcreteCreatorA Creates Product A'. 112 | WHEN 'CONCRETE_CREATORB'. 113 | WRITE: / 'ConcreteCreatorB Creates Product B'. 114 | ENDCASE. 115 | 116 | product = ->factorymethod( ). 117 | get_clazz_name product class_name. 118 | product_name = product->get_name( ). 119 | WRITE: / 'Class=', class_name, 'Product=', product_name. 120 | ENDLOOP. 121 | ENDMETHOD. 122 | ENDCLASS. 123 | 124 | START-OF-SELECTION. 125 | main_app=>main( ). -------------------------------------------------------------------------------- /zdp_mediator.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_MEDIATOR 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_mediator. 9 | CLASS united_nations DEFINITION DEFERRED. 10 | 11 | CLASS country DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: 14 | constructor IMPORTING io_mediator TYPE REF TO united_nations. 15 | PROTECTED SECTION. 16 | DATA: mo_mediator TYPE REF TO united_nations. 17 | ENDCLASS. 18 | 19 | CLASS country IMPLEMENTATION. 20 | METHOD constructor. 21 | me->mo_mediator = io_mediator. 22 | ENDMETHOD. 23 | ENDCLASS. 24 | 25 | CLASS united_nations DEFINITION ABSTRACT. 26 | PUBLIC SECTION. 27 | METHODS: 28 | declear ABSTRACT IMPORTING iv_message TYPE string 29 | io_colleague TYPE REF TO country. 30 | ENDCLASS. 31 | 32 | CLASS irag DEFINITION INHERITING FROM country. 33 | PUBLIC SECTION. 34 | METHODS: 35 | constructor IMPORTING io_mediator TYPE REF TO united_nations 36 | ,declear IMPORTING iv_message TYPE string 37 | ,get_message IMPORTING iv_message TYPE string 38 | . 39 | ENDCLASS. 40 | 41 | CLASS irag IMPLEMENTATION. 42 | METHOD constructor. 43 | super->constructor( io_mediator ). 44 | ENDMETHOD. 45 | 46 | METHOD declear. 47 | me->mo_mediator->declear( iv_message = iv_message io_colleague = 48 | me ). 49 | ENDMETHOD. 50 | 51 | METHOD get_message. 52 | WRITE: / '伊拉克获得对方信息: ', iv_message. 53 | ENDMETHOD. 54 | ENDCLASS. 55 | 56 | CLASS usa DEFINITION INHERITING FROM country. 57 | PUBLIC SECTION. 58 | METHODS: 59 | constructor IMPORTING io_mediator TYPE REF TO united_nations 60 | ,declear IMPORTING iv_message TYPE string 61 | ,get_message IMPORTING iv_message TYPE string 62 | . 63 | ENDCLASS. 64 | 65 | CLASS usa IMPLEMENTATION. 66 | METHOD constructor. 67 | super->constructor( io_mediator ). 68 | ENDMETHOD. 69 | 70 | METHOD declear. 71 | me->mo_mediator->declear( iv_message = iv_message io_colleague = me ). 72 | ENDMETHOD. 73 | 74 | METHOD get_message. 75 | WRITE: / '美国获得对方信息: ', iv_message. 76 | ENDMETHOD. 77 | ENDCLASS. 78 | 79 | CLASS united_nations_securitycouncil DEFINITION INHERITING FROM united_nations. 80 | 81 | 82 | PUBLIC SECTION. 83 | METHODS: 84 | set_colleague1 IMPORTING io_co1 TYPE REF TO usa, 85 | set_colleague2 IMPORTING io_co2 TYPE REF TO irag, 86 | declear REDEFINITION. 87 | PRIVATE SECTION. 88 | DATA: mo_co1 TYPE REF TO usa, 89 | mo_co2 TYPE REF TO irag. 90 | ENDCLASS. 91 | 92 | 93 | CLASS united_nations_securitycouncil IMPLEMENTATION. 94 | METHOD set_colleague1. 95 | me->mo_co1 = io_co1. 96 | ENDMETHOD. 97 | 98 | METHOD set_colleague2. 99 | me->mo_co2 = io_co2. 100 | ENDMETHOD. 101 | 102 | METHOD declear. 103 | IF io_colleague EQ mo_co1. 104 | mo_co2->get_message( iv_message ). 105 | ELSE. 106 | mo_co1->get_message( iv_message ). 107 | ENDIF. 108 | ENDMETHOD. 109 | ENDCLASS. 110 | 111 | CLASS mainapp DEFINITION. 112 | PUBLIC SECTION. 113 | CLASS-METHODS: 114 | main. 115 | ENDCLASS. 116 | 117 | CLASS mainapp IMPLEMENTATION. 118 | METHOD main. 119 | DATA: unsc TYPE REF TO united_nations_securitycouncil, 120 | c1 TYPE REF TO usa 121 | , c2 TYPE REF TO irag. 122 | CREATE OBJECT unsc. 123 | 124 | c1 = NEW usa( unsc ). 125 | c2 = NEW irag( unsc ). 126 | 127 | unsc->set_colleague2( c2 ). 128 | unsc->set_colleague1( c1 ). 129 | 130 | c1->declear( '不准研制核武器，否则就要发动战争' ). 131 | c2->declear( '我们没有核武器，也不怕侵略' ). 132 | ENDMETHOD. 133 | ENDCLASS. 134 | 135 | START-OF-SELECTION. 136 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_decorator.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_DECORATOR 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_decorator. 9 | 10 | 11 | CLASS output DEFINITION ABSTRACT. 12 | PUBLIC SECTION. 13 | METHODS: process_output ABSTRACT. 14 | ENDCLASS. 15 | 16 | CLASS alv_output DEFINITION INHERITING FROM output. 17 | PUBLIC SECTION. 18 | METHODS: process_output REDEFINITION. 19 | ENDCLASS. 20 | 21 | CLASS alv_output IMPLEMENTATION. 22 | METHOD process_output. 23 | WRITE: / 'Standard ALV output'. 24 | ENDMETHOD. 25 | ENDCLASS. 26 | 27 | CLASS op_decorator DEFINITION INHERITING FROM output. 28 | PUBLIC SECTION. 29 | METHODS: 30 | constructor IMPORTING io_decorator TYPE REF TO output, 31 | process_output REDEFINITION. 32 | PRIVATE SECTION. 33 | DATA: o_decorator TYPE REF TO output. 34 | ENDCLASS. 35 | 36 | 37 | CLASS op_decorator IMPLEMENTATION. 38 | METHOD constructor. 39 | super->constructor( ). 40 | me->o_decorator = io_decorator. 41 | ENDMETHOD. 42 | 43 | METHOD process_output. 44 | CHECK o_decorator IS BOUND. 45 | o_decorator->process_output( ). 46 | ENDMETHOD. 47 | ENDCLASS. 48 | 49 | CLASS op_pdf DEFINITION INHERITING FROM op_decorator. 50 | PUBLIC SECTION. 51 | METHODS: process_output REDEFINITION. 52 | ENDCLASS. 53 | 54 | CLASS op_pdf IMPLEMENTATION. 55 | METHOD process_output. 56 | super->process_output( ). 57 | WRITE: /(10) space, 'Generating PDF'. 58 | ENDMETHOD. 59 | ENDCLASS. 60 | 61 | CLASS op_xls DEFINITION INHERITING FROM op_decorator. 62 | PUBLIC SECTION. 63 | METHODS: process_output REDEFINITION. 64 | ENDCLASS. 65 | 66 | CLASS op_xls IMPLEMENTATION. 67 | METHOD process_output. 68 | super->process_output( ). 69 | WRITE: /(10) space, 'Generating Excel'. 70 | ENDMETHOD. 71 | ENDCLASS. 72 | 73 | CLASS op_email DEFINITION INHERITING FROM op_decorator. 74 | PUBLIC SECTION. 75 | METHODS: process_output REDEFINITION. 76 | ENDCLASS. 77 | 78 | CLASS op_email IMPLEMENTATION. 79 | METHOD process_output. 80 | super->process_output( ). 81 | WRITE: /(10) space, 'Sending Email'. 82 | ENDMETHOD. 83 | ENDCLASS. 84 | 85 | CLASS op_alv DEFINITION INHERITING FROM op_decorator. 86 | PUBLIC SECTION. 87 | METHODS: process_output REDEFINITION. 88 | ENDCLASS. 89 | 90 | 91 | CLASS op_alv IMPLEMENTATION. 92 | METHOD process_output. 93 | super->process_output( ). 94 | WRITE: /(10) space, 'Generating ALV'. 95 | ENDMETHOD. 96 | ENDCLASS. 97 | 98 | 99 | CLASS main_app DEFINITION. 100 | PUBLIC SECTION. 101 | CLASS-METHODS:run IMPORTING 102 | iv_pdf TYPE flag 103 | iv_email TYPE flag 104 | iv_xls TYPE flag. 105 | ENDCLASS. 106 | 107 | CLASS main_app IMPLEMENTATION. 108 | METHOD run. 109 | DATA: lo_decorator TYPE REF TO output, 110 | lo_pre TYPE REF TO output. 111 | 112 | CREATE OBJECT lo_decorator TYPE alv_output. 113 | lo_pre = lo_decorator. 114 | 115 | IF iv_pdf IS NOT INITIAL. 116 | CREATE OBJECT lo_decorator 117 | TYPE op_pdf 118 | EXPORTING 119 | io_decorator = lo_pre. 120 | lo_pre = lo_decorator. 121 | ENDIF. 122 | 123 | IF iv_email IS NOT INITIAL. 124 | CREATE OBJECT lo_decorator 125 | TYPE op_email 126 | EXPORTING 127 | io_decorator = lo_pre. 128 | lo_pre = lo_decorator. 129 | ENDIF. 130 | 131 | IF iv_xls IS NOT INITIAL. 132 | CREATE OBJECT lo_decorator 133 | TYPE op_xls 134 | EXPORTING 135 | io_decorator = lo_pre. 136 | lo_pre = lo_decorator. 137 | ENDIF. 138 | 139 | lo_decorator->process_output( ). 140 | ENDMETHOD. 141 | ENDCLASS. 142 | 143 | PARAMETERS: p_pdf AS CHECKBOX, 144 | p_email AS CHECKBOX, 145 | p_xls AS CHECKBOX. 146 | 147 | START-OF-SELECTION. 148 | main_app=>run( 149 | iv_pdf = p_pdf 150 | iv_email = p_email 151 | iv_xls = p_xls 152 | ). -------------------------------------------------------------------------------- /zdp_composite.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_COMPOSITE 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_composite. 9 | 10 | CLASS lcl_shape DEFINITION ABSTRACT. 11 | PUBLIC SECTION. 12 | METHODS: constructor IMPORTING iv_name TYPE string, 13 | add ABSTRACT IMPORTING io_shape TYPE REF TO lcl_shape, 14 | remove ABSTRACT IMPORTING io_shape TYPE REF TO lcl_shape, 15 | display ABSTRACT IMPORTING indent TYPE i. 16 | PROTECTED SECTION. 17 | DATA: v_name TYPE string. 18 | ENDCLASS. 19 | 20 | CLASS lcl_shape IMPLEMENTATION. 21 | METHOD constructor. 22 | me->v_name = iv_name. 23 | ENDMETHOD. 24 | ENDCLASS. 25 | 26 | CLASS lcl_line DEFINITION INHERITING FROM lcl_shape. 27 | PUBLIC SECTION. 28 | METHODS: constructor IMPORTING iv_name TYPE string. 29 | METHODS: add REDEFINITION, 30 | remove REDEFINITION, 31 | display REDEFINITION. 32 | ENDCLASS. 33 | 34 | CLASS lcl_line IMPLEMENTATION. 35 | METHOD constructor. 36 | super->constructor( iv_name ). 37 | ENDMETHOD. 38 | 39 | METHOD add. 40 | WRITE: / 'Can not add'. 41 | ENDMETHOD. 42 | 43 | METHOD remove. 44 | WRITE: / 'Can not delete'. 45 | ENDMETHOD. 46 | 47 | METHOD display. 48 | WRITE: / ''. 49 | DO indent TIMES. 50 | WRITE: '-'. 51 | ENDDO. 52 | 53 | WRITE: v_name. 54 | ENDMETHOD. 55 | ENDCLASS. 56 | 57 | CLASS lcl_picture DEFINITION INHERITING FROM lcl_shape. 58 | PUBLIC SECTION. 59 | METHODS: constructor IMPORTING iv_name TYPE string. 60 | METHODS: add REDEFINITION, 61 | remove REDEFINITION, 62 | display REDEFINITION. 63 | 64 | PRIVATE SECTION. 65 | TYPES: BEGIN OF lty_shapes, 66 | o_shape TYPE REF TO lcl_shape, 67 | END OF lty_shapes. 68 | DATA: li_shapes TYPE STANDARD TABLE OF REF TO lcl_shape. 69 | ENDCLASS. 70 | 71 | CLASS lcl_picture IMPLEMENTATION. 72 | METHOD constructor. 73 | super->constructor( iv_name ). 74 | ENDMETHOD. 75 | 76 | METHOD add. 77 | APPEND io_shape TO li_shapes. 78 | ENDMETHOD. 79 | 80 | METHOD remove. 81 | DELETE li_shapes WHERE table_line EQ io_shape. 82 | ENDMETHOD. 83 | 84 | METHOD display. 85 | DATA: lo_shape TYPE REF TO lcl_shape. 86 | WRITE: / ''. 87 | DO indent TIMES. 88 | WRITE: (2) '-'. 89 | ENDDO. 90 | WRITE: v_name. 91 | DATA: lv_indent TYPE i. 92 | lv_indent = indent + 1. 93 | LOOP AT li_shapes INTO lo_shape. 94 | lo_shape->display( lv_indent ). 95 | ENDLOOP. 96 | ENDMETHOD. 97 | ENDCLASS. 98 | 99 | CLASS lcl_main DEFINITION. 100 | PUBLIC SECTION. 101 | CLASS-METHODS: run. 102 | ENDCLASS. 103 | * 104 | CLASS lcl_main IMPLEMENTATION. 105 | METHOD run. 106 | 107 | DATA: lo_pic TYPE REF TO lcl_shape. 108 | DATA: lo_shape TYPE REF TO lcl_shape. 109 | 110 | CREATE OBJECT lo_pic TYPE lcl_picture EXPORTING iv_name = 'Picture'. 111 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Left Line'. 112 | lo_pic->add( lo_shape ). 113 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Top Line'. 114 | lo_pic->add( lo_shape ). 115 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Right Line'. 116 | lo_pic->add( lo_shape ). 117 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Bottom Line'. 118 | lo_pic->add( lo_shape ). 119 | 120 | DATA: lo_pic2 TYPE REF TO lcl_shape. 121 | CREATE OBJECT lo_pic2 TYPE lcl_picture EXPORTING iv_name = 'Picture 2'. 122 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Left Line'. 123 | lo_pic2->add( lo_shape ). 124 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Top Line'. 125 | lo_pic2->add( lo_shape ). 126 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Right Line'. 127 | lo_pic2->add( lo_shape ). 128 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'Bottom Line'. 129 | lo_pic2->add( lo_shape ). 130 | lo_pic->add( lo_pic2 ). 131 | 132 | CREATE OBJECT lo_shape TYPE lcl_line EXPORTING iv_name = 'text'. 133 | lo_pic->add( lo_shape ). 134 | 135 | * Uniform way to access the composition - it could be a primitive object 136 | * or composition itself. 137 | lo_pic->display( 4 ). 138 | 139 | ENDMETHOD. 140 | ENDCLASS. 141 | * 142 | START-OF-SELECTION. 143 | lcl_main=>run( ). -------------------------------------------------------------------------------- /zdp_chainofresp.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_CHAINOFRESP 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_chainofresp. 9 | 10 | 11 | CLASS cl_abap_typedescr DEFINITION LOAD. 12 | 13 | DATA: moff TYPE I 14 | , slen TYPE I 15 | , mlen TYPE I. 16 | 17 | DEFINE get_clazz_name. 18 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 19 | FIND REGEX 'CLASS=' IN &2 MATCH OFFSET moff match LENGTH mlen. 20 | slen = moff + mlen. 21 | SHIFT &2 BY slen PLACES LEFT. 22 | END-OF-DEFINITION. 23 | 24 | CLASS HANDLER DEFINITION ABSTRACT. 25 | PUBLIC SECTION. 26 | METHODS: 27 | set_successor IMPORTING io_successor TYPE REF TO HANDLER 28 | , handle_request ABSTRACT IMPORTING iv_request TYPE I. 29 | 30 | PROTECTED SECTION. 31 | DATA: 32 | successor TYPE REF TO HANDLER. 33 | ENDCLASS. 34 | 35 | CLASS HANDLER IMPLEMENTATION. 36 | METHOD set_successor. 37 | me->successor = io_successor. 38 | ENDMETHOD. 39 | ENDCLASS. 40 | 41 | CLASS concrete_handler1 DEFINITION INHERITING FROM HANDLER. 42 | PUBLIC SECTION. 43 | METHODS: 44 | handle_request REDEFINITION. 45 | ENDCLASS. 46 | 47 | CLASS concrete_handler1 IMPLEMENTATION. 48 | METHOD handle_request. 49 | DATA: class_name TYPE abap_abstypename. 50 | get_clazz_name me class_name. 51 | 52 | IF ( iv_request >= 0 AND iv_request < 10 ). 53 | WRITE: / class_name, 'Handled request', iv_request. 54 | ELSEIF ( NOT successor IS INITIAL ). 55 | me->successor->handle_request( iv_request ). 56 | ENDIF. 57 | ENDMETHOD. 58 | ENDCLASS. 59 | 60 | CLASS concrete_handler2 DEFINITION INHERITING FROM HANDLER. 61 | PUBLIC SECTION. 62 | METHODS: 63 | handle_request REDEFINITION. 64 | ENDCLASS. 65 | 66 | CLASS concrete_handler2 IMPLEMENTATION. 67 | METHOD handle_request. 68 | DATA: class_name TYPE abap_abstypename. 69 | get_clazz_name me class_name. 70 | 71 | IF ( iv_request >= 10 AND iv_request < 20 ). 72 | WRITE: / class_name, 'Handled request', iv_request. 73 | ELSEIF ( NOT successor IS INITIAL ). 74 | me->successor->handle_request( iv_request ). 75 | ENDIF. 76 | ENDMETHOD. "handlerequest 77 | ENDCLASS. 78 | 79 | CLASS concrete_handler3 DEFINITION INHERITING FROM HANDLER. 80 | PUBLIC SECTION. 81 | METHODS: 82 | handle_request REDEFINITION. 83 | ENDCLASS. 84 | 85 | CLASS concrete_handler3 IMPLEMENTATION. 86 | METHOD handle_request. 87 | DATA: class_name TYPE abap_abstypename. 88 | get_clazz_name me class_name. 89 | 90 | IF ( iv_request >= 20 AND iv_request < 30 ). 91 | WRITE: / class_name, 'Handled request', iv_request. 92 | ELSEIF ( NOT successor IS INITIAL ). 93 | me->successor->handle_request( iv_request ). 94 | ENDIF. 95 | ENDMETHOD. "handlerequest 96 | ENDCLASS. 97 | 98 | CLASS lcl_application DEFINITION CREATE PRIVATE. 99 | PUBLIC SECTION. 100 | CLASS-METHODS: RUN. 101 | METHODS: constructor. 102 | PRIVATE SECTION. 103 | CLASS-DATA: so_application TYPE REF TO lcl_application. 104 | ENDCLASS. 105 | 106 | CLASS lcl_application IMPLEMENTATION. 107 | 108 | *---------------------------------------------------------- 109 | * LCL_APPLICATION->RUN(). 110 | *---------------------------------------------------------- 111 | METHOD RUN. 112 | DATA: 113 | exc_ref TYPE REF TO cx_root 114 | ,exc_text TYPE string. 115 | 116 | IF lcl_application=>so_application IS INITIAL. 117 | TRY. 118 | CREATE OBJECT lcl_application=>so_application. 119 | CATCH cx_sy_create_object_error INTO exc_ref. 120 | exc_text = exc_ref->get_text( ). 121 | MESSAGE exc_text TYPE 'I'. 122 | ENDTRY. 123 | ENDIF. 124 | ENDMETHOD. 125 | 126 | METHOD constructor. 127 | DATA: 128 | h1 TYPE REF TO concrete_handler1 129 | ,h2 TYPE REF TO concrete_handler2 130 | ,h3 TYPE REF TO concrete_handler3 131 | ,t_request TYPE TABLE OF I 132 | ,request TYPE I 133 | . 134 | 135 | * create objects 136 | CREATE OBJECT h1. 137 | CREATE OBJECT h2. 138 | CREATE OBJECT h3. 139 | 140 | h1->set_successor( h2 ). 141 | h2->set_successor( h3 ). 142 | 143 | INSERT 2 INTO TABLE t_request. 144 | INSERT 5 INTO TABLE t_request. 145 | INSERT 14 INTO TABLE t_request. 146 | INSERT 22 INTO TABLE t_request. 147 | INSERT 18 INTO TABLE t_request. 148 | INSERT 3 INTO TABLE t_request. 149 | INSERT 27 INTO TABLE t_request. 150 | INSERT 20 INTO TABLE t_request. 151 | 152 | LOOP AT t_request INTO request. 153 | h1->handle_request( request ). 154 | ENDLOOP. 155 | 156 | ENDMETHOD. "constructor 157 | 158 | ENDCLASS. 159 | 160 | START-OF-SELECTION. 161 | lcl_application=>run( ). -------------------------------------------------------------------------------- /zdp_state2.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_STATE2 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_state2. 9 | CLASS account DEFINITION DEFERRED. 10 | CLASS silverstate DEFINITION DEFERRED. 11 | 12 | CLASS state DEFINITION ABSTRACT. 13 | PUBLIC SECTION. 14 | METHODS: 15 | deposit ABSTRACT IMPORTING iv_amount TYPE d 16 | , withdraw ABSTRACT EXPORTING ev_amount TYPE d 17 | , payinterest ABSTRACT 18 | , get_account ABSTRACT RETURNING VALUE(ro_account) TYPE REF TO account 19 | , get_balance ABSTRACT RETURNING VALUE(rv_account) TYPE d 20 | , get_interest ABSTRACT RETURNING VALUE(rv_interest) TYPE d 21 | , get_lowerlimit ABSTRACT RETURNING VALUE(rv_lowerlimit) TYPE d 22 | , get_upperlimit ABSTRACT RETURNING VALUE(rv_upperlimit) TYPE d. 23 | PROTECTED SECTION. 24 | DATA: mo_account TYPE REF TO account 25 | , mv_balance TYPE d 26 | , mv_interest TYPE d 27 | , mv_lowerlimit TYPE d 28 | , mv_upperlimit TYPE d. 29 | ENDCLASS. 30 | 31 | CLASS account DEFINITION. 32 | PUBLIC SECTION. 33 | METHODS: 34 | get_account RETURNING VALUE(rv_account) TYPE string 35 | , set_account IMPORTING iv_account TYPE string 36 | , get_state RETURNING VALUE(ro_state) TYPE REF TO state 37 | , set_state IMPORTING io_state TYPE REF TO state. 38 | 39 | PRIVATE SECTION. 40 | DATA: mv_account TYPE string, 41 | mo_state TYPE REF TO state. 42 | ENDCLASS. 43 | 44 | CLASS account IMPLEMENTATION. 45 | METHOD get_state. 46 | ro_state = me->mo_state. 47 | ENDMETHOD. 48 | 49 | METHOD set_state. 50 | me->mo_state = io_state. 51 | ENDMETHOD. 52 | METHOD get_account. 53 | rv_account = me->mv_account. 54 | ENDMETHOD. 55 | 56 | METHOD set_account. 57 | me->mv_account = iv_account. 58 | ENDMETHOD. 59 | ENDCLASS. 60 | 61 | CLASS balance DEFINITION. 62 | PUBLIC SECTION. 63 | METHODS: 64 | get_balance RETURNING VALUE(rv_balance) TYPE d 65 | , set_balance IMPORTING iv_balance TYPE d. 66 | 67 | PRIVATE SECTION. 68 | DATA: mv_balance TYPE d. 69 | ENDCLASS. 70 | 71 | CLASS balance IMPLEMENTATION. 72 | METHOD get_balance. 73 | rv_balance = me->mv_balance. 74 | ENDMETHOD. 75 | 76 | METHOD set_balance. 77 | me->mv_balance = iv_balance. 78 | ENDMETHOD. 79 | ENDCLASS. 80 | 81 | CLASS redstate DEFINITION INHERITING FROM state. 82 | PUBLIC SECTION. 83 | METHODS: constructor IMPORTING io_state TYPE REF TO state, 84 | initialize, 85 | deposit REDEFINITION, 86 | withdraw REDEFINITION, 87 | payinterest REDEFINITION, 88 | get_account REDEFINITION, 89 | get_balance REDEFINITION, 90 | get_interest REDEFINITION, 91 | get_lowerlimit REDEFINITION, 92 | get_upperlimit REDEFINITION. 93 | 94 | PRIVATE SECTION. 95 | METHODS: statechangecheck. 96 | DATA: mv_servicefee. 97 | ENDCLASS. 98 | 99 | CLASS redstate IMPLEMENTATION. 100 | METHOD constructor. 101 | super->constructor( ). 102 | me->mv_balance = io_state->mv_balance. 103 | me->mo_account = NEW account( ). 104 | me->initialize( ). 105 | ENDMETHOD. 106 | 107 | METHOD initialize. 108 | me->mv_interest = 0. 109 | me->mv_lowerlimit = -100. 110 | me->mv_upperlimit = 0. 111 | me->mv_servicefee = 15. 112 | ENDMETHOD. 113 | 114 | METHOD deposit. 115 | me->mv_balance = me->mv_balance + iv_amount. 116 | me->statechangecheck( ). 117 | ENDMETHOD. 118 | 119 | METHOD withdraw. 120 | ev_amount = ev_amount - me->mv_servicefee. 121 | WRITE: / 'No funds available for withdrawal!'. 122 | ENDMETHOD. 123 | 124 | METHOD payinterest. 125 | ENDMETHOD. 126 | 127 | METHOD statechangecheck. 128 | IF mv_balance > mv_upperlimit. 129 | DATA: m_silverstate TYPE REF TO silverstate. 130 | CREATE OBJECT m_silverstate. 131 | mv_account->set_state( io_state = m_silverstate). 132 | ENDIF. 133 | ENDMETHOD. 134 | 135 | METHOD get_balance. 136 | rv_balance = me->mv_balance. 137 | ENDMETHOD. 138 | 139 | METHOD get_interest. 140 | rv_interest = me->mv_interest. 141 | ENDMETHOD. 142 | 143 | METHOD get_account. 144 | ro_account = me->mo_account. 145 | ENDMETHOD. 146 | 147 | METHOD get_lowerlimit. 148 | rv_lowerlimit = me->mv_lowerlimit. 149 | ENDMETHOD. 150 | 151 | METHOD get_upperlimit. 152 | rv_upperlimit = me->mv_upperlimit. 153 | ENDMETHOD. 154 | ENDCLASS. 155 | 156 | CLASS silverstate DEFINITION INHERITING FROM state. 157 | PUBLIC SECTION. 158 | METHODS: 159 | constructor IMPORTING io_state TYPE REF TO state OPTIONAL 160 | iv_balance TYPE d OPTIONAL 161 | io_account TYPE REF TO account OPTIONAL. 162 | ENDCLASS. 163 | 164 | CLASS silverstate IMPLEMENTATION. 165 | IF io_state IS INITIAL. 166 | me->mv_balance = io_state->get_balance( ). 167 | me->mo_account = io_state->get_account( ). 168 | ELSE. 169 | me->mv_balance = iv_balance. 170 | me->mo_account = io_account. 171 | ENDIF. 172 | ENDCLASS. -------------------------------------------------------------------------------- /zdp_factorymethod3.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_FACTORYMETHOD3 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_factorymethod3 NO STANDARD PAGE HEADING LINE-SIZE 80. 9 | 10 | CLASS cl_abap_typedescr DEFINITION LOAD. 11 | 12 | DATA: moff TYPE i 13 | , slen TYPE i 14 | , mlen TYPE i. 15 | 16 | DEFINE get_clazz_name. 17 | &2 = cl_abap_classdescr=>get_class_name( &1 ). 18 | find REGEX 'CLASS=' in &2 MATCH OFFSET moff MATCH LENGTH mlen. 19 | slen = moff + mlen. 20 | SHIFT &2 by slen PLACES LEFT. 21 | END-OF-DEFINITION. 22 | 23 | CLASS page DEFINITION ABSTRACT. 24 | ENDCLASS. 25 | 26 | CLASS skillspage DEFINITION INHERITING FROM page. 27 | ENDCLASS. 28 | 29 | CLASS educationpage DEFINITION INHERITING FROM page. 30 | ENDCLASS. 31 | 32 | CLASS experiencepage DEFINITION INHERITING FROM page. 33 | ENDCLASS. 34 | 35 | CLASS introductionpage DEFINITION INHERITING FROM page. 36 | ENDCLASS. 37 | 38 | CLASS resultspage DEFINITION INHERITING FROM page. 39 | ENDCLASS. 40 | 41 | CLASS conclusionpage DEFINITION INHERITING FROM page. 42 | ENDCLASS. 43 | 44 | CLASS summarypage DEFINITION INHERITING FROM page. 45 | ENDCLASS. 46 | 47 | CLASS bibliographypage DEFINITION INHERITING FROM page. 48 | ENDCLASS. 49 | 50 | CLASS document DEFINITION ABSTRACT. 51 | PUBLIC SECTION. 52 | METHODS: 53 | createpages ABSTRACT 54 | , pages EXPORTING pages TYPE ANY TABLE. 55 | 56 | PROTECTED SECTION. 57 | DATA: 58 | oa_pages_coll TYPE TABLE OF REF TO page. 59 | ENDCLASS. 60 | 61 | CLASS document IMPLEMENTATION. 62 | METHOD pages. 63 | pages[] = oa_pages_coll[]. 64 | ENDMETHOD. 65 | ENDCLASS. 66 | 67 | CLASS resume DEFINITION INHERITING FROM document. 68 | PUBLIC SECTION. 69 | METHODS: 70 | constructor 71 | , createpages REDEFINITION. 72 | ENDCLASS. 73 | 74 | CLASS resume IMPLEMENTATION. 75 | METHOD constructor. 76 | super->constructor( ). 77 | CALL METHOD me->createpages. 78 | ENDMETHOD. 79 | 80 | METHOD createpages. 81 | DATA: page TYPE REF TO page. 82 | CREATE OBJECT page TYPE skillspage. 83 | APPEND page TO oa_pages_coll. 84 | 85 | CREATE OBJECT page TYPE educationpage. 86 | APPEND page TO oa_pages_coll. 87 | 88 | CREATE OBJECT page TYPE experiencepage. 89 | APPEND page TO oa_pages_coll. 90 | ENDMETHOD. 91 | ENDCLASS. 92 | 93 | CLASS report DEFINITION INHERITING FROM document. 94 | PUBLIC SECTION. 95 | METHODS: 96 | constructor 97 | , createpages REDEFINITION. 98 | ENDCLASS. 99 | 100 | CLASS report IMPLEMENTATION. 101 | METHOD constructor. 102 | super->constructor( ). 103 | CALL METHOD me->createpages. 104 | ENDMETHOD. 105 | 106 | METHOD createpages. 107 | DATA: page TYPE REF TO page. 108 | CREATE OBJECT page TYPE introductionpage. 109 | APPEND page TO oa_pages_coll. 110 | 111 | CREATE OBJECT page TYPE resultspage. 112 | APPEND page TO oa_pages_coll. 113 | 114 | CREATE OBJECT page TYPE conclusionpage. 115 | APPEND page TO oa_pages_coll. 116 | 117 | CREATE OBJECT page TYPE summarypage. 118 | APPEND page TO oa_pages_coll. 119 | 120 | CREATE OBJECT page TYPE bibliographypage. 121 | APPEND page TO oa_pages_coll. 122 | ENDMETHOD. 123 | ENDCLASS. 124 | 125 | CLASS mainapp DEFINITION. 126 | PUBLIC SECTION. 127 | CLASS-DATA: oa_document_coll TYPE TABLE OF REF TO document. 128 | CLASS-METHODS main. 129 | ENDCLASS. 130 | 131 | CLASS mainapp IMPLEMENTATION. 132 | METHOD main. 133 | DATA: document TYPE REF TO document 134 | ,resume TYPE REF TO resume 135 | ,report TYPE REF TO report 136 | ,page TYPE REF TO page 137 | ,class_name TYPE abap_abstypename 138 | ,pages_coll TYPE TABLE OF REF TO page. 139 | . 140 | FIELD-SYMBOLS: TYPE REF TO document 141 | , TYPE REF TO page. 142 | 143 | CREATE OBJECT resume. 144 | APPEND resume TO oa_document_coll. 145 | 146 | CREATE OBJECT report. 147 | APPEND report TO oa_document_coll. 148 | 149 | * Loop at all documents 150 | LOOP AT oa_document_coll ASSIGNING . 151 | * Call macro to find out which Creator and Product are active 152 | get_clazz_name class_name. 153 | CASE class_name. 154 | WHEN 'RESUME'. 155 | WRITE: / 'Resume contains following pages:', / sy-uline. 156 | CALL METHOD ->pages( IMPORTING pages = pages_coll ). 157 | * Loop at all pages in document Resume 158 | LOOP AT pages_coll ASSIGNING . 159 | get_clazz_name class_name. 160 | WRITE: / class_name. 161 | ENDLOOP. 162 | WHEN 'REPORT'. 163 | WRITE: / 'Report contains following pages:', / sy-uline. 164 | CALL METHOD ->pages( IMPORTING pages = pages_coll ). 165 | * Loop at all pages in document Resume 166 | LOOP AT pages_coll ASSIGNING . 167 | get_clazz_name class_name. 168 | WRITE: / class_name. 169 | ENDLOOP. 170 | ENDCASE. 171 | ENDLOOP. 172 | 173 | ENDMETHOD. "main 174 | ENDCLASS. "mainapp IMPLEMENTATION 175 | 176 | START-OF-SELECTION. 177 | mainapp=>main( ). -------------------------------------------------------------------------------- /zdp_iterator.abap: -------------------------------------------------------------------------------- 1 | *&---------------------------------------------------------------------* 2 | *& Report ZDP_ITERATOR 3 | *& 4 | *&---------------------------------------------------------------------* 5 | *& 6 | *& 7 | *&---------------------------------------------------------------------* 8 | REPORT zdp_iterator. 9 | 10 | 11 | CLASS lcl_item DEFINITION. 12 | PUBLIC SECTION. 13 | METHODS: constructor IMPORTING iv_name TYPE string. 14 | DATA: v_name TYPE string READ-ONLY. 15 | ENDCLASS. 16 | 17 | CLASS lcl_item IMPLEMENTATION. 18 | METHOD constructor. 19 | v_name = iv_name. 20 | ENDMETHOD. 21 | ENDCLASS. 22 | 23 | INTERFACE if_collection DEFERRED. 24 | 25 | INTERFACE if_iterator. 26 | METHODS: get_index RETURNING VALUE(index) TYPE i, 27 | has_next RETURNING VALUE(has_next) TYPE flag, 28 | get_next RETURNING VALUE(object) TYPE REF TO object, 29 | first RETURNING VALUE(object) TYPE REF TO object, 30 | set_step IMPORTING VALUE(iv_step) TYPE i. 31 | DATA: v_step TYPE i. 32 | DATA: v_current TYPE i. 33 | DATA: o_collection TYPE REF TO if_collection. 34 | ENDINTERFACE. 35 | 36 | INTERFACE if_collection. 37 | METHODS: get_iterator RETURNING VALUE(iterator) TYPE REF TO if_iterator. 38 | METHODS: add IMPORTING element TYPE REF TO object, 39 | remove IMPORTING element TYPE REF TO object, 40 | clear, 41 | size RETURNING VALUE(size) TYPE i, 42 | is_empty RETURNING VALUE(empty) TYPE flag, 43 | get IMPORTING index TYPE i 44 | RETURNING VALUE(object) TYPE REF TO object. 45 | ENDINTERFACE. 46 | 47 | CLASS lcl_iterator DEFINITION. 48 | PUBLIC SECTION. 49 | INTERFACES: if_iterator. 50 | METHODS: constructor IMPORTING io_collection TYPE REF TO if_collection. 51 | ALIASES: get_index FOR if_iterator~get_index, 52 | has_next FOR if_iterator~has_next, 53 | get_next FOR if_iterator~get_next, 54 | first FOR if_iterator~first, 55 | set_step FOR if_iterator~set_step. 56 | 57 | PRIVATE SECTION. 58 | ALIASES: v_step FOR if_iterator~v_step, 59 | v_current FOR if_iterator~v_current, 60 | o_collection FOR if_iterator~o_collection. 61 | ENDCLASS. 62 | 63 | CLASS lcl_collection DEFINITION. 64 | PUBLIC SECTION. 65 | INTERFACES: if_collection. 66 | DATA: i_items TYPE STANDARD TABLE OF REF TO object. 67 | ALIASES: get_iterator FOR if_collection~get_iterator, 68 | add FOR if_collection~add, 69 | remove FOR if_collection~clear, 70 | clear FOR if_collection~size, 71 | size FOR if_collection~is_empty, 72 | get FOR if_collection~get. 73 | ENDCLASS. 74 | 75 | CLASS lcl_collection IMPLEMENTATION. 76 | METHOD if_collection~get_iterator. 77 | CREATE OBJECT iterator 78 | TYPE lcl_iterator 79 | EXPORTING 80 | io_collection = me. 81 | ENDMETHOD. 82 | 83 | METHOD if_collection~add. 84 | APPEND element TO i_items. 85 | ENDMETHOD. 86 | 87 | METHOD if_collection~remove. 88 | DELETE i_items WHERE table_line EQ element. 89 | ENDMETHOD. 90 | 91 | METHOD if_collection~clear. 92 | CLEAR: i_items. 93 | ENDMETHOD. 94 | 95 | METHOD if_collection~size. 96 | size = lines( i_items ). 97 | ENDMETHOD. 98 | 99 | METHOD if_collection~is_empty. 100 | IF me->size( ) IS INITIAL. 101 | empty = 'X'. 102 | ENDIF. 103 | ENDMETHOD. 104 | 105 | METHOD if_collection~get. 106 | READ TABLE i_items INTO object INDEX index. 107 | ENDMETHOD. 108 | ENDCLASS. 109 | 110 | CLASS lcl_iterator IMPLEMENTATION. 111 | METHOD constructor. 112 | o_collection = io_collection. 113 | v_step = 1. 114 | ENDMETHOD. 115 | 116 | METHOD if_iterator~first. 117 | v_current = 1. 118 | object = o_collection->get( v_current ). 119 | ENDMETHOD. 120 | 121 | METHOD if_iterator~get_next. 122 | v_current = v_current + v_step. 123 | object = o_collection->get( v_current ). 124 | ENDMETHOD. 125 | 126 | METHOD if_iterator~has_next. 127 | DATA obj TYPE REF TO object. 128 | DATA idx TYPE i. 129 | idx = v_current + v_step. 130 | obj = o_collection->get( idx ). 131 | IF obj IS BOUND. 132 | has_next = 'X'. 133 | ENDIF. 134 | ENDMETHOD. 135 | 136 | METHOD if_iterator~set_step. 137 | me->v_step = iv_step. 138 | ENDMETHOD. 139 | 140 | METHOD if_iterator~get_index. 141 | index = index. 142 | ENDMETHOD. 143 | ENDCLASS. 144 | 145 | CLASS lcl_main DEFINITION. 146 | PUBLIC SECTION. 147 | CLASS-METHODS:run. 148 | ENDCLASS. 149 | 150 | CLASS lcl_main IMPLEMENTATION. 151 | METHOD run. 152 | DATA: o_collection TYPE REF TO if_collection. 153 | DATA: o_iterator TYPE REF TO if_iterator. 154 | DATA: lo_item TYPE REF TO lcl_item. 155 | 156 | CREATE OBJECT o_collection TYPE lcl_collection. 157 | o_iterator = o_collection->get_iterator( ). 158 | 159 | CREATE OBJECT lo_item 160 | EXPORTING 161 | iv_name = 'Item1'. 162 | o_collection->add( lo_item ). 163 | 164 | CREATE OBJECT lo_item 165 | EXPORTING 166 | iv_name = 'Item2'. 167 | o_collection->add( lo_item ). 168 | 169 | CREATE OBJECT lo_item 170 | EXPORTING 171 | iv_name = 'Item3'. 172 | o_collection->add( lo_item ). 173 | 174 | CREATE OBJECT lo_item 175 | EXPORTING 176 | iv_name = 'Item4'. 177 | o_collection->add( lo_item ). 178 | 179 | CREATE OBJECT lo_item 180 | EXPORTING 181 | iv_name = 'Item5'. 182 | o_collection->add( lo_item ). 183 | 184 | WHILE o_iterator->has_next( ) IS NOT INITIAL. 185 | lo_item ?= o_iterator->get_next( ). 186 | WRITE: / lo_item->v_name. 187 | ENDWHILE. 188 | ENDMETHOD. 189 | ENDCLASS. 190 | 191 | START-OF-SELECTION. 192 | lcl_main=>run( ). --------------------------------------------------------------------------------