ProcessorTable

Internal class that stores a context-categorized key-value mapping for transforming third-party package assets. Parsed from raw Dictionary<string, string> data (loaded from a remote catalog), the table organizes entries into typed contexts (VARIABLES, DIRECTORIES, FILES, MATERIALS, etc.) and supports variable expansion — values in DIRECTORIES and FILES contexts can reference VARIABLES entries.

Definition

Namespace: Paragon.Editor.ThirdPartyPackageImporter Assembly: Paragon.Editor.dll

internal class ProcessorTable

Remarks

Data Format

The raw input is a flat Dictionary<string, string> where context headers are keys starting with $ and having empty values. Entries after a context header belong to that context until the next header:

$VARIABLES      → ""          (context header)
{PackagePath}   → "Assets/Third-Party/MyPackage"  (variable)
$DIRECTORIES    → ""          (context header)
Assets/OldPath  → "{PackagePath}/NewPath"           (directory mapping with variable)
$FILES          → ""          (context header)
OldFile.cs      → "NewFile.cs"                      (file mapping)
$MATERIALS      → ""
OldMaterial     → "NewMaterial"
$MESHES         → ""
OldMesh         → "NewMesh"
$ANIMATIONS     → ""
OldClip         → "NewClip"

Variable Expansion

After parsing, the ExpandVariables() method replaces all VARIABLES references in DIRECTORIES and FILES context values. For example, {PackagePath}/Scripts becomes Assets/Third-Party/MyPackage/Scripts.

Lookup Behavior

TryGetValue() iterates through each context flag set in the contexts parameter, checking each context's table in enum order. Returns false for empty string values (treated as "no mapping").

Constructors

public ProcessorTable(Dictionary<string, string> data)

Parameter	Type	Description
data	Dictionary<string, string>	Raw key-value data with $CONTEXT headers. Parsed into context tables and variable-expanded

Methods

GetValue

Looks up a key across the specified context(s).

public string GetValue(string key, Context contexts = Context.ALL)

Parameter	Type	Default	Description
key	string	—	The key to look up
contexts	Context	ALL	Which contexts to search (flags can be combined)

Returns: The mapped value, or null if not found.

TryGetValue

Attempts to look up a key across the specified context(s).

public bool TryGetValue(string key, out string value, Context contexts = Context.ALL)

Returns: true if the key was found and has a non-empty value. Iterates contexts in enum order, returns on first match.

ToString

Debug representation showing all contexts and their key-value entries.

public override string ToString()

Context Enum

[Flags]
internal enum Context
{
    VARIABLES   = 1 << 0,
    DIRECTORIES = 1 << 1,
    FILES       = 1 << 2,
    MATERIALS   = 1 << 3,
    MESHES      = 1 << 4,
    ANIMATIONS  = 1 << 5,
    OTHER       = 1 << 6,
    ALL = VARIABLES | DIRECTORIES | FILES | MATERIALS | MESHES | ANIMATIONS,
}

Flag	Usage
VARIABLES	Variable definitions for path expansion (e.g., {PackagePath})
DIRECTORIES	Directory path mappings (source → destination)
FILES	Individual file path mappings
MATERIALS	Material name mappings (used by FBXProcessor, MaterialProcessor)
MESHES	Mesh/node name mappings (used by FBXProcessor)
ANIMATIONS	Animation clip name mappings (used by FBXProcessor)
OTHER	Fallback context for entries before any valid context header
ALL	All contexts except OTHER (default for lookups)

OTHER is excluded from ALL. The ALL flag combines VARIABLES through ANIMATIONS but does not include OTHER. Entries before the first valid context header are placed in OTHER and require explicit context filtering to access.

Common Pitfalls

Duplicate context headers assert. The parser asserts if the same $CONTEXT header appears twice in the raw data. Each context must appear at most once.

Empty values return false from TryGetValue. A key that exists but has an empty string value ("") is treated as "no mapping" — TryGetValue returns false. This means empty strings cannot be used as intentional mapped values.

Variable expansion only applies to DIRECTORIES and FILES. MATERIALS, MESHES, and ANIMATIONS values are not variable-expanded. Variable references like {PackagePath} in these contexts will remain as literal strings.

Examples

Constructing a Processor Table

var data = new Dictionary<string, string>
{
    { "$VARIABLES", "" },
    { "{Root}", "Assets/Third-Party/MyPlugin" },
    { "$DIRECTORIES", "" },
    { "Assets/MyPlugin/Scripts", "{Root}/Scripts" },
    { "Assets/MyPlugin/Prefabs", "{Root}/Prefabs" },
    { "$FILES", "" },
    { "OldConfig.asset", "NewConfig.asset" },
    { "$MATERIALS", "" },
    { "Default-Material", "MyPlugin-Material" },
};

var table = new ProcessorTable(data);

// After construction, DIRECTORIES values are expanded:
// "Assets/MyPlugin/Scripts" → "Assets/Third-Party/MyPlugin/Scripts"

Context-Specific Lookups

// Look up a directory mapping only
string newDir = table.GetValue("Assets/MyPlugin/Scripts", ProcessorTable.Context.DIRECTORIES);

// Look up across all contexts
string value = table.GetValue("OldConfig.asset");

// Try with specific context
if (table.TryGetValue("Default-Material", out string newMat, ProcessorTable.Context.MATERIALS))
{
    // newMat = "MyPlugin-Material"
}

See Also

• Processor — abstract base class that reads from this table

• ThirdPartyPackage — holds and delegates lookups to this table

• Processor Overview — processor subsystem overview