106 lines
2.4 KiB
Go
106 lines
2.4 KiB
Go
package cps
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
// Manager provides runtime packet management with caching
|
|
type Manager struct {
|
|
compiler *Compiler
|
|
cache sync.Map // map[string]*CompiledStruct
|
|
}
|
|
|
|
// NewManager creates a packet manager
|
|
func NewManager() *Manager {
|
|
return &Manager{}
|
|
}
|
|
|
|
// LoadCSS loads and parses CSS packet definitions
|
|
func (m *Manager) LoadCSS(content string) error {
|
|
parser := NewParser(content)
|
|
packets, err := parser.Parse()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
m.compiler = NewCompiler(packets)
|
|
return nil
|
|
}
|
|
|
|
// GetPacket returns a compiled packet structure (cached)
|
|
func (m *Manager) GetPacket(name string, version int) (*CompiledStruct, error) {
|
|
key := fmt.Sprintf("%s_%d", name, version)
|
|
|
|
if cached, ok := m.cache.Load(key); ok {
|
|
return cached.(*CompiledStruct), nil
|
|
}
|
|
|
|
compiled, err := m.compiler.Compile(name, version)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
m.cache.Store(key, compiled)
|
|
return compiled, nil
|
|
}
|
|
|
|
// ListPackets returns names of all available packets
|
|
func (m *Manager) ListPackets() []string {
|
|
if m.compiler == nil {
|
|
return nil
|
|
}
|
|
|
|
var names []string
|
|
for name := range m.compiler.packets {
|
|
names = append(names, name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
// GetVersions returns all available versions for a packet
|
|
func (m *Manager) GetVersions(packetName string) []int {
|
|
if m.compiler == nil {
|
|
return nil
|
|
}
|
|
|
|
packet, exists := m.compiler.packets[packetName]
|
|
if !exists {
|
|
return nil
|
|
}
|
|
|
|
var versions []int
|
|
for version := range packet.Versions {
|
|
versions = append(versions, version)
|
|
}
|
|
return versions
|
|
}
|
|
|
|
// ClearCache clears the compiled packet cache
|
|
func (m *Manager) ClearCache() {
|
|
m.cache = sync.Map{}
|
|
}
|
|
|
|
// Convenience functions
|
|
|
|
// MustLoadCSS loads CSS definitions and panics on error
|
|
func MustLoadCSS(content string) *Manager {
|
|
manager := NewManager()
|
|
if err := manager.LoadCSS(content); err != nil {
|
|
panic(err)
|
|
}
|
|
return manager
|
|
}
|
|
|
|
// QuickSerialize is a convenience function for one-off serialization
|
|
func QuickSerialize(manager *Manager, packetName string, version int, data map[string]any) ([]byte, error) {
|
|
serializer := NewSerializer(manager)
|
|
return serializer.Serialize(packetName, version, data)
|
|
}
|
|
|
|
// QuickDeserialize is a convenience function for one-off deserialization
|
|
func QuickDeserialize(manager *Manager, packetName string, version int, data []byte) (map[string]any, error) {
|
|
serializer := NewSerializer(manager)
|
|
return serializer.Deserialize(packetName, version, data)
|
|
}
|