pjson-rs 0.5.2

Priority JSON Streaming Protocol - high-performance priority-based JSON streaming (requires nightly Rust)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! # PJS Core
//!
//! Core types and protocols for the Priority JSON Streaming Protocol.
//! This crate provides high-performance JSON parsing with SIMD optimizations,
//! zero-copy operations, and semantic type hints for automatic optimization.

#![feature(impl_trait_in_assoc_type)]
#![cfg_attr(feature = "metrics", feature(once_cell_try))]
#![warn(rust_2018_idioms)]
#![deny(unsafe_op_in_unsafe_fn)]
// Allow specific clippy warnings that are intentional design choices
#![allow(clippy::manual_div_ceil)] // Performance: manual div_ceil is faster
#![allow(clippy::only_used_in_recursion)] // Recursive algorithms by design
// Note: dead_code is now handled per-item with targeted annotations

pub mod application;
pub mod compression;
pub mod config;
pub mod domain;
pub mod error;
pub mod frame;
pub mod global_alloc;
pub mod infrastructure;
pub mod memory;
pub mod parser;
pub mod security;
pub mod semantic;
pub mod stream;

// Global allocator diagnostics
pub use global_alloc::global_allocator_name;

// Domain layer exports
pub use domain::{
    DomainError,
    DomainEvent,
    DomainResult,
    Frame as DomainFrame,
    JsonPath,
    Priority,
    SessionId,
    Stream,
    StreamId,
    StreamSession,
    // GAT-based domain ports (zero-cost async abstractions)
    ports::{
        EventPublisherGat, FrameSinkGat, FrameSinkGatExt, FrameSourceGat, StreamRepositoryGat,
        StreamStoreGat,
    },
    services::{
        GatOrchestratorFactory, GatStreamingOrchestrator, HealthStatus, OrchestratorConfig,
        ValidationService,
    },
    value_objects::{
        JsonData, Schema, SchemaId, SchemaType, SchemaValidationError, SchemaValidationResult,
    },
};

// Events exports
pub use domain::events::{PriorityDistribution, PriorityPercentages};

// Application layer exports
pub use application::{
    ApplicationError, ApplicationResult, commands,
    dto::{
        SchemaDefinitionDto, SchemaMetadataDto, SchemaRegistrationDto, ValidationErrorDto,
        ValidationRequestDto, ValidationResultDto,
    },
    queries,
};

// Configuration exports
pub use config::{
    ConfigError, ParserConfig, PjsConfig, SecurityConfig, SimdConfig, StreamingConfig,
    security::{BufferLimits, JsonLimits, NetworkLimits, RateLimitingConfig, SessionLimits},
};

// Compression exports
pub use compression::{
    CompressedData, CompressionConfig, CompressionStrategy, SchemaAnalyzer, SchemaCompressor,
    secure::{
        ByteCodec, CompressionQuality, DecompressionContextStats, SecureCompressedData,
        SecureCompressor, SecureDecompressionContext,
    },
};

// Streaming exports
pub use error::{Error, Result};
pub use frame::{Frame, FrameFlags, FrameHeader};
#[cfg(any(feature = "websocket-client", feature = "websocket-server"))]
pub use infrastructure::websocket::SecureWebSocketHandler;
pub use memory::{CombinedArenaStats, JsonArena};
pub use parser::{
    LazyParser, ParseConfig, ParseStats, Parser, SimpleParser, SonicParser, ZeroCopyParser,
};
pub use security::{
    CompressionBombConfig, CompressionBombDetector, CompressionBombProtector,
    CompressionStats as BombCompressionStats, DepthTracker, RateLimitConfig, RateLimitError,
    RateLimitGuard, RateLimitStats, SecurityValidator, WebSocketRateLimiter,
};
pub use semantic::{SemanticMeta, SemanticType};
pub use stream::{
    CompressedFrame, CompressionStats, DecompressionMetadata, DecompressionStats,
    JsonReconstructor, PriorityStreamer, ProcessResult, StreamConfig, StreamFrame, StreamProcessor,
    StreamStats, StreamingCompressor, StreamingDecompressor,
};

/// Re-export commonly used types
pub mod prelude {
    pub use super::{
        ApplicationError, ApplicationResult, DomainError, DomainEvent, DomainFrame, DomainResult,
        Error, Frame, FrameFlags, FrameHeader, JsonData, JsonPath, JsonReconstructor, Priority,
        PriorityDistribution, PriorityPercentages, ProcessResult, Result, Schema, SchemaId,
        SchemaRepository, SchemaType, SchemaValidationError, SemanticMeta, SemanticType, SessionId,
        Stream, StreamId, StreamProcessor, StreamSession, ValidationService,
    };
}

// Infrastructure exports for schema validation
pub use infrastructure::SchemaRepository;