COBOL Tutorial

COBOL FACTORY Clause - Quick Reference

Progress0 of 0 lessons

Overview

The FACTORY clause is used in object-oriented COBOL to define factory methods that provide controlled and flexible object creation mechanisms. Factory methods allow for different initialization strategies and creation logic beyond simple object instantiation.

Purpose and Usage

Controlled object creation - Provide controlled ways to create objects
Flexible instantiation - Support different initialization strategies
Parameter validation - Validate parameters during object creation
Object pooling - Support object pooling and reuse
Design patterns - Implement factory design patterns

Factory Method Concept

Factory Method: [Parameters] → [Validation] → [Creation Logic] → [Object]

Object Creation: [Factory Call] → [Parameter Check] → [Object Instantiation] → [Return Object]

Factory Types: [Simple Factory] [Parameterized Factory] [Abstract Factory] [Builder Factory]

FACTORY provides flexible and controlled object creation mechanisms

FACTORY enables sophisticated object creation patterns in object-oriented COBOL.

Syntax

The FACTORY clause follows specific syntax patterns and is used within class definitions in object-oriented COBOL.

Basic Syntax

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
* Basic FACTORY clause syntax
FACTORY.
    METHOD-ID factory-method-name.
    DATA DIVISION.
    LINKAGE SECTION.
    * Parameters for factory method
    PROCEDURE DIVISION USING parameters RETURNING object-reference.
        * Factory method logic
        * Object creation and initialization
    END METHOD.
END FACTORY.
 
* Examples
FACTORY.
    METHOD-ID CreateInstance.
    DATA DIVISION.
    LINKAGE SECTION.
    01 PARAM1 PIC X(50).
    01 RETURN-OBJECT OBJECT REFERENCE.
    PROCEDURE DIVISION USING PARAM1 RETURNING RETURN-OBJECT.
        * Create and return object
        INVOKE SELF "new" RETURNING RETURN-OBJECT
    END METHOD.
END FACTORY.
 
* Complete example with multiple factory methods
CLASS-ID MyClass.
    DATA DIVISION.
    WORKING-STORAGE SECTION.
    01 INSTANCE-DATA PIC X(100).
    
    FACTORY.
        METHOD-ID CreateDefault.
        DATA DIVISION.
        LINKAGE SECTION.
        01 RETURN-OBJECT OBJECT REFERENCE.
        PROCEDURE DIVISION RETURNING RETURN-OBJECT.
            INVOKE SELF "new" RETURNING RETURN-OBJECT
            INVOKE RETURN-OBJECT "InitializeDefault"
        END METHOD.
        
        METHOD-ID CreateWithData.
        DATA DIVISION.
        LINKAGE SECTION.
        01 INPUT-DATA PIC X(100).
        01 RETURN-OBJECT OBJECT REFERENCE.
        PROCEDURE DIVISION USING INPUT-DATA RETURNING RETURN-OBJECT.
            INVOKE SELF "new" RETURNING RETURN-OBJECT
            INVOKE RETURN-OBJECT "InitializeWithData" USING INPUT-DATA
        END METHOD.
    END FACTORY.
END-CLASS.

FACTORY is used within class definitions to create factory methods for object instantiation.

Factory Method Types

Factory Type	Description	Use Case
Simple Factory	Basic object creation	Standard object instantiation
Parameterized Factory	Creation with parameters	Objects with specific initialization
Abstract Factory	Family of related objects	Related object creation
Builder Factory	Complex object construction	Complex object creation
Singleton Factory	Single instance creation	Unique object instances

Usage in Object Creation

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
* Using FACTORY methods for object creation
PROCEDURE DIVISION.
    * Create objects using factory methods
    INVOKE MyClass "CreateDefault" RETURNING default-obj
    INVOKE MyClass "CreateWithData" USING "Custom Data" RETURNING custom-obj
    
    * Use the created objects
    INVOKE default-obj "ProcessData"
    INVOKE custom-obj "ProcessData"
    
    * Factory method with validation
    INVOKE MyClass "CreateValidated" USING input-param RETURNING validated-obj
    IF validated-obj = NULL
        DISPLAY "Object creation failed - invalid parameters"
    ELSE
        INVOKE validated-obj "ProcessData"
    END-IF
 
