•  Preface
  • Purpose
  • Audience
  • Organization
  •  Using ABL documentation
    • References to ABL compiler and run-time features
    • References to ABL data types
  • Typographical conventions
  •  Examples of syntax descriptions
    • Long syntax descriptions split across lines
    • Complex syntax descriptions with both required and optional elements
  • Example procedures
  •  OpenEdge messages
    • Obtaining more information about OpenEdge messages
•  Object-oriented Programming and ABL
  •  Support for classes in ABL
    • Advantages of classes in ABL
    • Foundations of ABL classes
  •  Programming models in ABL
    • Procedure-based model
    • Class-based model
    • Comparing programming models
  •  Overview of object-oriented programming
    •  Encapsulation
      • Comparison with procedure-based programming
    •  Inheritance
      • Comparison with procedure-based programming
    •  Delegation
      • Comparison with procedure-based programming
    • Polymorphism
    • Method overloading
    •  Strong typing
      • Comparison with procedure-based programming
    • Glossary of terms
  •  Overview of class-based ABL
    •  Defining classes
      • Comparison with procedure-based programming
    •  Defining methods
      • Comparison with procedure-based programming
    •  Defining data members
      • Comparison with procedure-based programming
    •  Defining properties
      • Comparison with procedure-based programming
    •  Defining class events
      • Comparison with procedure-based programming
    •  Defining constructors
      • Comparison with procedure-based programming
    •  Defining the destructor
      • Comparison with procedure-based programming
    •  Defining interfaces
      • Comparison with procedure-based programming
    • Using object types
    • Specifying unqualified class or interface type names
    •  Creating and destroying a class instance
      • Comparison with procedure-based programming
    •  Invoking methods
      • Comparison with procedure-based programming
    •  Accessing data members and properties
      • Comparison with procedure-based programming
    •  Publishing and responding to class events
      • Comparison with procedure-based programming
    • Supporting ABL
    • General comparison with procedure-based programming
  • Programming conventions for classes
•  Getting Started with Classes, Interfaces, and Objects
  •  Class definition files and object type names
    • Class definition file structure
    •  Defining and referencing object type names
      • Valid and invalid object type name references
      • How object type names are used to locate type definitions on PROPATH
    • Referencing an object type name without its package
    • Comparing class definition files and procedure source files
  •  Defining classes
    •  Defining state in a class
      • Data members and properties
      • Class-scoped handle-based objects
      • Local variables and other data elements of methods
    •  Defining behavior in a class
      • Methods of a class
      • Events of a class
    • Defining classes based on other classes
  •  Using the CLASS construct
    •  Defining data members within a class
      • Comparison with procedure-based programming
    •  Defining properties within a class
      • DEFINE PROPERTY statement
      • Comparison with procedure-based programming
    •  Defining methods within a class
      • DEFINE METHOD statement
    •  Defining events within a class
      • DEFINE EVENT statement
      • Comparison with procedure-based programming
    •  Namespaces for naming class members
      • Tables
      • Fields
      • Abbreviations
      • Static class members
    •  Defining class constructors
      • CONSTRUCTOR statement
      • Comparison with procedure-based programming
    •  Defining the class destructor
      • DESTRUCTOR statement
      • Comparison with procedure-based programming
    • Defining class-scoped handle-based objects
    • Using the root class: Progress.Lang.Object
  • Defining interfaces
  •  Using the INTERFACE construct
    • INTERFACE statement
    • Using an interface definition
  •  Managing the object life-cycle
    • DELETE OBJECT statement
•  Designing Objects: Inheritance, Polymorphism, and Delegation
  •  Class hierarchies and inheritance
    • Classes and strong typing
    •  Class hierarchies and procedure hierarchies
      • Comparison with procedure-based programming
    •  Method scoping within a class hierarchy
      • Comparison with procedure-based programming
    •  Data member and property scoping within a class hierarchy
      • Comparison with procedure-based programming
    •  Event scoping within a class hierarchy
      • Comparison with procedure-based programming
    • Overriding data within a class hierarchy
    • Overriding methods within a class hierarchy
    • Overriding class events within a class hierarchy
    •  Overloading methods and constructors
      • Defining overloaded methods and constructors
      • Invoking overloaded methods and constructors
    •  Constructing an object
      • SUPER statement
      • THIS-OBJECT statement
    •  Calling up the class hierarchy
      • SUPER system reference
      • THIS-OBJECT system reference
    • Deleting an object
  •  Interface hierarchies and inheritance
    • Multiple interfaces in a hierarchy
    • Duplicate members in a hierarchy
    • Using interface hierarchies
  • Using polymorphism with classes
  •  Using delegation with classes
    • Comparison with procedure-based programming
