json

package module
v1.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 24, 2025 License: MIT Imports: 24 Imported by: 0

README ΒΆ

πŸš€ cybergodev/json - High-Performance Go JSON Processing Library

Go Version MIT license Performance Thread Safe

A high-performance, feature-rich Go JSON processing library with 100% encoding/json compatibility, providing powerful path operations, type safety, performance optimization, and rich advanced features.

πŸ“– δΈ­ζ–‡ζ–‡ζ‘£ - User guide

πŸ“š Table of Contents

πŸ“– Overview

cybergodev/json is a high-performance Go JSON processing library that maintains 100% compatibility with the standard encoding/json package while providing powerful path operations, type safety, performance optimization, and rich advanced features.

πŸ† Core Advantages
  • πŸ”„ Full Compatibility - 100% compatible with standard encoding/json, zero learning curve, drop-in replacement
  • 🎯 Powerful Paths - Support for complex path expressions, complete complex data operations in one line
  • πŸš€ High Performance - Smart caching, concurrent safety, memory optimization, production-ready performance
  • πŸ›‘οΈ Type Safety - Generic support, compile-time checking, intelligent type conversion
  • πŸ”§ Feature Rich - Batch operations, data validation, file operations, performance monitoring
  • πŸ—οΈ Production Ready - Thread-safe, error handling, security configuration, monitoring metrics
🎯 Use Cases
  • 🌐 API Data Processing - Fast extraction and transformation of complex response data
  • βš™οΈ Configuration Management - Dynamic configuration reading and batch updates
  • πŸ“Š Data Analysis - Statistics and analysis of large amounts of JSON data
  • πŸ”„ Microservice Communication - Data exchange and format conversion between services
  • πŸ“ Log Processing - Parsing and analysis of structured logs
πŸ“š More Examples & Documentation

πŸ“‹ Basic Path Syntax

Syntax Description Example Result
. Property access user.name Get user's name property
[n] Array index users[0] Get first user
[-n] Negative index users[-1] Get last user
[start:end:step] Array slice users[1:3] Get users at index 1-2
{field} Batch extract users{name} Extract all user names
{flat:field} Flatten extract users{flat:skills} Flatten extract all skills

πŸš€ Quick Start

Installation
go get github.com/cybergodev/json
Basic Usage
package main

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

func main() {
    // 1. Full compatibility with standard library
    data := map[string]any{"name": "Alice", "age": 25}
    jsonBytes, err := json.Marshal(data)

    var result map[string]any
    json.Unmarshal(jsonBytes, &result)

    // 2. Powerful path operations (enhanced features)
    jsonStr := `{"user":{"profile":{"name":"Alice","age":25}}}`

    name, err := json.GetString(jsonStr, "user.profile.name")
    fmt.Println(name) // "Alice"

    age, err := json.GetInt(jsonStr, "user.profile.age")
    fmt.Println(age) // 25
}
Path Operations Example
// Complex JSON data
complexData := `{
  "users": [
    {"name": "Alice", "skills": ["Go", "Python"], "active": true},
    {"name": "Bob", "skills": ["Java", "React"], "active": false}
  ]
}`

// Get all usernames
names, err := json.Get(complexData, "users{name}")
// Result: ["Alice", "Bob"]

// Get all skills (flattened)
skills, err := json.Get(complexData, "users{flat:skills}")
// Result: ["Go", "Python", "Java", "React"]

// Batch get multiple values
paths := []string{"users[0].name", "users[1].name", "users{active}"}
results, err := json.GetMultiple(complexData, paths)

⚑ Core Features

Data Retrieval
// Basic retrieval
json.Get(data, "user.name")          // Get any type
json.GetString(data, "user.name")    // Get string
json.GetInt(data, "user.age")        // Get integer
json.GetFloat64(data, "user.score")  // Get float64
json.GetBool(data, "user.active")    // Get boolean
json.GetArray(data, "user.tags")     // Get array
json.GetObject(data, "user.profile") // Get object

// Type-safe retrieval
json.GetTyped[string](data, "user.name") // Generic type safety
json.GetTyped[[]User](data, "users")     // Custom types

// Retrieval with default values
json.GetWithDefault(data, "user.name", "Anonymous")
json.GetStringWithDefault(data, "user.name", "Anonymous")
json.GetIntWithDefault(data, "user.age", 0)
json.GetFloat64WithDefault(data, "user.score", 0.0)
json.GetBoolWithDefault(data, "user.active", false)
json.GetArrayWithDefault(data, "user.tags", []any{})
json.GetObjectWithDefault(data, "user.profile", map[string]any{})

// Batch retrieval
paths := []string{"user.name", "user.age", "user.email"}
results, err := json.GetMultiple(data, paths)
Data Modification
// Basic setting - returns modified data on success, original data on failure
data := `{"user":{"name":"Bob","age":25}}`
result, err := json.Set(data, "user.name", "Alice")
// result => {"user":{"name":"Alice","age":25}}

// Auto-create paths
data := `{}`
result, err := json.SetWithAdd(data, "user.name", "Alice")
// result => {"user":{"name":"Alice"}}

// Batch setting
updates := map[string]any{
    "user.name": "Bob",
    "user.age":  30,
    "user.active": true,
}
result, err := json.SetMultiple(data, updates)
result, err := json.SetMultipleWithAdd(data, updates) // With auto-create paths
// Same behavior: success = modified data, failure = original data
Data Deletion
json.Delete(data, "user.temp") // Delete field
json.DeleteWithCleanNull(data, "user.temp") // Delete and cleanup nulls
Data Iteration
// Basic iteration - read-only traversal
json.Foreach(data, func (key any, item *json.IterableValue) {
    name := item.GetString("name")
    fmt.Printf("Key: %v, Name: %s\n", key, name)
})

// Advanced iteration variants
json.ForeachNested(data, callback)           // Nested-safe iteration
json.ForeachWithIterator(data, callback)     // With iterator access
json.ForeachWithPath(data, "users", callback) // Iterate specific path

// Iterate and return modified JSON - supports data modification
modifiedJson, err := json.ForeachReturn(data, func (key any, item *json.IterableValue) {
    // Modify data during iteration
    if item.GetString("status") == "inactive" {
        item.Set("status", "active")
        item.Set("updated_at", time.Now().Format("2006-01-02"))
    }
    
    // Batch update user information
    if key == "users" {
        item.SetMultiple(map[string]any{
            "last_login": time.Now().Unix(),
            "version": "2.0",
        })
    }
})
JSON Encoding & Formatting
// Standard encoding (100% compatible with encoding/json)
bytes, err := json.Marshal(data)
err = json.Unmarshal(bytes, &target)
bytes, err := json.MarshalIndent(data, "", "  ")

// Advanced encoding with configuration
config := &json.EncodeConfig{
    Pretty:       true,
    SortKeys:     true,
    EscapeHTML:   false,
}
jsonStr, err := json.Encode(data, config)
jsonStr, err := json.EncodePretty(data, config)
jsonStr, err := json.EncodeCompact(data, config)

// Formatting operations
pretty, err := json.FormatPretty(jsonStr)
compact, err := json.FormatCompact(jsonStr)

// Buffer operations (encoding/json compatible)
json.Compact(dst, src)
json.Indent(dst, src, prefix, indent)
json.HTMLEscape(dst, src)
File Operations
// Load and save JSON files
jsonStr, err := json.LoadFromFile("data.json")
err = json.SaveToFile("output.json", data, true) // pretty format

// Marshal/Unmarshal with files
err = json.MarshalToFile("user.json", user)
err = json.MarshalToFile("user_pretty.json", user, true)
err = json.UnmarshalFromFile("user.json", &loadedUser)

// Stream operations
data, err := processor.LoadFromReader(reader)
err = processor.SaveToWriter(writer, data, true)
Type Conversion & Utilities
// Safe type conversion
intVal, ok := json.ConvertToInt(value)
floatVal, ok := json.ConvertToFloat64(value)
boolVal, ok := json.ConvertToBool(value)
strVal := json.ConvertToString(value)

// Generic type conversion
result, ok := json.UnifiedTypeConversion[int](value)
result, err := json.TypeSafeConvert[string](value)

// JSON comparison and merging
equal, err := json.CompareJson(json1, json2)
merged, err := json.MergeJson(json1, json2)
copy, err := json.DeepCopy(data)
Processor Management
// Create processor with configuration
config := &json.Config{
    EnableCache:      true,
    MaxCacheSize:     5000,
    MaxJSONSize:      50 * 1024 * 1024,
    MaxConcurrency:   100,
    EnableValidation: true,
}
processor := json.New(config)
defer processor.Close()

// Processor operations
result, err := processor.Get(jsonStr, path)
stats := processor.GetStats()
health := processor.GetHealthStatus()
processor.ClearCache()

// Cache warmup
paths := []string{"user.name", "user.age", "user.profile"}
warmupResult, err := processor.WarmupCache(jsonStr, paths)

// Global processor management
json.SetGlobalProcessor(processor)
json.ShutdownGlobalProcessor()
Complex Path Examples
complexData := `{
  "company": {
    "departments": [
      {
        "name": "Engineering",
        "teams": [
          {
            "name": "Backend",
            "members": [
              {"name": "Alice", "skills": ["Go", "Python"], "level": "Senior"},
              {"name": "Bob", "skills": ["Java", "Spring"], "level": "Mid"}
            ]
          }
        ]
      }
    ]
  }
}`

// Multi-level nested extraction
allMembers, err := json.Get(complexData, "company.departments{teams}{flat:members}")
// Result: [Alice's data, Bob's data]

// Extract specific fields
allNames, err := json.Get(complexData, "company.departments{teams}{flat:members}{name}")
// Result: ["Alice", "Bob"]

// Flatten skills extraction
allSkills, err := json.Get(complexData, "company.departments{teams}{flat:members}{flat:skills}")
// Result: ["Go", "Python", "Java", "Spring"]
Array Operations
arrayData := `{
  "numbers": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
  "users": [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 30}
  ]
}`

// Array indexing and slicing
first, err := json.GetInt(arrayData, "numbers[0]")       // 1
last, err := json.GetInt(arrayData, "numbers[-1]")       // 10 (negative index)
slice, err := json.Get(arrayData, "numbers[1:4]")        // [2, 3, 4]
everyOther, err := json.Get(arrayData, "numbers[::2]")   // [1, 3, 5, 7, 9]
everyOther, err := json.Get(arrayData, "numbers[::-2]")  // [10 8 6 4 2]

// Nested array access
ages, err := json.Get(arrayData, "users{age}") // [25, 30]

πŸ”§ Configuration Options

Processor Configuration

The json.New() function now supports optional configuration parameters:

// 1. No parameters - uses default configuration
processor1 := json.New()
defer processor1.Close()

// 2. Explicit nil - same as default configuration
processor2 := json.New()
defer processor2.Close()

// 3. Custom configuration
customConfig := &json.Config{
    // Cache settings
    EnableCache:      true,             // Enable cache
    MaxCacheSize:     5000,             // Cache entry count
    CacheTTL:         10 * time.Minute, // Cache expiration time

    // Size limits
    MaxJSONSize:      50 * 1024 * 1024, // 50MB JSON size limit
    MaxPathDepth:     200,              // Path depth limit
    MaxBatchSize:     2000,             // Batch operation size limit

    // Concurrency settings
    MaxConcurrency:   100,   // Maximum concurrency
    ParallelThreshold: 20,   // Parallel processing threshold

    // Processing options
    EnableValidation: true,  // Enable validation
    StrictMode:       false, // Non-strict mode
    CreatePaths:      true,  // Auto-create paths
    CleanupNulls:     true,  // Cleanup null values
}

processor3 := json.New(customConfig)
defer processor3.Close()

// 4. Predefined configurations
secureProcessor := json.New(json.HighSecurityConfig())
largeDataProcessor := json.New(json.LargeDataConfig())
Operation Options
opts := &json.ProcessorOptions{
    CreatePaths:     true,  // Auto-create paths
    CleanupNulls:    true,  // Cleanup null values
    CompactArrays:   true,  // Compact arrays
    ContinueOnError: false, // Continue on error
    MaxDepth:        50,    // Maximum depth
}

result, err := json.Get(data, "path", opts)
Performance Monitoring
processor := json.New(json.DefaultConfig())
defer processor.Close()

// Get statistics after operations
stats := processor.GetStats()
fmt.Printf("Total operations: %d\n", stats.OperationCount)
fmt.Printf("Cache hit rate: %.2f%%\n", stats.HitRatio*100)
fmt.Printf("Cache memory usage: %d bytes\n", stats.CacheMemory)

// Get health status
health := processor.GetHealthStatus()
fmt.Printf("System health: %v\n", health.Healthy)

πŸ“ File Operations

Basic File Operations
// Load JSON from file
data, err := json.LoadFromFile("example.json")

// Save to file (pretty format)
err = json.SaveToFile("output_pretty.json", data, true)

// Save to file (compact format)
err = json.SaveToFile("output.json", data, false)

// Load from Reader
file, err := os.Open("large_data.json")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

data, err := json.LoadFromReader(file)

// Save to Writer
var buffer bytes.Buffer
err = json.SaveToWriter(&buffer, data, true)
Marshal/Unmarshal File Operations
// Marshal data to file (compact format by default)
user := map[string]any{
    "name": "Alice",
    "age":  30,
    "email": "alice@example.com",
}
err := json.MarshalToFile("user.json", user)

// Marshal data to file (pretty format)
err = json.MarshalToFile("user_pretty.json", user, true)

// Unmarshal data from file
var loadedUser map[string]any
err = json.UnmarshalFromFile("user.json", &loadedUser)

// Works with structs too
type User struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

var person User
err = json.UnmarshalFromFile("user.json", &person)

// Using processor for advanced options
processor := json.New()
defer processor.Close()

err = processor.MarshalToFile("advanced.json", user, true)
err = processor.UnmarshalFromFile("advanced.json", &loadedUser, opts...)
Batch File Processing
configFiles := []string{
    "database.json",
    "cache.json",
    "logging.json",
}

allConfigs := make(map[string]any)

for _, filename := range configFiles {
    config, err := json.LoadFromFile(filename)
    if err != nil {
        log.Printf("Loading %s failed: %v", filename, err)
        continue
    }

    configName := strings.TrimSuffix(filename, ".json")
    allConfigs[configName] = config
}

// Save merged configuration
err := json.SaveToFile("merged_config.json", allConfigs, true)
Security Configuration
// Security configuration
secureConfig := &json.Config{
    MaxJSONSize:       10 * 1024 * 1024,    // 10MB JSON size limit
    MaxPathDepth:      50,                  // Path depth limit
    MaxNestingDepth:   100,                 // Object nesting depth limit
    MaxArrayElements:  10000,               // Array element count limit
    MaxObjectKeys:     1000,                // Object key count limit
    ValidateInput:     true,                // Input validation
    EnableValidation:  true,                // Enable validation
    StrictMode:        true,                // Strict mode
}

processor := json.New(secureConfig)
defer processor.Close()

🎯 Use Cases

Example - API Response Processing
// Typical REST API response
apiResponse := `{
    "status": "success",
    "code": 200,
    "data": {
        "users": [
            {
                "id": 1,
                "profile": {
                    "name": "Alice Johnson",
                    "email": "alice@example.com"
                },
                "permissions": ["read", "write", "admin"],
                "metadata": {
                    "created_at": "2023-01-15T10:30:00Z",
                    "tags": ["premium", "verified"]
                }
            }
        ],
        "pagination": {
            "page": 1,
            "total": 25
        }
    }
}`