* Factory method implementation with validation
FACTORY.
    METHOD-ID CreateValidated.
    DATA DIVISION.
    LINKAGE SECTION.
    01 INPUT-PARAM PIC X(50).
    01 RETURN-OBJECT OBJECT REFERENCE.
    PROCEDURE DIVISION USING INPUT-PARAM RETURNING RETURN-OBJECT.
        * Validate input parameter
        IF INPUT-PARAM = SPACES OR INPUT-PARAM = LOW-VALUES
            MOVE NULL TO RETURN-OBJECT
        ELSE
            * Create object with valid parameter
            INVOKE SELF "new" RETURNING RETURN-OBJECT
            INVOKE RETURN-OBJECT "InitializeWithData" USING INPUT-PARAM
        END-IF
    END METHOD.
END FACTORY.

FACTORY methods provide controlled object creation with validation and initialization.

Common Use Cases

FACTORY is commonly used in specific scenarios where controlled and flexible object creation is needed.

Parameterized Object Creation

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
* Parameterized object creation with FACTORY
CLASS-ID DatabaseConnection.
    DATA DIVISION.
    WORKING-STORAGE SECTION.
    01 CONNECTION-STRING PIC X(200).
    01 USERNAME PIC X(50).
    01 PASSWORD PIC X(50).
    
    FACTORY.
        METHOD-ID CreateConnection.
        DATA DIVISION.
        LINKAGE SECTION.
        01 DB-URL PIC X(200).
        01 DB-USER PIC X(50).
        01 DB-PASS PIC X(50).
        01 RETURN-CONNECTION OBJECT REFERENCE.
        PROCEDURE DIVISION USING DB-URL DB-USER DB-PASS RETURNING RETURN-CONNECTION.
            * Create connection object
            INVOKE SELF "new" RETURNING RETURN-CONNECTION
            * Initialize with parameters
            INVOKE RETURN-CONNECTION "InitializeConnection" 
                USING DB-URL DB-USER DB-PASS
        END METHOD.
        
        METHOD-ID CreateDefaultConnection.
        DATA DIVISION.
        LINKAGE SECTION.
        01 RETURN-CONNECTION OBJECT REFERENCE.
        PROCEDURE DIVISION RETURNING RETURN-CONNECTION.
            * Create with default parameters
            INVOKE SELF "CreateConnection" 
                USING "localhost:5432/mydb" "admin" "password"
                RETURNING RETURN-CONNECTION
        END METHOD.
    END FACTORY.
END-CLASS.
 
* Usage
PROCEDURE DIVISION.
    * Create connections using factory methods
    INVOKE DatabaseConnection "CreateConnection" 
        USING "server:3306/production" "prod_user" "prod_pass"
        RETURNING prod-connection
    
    INVOKE DatabaseConnection "CreateDefaultConnection" 
        RETURNING default-connection

Create objects with different initialization parameters using factory methods.