•  Programming with Class-based Objects
  •  Instantiating and managing class-based objects
    • Defining an object reference variable or property
    •  Creating a class instance
      • NEW and DYNAMIC-NEW statements
      • New( ) method
    •  Calling class-based methods
      • Calling methods from inside a class hierarchy where they are defined
      • Calling instance methods from outside a class hierarchy where they are defined
      • Dynamically invoking a method at run time
      • Comparison with procedure-based programming
    • Calling an overloaded method or constructor
    •  Accessing data members and properties
      • Referencing a public data member or property outside of the object that defines it
    • Dynamically accessing a property at runtime
    • Defining an object reference parameter
    • Passing object reference parameters
    • Defining an object reference return type
    • Defining an object reference field in a temp-table
    •  Publishing and subscribing to class events
      • Specifying handler subscriptions for class events
      • Publishing class events
  •  Verifying the type and validity of an object reference
    • VALID-OBJECT function
    • TYPE-OF function
  •  Using built-in system and object reference elements
    • THIS-OBJECT system reference
    • SUPER system reference
    • ABL session object reference attributes
  •  Assigning object references
    • Object reference assignment and casting
    •  Using the CAST function
      • Casting an object reference assignment
      • Casting an object reference parameter
      • Casting an object reference to invoke a method
    • Using the DYNAMIC-CAST function
  • Comparing objects
  •  Using static members of a class
    • Static member scoping
    •  Accessing static members
      • Options for referencing static members
      • Using static type-name syntax
      • Accessing static members from outside the defining class
      • Accessing static members from inside the defining class
      • Calling static methods from inside the defining class
      • Calling overridden and super-class static methods
      • Calling overloaded static methods
      • Accessing static and instance events and event handlers
    •  Defining static members
      • Defining a static constructor
      • Defining static method overrides and overloadings
    • Initializing and deleting static members
    • Common use case for static members
    • Static type-name syntax and naming conflicts
  • Defining and using widgets in classes
  •  Using preprocessor features in a class
    • Using compile-time arguments
    • Using preprocessor names and directives
  •  Raising and handling error conditions
    • Structured and traditional error handling
    •  Raising errors within a method
      • Method error handling example
    • Raising errors within a class event handler
    •  Raising errors within a property
      • GET accessors raising ERROR
      • SET accessors raising ERROR
      • Property error handling example
    •  Raising errors within an instance constructor
      • Handling instance constructor errors
      • Instance constructor error handling example
    • Raising errors within a static constructor
    • Raising errors within a destructor
  •  Reflection: using built-in ABL classes
    •  Using the Progress.Lang.Class class
      • Getting a Progress.Lang.Class instance
      • Using Progress.Lang.Class properties and methods
  •  Using the Progress.Lang.ParameterList class
    • Getting and using a Progress.Lang.ParameterList instance
    • Using Progress.Lang.ParameterList methods and properties
  • Understanding classes in the Progress.Reflect package
  •  Serialization and deserialization
    • Serializing an instance to file
    • Deserializing from a file
•  Programming with Class-based and Procedure Objects
  •  Class-based and procedure object compatibility
    • Compatibility rules
    • Invalid ABL within a user-defined class
    • Verifying the source for an r-code file at run time
  •  Comparing handles and object references
    • Using handles
    • Using object references
  •  Using handle-based object events in classes
    • ON statement
    • SET-CALLBACK( ) method
  • Using widget pools
  • Referencing routines on the call stack
  • Comparing constructs in classes and procedures
  • Sample classes
  • Comparative procedures
  • Summary comparison of classes and procedures
•  Developing and Deploying Classes
  •  Accessing class definition files using the Procedure Editor
    • Saving and opening class definition files
    •  Checking and running a class from the Procedure Editor
      • Check Syntax option
      • Run option
  •  Accessing class definition files using Progress Developer Studio for OpenEdge
    • Syntax checking, compiling, and running a class
  •  Compiling class definition files
    • Protocol for class hierarchy and references
    • Data type matching
    •  Using the COMPILER system handle
      • MULTI-COMPILE attribute
      • CLASS-TYPE attribute
      • NUM-MESSAGES attribute
      • GET-MESSAGE(n) method
      • GET-NUMBER(n) method
      • GET-FILE-NAME(n) method
      • GET-ERROR-ROW(n) method
      • GET-ERROR-COLUMN(n) method
      • GET-FILE-OFFSET(n) method
  • Using procedure libraries
  • Using the XCODE utility
•  Overloaded Method and Constructor Calling Scenarios
  • Parameters differing only by mode
  • Parameter data types differing only by extent
  • Parameters matching widened data types
  • Matching dynamic and static temp-table or ProDataset parameters
  • Object reference parameters matching a class hierarchy or interface
  • Matching the Unknown value (?) to parameters
  • Matching values of unknown data types to parameters