[ABAP] Enumerator definieren

Variante 1 (einfaches Beispiel, mit impliziter Aufzählungskonstante 0..n)

TYPES:
  BEGIN OF ENUM e_drive_mode,
    forward,
    backward,
  END OF ENUM e_drive_mode.

DATA: lv_drivemode TYPE e_drive_mode.
lv_drivemode = forward.

DATA(lv_num) = CONV i( lv_drivemode ).

* FORWARD, 0
WRITE: / lv_drivemode, lv_num.

Variante 2 (explizite Aufzählungskonstante mit BASE TYPE)

TYPES:
  BEGIN OF ENUM e_drive_mode BASE TYPE symsgty,
    unknown  VALUE IS INITIAL,
    forward  VALUE 'F',
    backward VALUE 'B',
  END OF ENUM e_drive_mode.

DATA: lv_drivemode TYPE e_drive_mode.
lv_drivemode = forward.

DATA(lv_char) = CONV symsgty( lv_drivemode ).

* FORWARD, F
WRITE: / lv_drivemode, lv_char.

Variante 3 (Klassenbasiert, explizite Aufzählungskonstante mit BASE TYPE)

CLASS lcl_drive_mode DEFINITION FINAL.
  PUBLIC SECTION.
    TYPES: BEGIN OF ENUM e_drive_mode BASE TYPE symsgty,
             unknown  VALUE IS INITIAL,
             forward  VALUE 'F',
             backward VALUE 'B',
           END OF ENUM e_drive_mode.

    CLASS-METHODS:
      check_mode
        IMPORTING
                  i_drive_mode TYPE symsgty
        RETURNING VALUE(rv_ok) TYPE abap_bool.
ENDCLASS.

CLASS lcl_drive_mode IMPLEMENTATION.
  METHOD check_mode.
    rv_ok = abap_false.

    TRY.
* gibt es den übergebenen ENUM-Wert?
        DATA(lv_type) = CONV e_drive_mode( i_drive_mode ).
        rv_ok = abap_true.

      CATCH cx_root INTO DATA(e_txt).
    ENDTRY.

  ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
* F
  DATA(lv_fwd) = CONV symsgty( lcl_drive_mode=>forward ).
  WRITE: / lv_fwd.

* lcl_drive_mode=>forward
  DATA(lv_type) = CONV lcl_drive_mode=>e_drive_mode( 'F' ).
  WRITE: / lv_type.

* Funktion zum Prüfen von ENUM-Werten
  IF abap_true = lcl_drive_mode=>check_mode( 'X' ).
    WRITE: / 'Enum-Wert vorhanden.'.
  ELSE.
    WRITE: / 'Enum-Wert nicht vorhanden.'.
  ENDIF.

Variante 4 (CL_ABAP_ENUMDESCR)

TYPES: BEGIN OF ENUM e_drive_mode BASE TYPE symsgty,
         unknown  VALUE IS INITIAL,
         forward  VALUE 'F',
         backward VALUE 'B',
       END OF ENUM e_drive_mode.

DATA(lv_mode) = VALUE e_drive_mode( ).

DATA(o_desc) = CAST cl_abap_enumdescr( cl_abap_typedescr=>describe_by_data( lv_mode ) ).

cl_demo_output=>write_data( o_desc->kind ).
cl_demo_output=>write_data( o_desc->type_kind ).
cl_demo_output=>write_data( o_desc->base_type_kind ).
cl_demo_output=>write_data( o_desc->members ).

* HTML-Code vom Demo-Output holen
DATA(lv_html) = cl_demo_output=>get( ).

* Daten im Inline-Browser im SAP-Fenster anzeigen
cl_abap_browser=>show_html( EXPORTING title       = 'ENUM'
                                      html_string = lv_html
                                      container   = cl_gui_container=>default_screen ).

* cl_gui_container=>default_screen erzwingen
WRITE: space.

Variante 5 (bis Release 750)

CONSTANTS: BEGIN OF e_status,
             open      TYPE i VALUE 0,
             close     TYPE i VALUE 1,
             undefined TYPE i VALUE 2,
           END OF e_status.

Links

Generische Listenklasse mit Indexer und Enumerator

using System;
using System.Collections;
using System.Collections.Generic;
/// <summary>
/// generic list class with indexer and enumerator
/// freeware 2011 by admin of codezentrale.6x.to
/// </summary>
/// <typeparam name="T">datatype you want to manage</typeparam>
public class GenericList<T> : IEnumerable, IDisposable
{
    /// <summary>
    /// internal class, with interface for IEnumerable and IEnumerator
    /// </summary>
    private class GenericListEnumerator : IEnumerator
    {
        private int pos = -1;
        private GenericList<T> _t;

        public GenericListEnumerator(GenericList<T> t)
        {
            this._t = t;
        }

        public bool MoveNext()
        {
            if (pos < _t.Count - 1)
            {
                pos++;
                return true;
            }
            else
            {
                return false;
            }
        }

        public void Reset()
        {
            pos = -1;
        }

        public object Current
        {
            get
            {
                try
                {
                    return _t[pos];
                }
                catch (IndexOutOfRangeException)
                {
                    throw new InvalidOperationException();
                }
            }
        }
    }

    private List<T> _ObjectList = new List<T>();
    private bool _bDisposed = false;

    /// <summary>
    /// object counter
    /// </summary>
    public int Count
    {
        get { return _ObjectList.Count; }
    }
    /// <summary>
    /// indexer for direct index based access (e.g. mylist[1])
    /// </summary>
    /// <param name="pos"></param>
    /// <returns></returns>
    public T this[int pos]
    {
        get { return _ObjectList[pos]; }
        set { _ObjectList[pos] = value; }
    }

    public GenericList()
    {
    }

    // destructor, makro for 'protected override void Finalize()'
    ~GenericList()
    {
        this.Dispose(false);
    }

    // public Dispose-method for cleanup
    public void Dispose()
    {
        this.Dispose(true);
    }

    // internal Dispose-method
    private void Dispose(bool bDisposing)
    {
        if (!_bDisposed)
        {
            if (bDisposing)
            {
                // e.g. free managed resources here
            }
        }

        _bDisposed = true;
    }

    /// <summary>
    /// interface function for IEnumerable and IEnumerator
    /// </summary>
    /// <returns></returns>
    public IEnumerator GetEnumerator()
    {
        return new GenericListEnumerator(this);
    }
    /// <summary>
    /// add object to list
    /// </summary>
    /// <param name="obj">your object</param>
    public void Add(T obj)
    {
        _ObjectList.Add(obj);
    }
    /// <summary>
    /// clear list
    /// </summary>
    public void Clear()
    {
        _ObjectList.Clear();
    }
    /// <summary>
    /// swap objects inside list
    /// </summary>
    /// <param name="index1">index number one</param>
    /// <param name="index2">index number one</param>
    public void Swap(int index1, int index2)
    {
        if ((index1 >= 0) && (index2 >= 0) && (index1 < _ObjectList.Count) && (index2 < _ObjectList.Count))
        {
            T temp = _ObjectList[index1];
            _ObjectList[index1] = _ObjectList[index2];
            _ObjectList[index2] = temp;
        }
    }
    /// <summary>
    /// remove object from list
    /// </summary>
    /// <param name="obj"></param>
    public void Remove(T obj)
    {
        _ObjectList.Remove(obj);
    }
}