Object Pooling with Factory

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
* Object pooling with FACTORY
CLASS-ID ConnectionPool.
    DATA DIVISION.
    WORKING-STORAGE SECTION.
    01 POOL-SIZE PIC 9(4) VALUE 10.
    01 AVAILABLE-CONNECTIONS OCCURS 10 TIMES.
        02 CONNECTION-OBJECT OBJECT REFERENCE.
        02 IS-AVAILABLE PIC X VALUE 'Y'.
    
    FACTORY.
        METHOD-ID GetConnection.
        DATA DIVISION.
        LINKAGE SECTION.
        01 RETURN-CONNECTION OBJECT REFERENCE.
        PROCEDURE DIVISION RETURNING RETURN-CONNECTION.
            * Find available connection in pool
            PERFORM VARYING I FROM 1 BY 1 UNTIL I > POOL-SIZE
                IF IS-AVAILABLE(I) = 'Y'
                    MOVE CONNECTION-OBJECT(I) TO RETURN-CONNECTION
                    MOVE 'N' TO IS-AVAILABLE(I)
                    EXIT PERFORM
                END-IF
            END-PERFORM
            
            * If no available connection, create new one
            IF RETURN-CONNECTION = NULL
                INVOKE DatabaseConnection "CreateDefaultConnection" 
                    RETURNING RETURN-CONNECTION
            END-IF
        END METHOD.
        
        METHOD-ID ReturnConnection.
        DATA DIVISION.
        LINKAGE SECTION.
        01 CONNECTION-TO-RETURN OBJECT REFERENCE.
        PROCEDURE DIVISION USING CONNECTION-TO-RETURN.
            * Return connection to pool
            PERFORM VARYING I FROM 1 BY 1 UNTIL I > POOL-SIZE
                IF CONNECTION-OBJECT(I) = CONNECTION-TO-RETURN
                    MOVE 'Y' TO IS-AVAILABLE(I)
                    EXIT PERFORM
                END-IF
            END-PERFORM
        END METHOD.
    END FACTORY.
END-CLASS.

Implement object pooling for efficient resource management.

Singleton Pattern with Factory

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
* Singleton pattern with FACTORY
CLASS-ID ConfigurationManager.
    DATA DIVISION.
    WORKING-STORAGE SECTION.
    01 INSTANCE OBJECT REFERENCE.
    01 CONFIG-DATA PIC X(1000).
    
    FACTORY.
        METHOD-ID GetInstance.
        DATA DIVISION.
        LINKAGE SECTION.
        01 RETURN-INSTANCE OBJECT REFERENCE.
        PROCEDURE DIVISION RETURNING RETURN-INSTANCE.
            * Return existing instance or create new one
            IF INSTANCE = NULL
                INVOKE SELF "new" RETURNING INSTANCE
                INVOKE INSTANCE "LoadConfiguration"
            END-IF
            MOVE INSTANCE TO RETURN-INSTANCE
        END METHOD.
    END FACTORY.
    
    METHOD-ID LoadConfiguration.
    DATA DIVISION.
    PROCEDURE DIVISION.
        * Load configuration from file or database
        MOVE "Default configuration data" TO CONFIG-DATA
    END METHOD.
    
    METHOD-ID GetConfigValue.
    DATA DIVISION.
    LINKAGE SECTION.
    01 CONFIG-KEY PIC X(50).
    01 CONFIG-VALUE PIC X(100).
    PROCEDURE DIVISION USING CONFIG-KEY RETURNING CONFIG-VALUE.
        * Return configuration value based on key
        MOVE "Default value" TO CONFIG-VALUE
    END METHOD.
END-CLASS.
 
* Usage
PROCEDURE DIVISION.
    * Get singleton instance
    INVOKE ConfigurationManager "GetInstance" RETURNING config-manager
    INVOKE config-manager "GetConfigValue" USING "database_url" RETURNING db-url

Implement singleton pattern for unique object instances.

Best Practices and Tips

Following these best practices ensures effective use of the FACTORY clause for proper object creation.

FACTORY Design Principles

Single responsibility - Each factory method should have a single purpose
Parameter validation - Always validate parameters in factory methods
Meaningful names - Use descriptive names for factory methods
Error handling - Handle creation failures gracefully
Documentation - Document factory method behavior and parameters
Consistent patterns - Use consistent factory patterns throughout your application

Common Pitfalls to Avoid