// Quick extraction of key information
status, err := json.GetString(apiResponse, "status")
// Result: success

code, err := json.GetInt(apiResponse, "code")
// Result: 200

// Get pagination information
totalUsers, err := json.GetInt(apiResponse, "data.pagination.total")
// Result: 25

currentPage, err := json.GetInt(apiResponse, "data.pagination.page")
// Result: 1

// Batch extract user information
userNames, err := json.Get(apiResponse, "data.users.profile.name")
// Result: ["Alice Johnson"]

userEmails, err := json.Get(apiResponse, "data.users.profile.email")
// Result: ["alice@example.com"]

// Flatten extract all permissions
allPermissions, err := json.Get(apiResponse, "data.users{flat:permissions}")
// Result: ["read", "write", "admin"]
Example - Configuration File Management
// Multi-environment configuration file
configJSON := `{
    "app": {
        "name": "MyApplication",
        "version": "1.2.3"
    },
    "environments": {
        "development": {
            "database": {
                "host": "localhost",
                "port": 5432,
                "name": "myapp_dev"
            },
            "cache": {
                "enabled": true,
                "host": "localhost",
                "port": 6379
            }
        },
        "production": {
            "database": {
                "host": "prod-db.example.com",
                "port": 5432,
                "name": "myapp_prod"
            },
            "cache": {
                "enabled": true,
                "host": "prod-cache.example.com",
                "port": 6379
            }
        }
    }
}`

// Type-safe configuration retrieval
dbHost := json.GetStringWithDefault(configJSON, "environments.production.database.host", "localhost")
dbPort := json.GetIntWithDefault(configJSON, "environments.production.database.port", 5432)
cacheEnabled := json.GetBoolWithDefault(configJSON, "environments.production.cache.enabled", false)

fmt.Printf("Production database: %s:%d\n", dbHost, dbPort)
fmt.Printf("Cache enabled: %v\n", cacheEnabled)

// Dynamic configuration updates
updates := map[string]any{
    "app.version": "1.2.4",
    "environments.production.cache.ttl": 10800, // 3 hours
}

newConfig, _ := json.SetMultiple(configJSON, updates)
Example - Data Analysis Processing
// Log and monitoring data
analyticsData := `{
    "events": [
        {
            "type": "request",
            "user_id": "user_123",
            "endpoint": "/api/users",
            "status_code": 200,
            "response_time": 45
        },
        {
            "type": "error",
            "user_id": "user_456",
            "endpoint": "/api/orders",
            "status_code": 500,
            "response_time": 5000
        }
    ]
}`

// Extract all event types
eventTypes, _ := json.Get(analyticsData, "events.type")
// Result: ["request", "error"]

// Extract all status codes
statusCodes, _ := json.Get(analyticsData, "events.status_code")
// Result: [200, 500]

// Extract all response times
responseTimes, _ := json.GetTyped[[]float64](analyticsData, "events.response_time")
// Result: [45, 5000]

// Calculate average response time
times := responseTimes
var total float64
for _, t := range times {
    total += t
}

avgTime := total / float64(len(times))
fmt.Printf("Average response time: %.2f ms\n", avgTime)

Set Operations - Data Safety Guarantee

All Set operations follow a safe-by-default pattern that ensures your data is never corrupted:

// βœ… Success: Returns modified data
result, err := json.Set(data, "user.name", "Alice")
if err == nil {
    // result contains successfully modified JSON
    fmt.Println("Data updated:", result)
}

// ❌ Failure: Returns original unmodified data
result, err := json.Set(data, "invalid[path", "value")
if err != nil {
    // result still contains valid original data
    // Your original data is NEVER corrupted
    fmt.Printf("Set failed: %v\n", err)
    fmt.Println("Original data preserved:", result)
}

Key Benefits:

  • πŸ”’ Data Integrity: Original data never corrupted on error
  • βœ… Safe Fallback: Always have valid JSON to work with
  • 🎯 Predictable: Consistent behavior across all operations

πŸ’‘ Examples & Resources

πŸ“ Example Code

The repository includes comprehensive examples demonstrating various features and use cases:

Basic Examples
Advanced Examples
Configuration Examples

πŸ“„ License

This project is licensed under the MIT License - see the LICENSE file for details.

🀝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

🌟 Star History

If you find this project useful, please consider giving it a star! ⭐

Made with ❀️ by the CyberGoDev team

Documentation ΒΆ

Index ΒΆ

Constants ΒΆ

View Source 
const (
	// Buffer and Pool Sizes - Optimized for production workloads
	DefaultBufferSize        = 1024
	MaxPoolBufferSize        = 16384
	MinPoolBufferSize        = 512
	DefaultPathSegmentCap    = 8
	MaxPathSegmentCap        = 128
	DefaultStringBuilderSize = 256

	// Cache Sizes - Balanced for performance and memory
	DefaultCacheSize     = 128
	MaxCacheEntries      = 512
	CacheCleanupKeepSize = 256

	// Operation Limits - Secure defaults with reasonable headroom
	InvalidArrayIndex        = -999999
	DefaultMaxJSONSize       = 10 * 1024 * 1024 // 10MB - reasonable for most use cases
	DefaultMaxSecuritySize   = 10 * 1024 * 1024
	DefaultMaxNestingDepth   = 32
	DefaultMaxObjectKeys     = 10000
	DefaultMaxArrayElements  = 10000
	DefaultMaxPathDepth      = 50
	DefaultMaxBatchSize      = 1000
	DefaultMaxConcurrency    = 50
	DefaultParallelThreshold = 10

	// Timing and Intervals - Optimized for responsiveness
	MemoryPressureCheckInterval = 30000
	PoolResetInterval           = 60000
	PoolResetIntervalPressure   = 30000
	CacheCleanupInterval        = 30 * time.Second
	DeadlockCheckInterval       = 30 * time.Second
	DeadlockThreshold           = 30 * time.Second
	SlowOperationThreshold      = 100 * time.Millisecond

	// Retry and Timeout - Production-ready settings
	MaxRetries              = 3
	BaseRetryDelay          = 10 * time.Millisecond
	DefaultOperationTimeout = 30 * time.Second
	AcquireSlotRetryDelay   = 1 * time.Millisecond

	// Path Validation - Secure but flexible
	MaxPathLength          = 5000
	MaxSegmentLength       = 1024
	MaxExtractionDepth     = 10
	MaxConsecutiveColons   = 3
	MaxConsecutiveBrackets = 3

	// Security constants (aliases for backward compatibility)
	MaxSecurityValidationSize = DefaultMaxSecuritySize
	MaxAllowedNestingDepth    = DefaultMaxNestingDepth
	MaxAllowedObjectKeys      = DefaultMaxObjectKeys
	MaxAllowedArrayElements   = DefaultMaxArrayElements

	// Cache TTL - Default cache time-to-live
	DefaultCacheTTL = 5 * time.Minute
)
View Source 
const (
	ErrCodeInvalidJSON       = "ERR_INVALID_JSON"
	ErrCodePathNotFound      = "ERR_PATH_NOT_FOUND"
	ErrCodeTypeMismatch      = "ERR_TYPE_MISMATCH"
	ErrCodeSizeLimit         = "ERR_SIZE_LIMIT"
	ErrCodeDepthLimit        = "ERR_DEPTH_LIMIT"
	ErrCodeSecurityViolation = "ERR_SECURITY_VIOLATION"
	ErrCodeOperationFailed   = "ERR_OPERATION_FAILED"
	ErrCodeTimeout           = "ERR_TIMEOUT"
	ErrCodeConcurrencyLimit  = "ERR_CONCURRENCY_LIMIT"
	ErrCodeProcessorClosed   = "ERR_PROCESSOR_CLOSED"
	ErrCodeRateLimit         = "ERR_RATE_LIMIT"
)

Error codes for machine-readable error identification

Variables ΒΆ

View Source 
var (
	ErrPathNotFoundNew   = &ProcessorError{Type: ErrTypeNavigation, Message: "path not found"}
	ErrInvalidPathNew    = &ProcessorError{Type: ErrTypeValidation, Message: "invalid path"}
	ErrInvalidJSONNew    = &ProcessorError{Type: ErrTypeValidation, Message: "invalid JSON"}
	ErrIndexOutOfBounds  = &ProcessorError{Type: ErrTypeBoundary, Message: "index out of bounds"}
	ErrTypeConversionNew = &ProcessorError{Type: ErrTypeConversion, Message: "type conversion failed"}
	ErrTimeoutNew        = &ProcessorError{Type: ErrTypeTimeout, Message: "operation timeout"}
	ErrRateLimitNew      = &ProcessorError{Type: ErrTypeRateLimit, Message: "rate limit exceeded"}
)

Common error variables for the new architecture

View Source 
var (
	// Primary errors for common cases
	ErrInvalidJSON     = errors.New("invalid JSON format")
	ErrPathNotFound    = errors.New("path not found")
	ErrTypeMismatch    = errors.New("type mismatch")
	ErrOperationFailed = errors.New("operation failed")
	ErrInvalidPath     = errors.New("invalid path format")
	ErrProcessorClosed = errors.New("processor is closed")

	// Limit-related errors
	ErrSizeLimit        = errors.New("size limit exceeded")
	ErrDepthLimit       = errors.New("depth limit exceeded")
	ErrConcurrencyLimit = errors.New("concurrency limit exceeded")

	// Security and validation errors
	ErrSecurityViolation = errors.New("security violation detected")
	ErrUnsupportedPath   = errors.New("unsupported path operation")

	// Resource and performance errors
	ErrCacheFull         = errors.New("cache is full")
	ErrCacheDisabled     = errors.New("cache is disabled")
	ErrOperationTimeout  = errors.New("operation timeout")
	ErrResourceExhausted = errors.New("system resources exhausted")

	// Control flow errors (internal use)
	ErrIteratorControl = errors.New("iterator control signal")
)

Core error definitions - simplified and optimized for performance

View Source 
var DeletedMarker = &struct{ deleted bool }{deleted: true}

Special marker for deleted values

Functions ΒΆ

func ClampIndex ΒΆ 

func ClampIndex(index, length int) int

ClampIndex clamps an index to valid bounds for an array

func Compact ΒΆ 

func Compact(dst *bytes.Buffer, src []byte) error

Compact appends to dst the JSON-encoded src with insignificant space characters elided.

func CompareJson ΒΆ 

func CompareJson(json1, json2 string) (bool, error)

CompareJson compares two JSON strings for equality

func ConvertFromScientific ΒΆ 

func ConvertFromScientific(s string) (string, error)

ConvertFromScientific converts a scientific notation string to regular number format

func ConvertToBool ΒΆ added in v1.0.4 

func ConvertToBool(value any) (bool, bool)

ConvertToBool converts any value to bool

func ConvertToFloat64 ΒΆ added in v1.0.4 

func ConvertToFloat64(value any) (float64, bool)

ConvertToFloat64 converts any value to float64

func ConvertToInt ΒΆ added in v1.0.4 

func ConvertToInt(value any) (int, bool)

ConvertToInt converts any value to int with comprehensive type support

func ConvertToInt64 ΒΆ added in v1.0.4 

func ConvertToInt64(value any) (int64, bool)

ConvertToInt64 converts any value to int64

func ConvertToString ΒΆ added in v1.0.4 

func ConvertToString(value any) string

ConvertToString converts any value to string (for backward compatibility)

func ConvertToUint64 ΒΆ added in v1.0.4 

func ConvertToUint64(value any) (uint64, bool)

ConvertToUint64 converts any value to uint64

func CreateEmptyContainer ΒΆ 

func CreateEmptyContainer(containerType string) any

CreateEmptyContainer creates an empty container of the specified type

func DeepCopy ΒΆ 

func DeepCopy(data any) (any, error)

DeepCopy creates a deep copy of JSON-compatible data with improved efficiency

func Delete ΒΆ 

func Delete(jsonStr, path string, opts ...*ProcessorOptions) (string, error)

Delete deletes a value from JSON at the specified path

func DeleteWithCleanNull ΒΆ 

func DeleteWithCleanNull(jsonStr, path string, opts ...*ProcessorOptions) (string, error)

DeleteWithCleanNull removes a value from JSON and cleans up null values

func Encode ΒΆ 

func Encode(value any, config ...*EncodeConfig) (string, error)

Encode converts any Go value to JSON string

func EncodeCompact ΒΆ 

func EncodeCompact(value any, config ...*EncodeConfig) (string, error)

EncodeCompact converts any Go value to compact JSON string

func EncodePretty ΒΆ 

func EncodePretty(value any, config ...*EncodeConfig) (string, error)

EncodePretty converts any Go value to pretty-formatted JSON string

func EscapeJSONPointer ΒΆ 

func EscapeJSONPointer(s string) string

EscapeJSONPointer escapes special characters for JSON Pointer

func FastValidateJSON ΒΆ added in v1.0.6 

func FastValidateJSON(jsonStr string) bool

FastValidateJSON performs ultra-fast JSON validation for hot paths

func FastValidatePath ΒΆ added in v1.0.6 

func FastValidatePath(path string) bool

FastValidatePath performs ultra-fast path validation for hot paths

func Foreach ΒΆ 

func Foreach(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) error

Foreach iterates over JSON data and calls the callback for each item This matches the user's expected usage: json.Foreach(jsonStr, func(key, item any) { ... }) Automatically detects nested calls and uses isolated processor to prevent state conflicts

func ForeachNested ΒΆ 

