# EFQRCode Generation and Recognition: Main Entry Points Explained

> Discover EFQRCode generation and recognition entry points in Source/EFQRCode+Generator.swift and Source/EFQRCode+Recognizer.swift. Access core functionalities easily.

- Repository: [EFPrefix/efqrcode](https://github.com/efprefix/efqrcode)
- Tags: internals
- Published: 2026-03-01

---

**The main entry points for EFQRCode generation and recognition are the nested classes `EFQRCode.Generator` and `EFQRCode.Recognizer`, defined in `Source/EFQRCode+Generator.swift` and `Source/EFQRCode+Recognizer.swift` respectively.**

EFQRCode is a lightweight Swift library for generating and recognizing QR codes with extensive styling options. Unlike monolithic libraries that expose dozens of top-level functions, EFQRCode adopts a minimalist namespace pattern where an empty `EFQRCode` class serves as the container for two specialized entry points.

## Understanding the EFQRCode Namespace Architecture

The library’s architecture centers on a deliberate separation between the namespace container and the functional implementations.

### The Empty Namespace Class

In [`Source/EFQRCode.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/EFQRCode.swift), the library defines a bare `EFQRCode` class:

```swift
public class EFQRCode { }

```

This class contains no logic, methods, or properties. Its sole purpose is to provide a static namespace that prevents naming collisions and creates a clean import experience (`import EFQRCode`).

### Extension-Based Organization

All functionality is added via Swift extensions on this empty class. The library splits generation and recognition into separate files using the `+` naming convention common in Swift projects:

- `Source/EFQRCode+Generator.swift` — Contains `public extension EFQRCode { class Generator { … } }`
- `Source/EFQRCode+Recognizer.swift` — Contains `public extension EFQRCode { class Recognizer { … } }`

This structure ensures that the main entry points for EFQRCode generation and recognition are discoverable under the `EFQRCode` prefix while maintaining clean separation of concerns.

## EFQRCode Generation Entry Point

QR code creation flows through the `EFQRCode.Generator` class, which encapsulates the entire generation pipeline from raw data to styled output.

### The Generator Class Location and Structure

The generator is defined in `Source/EFQRCode+Generator.swift` as a public class nested inside the `EFQRCode` extension:

```swift
public extension EFQRCode {
    public class Generator {
        public let qrcode: QRCode
        public let style: EFQRCodeStyleBase
        // ...
    }
}

```

The class holds two critical references: a `qrcode` property containing the underlying `QRCode` object (from the `QRCodeSwift` dependency) and a `style` property implementing the `EFQRCodeStyleBase` protocol.

### Key Initializers and Methods

The generator provides multiple convenience initializers to accommodate different input types:

- `init(_ text: String, encoding:, errorCorrectLevel:, style:)` — For string content with specified encoding
- `init(_ data: Data, errorCorrectLevel:, style:)` — For raw binary data
- `init(_ qrcode: QRCode, style:)` — For existing QR code objects

Each initializer validates the input and constructs the internal `QRCode` instance with the specified error correction level.

### Output Methods

Once initialized, the generator offers several export methods defined in the same file:

- `toImage(width:)` — Returns a `CGImage` of the specified width
- `toPNGData(width:)` — Returns PNG binary data
- `toSVGString(width:)` — Returns an SVG string representation

These methods delegate to the style implementation to render the QR matrix into the desired format, making `EFQRCode.Generator` the definitive entry point for all EFQRCode generation operations.

## EFQRCode Recognition Entry Point

For decoding QR codes from images, the library exposes `EFQRCode.Recognizer`, which wraps Core Image’s detection capabilities.

### The Recognizer Class Structure

Located in `Source/EFQRCode+Recognizer.swift`, the recognizer is implemented as:

```swift
public extension EFQRCode {
    public class Recognizer {
        public init(image: CGImage)
        public func recognize() -> [String]
        // ...
    }
}

```

The class requires a `CGImage` at initialization and maintains internal state to cache detection results.

### Recognition Workflow

The recognition process follows a simple two-step pattern:

1. **Initialization** — Pass a `CGImage` to `EFQRCode.Recognizer(image:)`
2. **Extraction** — Call `recognize()` to return an array of decoded strings

Under the hood, the implementation uses Core Image’s `CIDetector` with the `CIDetectorTypeQRCode` type to locate and decode QR codes within the image bounds. The results are cached, allowing repeated calls to `recognize()` without re-processing the image.

This design makes `EFQRCode.Recognizer` the primary entry point for all EFQRCode recognition tasks, providing a clean Swift wrapper around Core Image’s functionality.

## Practical Implementation Examples

The following examples demonstrate the complete workflow for both generation and recognition using the main entry points.

### Generating a Styled QR Code

```swift
import EFQRCode
import CoreGraphics

// Create a styled generator
do {
    let style = EFQRCodeStyle.bubble
    
    let generator = try EFQRCode.Generator(
        "https://github.com/efprefix/efqrcode",
        style: style
    )
    
    // Export as PNG
    let pngData = try generator.toPNGData(width: 400)
    try pngData.write(to: URL(fileURLWithPath: "/tmp/qrcode.png"))
} catch {
    print("Generation failed: \(error)")
}

```

### Recognizing QR Codes from an Image

```swift
import EFQRCode
import CoreGraphics

// Load an image (example uses NSImage, UIImage works similarly)
if let cgImage = NSImage(named: "sampleQR")?.cgImage(forProposedRect: nil, context: nil, hints: nil) {
    
    // Initialize the recognizer
    let recognizer = EFQRCode.Recognizer(image: cgImage)
    
    // Extract contents
    let decoded = recognizer.recognize()
    print("Found \(decoded.count) QR code(s):", decoded)
}

```

## Summary

- **EFQRCode** serves as an empty namespace class defined in [`Source/EFQRCode.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/EFQRCode.swift), providing the organizational structure for the library.
- **EFQRCode.Generator** in `Source/EFQRCode+Generator.swift` is the main entry point for QR code generation, offering initializers for text and data input along with export methods for images, PNG data, and SVG strings.
- **EFQRCode.Recognizer** in `Source/EFQRCode+Recognizer.swift` is the main entry point for QR code recognition, wrapping Core Image’s `CIDetector` to extract string payloads from `CGImage` inputs.
- Both classes are accessed through the `EFQRCode` static namespace, creating a clean, discoverable API surface for Swift developers.

## Frequently Asked Questions

### Where is the EFQRCode Generator class defined?

The `EFQRCode.Generator` class is defined in `Source/EFQRCode+Generator.swift` as a public class nested inside a `public extension EFQRCode` block. This file contains all generation logic, including initializers for text and data input, style configuration, and output methods like `toPNGData(width:)` and `toSVGString(width:)`.

### How does EFQRCode recognize QR codes from images?

EFQRCode recognizes QR codes through the `EFQRCode.Recognizer` class located in `Source/EFQRCode+Recognizer.swift`. The class initializes with a `CGImage` and uses Core Image’s `CIDetector` with the `CIDetectorTypeQRCode` type to detect and decode QR codes. The `recognize()` method returns an array of strings containing the decoded payloads.

### What is the purpose of the empty EFQRCode class?

The empty `EFQRCode` class in [`Source/EFQRCode.swift`](https://github.com/efprefix/efqrcode/blob/main/Source/EFQRCode.swift) serves as a namespace container. It contains no properties or methods of its own, but provides the organizational structure for the library’s public API. By defining `Generator` and `Recognizer` as nested classes within extensions on `EFQRCode`, the library creates a clean, discoverable interface where users access functionality through `EFQRCode.Generator` and `EFQRCode.Recognizer`.

### Can I use EFQRCode to generate QR codes with custom styles?

Yes, the `EFQRCode.Generator` class supports extensive styling through the `EFQRCodeStyleBase` protocol. When initializing a generator, you can pass a style implementation such as `EFQRCodeStyle.bubble` or create custom styles by conforming to `EFQRCodeStyleBase`. The generator stores the style in its `public let style: EFQRCodeStyleBase` property and applies it when rendering output through methods like `toImage(width:)` or `toSVGString(width:)`.