Pitfall	Problem	Solution
Complex factory methods	Difficult to maintain and understand	Keep factory methods simple and focused
No parameter validation	Invalid objects created	Always validate parameters in factory methods
Inconsistent naming	Confusing and hard to use	Use consistent naming conventions
No error handling	Creation failures not handled	Handle creation failures gracefully
Overuse of factories	Unnecessary complexity	Use factories only when needed

Performance Considerations

Factory method overhead - Factory methods add method call overhead
Parameter validation cost - Parameter validation adds processing time
Object creation cost - Object creation is still expensive
Memory usage - Factory methods don't reduce memory usage
Caching opportunities - Consider caching frequently created objects
Pooling benefits - Object pooling can improve performance

When to Use FACTORY

Use Case	FACTORY Suitability	Reasoning
Complex object creation	Excellent	Perfect for complex initialization logic
Parameter validation	Excellent	Ideal for validating creation parameters
Object pooling	Excellent	Excellent for resource management
Simple object creation	Poor	Overkill for simple instantiation
Performance-critical code	Poor	Factory overhead may be too high

FACTORY Clause Quick Reference

Usage	Syntax	Example
Basic factory	FACTORY with METHOD-ID	FACTORY with CreateInstance method
Parameterized factory	FACTORY with USING parameters	FACTORY with CreateWithData USING param
Factory method call	INVOKE class-name "method-name"	INVOKE MyClass "CreateInstance"
Factory with validation	FACTORY with parameter checking	FACTORY with CreateValidated method
Multiple factory methods	FACTORY with multiple METHOD-ID	FACTORY with CreateDefault and CreateCustom

Test Your Knowledge

1. What is the primary purpose of the FACTORY clause in COBOL?

To define data types
To create factory methods for object instantiation in object-oriented COBOL
To control file operations
To perform calculations

2. Where is the FACTORY clause typically used?

In DATA DIVISION
In class definitions and object-oriented COBOL programs
In PROCEDURE DIVISION
In ENVIRONMENT DIVISION

3. What is the main benefit of using FACTORY methods?

Faster execution
Controlled object creation with flexible instantiation logic
Memory optimization
Simpler syntax

4. When is the FACTORY clause most useful?

In simple programs
In complex object-oriented applications requiring flexible object creation
Only during compilation
Only during program termination

5. How does FACTORY relate to object creation?

They are completely independent
FACTORY provides controlled and flexible object creation mechanisms
FACTORY overrides normal object creation
They serve the same purpose

COBOL Tutorial

COBOL FACTORY Clause - Quick Reference

Overview

Purpose and Usage

Factory Method Concept

Syntax

Basic Syntax

Factory Method Types

Usage in Object Creation

Common Use Cases

Parameterized Object Creation

Object Pooling with Factory

Singleton Pattern with Factory

Best Practices and Tips

FACTORY Design Principles

Common Pitfalls to Avoid

Performance Considerations

When to Use FACTORY

FACTORY Clause Quick Reference

Test Your Knowledge

Frequently Asked Questions

Related Concepts

CLASS-ID Clause

METHOD-ID Clause

Object-Oriented COBOL

Object Creation

Design Patterns

Related Pages

COBOL Tutorial

COBOL FACTORY Clause - Quick Reference

Overview

Purpose and Usage

Factory Method Concept

Syntax

Basic Syntax

Factory Method Types

Usage in Object Creation

Common Use Cases

Parameterized Object Creation

Object Pooling with Factory

Singleton Pattern with Factory

Best Practices and Tips

FACTORY Design Principles

Common Pitfalls to Avoid

Performance Considerations

When to Use FACTORY

FACTORY Clause Quick Reference

Test Your Knowledge

Frequently Asked Questions

What is the difference between FACTORY and normal object instantiation?

Can FACTORY be used in traditional COBOL programs?

What types of factory methods can be created with FACTORY?

How do you implement a FACTORY method in COBOL?

Are there performance implications when using FACTORY?

Related Concepts

CLASS-ID Clause

METHOD-ID Clause

Object-Oriented COBOL

Object Creation

Design Patterns

Related Pages