func ForeachNested(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachNested iterates over JSON data with isolated processor instance for nested calls This prevents state conflicts when nesting Foreach calls

func ForeachReturn ΒΆ 

func ForeachReturn(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) (string, error)

ForeachReturn iterates over JSON data and returns the modified JSON string Automatically detects nested calls and uses isolated processor to prevent state conflicts

func ForeachReturnNested ΒΆ 

func ForeachReturnNested(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) (string, error)

ForeachReturnNested iterates over JSON data and returns the modified JSON string Uses isolated processor instance to prevent state conflicts in nested calls

func ForeachWithIterator ΒΆ 

func ForeachWithIterator(jsonStr string, callback ForeachCallbackWithIterator, opts ...*ProcessorOptions) error

ForeachWithIterator iterates over JSON data with iterator access in callback Automatically detects nested calls and uses isolated processor to prevent state conflicts

func ForeachWithIteratorNested ΒΆ 

func ForeachWithIteratorNested(jsonStr string, callback ForeachCallbackWithIterator, opts ...*ProcessorOptions) error

ForeachWithIteratorNested iterates over JSON data with iterator access using isolated processor

func ForeachWithPath ΒΆ 

func ForeachWithPath(jsonStr string, path string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachWithPath iterates over JSON data at a specific path This allows iteration over a subset of the JSON structure

func ForeachWithPathNested ΒΆ 

func ForeachWithPathNested(jsonStr string, path string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachWithPathNested iterates over JSON data at a specific path using isolated processor

func FormatCompact ΒΆ 

func FormatCompact(jsonStr string, opts ...*ProcessorOptions) (string, error)

FormatCompact removes whitespace from JSON

func FormatNumber ΒΆ 

func FormatNumber(value any) string

FormatNumber formats a number value as a string

func FormatPretty ΒΆ 

func FormatPretty(jsonStr string, opts ...*ProcessorOptions) (string, error)

FormatPretty formats JSON with indentation

func Get ΒΆ 

func Get(jsonStr, path string, opts ...*ProcessorOptions) (any, error)

Get retrieves a value from JSON at the specified path

func GetArray ΒΆ 

func GetArray(jsonStr, path string, opts ...*ProcessorOptions) ([]any, error)

GetArray retrieves an array from JSON

func GetArrayWithDefault ΒΆ 

func GetArrayWithDefault(jsonStr, path string, defaultValue []any, opts ...*ProcessorOptions) []any

func GetBool ΒΆ 

func GetBool(jsonStr, path string, opts ...*ProcessorOptions) (bool, error)

GetBool retrieves a bool value from JSON

func GetBoolWithDefault ΒΆ 

func GetBoolWithDefault(jsonStr, path string, defaultValue bool, opts ...*ProcessorOptions) bool

func GetContainerSize ΒΆ 

func GetContainerSize(data any) int

GetContainerSize returns the size of a container

func GetFloat64 ΒΆ 

func GetFloat64(jsonStr, path string, opts ...*ProcessorOptions) (float64, error)

GetFloat64 retrieves a float64 value from JSON

func GetFloat64WithDefault ΒΆ 

func GetFloat64WithDefault(jsonStr, path string, defaultValue float64, opts ...*ProcessorOptions) float64

func GetInt ΒΆ 

func GetInt(jsonStr, path string, opts ...*ProcessorOptions) (int, error)

GetInt retrieves an int value from JSON

func GetIntWithDefault ΒΆ 

func GetIntWithDefault(jsonStr, path string, defaultValue int, opts ...*ProcessorOptions) int

func GetIterableValue ΒΆ 

func GetIterableValue[T any](iv *IterableValue, path string) (T, error)

GetIterableValue is a generic function that provides GetTyped functionality for IterableValue Usage: name, err := GetIterableValue[string](item, "name")

func GetIterableValueWithDefault ΒΆ 

func GetIterableValueWithDefault[T any](iv *IterableValue, path string, defaultValue T) T

GetIterableValueWithDefault retrieves a typed value from IterableValue with a default fallback

func GetMultiple ΒΆ 

func GetMultiple(jsonStr string, paths []string, opts ...*ProcessorOptions) (map[string]any, error)

GetMultiple retrieves multiple values from JSON using multiple path expressions

func GetObject ΒΆ 

func GetObject(jsonStr, path string, opts ...*ProcessorOptions) (map[string]any, error)

GetObject retrieves an object from JSON

func GetObjectWithDefault ΒΆ 

func GetObjectWithDefault(jsonStr, path string, defaultValue map[string]any, opts ...*ProcessorOptions) map[string]any

func GetString ΒΆ 

func GetString(jsonStr, path string, opts ...*ProcessorOptions) (string, error)

GetString retrieves a string value from JSON

func GetStringWithDefault ΒΆ 

func GetStringWithDefault(jsonStr, path, defaultValue string, opts ...*ProcessorOptions) string

Type-specific convenience functions with defaults

func GetTyped ΒΆ 

func GetTyped[T any](jsonStr, path string, opts ...*ProcessorOptions) (T, error)

GetTyped retrieves a typed value from JSON at the specified path

func GetTypedWithDefault ΒΆ 

func GetTypedWithDefault[T any](jsonStr, path string, defaultValue T, opts ...*ProcessorOptions) T

GetTypedWithDefault retrieves a typed value with a default fallback

func GetTypedWithProcessor ΒΆ 

func GetTypedWithProcessor[T any](processor *Processor, jsonStr, path string, opts ...*ProcessorOptions) (T, error)

GetTypedWithProcessor retrieves a typed value from JSON using a specific processor with optimized conversion

func GetWithDefault ΒΆ 

func GetWithDefault(jsonStr, path string, defaultValue any, opts ...*ProcessorOptions) any

GetWithDefault retrieves a value from JSON with a default fallback

func HTMLEscape ΒΆ 

func HTMLEscape(dst *bytes.Buffer, src []byte)

HTMLEscape appends to dst the JSON-encoded src with HTML-safe escaping.

func Indent ΒΆ 

func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error

Indent appends to dst an indented form of the JSON-encoded src.

func IsContainer ΒΆ 

func IsContainer(data any) bool

IsContainer checks if the data is a container type (map or slice)

func IsInteger ΒΆ 

func IsInteger(s string) bool

IsInteger checks if a string represents an integer value

func IsLargeNumber ΒΆ 

func IsLargeNumber(numStr string) bool

IsLargeNumber checks if a string represents a number that's too large for standard numeric types

func IsNumeric ΒΆ 

func IsNumeric(s string) bool

IsNumeric checks if a string represents a numeric value

func IsScientificNotation ΒΆ 

func IsScientificNotation(s string) bool

IsScientificNotation checks if a string represents a number in scientific notation

func IsValidIndex ΒΆ 

func IsValidIndex(index, length int) bool

IsValidIndex checks if an index is valid for an array of given length

func IsValidJson ΒΆ 

func IsValidJson(jsonStr string) bool

IsValidJson quickly checks if a string is valid JSON

func IsValidPath ΒΆ 

func IsValidPath(path string) bool

IsValidPath checks if a path expression is valid with comprehensive validation

func LoadFromFile ΒΆ 

func LoadFromFile(filename string) (string, error)

LoadFromFile loads JSON data from a file

func Marshal ΒΆ 

func Marshal(v any) ([]byte, error)

Marshal returns the JSON encoding of v. This function is 100% compatible with encoding/json.Marshal.

func MarshalIndent ΒΆ 

func MarshalIndent(v any, prefix, indent string) ([]byte, error)

MarshalIndent is like Marshal but applies indentation to format the output. This function is 100% compatible with encoding/json.MarshalIndent.

func MarshalToFile ΒΆ added in v1.0.6 

func MarshalToFile(path string, data any, pretty ...bool) error

MarshalToFile converts data to JSON and saves it to the specified file. This is a convenience function that combines Marshal and file writing operations.

Parameters:

  • path: file path where JSON will be saved (directories are created automatically)
  • data: any Go value to be marshaled to JSON
  • pretty: optional parameter - true for formatted JSON, false for compact (default: false)

Returns error if marshaling fails or file cannot be written.

Example: 

user := map[string]any{"name": "John", "age": 30}
err := json.MarshalToFile("data/user.json", user, true)

func MergeJson ΒΆ 

func MergeJson(json1, json2 string) (string, error)

MergeJson merges two JSON objects

func NormalizeIndex ΒΆ 

func NormalizeIndex(index, length int) int

NormalizeIndex normalizes an array index (handles negative indices)

func ParseBool ΒΆ 

func ParseBool(s string) (bool, error)

ParseBool parses a string to boolean with error handling

func ParseFloat ΒΆ 

func ParseFloat(s string) (float64, error)

ParseFloat parses a string to float64 with error handling

func ParseInt ΒΆ 

func ParseInt(s string) (int, error)

ParseInt parses a string to integer with error handling

func PreservingUnmarshal ΒΆ 

func PreservingUnmarshal(data []byte, v any, preserveNumbers bool) error

PreservingUnmarshal unmarshals JSON with number preservation

func SafeConvertToInt64 ΒΆ 

func SafeConvertToInt64(value any) (int64, error)

SafeConvertToInt64 safely converts any value to int64 with error handling

func SafeConvertToUint64 ΒΆ 

func SafeConvertToUint64(value any) (uint64, error)

SafeConvertToUint64 safely converts any value to uint64 with error handling

func SafeTypeAssert ΒΆ 

func SafeTypeAssert[T any](value any) (T, bool)

SafeTypeAssert performs a safe type assertion with error handling

func SanitizeKey ΒΆ 

func SanitizeKey(key string) string

SanitizeKey sanitizes a key for safe use in maps

func SaveToFile ΒΆ 

func SaveToFile(filePath string, data any, pretty ...bool) error

SaveToFile saves JSON data to a file with optional formatting

func Set ΒΆ 

func Set(jsonStr, path string, value any, opts ...*ProcessorOptions) (string, error)

Set sets a value in JSON at the specified path Returns:

  • On success: modified JSON string and nil error
  • On failure: original unmodified JSON string and error information

func SetGlobalProcessor ΒΆ 

func SetGlobalProcessor(processor *Processor)

SetGlobalProcessor allows setting a custom global processor (thread-safe)

func SetMultiple ΒΆ 

func SetMultiple(jsonStr string, updates map[string]any, opts ...*ProcessorOptions) (string, error)

SetMultiple sets multiple values using a map of path-value pairs

func SetMultipleWithAdd ΒΆ 

func SetMultipleWithAdd(jsonStr string, updates map[string]any, opts ...*ProcessorOptions) (string, error)

SetMultipleWithAdd sets multiple values with automatic path creation

func SetWithAdd ΒΆ 

func SetWithAdd(jsonStr, path string, value any) (string, error)

SetWithAdd sets a value with automatic path creation Returns:

  • On success: modified JSON string and nil error
  • On failure: original unmodified JSON string and error information

func ShutdownGlobalProcessor ΒΆ 

func ShutdownGlobalProcessor()

ShutdownGlobalProcessor gracefully shuts down the global processor

func SmartNumberConversion ΒΆ 

func SmartNumberConversion(value any) any

SmartNumberConversion provides intelligent number type conversion

func TestProcessorResourcePools ΒΆ 

func TestProcessorResourcePools(processor *Processor) bool

TestProcessorResourcePools tests processor resource pool functionality

func TypeSafeConvert ΒΆ 

func TypeSafeConvert[T any](value any) (T, error)

TypeSafeConvert attempts to convert a value to the target type safely

func UnescapeJSONPointer ΒΆ 

func UnescapeJSONPointer(s string) string

UnescapeJSONPointer unescapes JSON Pointer special characters

func UnifiedTypeConversion ΒΆ added in v1.0.4 

func UnifiedTypeConversion[T any](value any) (T, bool)

UnifiedTypeConversion provides optimized type conversion with comprehensive support

func Unmarshal ΒΆ 

func Unmarshal(data []byte, v any) error

Unmarshal parses the JSON-encoded data and stores the result in v. This function is 100% compatible with encoding/json.Unmarshal.

func UnmarshalFromFile ΒΆ added in v1.0.6 

func UnmarshalFromFile(path string, v any) error

UnmarshalFromFile reads JSON data from the specified file and unmarshals it into the provided value. This is a convenience function that combines file reading and Unmarshal operations.

Parameters:

  • path: file path to read JSON from
  • v: pointer to the value where JSON will be unmarshaled

Returns error if file cannot be read or JSON unmarshaling fails.

Example: 

var user map[string]any
err := json.UnmarshalFromFile("data/user.json", &user)

// Or with a struct
var person Person
err := json.UnmarshalFromFile("data/person.json", &person)

func Valid ΒΆ 

func Valid(data []byte) bool

Valid reports whether data is valid JSON

func ValidateConfig ΒΆ 

func ValidateConfig(config *Config) error

ValidateConfig validates configuration values and applies corrections

func ValidateOptions ΒΆ 

func ValidateOptions(options *ProcessorOptions) error

ValidateOptions validates processor options with enhanced checks

func ValidatePath ΒΆ 

func ValidatePath(path string) error

ValidatePath validates a path expression and returns detailed error information

func WrapError ΒΆ added in v1.0.6 

func WrapError(err error, op, message string) error

WrapError wraps an error with additional context

func WrapPathError ΒΆ added in v1.0.6 

func WrapPathError(err error, op, path, message string) error

WrapPathError wraps an error with path context

Types ΒΆ

type ArrayExtensionError ΒΆ 

type ArrayExtensionError struct {
	CurrentLength  int
	RequiredLength int
	TargetIndex    int
	Value          any
	Message        string
	ExtendedArray  []any // For storing pre-created extended arrays
}

ArrayExtensionError represents an error that signals array extension is needed

func (*ArrayExtensionError) Error ΒΆ 

func (e *ArrayExtensionError) Error() string

type ArrayExtensionNeededError ΒΆ 

type ArrayExtensionNeededError struct {
	RequiredLength int
	CurrentLength  int
	Start          int
	End            int
	Step           int
	Value          any
}

ArrayExtensionNeededError indicates that an array needs to be extended

func (*ArrayExtensionNeededError) Error ΒΆ 

func (e *ArrayExtensionNeededError) Error() string

type ArrayOperations ΒΆ 

type ArrayOperations interface {
	HandleArrayAccess(data any, index int) NavigationResult
	HandleArraySlice(data any, start, end, step int) NavigationResult
	ParseArrayIndex(indexStr string) int
	HandleNegativeIndex(index, length int) int
	ValidateArrayBounds(index, length int) bool
	ExtendArray(arr []any, targetLength int) []any
	SetArrayElement(arr []any, index int, value any) error
}

ArrayOperations interface for array-related operations

func NewArrayOperations ΒΆ 

func NewArrayOperations(utils ProcessorUtils) ArrayOperations

NewArrayOperations creates a new array operations instance

type BatchOperation ΒΆ 

type BatchOperation struct {
	Type    string `json:"type"`     // "get", "set", "delete", "validate"
	JSONStr string `json:"json_str"` // JSON string to operate on
	Path    string `json:"path"`     // Path for the operation
	Value   any    `json:"value"`    // Value for set operations
	ID      string `json:"id"`       // Unique identifier for this operation
}

BatchOperation represents a single operation in a batch

type BatchResult ΒΆ 

type BatchResult struct {
	ID     string `json:"id"`     // Operation ID
	Result any    `json:"result"` // Operation result
	Error  error  `json:"error"`  // Operation error, if any
}

BatchResult represents the result of a batch operation

type BenchmarkHelper ΒΆ 

type BenchmarkHelper struct {
	// contains filtered or unexported fields
}

BenchmarkHelper provides utilities for benchmark tests

func NewBenchmarkHelper ΒΆ 

func NewBenchmarkHelper(b *testing.B) *BenchmarkHelper

NewBenchmarkHelper creates a new benchmark helper

func (*BenchmarkHelper) MeasureMemory ΒΆ 

func (bh *BenchmarkHelper) MeasureMemory(fn func())

MeasureMemory measures memory allocations during benchmark

type CacheKey ΒΆ 

type CacheKey struct {
	Operation string
	JSONStr   string
	Path      string
	Options   string
}

CacheKey represents a cache key for operations

type CacheStats ΒΆ 

type CacheStats struct {
	HitCount         int64        `json:"hit_count"`         // Total cache hits
	MissCount        int64        `json:"miss_count"`        // Total cache misses
	TotalMemory      int64        `json:"total_memory"`      // Total memory usage in bytes
	HitRatio         float64      `json:"hit_ratio"`         // Cache hit ratio
	MemoryEfficiency float64      `json:"memory_efficiency"` // Memory efficiency (hits per MB)
	Evictions        int64        `json:"evictions"`         // Total evictions performed
	ShardCount       int          `json:"shard_count"`       // Number of cache shards
	ShardStats       []ShardStats `json:"shard_stats"`       // Per-shard statistics
}

CacheStats provides comprehensive cache statistics

type CheckResult ΒΆ 

type CheckResult struct {
	Healthy bool   `json:"healthy"`
	Message string `json:"message"`
}

CheckResult represents the result of a single health check

type ComplexDeleteProcessor ΒΆ 

type ComplexDeleteProcessor struct {
	// contains filtered or unexported fields
}

ComplexDeleteProcessor handles complex path deletions with reverse mapping

func NewComplexDeleteProcessor ΒΆ 

func NewComplexDeleteProcessor(p *Processor) *ComplexDeleteProcessor

NewComplexDeleteProcessor creates a new complex delete processor

func (*ComplexDeleteProcessor) DeleteWithReverseMapping ΒΆ 

func (cdp *ComplexDeleteProcessor) DeleteWithReverseMapping(data any, path string) error

DeleteWithReverseMapping performs deletion using reverse mapping for complex paths

type ConcurrencyManager ΒΆ 

type ConcurrencyManager struct {
	// contains filtered or unexported fields
}

ConcurrencyManager manages concurrent operations with enhanced safety

func NewConcurrencyManager ΒΆ 

func NewConcurrencyManager(maxConcurrency int, operationsPerSecond int) *ConcurrencyManager

NewConcurrencyManager creates a new concurrency manager

func (*ConcurrencyManager) DetectDeadlocks ΒΆ 

func (cm *ConcurrencyManager) DetectDeadlocks() []DeadlockInfo

DetectDeadlocks detects potential deadlocks

func (*ConcurrencyManager) ExecuteWithConcurrencyControl ΒΆ 

func (cm *ConcurrencyManager) ExecuteWithConcurrencyControl(
	ctx context.Context,
	operation func() error,
	timeout time.Duration,
) error

ExecuteWithConcurrencyControl executes a function with concurrency control

func (*ConcurrencyManager) GetStats ΒΆ 

func (cm *ConcurrencyManager) GetStats() ConcurrencyStats

GetStats returns concurrency statistics

type ConcurrencyStats ΒΆ 

type ConcurrencyStats struct {
	MaxConcurrency      int
	CurrentOperations   int64
	TotalOperations     int64
	AverageWaitTime     time.Duration
	CircuitOpen         bool
	FailureCount        int64
	OperationsPerSecond int64
}

ConcurrencyStats represents concurrency statistics

type ConcurrencyTester ΒΆ 

type ConcurrencyTester struct {
	// contains filtered or unexported fields
}

ConcurrencyTester helps test concurrent operations

func NewConcurrencyTester ΒΆ 

func NewConcurrencyTester(t *testing.T, concurrency, iterations int) *ConcurrencyTester

NewConcurrencyTester creates a new concurrency tester

func (*ConcurrencyTester) Run ΒΆ 

func (ct *ConcurrencyTester) Run(operation func(workerID, iteration int) error)

Run runs concurrent test operations

type Config ΒΆ 

type Config struct {
	// Cache settings
	MaxCacheSize int           `json:"max_cache_size"` // Maximum number of cache entries
	CacheTTL     time.Duration `json:"cache_ttl"`      // Time-to-live for cache entries
	EnableCache  bool          `json:"enable_cache"`   // Whether to enable caching

	// Size limits
	MaxJSONSize  int64 `json:"max_json_size"`  // Maximum JSON size in bytes
	MaxPathDepth int   `json:"max_path_depth"` // Maximum path depth
	MaxBatchSize int   `json:"max_batch_size"` // Maximum batch operation size

	// Security limits (configurable)
	MaxNestingDepthSecurity   int   `json:"max_nesting_depth_security"`   // Maximum nesting depth for security validation (default: 50)
	MaxSecurityValidationSize int64 `json:"max_security_validation_size"` // Maximum size for security validation in bytes (default: 100MB)
	MaxObjectKeys             int   `json:"max_object_keys"`              // Maximum number of keys in JSON objects (default: 10000)
	MaxArrayElements          int   `json:"max_array_elements"`           // Maximum number of elements in arrays (default: 10000)

	// Concurrency settings
	MaxConcurrency    int `json:"max_concurrency"`    // Maximum concurrent operations
	ParallelThreshold int `json:"parallel_threshold"` // Threshold for parallel processing

	// Processing options
	EnableValidation bool `json:"enable_validation"` // Enable input validation
	StrictMode       bool `json:"strict_mode"`       // Enable strict parsing mode
	CreatePaths      bool `json:"create_paths"`      // Automatically create missing paths in Set operations
	CleanupNulls     bool `json:"cleanup_nulls"`     // Remove null values after deletion operations
	CompactArrays    bool `json:"compact_arrays"`    // Remove all null values from arrays (not just trailing)

	// Additional options for interface compatibility
	EnableMetrics       bool `json:"enable_metrics"`      // Enable metrics collection
	EnableHealthCheck   bool `json:"enable_health_check"` // Enable health checking
	AllowCommentsFlag   bool `json:"allow_comments"`      // Allow JSON with comments
	PreserveNumbersFlag bool `json:"preserve_numbers"`    // Preserve number format
	ValidateInput       bool `json:"validate_input"`      // Validate input
	MaxNestingDepth     int  `json:"max_nesting_depth"`   // Maximum nesting depth
	ValidateFilePath    bool `json:"validate_file_path"`  // Validate file paths
}

Config holds configuration for the JSON processor

func DefaultConfig ΒΆ 

func DefaultConfig() *Config

DefaultConfig returns the default configuration with optimized settings

func HighSecurityConfig ΒΆ 

func HighSecurityConfig() *Config

HighSecurityConfig returns a configuration with enhanced security settings

func LargeDataConfig ΒΆ 

func LargeDataConfig() *Config

LargeDataConfig returns a configuration optimized for processing large JSON datasets

func (*Config) AllowComments ΒΆ 

func (c *Config) AllowComments() bool

func (*Config) Clone ΒΆ added in v1.0.6 

func (c *Config) Clone() *Config

Clone creates a deep copy of the configuration

func (*Config) GetCacheTTL ΒΆ 

func (c *Config) GetCacheTTL() time.Duration

func (*Config) GetMaxCacheSize ΒΆ 

func (c *Config) GetMaxCacheSize() int

func (*Config) GetMaxConcurrency ΒΆ 

func (c *Config) GetMaxConcurrency() int

func (*Config) GetMaxJSONSize ΒΆ 

func (c *Config) GetMaxJSONSize() int64

func (*Config) GetMaxNestingDepth ΒΆ 

func (c *Config) GetMaxNestingDepth() int

func (*Config) GetMaxPathDepth ΒΆ 

func (c *Config) GetMaxPathDepth() int

func (*Config) GetSecurityLimits ΒΆ 

func (c *Config) GetSecurityLimits() map[string]any

GetSecurityLimits returns a summary of current security limits

func (*Config) IsCacheEnabled ΒΆ 

func (c *Config) IsCacheEnabled() bool

ConfigInterface implementation methods

func (*Config) IsHealthCheckEnabled ΒΆ 

func (c *Config) IsHealthCheckEnabled() bool

func (*Config) IsMetricsEnabled ΒΆ 

func (c *Config) IsMetricsEnabled() bool

func (*Config) IsStrictMode ΒΆ 

func (c *Config) IsStrictMode() bool

func (*Config) PreserveNumbers ΒΆ 

func (c *Config) PreserveNumbers() bool

func (*Config) ShouldCleanupNulls ΒΆ 

func (c *Config) ShouldCleanupNulls() bool

func (*Config) ShouldCompactArrays ΒΆ 

func (c *Config) ShouldCompactArrays() bool

func (*Config) ShouldCreatePaths ΒΆ 

func (c *Config) ShouldCreatePaths() bool

func (*Config) ShouldValidateFilePath ΒΆ 

func (c *Config) ShouldValidateFilePath() bool

func (*Config) ShouldValidateInput ΒΆ 

func (c *Config) ShouldValidateInput() bool

func (*Config) Validate ΒΆ added in v1.0.6 

func (c *Config) Validate() error

Validate validates the configuration and applies corrections

type ConsecutiveExtractionGroup ΒΆ 

type ConsecutiveExtractionGroup struct {
	StartIndex int
	EndIndex   int
	Segments   []PathSegment
}

ConsecutiveExtractionGroup represents a group of consecutive extraction operations

type CustomEncoder ΒΆ 

type CustomEncoder struct {
	// contains filtered or unexported fields
}

CustomEncoder provides advanced JSON encoding with configurable options

func NewCustomEncoder ΒΆ 

func NewCustomEncoder(config *EncodeConfig) *CustomEncoder

NewCustomEncoder creates a new custom encoder with the given configuration

func (*CustomEncoder) Close ΒΆ 

func (e *CustomEncoder) Close()

Close releases the encoder's buffers back to the pool

func (*CustomEncoder) Encode ΒΆ 

func (e *CustomEncoder) Encode(value any) (string, error)

Encode encodes the given value to JSON string using custom options

type DeadlockInfo ΒΆ 

type DeadlockInfo struct {
	GoroutineID uint64
	StartTime   time.Time
	Duration    time.Duration
}

DeadlockInfo represents information about a potential deadlock

type Decoder ΒΆ 

type Decoder struct {
	// contains filtered or unexported fields
}

Decoder reads and decodes JSON values from an input stream. This type is fully compatible with encoding/json.Decoder.

func NewDecoder ΒΆ 

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new decoder that reads from r. This function is fully compatible with encoding/json.NewDecoder.

The decoder introduces its own buffering and may read data from r beyond the JSON values requested.

func (*Decoder) Buffered ΒΆ 

func (dec *Decoder) Buffered() io.Reader

Buffered returns a reader of the data remaining in the Decoder's buffer. The reader is valid until the next call to Decode.

func (*Decoder) Decode ΒΆ 

func (dec *Decoder) Decode(v any) error

Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DisallowUnknownFields ΒΆ 

func (dec *Decoder) DisallowUnknownFields()

DisallowUnknownFields causes the Decoder to return an error when the destination is a struct and the input contains object keys which do not match any non-ignored, exported fields in the destination.

func (*Decoder) InputOffset ΒΆ 

func (dec *Decoder) InputOffset() int64

InputOffset returns the input stream byte offset of the current decoder position. The offset gives the location of the end of the most recently returned token and the beginning of the next token.

func (*Decoder) More ΒΆ 

func (dec *Decoder) More() bool

More reports whether there is another element in the current array or object being parsed.

func (*Decoder) Token ΒΆ 

func (dec *Decoder) Token() (Token, error)

Token returns the next JSON token in the input stream. At the end of the input stream, Token returns nil, io.EOF.

Token guarantees that the delimiters [ ] { } it returns are properly nested and matched: if Token encounters an unexpected delimiter in the input, it will return an error.

The input stream consists of zero or more JSON values, each separated by optional whitespace.

A Token holds one of these types: 

Delim, for the four JSON delimiters [ ] { }
bool, for JSON booleans
float64, for JSON numbers
Number, for JSON numbers
string, for JSON string literals
nil, for JSON null

func (*Decoder) UseNumber ΒΆ 

func (dec *Decoder) UseNumber()

UseNumber causes the Decoder to unmarshal a number into any as a Number instead of as a float64.

type DeepExtractionResult ΒΆ 

type DeepExtractionResult struct {
	Values []any
	Paths  []string // Optional: track the paths where values were found
}

DeepExtractionResult represents the result of a deep extraction operation

type DeleteOperations ΒΆ 

type DeleteOperations interface {
	DeleteValue(data any, path string) error
	DeleteValueWithSegments(data any, segments []PathSegmentInfo) error
	MarkForDeletion(data any, path string) error
	CleanupDeletedValues(data any) any
	CompactArray(arr []any) []any
}

DeleteOperations interface for deletion operations

func NewDeleteOperations ΒΆ 

func NewDeleteOperations(utils ProcessorUtils, pathParser PathParser, navigator Navigator, arrayOps ArrayOperations) DeleteOperations

NewDeleteOperations creates a new delete operations instance

type DeletionTarget ΒΆ 

type DeletionTarget struct {
	Container any    // The container (array or object) that holds the value to delete
	Key       any    // The key (string for objects, int for arrays) to delete
	Path      string // The path to this target for debugging
}

DeletionTarget represents a specific location in the original data structure that needs to be deleted

type Delim ΒΆ 

type Delim rune

Delim is a JSON delimiter.

func (Delim) String ΒΆ 

func (d Delim) String() string

type DetailedStats ΒΆ 

type DetailedStats struct {
	Stats Stats `json:"stats"`
	// contains filtered or unexported fields
}

DetailedStats provides comprehensive processor statistics (internal debugging)

type EncodeConfig ΒΆ 

type EncodeConfig struct {
	Pretty          bool   `json:"pretty"`
	Indent          string `json:"indent"`
	Prefix          string `json:"prefix"`
	EscapeHTML      bool   `json:"escape_html"`
	SortKeys        bool   `json:"sort_keys"`
	OmitEmpty       bool   `json:"omit_empty"`
	ValidateUTF8    bool   `json:"validate_utf8"`
	MaxDepth        int    `json:"max_depth"`
	DisallowUnknown bool   `json:"disallow_unknown"`

	// Number formatting options
	PreserveNumbers bool `json:"preserve_numbers"` // Preserve original number format and avoid type conversion
	FloatPrecision  int  `json:"float_precision"`  // Precision for float formatting (-1 for automatic)

	// Enhanced character escaping options
	DisableEscaping bool `json:"disable_escaping"` // Disable all character escaping (except quotes and backslashes)
	EscapeUnicode   bool `json:"escape_unicode"`   // Escape Unicode characters to \uXXXX format
	EscapeSlash     bool `json:"escape_slash"`     // Escape forward slashes to \/
	EscapeNewlines  bool `json:"escape_newlines"`  // Escape newlines to \n instead of literal newlines
	EscapeTabs      bool `json:"escape_tabs"`      // Escape tabs to \t instead of literal tabs

	// Null value handling
	IncludeNulls bool `json:"include_nulls"` // Include null values in output (default: true)

	// Custom escape characters
	CustomEscapes map[rune]string `json:"custom_escapes,omitempty"` // Custom character escape mappings
}

EncodeConfig provides advanced encoding configuration (for complex use cases)

func DefaultEncodeConfig ΒΆ 

func DefaultEncodeConfig() *EncodeConfig

DefaultEncodeConfig returns default encoding configuration

func NewCleanConfig ΒΆ 

func NewCleanConfig() *EncodeConfig

NewCleanConfig creates a configuration that omits null and empty values

func NewCompactConfig ΒΆ 

func NewCompactConfig() *EncodeConfig

NewCompactConfig returns configuration for compact JSON

func NewPrettyConfig ΒΆ 

func NewPrettyConfig() *EncodeConfig

NewPrettyConfig returns configuration for pretty-printed JSON

func NewReadableConfig ΒΆ 

func NewReadableConfig() *EncodeConfig

NewReadableConfig creates a configuration for human-readable JSON with minimal escaping

func NewWebSafeConfig ΒΆ 

func NewWebSafeConfig() *EncodeConfig

NewWebSafeConfig creates a configuration for web-safe JSON

func (*EncodeConfig) Clone ΒΆ 

func (c *EncodeConfig) Clone() *EncodeConfig

Clone creates a deep copy of the EncodeConfig

type Encoder ΒΆ 

type Encoder struct {
	// contains filtered or unexported fields
}

Encoder writes JSON values to an output stream. This type is fully compatible with encoding/json.Encoder.

func NewEncoder ΒΆ 

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new encoder that writes to w. This function is fully compatible with encoding/json.NewEncoder.

func (*Encoder) Encode ΒΆ 

func (enc *Encoder) Encode(v any) error

Encode writes the JSON encoding of v to the stream, followed by a newline character.

See the documentation for Marshal for details about the conversion of Go values to JSON.

func (*Encoder) SetEscapeHTML ΒΆ 

func (enc *Encoder) SetEscapeHTML(on bool)

SetEscapeHTML specifies whether problematic HTML characters should be escaped inside JSON quoted strings. The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003e to avoid certain safety problems that can arise when embedding JSON in HTML.

In non-HTML settings where the escaping interferes with the readability of the output, SetEscapeHTML(false) disables this behavior.

func (*Encoder) SetIndent ΒΆ 

func (enc *Encoder) SetIndent(prefix, indent string)

SetIndent instructs the encoder to format each subsequent encoded value as if indented by the package-level function Indent(dst, src, prefix, indent). Calling SetIndent("", "") disables indentation.

type ErrorClassifier ΒΆ added in v1.0.6 

type ErrorClassifier struct{}

ErrorClassifier helps classify errors for better handling

func NewErrorClassifier ΒΆ added in v1.0.6 

func NewErrorClassifier() *ErrorClassifier

NewErrorClassifier creates a new error classifier

func (*ErrorClassifier) GetErrorSuggestion ΒΆ added in v1.0.6 

func (ec *ErrorClassifier) GetErrorSuggestion(err error) string

GetErrorSuggestion provides helpful suggestions for common errors

func (*ErrorClassifier) IsRetryable ΒΆ added in v1.0.6 

func (ec *ErrorClassifier) IsRetryable(err error) bool

IsRetryable determines if an error is retryable

func (*ErrorClassifier) IsSecurityError ΒΆ added in v1.0.6 

func (ec *ErrorClassifier) IsSecurityError(err error) bool

IsSecurityError determines if an error is security-related

func (*ErrorClassifier) IsUserError ΒΆ added in v1.0.6 

func (ec *ErrorClassifier) IsUserError(err error) bool

IsUserError determines if an error is caused by user input

type ErrorType ΒΆ 

type ErrorType int

ErrorType represents different types of errors 

const (
	ErrTypeValidation ErrorType = iota
	ErrTypeNavigation
	ErrTypeConversion
	ErrTypeBoundary
	ErrTypeTimeout
	ErrTypeRateLimit
)

type ExtractionContext ΒΆ 

type ExtractionContext struct {
	OriginalContainers []any  // Original containers that hold the target arrays
	ArrayFieldName     string // Name of the array field being operated on
	TargetIndices      []int  // Target indices for each container
	OperationType      string // Type of operation: "get", "set", "delete"
}

ExtractionContext holds context for distributed operations

type ExtractionOperations ΒΆ 

type ExtractionOperations interface {
	// Basic extraction
	HandleExtraction(data any, key string) (any, error)
	ExtractFromArray(arr []any, key string) []any
	ExtractFromObject(obj map[string]any, key string) (any, bool)

	// Deep extraction
	HandleDeepExtraction(data any, keys []string) (any, error)
	HandleConsecutiveExtractions(data any, segments []PathSegmentInfo) (any, error)
	DetectConsecutiveExtractions(segments []PathSegmentInfo) [][]PathSegmentInfo

	// Mixed operations
	HandleMixedExtractionOperations(data any, segments []PathSegmentInfo) (any, error)

	// Utility functions
	FlattenExtractionResults(data any) []any
	IsExtractionPath(path string) bool
	CountExtractions(path string) int
	ValidateExtractionSyntax(path string) error
	ExtractMultipleKeys(data any, keys []string) (map[string]any, error)
	FilterExtractionResults(data any, predicate func(any) bool) []any
}

ExtractionOperations interface for extraction operations

func NewExtractionOperations ΒΆ 

func NewExtractionOperations(utils ProcessorUtils) ExtractionOperations

NewExtractionOperations creates a new extraction operations instance

type Float ΒΆ 

type Float interface {
	~float32 | ~float64
}

Float represents floating-point types

type ForeachCallback ΒΆ 

type ForeachCallback func(key any, value *IterableValue)

ForeachCallback represents the callback function for iteration The value parameter is always *IterableValue, so no type assertion is needed

type ForeachCallbackWithIterator ΒΆ 

type ForeachCallbackWithIterator func(key, value any, it *Iterator)

ForeachCallbackWithIterator represents the callback function with iterator access

type HealthStatus ΒΆ 

type HealthStatus struct {
	Timestamp time.Time              `json:"timestamp"`
	Healthy   bool                   `json:"healthy"`
	Checks    map[string]CheckResult `json:"checks"`
}

HealthStatus represents the health status of the processor

type InvalidUnmarshalError ΒΆ 

type InvalidUnmarshalError struct {
	Type reflect.Type
}

InvalidUnmarshalError describes an invalid argument passed to Unmarshal. (The argument to Unmarshal must be a non-nil pointer.)

func (*InvalidUnmarshalError) Error ΒΆ 

func (e *InvalidUnmarshalError) Error() string

type IterableValue ΒΆ 

type IterableValue struct {
	// contains filtered or unexported fields
}

IterableValue represents a value that supports Get operations like the user expects

func NewIterableValue ΒΆ 

func NewIterableValue(data any, processor *Processor) *IterableValue

NewIterableValue creates a new IterableValue

func NewIterableValueWithIterator ΒΆ 

func NewIterableValueWithIterator(data any, processor *Processor, iterator *Iterator) *IterableValue

NewIterableValueWithIterator creates a new IterableValue with iterator reference

func (*IterableValue) Break ΒΆ 

func (iv *IterableValue) Break()

Break stops the entire iteration elegantly without requiring return

func (*IterableValue) Continue ΒΆ 

func (iv *IterableValue) Continue()

Continue skips the current iteration elegantly without requiring return

func (*IterableValue) Delete ΒΆ 

func (iv *IterableValue) Delete(path string) error

Delete deletes a value using path notation with unified behavior

func (*IterableValue) DeleteWithValidation ΒΆ 

func (iv *IterableValue) DeleteWithValidation(path string) error

DeleteWithValidation deletes a value with path validation and suggestions

func (*IterableValue) Exists ΒΆ 

func (iv *IterableValue) Exists(path string) bool

Exists checks if a path exists in the current item

func (*IterableValue) ForeachNested ΒΆ 

func (iv *IterableValue) ForeachNested(path string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachNested performs nested iteration on a sub-path with isolated processor This prevents state conflicts when performing nested iterations

func (*IterableValue) ForeachReturnNested ΒΆ 

func (iv *IterableValue) ForeachReturnNested(path string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachReturnNested performs nested iteration with modifications on a sub-path Returns the modified sub-structure and applies it back to the current item

func (*IterableValue) Get ΒΆ 

func (iv *IterableValue) Get(path string) any

Get retrieves a value using path notation (like user expects: item.Get("name"))

func (*IterableValue) GetArray ΒΆ 

func (iv *IterableValue) GetArray(path string) []any

GetArray retrieves an array value using path notation

func (*IterableValue) GetArrayWithDefault ΒΆ 

func (iv *IterableValue) GetArrayWithDefault(path string, defaultValue []any) []any

GetArrayWithDefault retrieves an array value with a default fallback

func (*IterableValue) GetBool ΒΆ 

func (iv *IterableValue) GetBool(path string) bool

GetBool retrieves a bool value using path notation

func (*IterableValue) GetBoolWithDefault ΒΆ 

func (iv *IterableValue) GetBoolWithDefault(path string, defaultValue bool) bool

GetBoolWithDefault retrieves a bool value with a default fallback

func (*IterableValue) GetFloat64 ΒΆ 

func (iv *IterableValue) GetFloat64(path string) float64

GetFloat64 retrieves a float64 value using path notation

func (*IterableValue) GetFloat64WithDefault ΒΆ 

func (iv *IterableValue) GetFloat64WithDefault(path string, defaultValue float64) float64

GetFloat64WithDefault retrieves a float64 value with a default fallback

func (*IterableValue) GetInt ΒΆ 

func (iv *IterableValue) GetInt(path string) int

GetInt retrieves an int value using path notation

func (*IterableValue) GetInt64 ΒΆ 

func (iv *IterableValue) GetInt64(path string) int64

GetInt64 retrieves an int64 value using path notation

func (*IterableValue) GetInt64WithDefault ΒΆ 

func (iv *IterableValue) GetInt64WithDefault(path string, defaultValue int64) int64

GetInt64WithDefault retrieves an int64 value with a default fallback

func (*IterableValue) GetIntWithDefault ΒΆ 

func (iv *IterableValue) GetIntWithDefault(path string, defaultValue int) int

GetIntWithDefault retrieves an int value with a default fallback

func (*IterableValue) GetObject ΒΆ 

func (iv *IterableValue) GetObject(path string) map[string]any

GetObject retrieves an object value using path notation

func (*IterableValue) GetObjectWithDefault ΒΆ 

func (iv *IterableValue) GetObjectWithDefault(path string, defaultValue map[string]any) map[string]any

GetObjectWithDefault retrieves an object value with a default fallback

func (*IterableValue) GetString ΒΆ 

func (iv *IterableValue) GetString(path string) string

GetString retrieves a string value using path notation

func (*IterableValue) GetStringWithDefault ΒΆ 

func (iv *IterableValue) GetStringWithDefault(path, defaultValue string) string

GetStringWithDefault retrieves a string value with a default fallback

func (*IterableValue) GetWithDefault ΒΆ 

func (iv *IterableValue) GetWithDefault(path string, defaultValue any) any

GetWithDefault retrieves a value with a default fallback

func (*IterableValue) IsEmpty ΒΆ 

func (iv *IterableValue) IsEmpty(path string) bool

IsEmpty checks if a path contains an empty value (empty string, empty array, empty object)

func (*IterableValue) IsNull ΒΆ 

func (iv *IterableValue) IsNull(path string) bool

IsNull checks if a path contains a null value

func (*IterableValue) Keys ΒΆ 

func (iv *IterableValue) Keys(path string) []string

Keys returns the keys of an object at the given path

func (*IterableValue) Length ΒΆ 

func (iv *IterableValue) Length(path string) int

Length returns the length of an array or object at the given path

func (*IterableValue) Set ΒΆ 

func (iv *IterableValue) Set(path string, value any) error

Set sets a value using path notation

func (*IterableValue) SetMultiple ΒΆ 

func (iv *IterableValue) SetMultiple(updates map[string]any) error

SetMultiple sets multiple values using path notation with a map of path-value pairs

func (*IterableValue) SetWithAdd ΒΆ 

func (iv *IterableValue) SetWithAdd(path string, value any) error

SetWithAdd sets a value using path notation with automatic path creation This is equivalent to json.SetWithAdd() but works on the current iteration item

func (*IterableValue) String ΒΆ 

func (iv *IterableValue) String() string

String returns the JSON string representation of the data

func (*IterableValue) Values ΒΆ 

func (iv *IterableValue) Values(path string) []any

Values returns the values of an object or array at the given path

type Iterator ΒΆ 

type Iterator struct {
	// contains filtered or unexported fields
}

Iterator represents an iterator for JSON data with support for read/write operations

func NewIterator ΒΆ 

func NewIterator(processor *Processor, data any, opts *ProcessorOptions) *Iterator

NewIterator creates a new iterator for the given JSON data

func (*Iterator) Break ΒΆ 

func (it *Iterator) Break() error

Break stops the entire iteration Returns an error that should be returned from the callback

func (*Iterator) Continue ΒΆ 

func (it *Iterator) Continue() error

Continue skips the current iteration Returns an error that should be returned from the callback

func (*Iterator) Delete ΒΆ 

func (it *Iterator) Delete(path string) error

Delete deletes a value from the current item using a relative path

func (*Iterator) Get ΒΆ 

func (it *Iterator) Get(path string) (any, error)

Get retrieves a value from the current item using a relative path

func (*Iterator) GetCurrentKey ΒΆ 

func (it *Iterator) GetCurrentKey() any

GetCurrentKey returns the current key (index for arrays, property name for objects)

func (*Iterator) GetCurrentPath ΒΆ 

func (it *Iterator) GetCurrentPath() string

GetCurrentPath returns the current path in dot notation

func (*Iterator) GetCurrentValue ΒΆ 

func (it *Iterator) GetCurrentValue() any

GetCurrentValue returns the current value

func (*Iterator) Set ΒΆ 

func (it *Iterator) Set(path string, value any) error

Set sets a value in the current item using a relative path

type IteratorControl ΒΆ 

type IteratorControl int

IteratorControl represents control flags for iteration 

const (
	IteratorNormal   IteratorControl = iota // normal execution
	IteratorContinue                        // Continue current item and continue
	IteratorBreak                           // Break entire iteration
)

type IteratorControlSignal ΒΆ 

type IteratorControlSignal struct {
	Type IteratorControl
}

IteratorControlSignal represents control flow signals for iteration

func (IteratorControlSignal) Error ΒΆ 

func (ics IteratorControlSignal) Error() string

Error implements error interface for IteratorControlSignal

type JSONValue ΒΆ 

type JSONValue interface {
	~bool | ~string | Numeric | ~[]any | ~map[string]any | any
}

JSONValue represents valid JSON value types

type JsonsError ΒΆ 

type JsonsError struct {
	Op      string `json:"op"`      // Operation that failed
	Path    string `json:"path"`    // JSON path where error occurred
	Message string `json:"message"` // Human-readable error message
	Err     error  `json:"err"`     // Underlying error
}

JsonsError represents a JSON processing error with essential context

func (*JsonsError) Error ΒΆ 

func (e *JsonsError) Error() string

func (*JsonsError) Is ΒΆ 

func (e *JsonsError) Is(target error) bool

Is implements error matching for Go 1.13+ error handling

func (*JsonsError) Unwrap ΒΆ 

func (e *JsonsError) Unwrap() error

Unwrap returns the underlying error for error chain support

type Marshaler ΒΆ 

type Marshaler interface {
	MarshalJSON() ([]byte, error)
}

Marshaler is the interface implemented by types that can marshal themselves into valid JSON.

type MarshalerError ΒΆ 

type MarshalerError struct {
	Type reflect.Type
	Err  error
	// contains filtered or unexported fields
}

MarshalerError represents an error from calling a MarshalJSON or MarshalText method.

func (*MarshalerError) Error ΒΆ 

func (e *MarshalerError) Error() string

func (*MarshalerError) Unwrap ΒΆ 

func (e *MarshalerError) Unwrap() error

type MemoryTracker ΒΆ 

type MemoryTracker struct {
	// contains filtered or unexported fields
}

MemoryTracker tracks memory usage during tests

func NewMemoryTracker ΒΆ 

func NewMemoryTracker(name string) *MemoryTracker

NewMemoryTracker creates a new memory tracker

func (*MemoryTracker) Report ΒΆ 

func (mt *MemoryTracker) Report(t *testing.T)

Report reports memory usage

type MetricsCollector ΒΆ 

type MetricsCollector interface {
	RecordOperation(duration time.Duration, success bool, cacheHit int)
	RecordCacheHit()
	RecordCacheMiss()
	StartConcurrentOperation()
	EndConcurrentOperation()
	GetStats() map[string]any
}

MetricsCollector interface for collecting metrics

type ModularProcessor ΒΆ 

type ModularProcessor interface {
	// Core operations
	Get(jsonStr, path string, opts ...*ProcessorOptions) (any, error)
	Set(jsonStr, path string, value any, opts ...*ProcessorOptions) (string, error)
	Delete(jsonStr, path string, opts ...*ProcessorOptions) (string, error)

	// Batch operations
	GetMultiple(jsonStr string, paths []string, opts ...*ProcessorOptions) (map[string]any, error)
	BatchProcess(operations []BatchOperation, opts ...*ProcessorOptions) ([]BatchResult, error)

	// Validation
	Valid(jsonStr string, opts ...*ProcessorOptions) (bool, error)

	// Configuration
	SetConfig(config *ProcessorConfig)
	GetConfig() *ProcessorConfig

	// Lifecycle
	Close() error
	IsClosed() bool
}

ModularProcessor interface that combines all operation interfaces

func NewModularProcessor ΒΆ 

func NewModularProcessor(config *ProcessorConfig) ModularProcessor

NewModularProcessor creates a new modular processor instance 

type NavigationResult struct {
	Value  any
	Exists bool
	Error  error
}

NavigationResult represents the result of a navigation operation 

type Navigator interface {
	NavigateToPath(data any, segments []PathSegmentInfo) (any, error)
	NavigateToSegment(data any, segment PathSegmentInfo) (NavigationResult, error)
	HandlePropertyAccess(data any, property string) NavigationResult
}

Navigator interface for basic navigation operations

func NewNavigator ΒΆ 

func NewNavigator(pathParser PathParser, utils ProcessorUtils) Navigator

NewNavigator creates a new navigator instance

type Number ΒΆ 

type Number string

Number represents a JSON number literal.

func (Number) Float64 ΒΆ 

func (n Number) Float64() (float64, error)

Float64 returns the number as a float64.

func (Number) Int64 ΒΆ 

func (n Number) Int64() (int64, error)

Int64 returns the number as an int64.

func (Number) String ΒΆ 

func (n Number) String() string

String returns the literal text of the number.

type NumberPreservingDecoder ΒΆ 

type NumberPreservingDecoder struct {
	// contains filtered or unexported fields
}

NumberPreservingDecoder provides JSON decoding with optimized number format preservation

func NewNumberPreservingDecoder ΒΆ 

func NewNumberPreservingDecoder(preserveNumbers bool) *NumberPreservingDecoder

NewNumberPreservingDecoder creates a new decoder with performance and number preservation

func (*NumberPreservingDecoder) DecodeToAny ΒΆ 

func (d *NumberPreservingDecoder) DecodeToAny(jsonStr string) (any, error)

DecodeToAny decodes JSON string to any type with performance and number preservation

type NumberPreservingValue ΒΆ 

type NumberPreservingValue struct {
	Value    any    `json:"value"`
	Original string `json:"original,omitempty"`
}

NumberPreservingValue wraps a value with its original string representation

func (NumberPreservingValue) IsNumber ΒΆ 

func (npv NumberPreservingValue) IsNumber() bool

IsNumber checks if the value represents a number

func (NumberPreservingValue) String ΒΆ 

func (npv NumberPreservingValue) String() string

String returns the string representation, preferring original if available

func (NumberPreservingValue) ToFloat64 ΒΆ 

func (npv NumberPreservingValue) ToFloat64() (float64, error)

ToFloat64 converts the value to float64 if possible

func (NumberPreservingValue) ToInt ΒΆ 

func (npv NumberPreservingValue) ToInt() (int, error)

ToInt converts the value to int if possible

type Numeric ΒΆ 

type Numeric interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64 |
		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
		~float32 | ~float64
}

Numeric represents all numeric types

type Operation ΒΆ 

type Operation int

Operation represents the type of operation being performed 

const (
	OpGet Operation = iota
	OpSet
	OpDelete
	OpValidate
)

func (Operation) String ΒΆ 

func (op Operation) String() string

String returns the string representation of the operation

type OperationContext ΒΆ 

type OperationContext struct {
	Context     context.Context
	Operation   Operation
	Path        string
	Value       any
	Options     *ProcessorOptions
	StartTime   time.Time
	CreatePaths bool
}

OperationContext contains context information for operations

type Ordered ΒΆ 

type Ordered interface {
	Numeric | ~string
}

Ordered represents types that can be ordered

type PathInfo ΒΆ 

type PathInfo struct {
	Segments     []PathSegment `json:"segments"`
	IsPointer    bool          `json:"is_pointer"`
	OriginalPath string        `json:"original_path"`
}

PathInfo contains parsed path information

type PathParser ΒΆ 

type PathParser interface {
	ParsePath(path string) ([]PathSegmentInfo, error)
	ValidatePath(path string) error
	SplitPathIntoSegments(path string) []PathSegmentInfo
	PreprocessPath(path string) string
}

PathParser interface for parsing path strings

func NewPathParser ΒΆ 

func NewPathParser() PathParser

NewPathParser creates a new path parser instance

type PathSegment ΒΆ 

type PathSegment = internal.PathSegment

PathSegment represents a parsed path segment with its type and value This is an alias to the internal PathSegment for backward compatibility

type PathSegmentInfo ΒΆ 

type PathSegmentInfo struct {
	Type    string
	Value   string
	Key     string
	Index   int
	Start   *int
	End     *int
	Step    *int
	Extract string
	IsFlat  bool
}

PathSegmentInfo contains information about a parsed path segment

type Processor ΒΆ 

type Processor struct {
	// contains filtered or unexported fields
}

Processor is the main JSON processing engine with thread safety and performance optimization

func New ΒΆ 

func New(config ...*Config) *Processor

New creates a new JSON processor with optimized configuration. If no configuration is provided, uses default configuration. This function follows the explicit config pattern as required by the design guidelines.

func (*Processor) ClearCache ΒΆ 

func (p *Processor) ClearCache()

ClearCache clears all cached data

func (*Processor) Close ΒΆ 

func (p *Processor) Close() error

Close closes the processor and cleans up resources

func (*Processor) Compact ΒΆ 

func (p *Processor) Compact(jsonStr string, opts ...*ProcessorOptions) (string, error)

Compact removes whitespace from JSON string

func (*Processor) Delete ΒΆ 

func (p *Processor) Delete(jsonStr, path string, opts ...*ProcessorOptions) (string, error)

Delete removes a value from JSON at the specified path

func (*Processor) EncodeBatch ΒΆ 

func (p *Processor) EncodeBatch(pairs map[string]any, pretty bool, opts ...*ProcessorOptions) (string, error)

EncodeBatch encodes multiple key-value pairs as a JSON object

func (*Processor) EncodeFields ΒΆ 

func (p *Processor) EncodeFields(value any, fields []string, pretty bool, opts ...*ProcessorOptions) (string, error)

EncodeFields encodes struct fields selectively based on field names

func (*Processor) EncodeStream ΒΆ 

func (p *Processor) EncodeStream(values any, pretty bool, opts ...*ProcessorOptions) (string, error)

EncodeStream encodes multiple values as a JSON array stream

func (*Processor) EncodeStreamWithOptions ΒΆ 

func (p *Processor) EncodeStreamWithOptions(values any, encOpts *EncodeConfig, opts ...*ProcessorOptions) (string, error)

EncodeStreamWithOptions encodes multiple values as a JSON array stream with advanced options

func (*Processor) EncodeWithConfig ΒΆ 

func (p *Processor) EncodeWithConfig(value any, config *EncodeConfig, opts ...*ProcessorOptions) (string, error)

EncodeWithConfig converts any Go value to JSON string with full configuration control

func (*Processor) EncodeWithOptions ΒΆ 

func (p *Processor) EncodeWithOptions(value any, encOpts *EncodeConfig, opts ...*ProcessorOptions) (string, error)

EncodeWithOptions converts any Go value to JSON string with advanced options

func (*Processor) EncodeWithTags ΒΆ 

func (p *Processor) EncodeWithTags(value any, pretty bool, opts ...*ProcessorOptions) (string, error)

EncodeWithTags encodes struct with custom JSON tags handling

func (*Processor) Foreach ΒΆ 

func (p *Processor) Foreach(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) error

Foreach iterates over JSON data using the processor The callback receives key and an IterableValue that supports Get() method

func (*Processor) ForeachReturn ΒΆ 

func (p *Processor) ForeachReturn(jsonStr string, callback ForeachCallback, opts ...*ProcessorOptions) (string, error)

ForeachReturn iterates over JSON data and returns the modified JSON string

func (*Processor) ForeachWithIterator ΒΆ 

func (p *Processor) ForeachWithIterator(jsonStr string, callback ForeachCallbackWithIterator, opts ...*ProcessorOptions) error

ForeachWithIterator iterates over JSON data with iterator access

func (*Processor) ForeachWithPath ΒΆ 

func (p *Processor) ForeachWithPath(jsonStr string, path string, callback ForeachCallback, opts ...*ProcessorOptions) error

ForeachWithPath iterates over JSON data at a specific path

func (*Processor) FormatPretty ΒΆ 

func (p *Processor) FormatPretty(jsonStr string, opts ...*ProcessorOptions) (string, error)

FormatPretty formats JSON string with indentation

func (*Processor) Get ΒΆ 

func (p *Processor) Get(jsonStr, path string, opts ...*ProcessorOptions) (any, error)

Get retrieves a value from JSON using a path expression with performance

func (*Processor) GetConfig ΒΆ 

func (p *Processor) GetConfig() *Config

GetConfig returns a copy of the processor configuration

func (*Processor) GetHealthStatus ΒΆ 

func (p *Processor) GetHealthStatus() HealthStatus

GetHealthStatus returns the current health status

func (*Processor) GetMultiple ΒΆ 

func (p *Processor) GetMultiple(jsonStr string, paths []string, opts ...*ProcessorOptions) (map[string]any, error)

GetMultiple retrieves multiple values from JSON using multiple path expressions

func (*Processor) GetStats ΒΆ 

func (p *Processor) GetStats() Stats

GetStats returns processor performance statistics

func (*Processor) IsClosed ΒΆ 

func (p *Processor) IsClosed() bool

IsClosed returns true if the processor has been closed

func (*Processor) LoadFromFile ΒΆ 

func (p *Processor) LoadFromFile(filePath string, opts ...*ProcessorOptions) (any, error)

LoadFromFile loads JSON data from a file

func (*Processor) LoadFromReader ΒΆ 

func (p *Processor) LoadFromReader(reader io.Reader, opts ...*ProcessorOptions) (any, error)

LoadFromReader loads JSON data from an io.Reader with size limits

func (*Processor) Marshal ΒΆ 

func (p *Processor) Marshal(value any, opts ...*ProcessorOptions) ([]byte, error)

Marshal converts any Go value to JSON bytes (similar to json.Marshal)

func (*Processor) MarshalIndent ΒΆ 

func (p *Processor) MarshalIndent(value any, prefix, indent string, opts ...*ProcessorOptions) ([]byte, error)

MarshalIndent converts any Go value to indented JSON bytes (similar to json.MarshalIndent)

func (*Processor) MarshalToFile ΒΆ added in v1.0.6 

func (p *Processor) MarshalToFile(path string, data any, pretty ...bool) error

MarshalToFile converts data to JSON and saves it to the specified file. This method provides the same functionality as the package-level MarshalToFile but with processor-specific configuration.

Parameters:

  • path: file path where JSON will be saved (directories are created automatically)
  • data: any Go value to be marshaled to JSON
  • pretty: optional parameter - true for formatted JSON, false for compact (default: false)

Returns error if marshaling fails or file cannot be written.

func (*Processor) Parse ΒΆ 

func (p *Processor) Parse(jsonStr string, target any, opts ...*ProcessorOptions) error

Parse parses a JSON string into the provided target with improved error handling

func (*Processor) ProcessBatch ΒΆ 

func (p *Processor) ProcessBatch(operations []BatchOperation, opts ...*ProcessorOptions) ([]BatchResult, error)

ProcessBatch processes multiple operations in a single batch

func (*Processor) SafeGet ΒΆ 

func (p *Processor) SafeGet(jsonStr, path string) TypeSafeAccessResult

SafeGet performs a type-safe get operation with comprehensive error handling

func (*Processor) SaveToFile ΒΆ 

func (p *Processor) SaveToFile(filePath string, data any, pretty ...bool) error

SaveToFile saves data to a JSON file with automatic directory creation Parameters:

  • filePath: file path and name, creates directories if they don't exist
  • data: JSON data to save
  • pretty: optional parameter - true for formatted JSON, false for compact JSON (default: false)

func (*Processor) SaveToWriter ΒΆ 

func (p *Processor) SaveToWriter(writer io.Writer, data any, pretty bool, opts ...*ProcessorOptions) error

SaveToWriter saves data to an io.Writer

func (*Processor) Set ΒΆ 

func (p *Processor) Set(jsonStr, path string, value any, opts ...*ProcessorOptions) (string, error)

Set sets a value in JSON at the specified path Returns:

  • On success: modified JSON string and nil error
  • On failure: original unmodified JSON string and error information

func (*Processor) SetLogger ΒΆ 

func (p *Processor) SetLogger(logger *slog.Logger)

SetLogger sets a custom structured logger for the processor

func (*Processor) SetMultiple ΒΆ 

func (p *Processor) SetMultiple(jsonStr string, updates map[string]any, opts ...*ProcessorOptions) (string, error)

SetMultiple sets multiple values in JSON using a map of path-value pairs Returns:

  • On success: modified JSON string and nil error
  • On failure: original unmodified JSON string and error information

func (*Processor) ToJsonString ΒΆ 

func (p *Processor) ToJsonString(value any, opts ...*ProcessorOptions) (string, error)

ToJsonString converts any Go value to JSON string with HTML escaping (safe for web)

func (*Processor) ToJsonStringPretty ΒΆ 

func (p *Processor) ToJsonStringPretty(value any, opts ...*ProcessorOptions) (string, error)

ToJsonStringPretty converts any Go value to pretty JSON string with HTML escaping

func (*Processor) ToJsonStringStandard ΒΆ 

func (p *Processor) ToJsonStringStandard(value any, opts ...*ProcessorOptions) (string, error)

ToJsonStringStandard converts any Go value to compact JSON string without HTML escaping

func (*Processor) Unmarshal ΒΆ 

func (p *Processor) Unmarshal(data []byte, v any, opts ...*ProcessorOptions) error

Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v. This method is fully compatible with encoding/json.Unmarshal.

func (*Processor) UnmarshalFromFile ΒΆ added in v1.0.6 

func (p *Processor) UnmarshalFromFile(path string, v any, opts ...*ProcessorOptions) error

UnmarshalFromFile reads JSON data from the specified file and unmarshals it into the provided value. This method provides the same functionality as the package-level UnmarshalFromFile but with processor-specific configuration.

Parameters:

  • path: file path to read JSON from
  • v: pointer to the value where JSON will be unmarshaled
  • opts: optional processor options for unmarshaling

Returns error if file cannot be read or JSON unmarshaling fails.

func (*Processor) Valid ΒΆ 

func (p *Processor) Valid(jsonStr string, opts ...*ProcessorOptions) (bool, error)

Valid validates JSON format without parsing the entire structure

func (*Processor) ValidateSchema ΒΆ 

func (p *Processor) ValidateSchema(jsonStr string, schema *Schema, opts ...*ProcessorOptions) ([]ValidationError, error)

ValidateSchema validates JSON data against a schema

func (*Processor) WarmupCache ΒΆ 

func (p *Processor) WarmupCache(jsonStr string, paths []string, opts ...*ProcessorOptions) (*WarmupResult, error)

WarmupCache pre-loads commonly used paths into cache to improve first-access performance

type ProcessorCache ΒΆ 

type ProcessorCache interface {
	Get(key CacheKey) (any, bool)
	Set(key CacheKey, value any, ttl time.Duration)
	Clear()
	Size() int
}

ProcessorCache interface for caching operations

type ProcessorConfig ΒΆ 

type ProcessorConfig struct {
	EnableCache      bool
	EnableMetrics    bool
	MaxConcurrency   int
	Timeout          time.Duration
	RateLimitEnabled bool
	RateLimitRPS     int
	MaxDepth         int
	MaxPathLength    int
}

ProcessorConfig holds configuration for the processor

func DefaultProcessorConfig ΒΆ 

func DefaultProcessorConfig() *ProcessorConfig

DefaultProcessorConfig returns a default configuration

type ProcessorConfigAdapter ΒΆ added in v1.0.6 

type ProcessorConfigAdapter struct {
	// contains filtered or unexported fields
}

ProcessorConfigAdapter adapts ProcessorConfig to implement internal.ConfigInterface

func NewProcessorConfigAdapter ΒΆ added in v1.0.6 

func NewProcessorConfigAdapter(config *ProcessorConfig) *ProcessorConfigAdapter

NewProcessorConfigAdapter creates a new adapter

func (*ProcessorConfigAdapter) AllowComments ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) AllowComments() bool

func (*ProcessorConfigAdapter) GetCacheTTL ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetCacheTTL() time.Duration

func (*ProcessorConfigAdapter) GetMaxCacheSize ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetMaxCacheSize() int

func (*ProcessorConfigAdapter) GetMaxConcurrency ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetMaxConcurrency() int

func (*ProcessorConfigAdapter) GetMaxJSONSize ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetMaxJSONSize() int64

Performance configuration

func (*ProcessorConfigAdapter) GetMaxNestingDepth ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetMaxNestingDepth() int

func (*ProcessorConfigAdapter) GetMaxPathDepth ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) GetMaxPathDepth() int

func (*ProcessorConfigAdapter) IsCacheEnabled ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) IsCacheEnabled() bool

Cache configuration

func (*ProcessorConfigAdapter) IsHealthCheckEnabled ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) IsHealthCheckEnabled() bool

