Processor

Processor provides high performance, configurability, and flexible reuse capabilities, suitable for repeated operations on the same data source.

Features

• High Performance: Internal caching mechanism for more efficient repeated operations
• Configurable: Supports multiple configuration options
• Chained Calls: Methods return modified JSON, supporting consecutive operations
• Resource Management: Explicit lifecycle control

Creating a Processor

New

Signature: func New(cfg ...Config) (*Processor, error)

Creates a Processor instance with optional Config parameters.

// Use default configuration
processor, err := json.New()
if err != nil {
    panic(err)
}
defer processor.Close()

// Use custom configuration
cfg := json.DefaultConfig()
cfg.StrictMode = true
processor, err := json.New(cfg)

// Use security configuration
processor, err := json.New(json.SecurityConfig())

Chained Calls

Processor methods return modified JSON strings, supporting consecutive operations:

processor, _ := json.New()

// Set multiple values
result1, _ := processor.Set(data, "user.name", "CyberGo")
result2, _ := processor.Set(result1, "user.version", "1.0.0")
finalResult, _ := processor.Delete(result2, "user.temporary")

API Directory

Category	Description
Path Query	GetString/Int/Float/Bool/Get/SafeGet/GetArray/GetObject
Data Modification	Set/Delete/DeleteClean
Output Methods	Encode/EncodePretty/EncodeWithConfig/Buffer operations
Parse and Load	ParseAny/Valid/LoadFromFile/LoadFromReader
Iteration Methods	Foreach/ForeachWithPath/ForeachNested
Batch Operations	ProcessBatch
JSONL Processing	StreamJSONL/Parallel/Chunked/Map/Reduce/Filter
Lifecycle	Close/Cache/Stats/Health Check

---

Global Processor Management

Package-level functions use an internal global processor. You can manage it with the following functions:

SetGlobalProcessor

Signature: func SetGlobalProcessor(processor *Processor)

Sets a custom global processor. All package-level functions (Get, Set, Marshal, etc.) will use this processor.

Parameters

Name	Type	Description
processor	*Processor	Custom processor instance

package main

import (
    "github.com/cybergodev/json"
)

func main() {
    // Create a processor with custom configuration
    cfg := json.SecurityConfig()
    processor, err := json.New(cfg)
    if err != nil {
        panic(err)
    }

    // Set as global processor
    json.SetGlobalProcessor(processor)

    // Now all package-level functions use the security configuration
    data, err := json.Get(`{"name":"Alice"}`, "name")
    // Uses SecurityConfig limits
    _ = data
}

Note

• Passing nil performs no operation
• The previous global processor is automatically closed
• This function is thread-safe

ShutdownGlobalProcessor

Signature: func ShutdownGlobalProcessor()

Closes and removes the global processor. Subsequent package-level operations will create a new default processor.

package main

import (
    "github.com/cybergodev/json"
)

func main() {
    // Use global processor
    data, _ := json.Get(`{"key":"value"}`, "key")
    _ = data

    // Clean up when application shuts down
    json.ShutdownGlobalProcessor()

    // Subsequent operations create a new default processor
    data2, _ := json.Get(`{"key":"value2"}`, "key")
    _ = data2
}

Use Cases

• Long-running services cleaning up resources on shutdown
• When you need to reset processor configuration
• Isolating different test cases in test environments

---

See Also

• Package Functions - Top-level function reference
• Config - Configuration options
• Interface Definitions - Hook interface
• Hook System - Detailed hook usage guide