func (*ProcessorConfigAdapter) IsMetricsEnabled ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) IsMetricsEnabled() bool

func (*ProcessorConfigAdapter) IsStrictMode ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) IsStrictMode() bool

Parsing configuration

func (*ProcessorConfigAdapter) PreserveNumbers ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) PreserveNumbers() bool

func (*ProcessorConfigAdapter) ShouldCleanupNulls ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) ShouldCleanupNulls() bool

func (*ProcessorConfigAdapter) ShouldCompactArrays ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) ShouldCompactArrays() bool

func (*ProcessorConfigAdapter) ShouldCreatePaths ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) ShouldCreatePaths() bool

Operation configuration

func (*ProcessorConfigAdapter) ShouldValidateFilePath ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) ShouldValidateFilePath() bool

func (*ProcessorConfigAdapter) ShouldValidateInput ΒΆ added in v1.0.6 

func (pca *ProcessorConfigAdapter) ShouldValidateInput() bool

Security configuration

type ProcessorError ΒΆ 

type ProcessorError struct {
	Type      ErrorType
	Operation string
	Path      string
	Message   string
	Cause     error
}

ProcessorError represents a structured error from the processor

func (*ProcessorError) Error ΒΆ 

func (e *ProcessorError) Error() string

func (*ProcessorError) Unwrap ΒΆ 

func (e *ProcessorError) Unwrap() error

type ProcessorMetrics ΒΆ 

type ProcessorMetrics struct {
	// Operation metrics
	TotalOperations      int64   `json:"total_operations"`
	SuccessfulOperations int64   `json:"successful_operations"`
	FailedOperations     int64   `json:"failed_operations"`
	SuccessRate          float64 `json:"success_rate"`

	// Cache metrics
	CacheHits    int64   `json:"cache_hits"`
	CacheMisses  int64   `json:"cache_misses"`
	CacheHitRate float64 `json:"cache_hit_rate"`

	// Performance metrics
	AverageProcessingTime time.Duration `json:"average_processing_time"`
	MaxProcessingTime     time.Duration `json:"max_processing_time"`
	MinProcessingTime     time.Duration `json:"min_processing_time"`

	// Memory metrics
	TotalMemoryAllocated int64 `json:"total_memory_allocated"`
	PeakMemoryUsage      int64 `json:"peak_memory_usage"`
	CurrentMemoryUsage   int64 `json:"current_memory_usage"`

	// Concurrency metrics
	ActiveConcurrentOps int64 `json:"active_concurrent_ops"`
	MaxConcurrentOps    int64 `json:"max_concurrent_ops"`
	// contains filtered or unexported fields
}

ProcessorMetrics provides comprehensive processor performance metrics

type ProcessorOptions ΒΆ 

type ProcessorOptions struct {
	Context         context.Context `json:"-"`                 // Context for cancellation and timeouts
	CacheResults    bool            `json:"cache_results"`     // Whether to cache results
	StrictMode      bool            `json:"strict_mode"`       // Enable strict mode for this operation
	MaxDepth        int             `json:"max_depth"`         // Maximum recursion depth
	AllowComments   bool            `json:"allow_comments"`    // Allow JSON with comments
	PreserveNumbers bool            `json:"preserve_numbers"`  // Preserve number format (avoid scientific notation)
	CreatePaths     bool            `json:"create_paths"`      // Override global CreatePaths setting for this operation
	CleanupNulls    bool            `json:"cleanup_nulls"`     // Remove null values after deletion operations
	CompactArrays   bool            `json:"compact_arrays"`    // Remove all null values from arrays (not just trailing)
	ContinueOnError bool            `json:"continue_on_error"` // Continue processing other operations even if some fail (for batch operations)
}

ProcessorOptions provides per-operation configuration

func DefaultOptions ΒΆ 

func DefaultOptions() *ProcessorOptions

DefaultOptions returns default processor options

func (*ProcessorOptions) Clone ΒΆ 

func (opts *ProcessorOptions) Clone() *ProcessorOptions

Clone creates a deep copy of ProcessorOptions

type ProcessorUtils ΒΆ 

type ProcessorUtils interface {
	IsArrayType(data any) bool
	IsObjectType(data any) bool
	IsEmptyContainer(data any) bool
	DeepCopy(data any) (any, error)
	GetDataType(data any) string
	ConvertToMap(data any) (map[string]any, bool)
	ConvertToArray(data any) ([]any, bool)
	ConvertToString(value any) string
	ConvertToNumber(value any) (float64, error)
}

ProcessorUtils interface for utility functions

func NewProcessorUtils ΒΆ 

func NewProcessorUtils() ProcessorUtils

NewProcessorUtils creates a new processor utils instance

type PropertyAccessResult ΒΆ 

type PropertyAccessResult struct {
	Value  any
	Exists bool
}

PropertyAccessResult represents the result of a property access operation

type RateLimiter ΒΆ 

type RateLimiter interface {
	Allow() bool
	Wait(ctx context.Context) error
	Limit() int
}

RateLimiter interface for rate limiting

type RecursiveProcessor ΒΆ 

type RecursiveProcessor struct {
	// contains filtered or unexported fields
}

RecursiveProcessor implements true recursive processing for all operations

func NewRecursiveProcessor ΒΆ 

func NewRecursiveProcessor(p *Processor) *RecursiveProcessor

NewRecursiveProcessor creates a new unified recursive processor

func (*RecursiveProcessor) ProcessRecursively ΒΆ 

func (urp *RecursiveProcessor) ProcessRecursively(data any, path string, operation Operation, value any) (any, error)

ProcessRecursively performs recursive processing for any operation

func (*RecursiveProcessor) ProcessRecursivelyWithOptions ΒΆ 

func (urp *RecursiveProcessor) ProcessRecursivelyWithOptions(data any, path string, operation Operation, value any, createPaths bool) (any, error)

ProcessRecursivelyWithOptions performs recursive processing with path creation options

type ResourceManagerStats ΒΆ added in v1.0.6 

type ResourceManagerStats struct {
	AllocatedBuilders int64 `json:"allocated_builders"`
	AllocatedSegments int64 `json:"allocated_segments"`
	AllocatedBuffers  int64 `json:"allocated_buffers"`
	LastCleanup       int64 `json:"last_cleanup"`
}

ResourceManagerStats provides statistics about resource usage

type ResourceMonitor ΒΆ 

type ResourceMonitor struct {
	// contains filtered or unexported fields
}

ResourceMonitor provides enhanced resource monitoring and leak detection

func NewResourceMonitor ΒΆ 

func NewResourceMonitor() *ResourceMonitor

NewResourceMonitor creates a new resource monitor

func (*ResourceMonitor) CheckForLeaks ΒΆ 

func (rm *ResourceMonitor) CheckForLeaks() []string

CheckForLeaks performs leak detection and returns potential issues

func (*ResourceMonitor) GetMemoryEfficiency ΒΆ 

func (rm *ResourceMonitor) GetMemoryEfficiency() float64

GetMemoryEfficiency returns memory efficiency as a percentage (0-100)

func (*ResourceMonitor) GetPoolEfficiency ΒΆ 

func (rm *ResourceMonitor) GetPoolEfficiency() float64

GetPoolEfficiency returns pool efficiency as a percentage (0-100)

func (*ResourceMonitor) GetStats ΒΆ 

func (rm *ResourceMonitor) GetStats() ResourceStats

GetStats returns current resource statistics

func (*ResourceMonitor) RecordAllocation ΒΆ 

func (rm *ResourceMonitor) RecordAllocation(bytes int64)

RecordAllocation records memory allocation

func (*ResourceMonitor) RecordDeallocation ΒΆ 

func (rm *ResourceMonitor) RecordDeallocation(bytes int64)

RecordDeallocation records memory deallocation

func (*ResourceMonitor) RecordOperation ΒΆ 

func (rm *ResourceMonitor) RecordOperation(duration time.Duration)

RecordOperation records an operation with timing

func (*ResourceMonitor) RecordPoolEviction ΒΆ 

func (rm *ResourceMonitor) RecordPoolEviction()

RecordPoolEviction records a pool eviction

func (*ResourceMonitor) RecordPoolHit ΒΆ 

func (rm *ResourceMonitor) RecordPoolHit()

RecordPoolHit records a pool cache hit

func (*ResourceMonitor) RecordPoolMiss ΒΆ 

func (rm *ResourceMonitor) RecordPoolMiss()

RecordPoolMiss records a pool cache miss

func (*ResourceMonitor) Reset ΒΆ 

func (rm *ResourceMonitor) Reset()

Reset resets all statistics

type ResourcePoolStats ΒΆ 

type ResourcePoolStats struct {
	StringBuilderPoolActive bool `json:"string_builder_pool_active"` // Whether string builder pool is active
	PathSegmentPoolActive   bool `json:"path_segment_pool_active"`   // Whether path segment pool is active
}

ResourcePoolStats provides statistics about resource pools

type ResourceStats ΒΆ 

type ResourceStats struct {
	AllocatedBytes    int64         // Total allocated bytes
	FreedBytes        int64         // Total freed bytes
	PeakMemoryUsage   int64         // Peak memory usage
	PoolHits          int64         // Pool cache hits
	PoolMisses        int64         // Pool cache misses
	PoolEvictions     int64         // Pool evictions
	MaxGoroutines     int64         // Maximum goroutines seen
	CurrentGoroutines int64         // Current goroutine count
	AvgResponseTime   time.Duration // Average response time
	TotalOperations   int64         // Total operations processed
}

ResourceStats represents resource usage statistics

type RootDataTypeConversionError ΒΆ 

type RootDataTypeConversionError struct {
	RequiredType string
	RequiredSize int
	CurrentType  string
}

RootDataTypeConversionError represents an error that signals root data type conversion is needed

func (*RootDataTypeConversionError) Error ΒΆ 

func (e *RootDataTypeConversionError) Error() string

type Schema ΒΆ 

type Schema struct {
	Type                 string             `json:"type,omitempty"`
	Properties           map[string]*Schema `json:"properties,omitempty"`
	Items                *Schema            `json:"items,omitempty"`
	Required             []string           `json:"required,omitempty"`
	MinLength            int                `json:"minLength,omitempty"`
	MaxLength            int                `json:"maxLength,omitempty"`
	Minimum              float64            `json:"minimum,omitempty"`
	Maximum              float64            `json:"maximum,omitempty"`
	Pattern              string             `json:"pattern,omitempty"`
	Format               string             `json:"format,omitempty"`
	AdditionalProperties bool               `json:"additionalProperties,omitempty"`

	// Enhanced validation options
	MinItems         int     `json:"minItems,omitempty"`         // Minimum array items
	MaxItems         int     `json:"maxItems,omitempty"`         // Maximum array items
	UniqueItems      bool    `json:"uniqueItems,omitempty"`      // Array items must be unique
	Enum             []any   `json:"enum,omitempty"`             // Allowed values
	Const            any     `json:"const,omitempty"`            // Constant value
	MultipleOf       float64 `json:"multipleOf,omitempty"`       // Number must be multiple of this
	ExclusiveMinimum bool    `json:"exclusiveMinimum,omitempty"` // Minimum is exclusive
	ExclusiveMaximum bool    `json:"exclusiveMaximum,omitempty"` // Maximum is exclusive
	Title            string  `json:"title,omitempty"`            // Schema title
	Description      string  `json:"description,omitempty"`      // Schema description
	Default          any     `json:"default,omitempty"`          // Default value
	Examples         []any   `json:"examples,omitempty"`         // Example values
	// contains filtered or unexported fields
}

Schema represents a JSON schema for validation

func DefaultSchema ΒΆ 

func DefaultSchema() *Schema

DefaultSchema returns a default schema configuration

func (*Schema) HasMaxItems ΒΆ 

func (s *Schema) HasMaxItems() bool

HasMaxItems returns true if MaxItems constraint is explicitly set

func (*Schema) HasMaxLength ΒΆ 

func (s *Schema) HasMaxLength() bool

HasMaxLength returns true if MaxLength constraint is explicitly set

func (*Schema) HasMaximum ΒΆ 

func (s *Schema) HasMaximum() bool

HasMaximum returns true if Maximum constraint is explicitly set

func (*Schema) HasMinItems ΒΆ 

func (s *Schema) HasMinItems() bool

HasMinItems returns true if MinItems constraint is explicitly set

func (*Schema) HasMinLength ΒΆ 

func (s *Schema) HasMinLength() bool

HasMinLength returns true if MinLength constraint is explicitly set

func (*Schema) HasMinimum ΒΆ 

func (s *Schema) HasMinimum() bool

HasMinimum returns true if Minimum constraint is explicitly set

func (*Schema) SetExclusiveMaximum ΒΆ 

func (s *Schema) SetExclusiveMaximum(exclusive bool) *Schema

SetExclusiveMaximum sets the exclusive maximum flag

func (*Schema) SetExclusiveMinimum ΒΆ 

func (s *Schema) SetExclusiveMinimum(exclusive bool) *Schema

SetExclusiveMinimum sets the exclusive minimum flag

func (*Schema) SetMaxItems ΒΆ 

func (s *Schema) SetMaxItems(maxItems int) *Schema

SetMaxItems sets the maximum items constraint for arrays

func (*Schema) SetMaxLength ΒΆ 

func (s *Schema) SetMaxLength(maxLength int) *Schema

SetMaxLength sets the maximum length constraint

func (*Schema) SetMaximum ΒΆ 

func (s *Schema) SetMaximum(maximum float64) *Schema

SetMaximum sets the maximum value constraint

func (*Schema) SetMinItems ΒΆ 

func (s *Schema) SetMinItems(minItems int) *Schema

SetMinItems sets the minimum items constraint for arrays

func (*Schema) SetMinLength ΒΆ 

func (s *Schema) SetMinLength(minLength int) *Schema

SetMinLength sets the minimum length constraint

func (*Schema) SetMinimum ΒΆ 

func (s *Schema) SetMinimum(minimum float64) *Schema

SetMinimum sets the minimum value constraint

type SecurityValidator ΒΆ added in v1.0.6 

type SecurityValidator struct {
	// contains filtered or unexported fields
}

SecurityValidator provides comprehensive security validation for JSON processing

func NewSecurityValidator ΒΆ added in v1.0.6 

func NewSecurityValidator(maxJSONSize int64, maxPathLength, maxNestingDepth int) *SecurityValidator

NewSecurityValidator creates a new security validator with the given limits

func (*SecurityValidator) ValidateJSONInput ΒΆ added in v1.0.6 

func (sv *SecurityValidator) ValidateJSONInput(jsonStr string) error

ValidateJSONInput performs comprehensive JSON input validation with enhanced security

func (*SecurityValidator) ValidatePathInput ΒΆ added in v1.0.6 

func (sv *SecurityValidator) ValidatePathInput(path string) error

ValidatePathInput performs comprehensive path validation with enhanced security

type SetOperations ΒΆ 

type SetOperations interface {
	SetValue(data any, path string, value any, createPaths bool) error
	SetValueWithSegments(data any, segments []PathSegmentInfo, value any, createPaths bool) error
	CreatePath(data any, segments []PathSegmentInfo) error
	HandleTypeConversion(data any, requiredType string) (any, error)
}

SetOperations interface for value setting operations

func NewSetOperations ΒΆ 

func NewSetOperations(utils ProcessorUtils, pathParser PathParser, navigator Navigator, arrayOps ArrayOperations) SetOperations

NewSetOperations creates a new set operations instance

type ShardStats ΒΆ 

type ShardStats struct {
	Size   int64 `json:"size"`   // Number of entries in shard
	Memory int64 `json:"memory"` // Memory usage of shard in bytes
}

ShardStats provides statistics for a single cache shard

type Signed ΒΆ 

type Signed interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

Signed represents signed integer types

type SimpleCacheImpl ΒΆ added in v1.0.6 

type SimpleCacheImpl struct {
	// contains filtered or unexported fields
}

SimpleCacheImpl implements ProcessorCache using internal.CacheManager

func NewSimpleCacheImpl ΒΆ added in v1.0.6 

func NewSimpleCacheImpl(config internal.ConfigInterface) *SimpleCacheImpl

NewSimpleCacheImpl creates a new simple cache implementation

func (*SimpleCacheImpl) Clear ΒΆ added in v1.0.6 

func (sc *SimpleCacheImpl) Clear()

Clear removes all entries from cache

func (*SimpleCacheImpl) Get ΒΆ added in v1.0.6 

func (sc *SimpleCacheImpl) Get(key CacheKey) (any, bool)

Get retrieves a value from cache using CacheKey

func (*SimpleCacheImpl) Set ΒΆ added in v1.0.6 

func (sc *SimpleCacheImpl) Set(key CacheKey, value any, ttl time.Duration)

Set stores a value in cache using CacheKey (ttl parameter is ignored as TTL is configured globally)

func (*SimpleCacheImpl) Size ΒΆ added in v1.0.6 

func (sc *SimpleCacheImpl) Size() int

Size returns the number of entries in cache

type Stats ΒΆ 

type Stats struct {
	CacheSize        int64         `json:"cache_size"`        // Current cache size
	CacheMemory      int64         `json:"cache_memory"`      // Cache memory usage in bytes
	MaxCacheSize     int           `json:"max_cache_size"`    // Maximum cache size
	HitCount         int64         `json:"hit_count"`         // Cache hit count
	MissCount        int64         `json:"miss_count"`        // Cache miss count
	HitRatio         float64       `json:"hit_ratio"`         // Cache hit ratio
	CacheTTL         time.Duration `json:"cache_ttl"`         // Cache TTL
	CacheEnabled     bool          `json:"cache_enabled"`     // Whether cache is enabled
	IsClosed         bool          `json:"is_closed"`         // Whether processor is closed
	MemoryEfficiency float64       `json:"memory_efficiency"` // Memory efficiency (hits per MB)
	OperationCount   int64         `json:"operation_count"`   // Total operations performed
	ErrorCount       int64         `json:"error_count"`       // Total errors encountered
}

Stats provides processor performance statistics

type SyntaxError ΒΆ 

type SyntaxError struct {
	Offset int64 // error occurred after reading Offset bytes
	// contains filtered or unexported fields
}

SyntaxError is a description of a JSON syntax error. Unmarshal will return a SyntaxError if the JSON can't be parsed.

func (*SyntaxError) Error ΒΆ 

func (e *SyntaxError) Error() string

type TestDataGenerator ΒΆ 

type TestDataGenerator struct {
	// contains filtered or unexported fields
}

TestDataGenerator generates test data for various scenarios

func NewTestDataGenerator ΒΆ 

func NewTestDataGenerator() *TestDataGenerator

NewTestDataGenerator creates a new test data generator

func (*TestDataGenerator) GenerateArrayJSON ΒΆ 

func (g *TestDataGenerator) GenerateArrayJSON() string

GenerateArrayJSON generates JSON with various array structures

func (*TestDataGenerator) GenerateComplexJSON ΒΆ 

func (g *TestDataGenerator) GenerateComplexJSON() string

GenerateComplexJSON generates complex nested JSON structures

func (*TestDataGenerator) GenerateInvalidJSON ΒΆ 

func (g *TestDataGenerator) GenerateInvalidJSON() []string

GenerateInvalidJSON generates invalid JSON for error testing

func (*TestDataGenerator) GenerateSimpleJSON ΒΆ 

func (g *TestDataGenerator) GenerateSimpleJSON() string

GenerateSimpleJSON generates simple JSON structures

type TestHelper ΒΆ 

type TestHelper struct {
	// contains filtered or unexported fields
}

TestHelper provides utilities for testing JSON operations

func NewTestHelper ΒΆ 

func NewTestHelper(t *testing.T) *TestHelper

NewTestHelper creates a new test helper

func (*TestHelper) AssertEqual ΒΆ 

func (h *TestHelper) AssertEqual(expected, actual any, msgAndArgs ...any)

AssertEqual checks if two values are equal

func (*TestHelper) AssertError ΒΆ 

func (h *TestHelper) AssertError(err error, msgAndArgs ...any)

AssertError checks that error is not nil

func (*TestHelper) AssertErrorContains ΒΆ 

func (h *TestHelper) AssertErrorContains(err error, contains string, msgAndArgs ...any)

AssertErrorContains checks that error contains specific text

func (*TestHelper) AssertFalse ΒΆ 

func (h *TestHelper) AssertFalse(condition bool, msgAndArgs ...any)

AssertFalse checks that condition is false

func (*TestHelper) AssertNil ΒΆ 

func (h *TestHelper) AssertNil(value any, msgAndArgs ...any)

AssertNil checks that value is nil

func (*TestHelper) AssertNoError ΒΆ 

func (h *TestHelper) AssertNoError(err error, msgAndArgs ...any)

AssertNoError checks that error is nil

func (*TestHelper) AssertNoPanic ΒΆ 

func (h *TestHelper) AssertNoPanic(fn func(), msgAndArgs ...any)

AssertNoPanic checks that function doesn't panic

func (*TestHelper) AssertNotEqual ΒΆ 

func (h *TestHelper) AssertNotEqual(expected, actual any, msgAndArgs ...any)

AssertNotEqual checks if two values are not equal

func (*TestHelper) AssertNotNil ΒΆ 

func (h *TestHelper) AssertNotNil(value any, msgAndArgs ...any)

AssertNotNil checks that value is not nil

func (*TestHelper) AssertPanic ΒΆ 

func (h *TestHelper) AssertPanic(fn func(), msgAndArgs ...any)

AssertPanic checks that function panics

func (*TestHelper) AssertTrue ΒΆ 

func (h *TestHelper) AssertTrue(condition bool, msgAndArgs ...any)

AssertTrue checks that condition is true

type TextMarshaler ΒΆ 

type TextMarshaler interface {
	MarshalText() (text []byte, err error)
}

TextMarshaler is the interface implemented by an object that can marshal itself into a textual form.

MarshalText encodes the receiver into UTF-8-encoded text and returns the result.

type TextUnmarshaler ΒΆ 

type TextUnmarshaler interface {
	UnmarshalText(text []byte) error
}

TextUnmarshaler is the interface implemented by an object that can unmarshal a textual representation of itself.

UnmarshalText must be able to decode the form generated by MarshalText. UnmarshalText must copy the text if it wishes to retain the text after returning.

type Token ΒΆ 

type Token any

Token holds a value of one of these types: 

Delim, for the four JSON delimiters [ ] { }
bool, for JSON booleans
float64, for JSON numbers
Number, for JSON numbers
string, for JSON string literals
nil, for JSON null

type TypeSafeAccessResult ΒΆ 

type TypeSafeAccessResult struct {
	Value  any
	Exists bool
	Type   string
}

TypeSafeAccessResult represents the result of a type-safe access operation

func (TypeSafeAccessResult) AsBool ΒΆ 

func (r TypeSafeAccessResult) AsBool() (bool, error)

AsBool safely converts the result to bool

func (TypeSafeAccessResult) AsInt ΒΆ 

func (r TypeSafeAccessResult) AsInt() (int, error)

AsInt safely converts the result to int

func (TypeSafeAccessResult) AsString ΒΆ 

func (r TypeSafeAccessResult) AsString() (string, error)

AsString safely converts the result to string

type TypeSafeResult ΒΆ 

type TypeSafeResult[T any] struct {
	Value  T
	Exists bool
	Error  error
}

TypeSafeResult represents a type-safe operation result

func SafeGetTypedWithProcessor ΒΆ 

func SafeGetTypedWithProcessor[T any](p *Processor, jsonStr, path string) TypeSafeResult[T]

SafeGetTypedWithProcessor performs a type-safe get operation with generic type constraints

func (TypeSafeResult[T]) Ok ΒΆ 

func (r TypeSafeResult[T]) Ok() bool

Ok returns true if the result is valid (no error and exists)

func (TypeSafeResult[T]) Unwrap ΒΆ 

func (r TypeSafeResult[T]) Unwrap() T

Unwrap returns the value or zero value if there's an error For panic behavior, use UnwrapOrPanic instead

func (TypeSafeResult[T]) UnwrapOr ΒΆ 

func (r TypeSafeResult[T]) UnwrapOr(defaultValue T) T

UnwrapOr returns the value or the provided default if there's an error or value doesn't exist

func (TypeSafeResult[T]) UnwrapOrPanic ΒΆ added in v1.0.4 

func (r TypeSafeResult[T]) UnwrapOrPanic() T

UnwrapOrPanic returns the value or panics if there's an error Use this only when you're certain the operation succeeded

type UnifiedResourceManager ΒΆ added in v1.0.6 

type UnifiedResourceManager struct {
	// contains filtered or unexported fields
}

UnifiedResourceManager consolidates all resource management for optimal performance

func GetGlobalResourceManager ΒΆ added in v1.0.6 

func GetGlobalResourceManager() *UnifiedResourceManager

GetGlobalResourceManager returns the global resource manager instance

func NewUnifiedResourceManager ΒΆ added in v1.0.6 

func NewUnifiedResourceManager() *UnifiedResourceManager

NewUnifiedResourceManager creates a new unified resource manager

func (*UnifiedResourceManager) GetBuffer ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) GetBuffer() []byte

GetBuffer retrieves a byte buffer from the pool

func (*UnifiedResourceManager) GetPathSegments ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) GetPathSegments() []PathSegment

GetPathSegments retrieves a path segments slice from the pool

func (*UnifiedResourceManager) GetStats ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) GetStats() ResourceManagerStats

GetStats returns resource usage statistics

func (*UnifiedResourceManager) GetStringBuilder ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) GetStringBuilder() *strings.Builder

GetStringBuilder retrieves a string builder from the pool

func (*UnifiedResourceManager) PerformMaintenance ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) PerformMaintenance()

PerformMaintenance performs periodic cleanup and optimization

func (*UnifiedResourceManager) PutBuffer ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) PutBuffer(buf []byte)

PutBuffer returns a byte buffer to the pool

func (*UnifiedResourceManager) PutPathSegments ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) PutPathSegments(segments []PathSegment)

PutPathSegments returns a path segments slice to the pool

func (*UnifiedResourceManager) PutStringBuilder ΒΆ added in v1.0.6 

func (urm *UnifiedResourceManager) PutStringBuilder(sb *strings.Builder)

PutStringBuilder returns a string builder to the pool

type UnmarshalTypeError ΒΆ 

type UnmarshalTypeError struct {
	Value  string       // description of JSON value - "bool", "array", "number -5"
	Type   reflect.Type // type of Go value it could not be assigned to
	Offset int64        // error occurred after reading Offset bytes
	Struct string       // name of the root type containing the field
	Field  string       // the full path from root node to the value
	Err    error        // may be nil
}

UnmarshalTypeError describes a JSON value that was not appropriate for a value of a specific Go type.

func (*UnmarshalTypeError) Error ΒΆ 

func (e *UnmarshalTypeError) Error() string

func (*UnmarshalTypeError) Unwrap ΒΆ 

func (e *UnmarshalTypeError) Unwrap() error

type Unmarshaler ΒΆ 

type Unmarshaler interface {
	UnmarshalJSON([]byte) error
}

Unmarshaler is the interface implemented by types that can unmarshal a JSON description of themselves. The input can be assumed to be a valid encoding of a JSON value. UnmarshalJSON must copy the JSON data if it wishes to retain the data after returning.

By convention, to approximate the behavior of Unmarshal itself, Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.

type Unsigned ΒΆ 

type Unsigned interface {
	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

Unsigned represents unsigned integer types

type UnsupportedTypeError ΒΆ 

type UnsupportedTypeError struct {
	Type reflect.Type
}

UnsupportedTypeError is returned by Marshal when attempting to encode an unsupported value type.

func (*UnsupportedTypeError) Error ΒΆ 

func (e *UnsupportedTypeError) Error() string

type UnsupportedValueError ΒΆ 

type UnsupportedValueError struct {
	Value reflect.Value
	Str   string
}

UnsupportedValueError is returned by Marshal when attempting to encode an unsupported value.

func (*UnsupportedValueError) Error ΒΆ 

func (e *UnsupportedValueError) Error() string

type ValidationError ΒΆ 

type ValidationError struct {
	Path    string `json:"path"`
	Message string `json:"message"`
}

ValidationError represents a schema validation error

func ValidateSchema ΒΆ 

func ValidateSchema(jsonStr string, schema *Schema, opts ...*ProcessorOptions) ([]ValidationError, error)

ValidateSchema validates JSON data against a schema

func (*ValidationError) Error ΒΆ 

func (ve *ValidationError) Error() string

type Validator ΒΆ added in v1.0.6 

type Validator struct {
	// contains filtered or unexported fields
}

Validator provides streamlined input validation with enhanced security

func NewValidator ΒΆ added in v1.0.6 

func NewValidator(maxJSONSize int64, maxPathLength, maxNestingDepth int) *Validator

NewValidator creates a new validator with the given limits

func (*Validator) ValidateJSONInput ΒΆ added in v1.0.6 

func (v *Validator) ValidateJSONInput(jsonStr string) error

ValidateJSONInput performs comprehensive JSON input validation

func (*Validator) ValidatePathInput ΒΆ added in v1.0.6 

func (v *Validator) ValidatePathInput(path string) error

ValidatePathInput performs comprehensive path validation

type WarmupResult ΒΆ 

type WarmupResult struct {
	TotalPaths  int      `json:"total_paths"`            // Total number of paths processed
	Successful  int      `json:"successful"`             // Number of successfully warmed up paths
	Failed      int      `json:"failed"`                 // Number of failed paths
	SuccessRate float64  `json:"success_rate"`           // Success rate as percentage (0-100)
	FailedPaths []string `json:"failed_paths,omitempty"` // List of paths that failed (optional)
}

WarmupResult represents the result of a cache warmup operation

Source Files ΒΆ

View all Source files

Directories ΒΆ

Path Synopsis
examples
basic command
compatibility command
comprehensive_validation command
configuration command
file_operations command
flat_extraction command
json_delete command
json_encode command
json_get command
json_iteration command
json_set command
marshal_file command
optional_config command
thread_safety command
writer_usage command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.