SourceImporter Class Reference

Inheritance diagram for SourceImporter:

Public Member Functions
	SourceImporter (IReadOnlyDictionary< string, SourceData > sourceMapping)
SourceData	FindSourceByName (string name)
IEnumerable< SourceData >	ImportFilesCached (IEnumerable< string > imports, bool resetData=true)

Static Public Member Functions
static void	HotInit (IEnumerable< SourceData > sourceData)
Static Public Member Functions inherited from EClass
static int	rndSeed (int a, int seed)
static int	rnd (long a)
static int	rnd (int a)
static int	curve (long _a, int start, int step, int rate=75)
static int	sqrt (int a)
static int	rndHalf (int a)
static float	rndf (float a)
static int	rndSqrt (int a)
static void	Wait (float a, Card c)
static void	Wait (float a, Point p)
static int	Bigger (int a, int b)
static int	Smaller (int a, int b)

Public Attributes
Dictionary< string, EMod >	fileProviders = new Dictionary<string, EMod>(PathComparer.Default)

Private Member Functions
SourceData.BaseRow[]	LoadBySheetName (ISheet sheet, string file)
string ISheet[] ISheet[] fetched	PrefetchWorkbook (string file, string[] prefetchNames)

Private Attributes
readonly IReadOnlyDictionary< string, SourceData >	_sourceMapping
	SourceData
string	file
string ISheet[]	sheets

Additional Inherited Members
Static Public Attributes inherited from EClass
static Core	core
Properties inherited from EClass
static Game	game [get]
static bool	AdvMode [get]
static Player	player [get]
static Chara	pc [get]
static UI	ui [get]
static Map	_map [get]
static Zone	_zone [get]
static FactionBranch	Branch [get]
static FactionBranch	BranchOrHomeBranch [get]
static Faction	Home [get]
static Faction	Wilds [get]
static Scene	scene [get]
static BaseGameScreen	screen [get]
static GameSetting	setting [get]
static GameData	gamedata [get]
static ColorProfile	Colors [get]
static World	world [get]
static SourceManager	sources [get]
static SourceManager	editorSources [get]
static SoundManager	Sound [get]
static CoreDebug	debug [get]

Detailed Description

Definition at line 10 of file SourceImporter.cs.

Constructor & Destructor Documentation

SourceImporter()

SourceImporter.SourceImporter ( IReadOnlyDictionary< string, SourceData >  sourceMapping )

inline

Definition at line 16 of file SourceImporter.cs.

    {
        _sourceMapping = sourceMapping;
    }

References _sourceMapping.

Member Function Documentation

FindSourceByName()

SourceData SourceImporter.FindSourceByName ( string  name )

inline

Definition at line 21 of file SourceImporter.cs.

    {
        string[] array = new string[3]
        {
            "Source" + name,
            "Lang" + name,
            name
        };
        foreach (string key in array)
        {
            if (_sourceMapping.TryGetValue(key, out var value))
            {
                return value;
            }
        }
        return null;
    }

References _sourceMapping.

Referenced by ImportFilesCached(), and LoadBySheetName().

HotInit()

static void SourceImporter.HotInit ( IEnumerable< SourceData >  sourceData )

inlinestatic

Definition at line 229 of file SourceImporter.cs.

    {
        Debug.Log("#source resetting data...");
        foreach (SourceData sourceDatum in sourceData)
        {
            try
            {
                sourceDatum.Reset();
                sourceDatum.Init();
            }
            catch (Exception arg)
            {
                Debug.LogError($"#source failed to reset dirty data {sourceDatum.GetType().Name}\n{arg}");
            }
        }
        Debug.Log("#source initialized data");
    }

References $, Debug, SourceData< T, T2 >.Init(), and SourceData< T, T2 >.Reset().

Referenced by ImportFilesCached().

ImportFilesCached()

IEnumerable< SourceData > SourceImporter.ImportFilesCached ( IEnumerable< string >  imports, bool  resetData = true  )

inline

Definition at line 84 of file SourceImporter.cs.

    {
        string[] prefetchSheetNames = new string[2] { "Element", "Material" };
        SourceCache[] array = imports.Select(SourceCache.GetOrCreate).Distinct().ToArray();
        Dictionary<SourceCache, (string, ISheet[], ISheet[])> dictionary = (from c in array
            where c.IsDirtyOrEmpty
            select PrefetchWorkbook(c.SheetFile.FullName, prefetchSheetNames)).ToArray().ToDictionary(((string file, ISheet[] sheets, ISheet[] fetched) p) => SourceCache.GetOrCreate(p.file));
        SourceElement elements = EClass.sources.elements;
        HashSet<SourceData> hashSet = new HashSet<SourceData> { elements };
        SourceCache[] array2 = array;
        foreach (SourceCache sourceCache in array2)
        {
            string arg = sourceCache.SheetFile.ShortPath();
            if (fileProviders.TryGetValue(sourceCache.SheetFile.FullName, out var value))
            {
                sourceCache.SetMod(value);
            }
            if (sourceCache.IsDirtyOrEmpty)
            {
                if (!dictionary.TryGetValue(sourceCache, out var value2) || value2.Item3.Length == 0)
                {
                    continue;
                }
                ISheet[] item = value2.Item3;
                foreach (ISheet sheet in item)
                {
                    ExcelParser.allowTrimming = true;
                    try
                    {
                        SourceData.BaseRow[] item2 = LoadBySheetName(sheet, value2.Item1).Item2;
                        if (!item2.IsEmpty())
                        {
                            sourceCache.EmplaceCache(sheet.SheetName, item2);
                            value?.sourceRows.UnionWith(item2);
                            Debug.Log($"#source workbook {arg}:{sheet.SheetName}:{item2.Length}");
                        }
                    }
                    finally
                    {
                        ExcelParser.allowTrimming = false;
                    }
                }
                continue;
            }
            string[] array3 = prefetchSheetNames;
            foreach (string text in array3)
            {
                if (sourceCache.TryGetCache(text, out var rows))
                {
                    int num = elements.ImportRows(rows);
                    value?.sourceRows.UnionWith(rows);
                    Debug.Log($"#source workbook-cache {arg}:{text}:{num}");
                }
            }
        }
        array2 = array;
        foreach (SourceCache sourceCache2 in array2)
        {
            string text2 = sourceCache2.SheetFile.ShortPath();
            string key;
            if (sourceCache2.IsDirtyOrEmpty)
            {
                if (!dictionary.TryGetValue(sourceCache2, out var value3) || value3.Item2.Length == 0)
                {
                    continue;
                }
                Debug.Log("#source workbook " + text2);
                ISheet[] item = value3.Item2;
                foreach (ISheet sheet2 in item)
                {
                    if (prefetchSheetNames.Contains(sheet2.SheetName))
                    {
                        continue;
                    }
                    key = sheet2.SheetName;
                    int allowTrimming;
                    switch (key)
                    {
                    default:
                        allowTrimming = ((!(key == "Word")) ? 1 : 0);
                        break;
                    case "General":
                    case "Game":
                    case "Note":
                    case "List":
                        allowTrimming = 0;
                        break;
                    }
                    ExcelParser.allowTrimming = (byte)allowTrimming != 0;
                    try
                    {
                        var (sourceData, array4) = LoadBySheetName(sheet2, value3.Item1);
                        if ((object)sourceData != null)
                        {
                            int? num2 = array4?.Length;
                            if (num2.HasValue && num2.GetValueOrDefault() > 0)
                            {
                                sourceCache2.EmplaceCache(sheet2.SheetName, array4);
                                sourceCache2.Mod?.sourceRows.UnionWith(array4);
                                hashSet.Add(sourceData);
                            }
                        }
                    }
                    finally
                    {
                        ExcelParser.allowTrimming = false;
                    }
                }
                continue;
            }
            foreach (KeyValuePair<string, SourceData.BaseRow[]> item3 in sourceCache2.Source)
            {
                item3.Deconstruct(out key, out var value4);
                string text3 = key;
                SourceData.BaseRow[] array5 = value4;
                SourceData sourceData2 = FindSourceByName(text3);
                if (!(sourceData2 is SourceThingV))
                {
                    if (sourceData2 is SourceElement || (object)sourceData2 == null)
                    {
                        continue;
                    }
                }
                else
                {
                    sourceData2 = EClass.sources.things;
                }
                if (array5 == null)
                {
                    Debug.Log("#source cached rows are empty " + text2 + ":" + text3);
                    continue;
                }
                int num3 = sourceData2.ImportRows(array5);
                sourceCache2.Mod?.sourceRows.UnionWith(array5);
                Debug.Log($"#source workbook-cache {text2}:{text3}:{num3}");
                hashSet.Add(sourceData2);
            }
        }
        if (resetData)
        {
            HotInit(hashSet);
        }
        return hashSet;
    }

References $, Debug, SourceManager.elements, file, fileProviders, FindSourceByName(), HotInit(), SourceData< T, T2 >.ImportRows(), item, LoadBySheetName(), PrefetchWorkbook(), sheets, EClass.sources, and SourceManager.things.

LoadBySheetName()

SourceData.BaseRow[] SourceImporter.LoadBySheetName ( ISheet  sheet, string  file  )

inlineprivate

Definition at line 39 of file SourceImporter.cs.

    {
        string sheetName = sheet.SheetName;
        try
        {
            SourceData sourceData = FindSourceByName(sheetName);
            if ((object)sourceData == null)
            {
                Debug.Log("#source skipping sheet " + sheetName);
                return (null, null);
            }
            IList list;
            if (!(sourceData is SourceThingV))
            {
                list = sourceData.GetField<IList>("rows");
            }
            else
            {
                IList rows = EClass.sources.things.rows;
                list = rows;
            }
            IList list2 = list;
            int count = list2.Count;
            Debug.Log("#source loading sheet " + sheetName);
            ExcelParser.path = file;
            ERROR.lastImported = 0;
            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
            if (!sourceData.ImportData(sheet, fileNameWithoutExtension, overwrite: true))
            {
                throw new SourceParseException("#source failed to import data " + sourceData.GetType().Name + ":" + fileNameWithoutExtension + "/" + sheetName);
            }
            if (ERROR.lastImported > 0)
            {
                SourceData.BaseRow[] item = list2.OfType<SourceData.BaseRow>().Skip(count).Take(ERROR.lastImported)
                    .ToArray();
                return (sourceData, item);
            }
        }
        catch (Exception arg)
        {
            Debug.LogError($"#source failed to load sheet {sheetName}\n{arg}");
        }
        return (null, Array.Empty<SourceData.BaseRow>());
    }

References $, Debug, file, FindSourceByName(), SourceData< T, T2 >.ImportData(), item, ERROR.lastImported, EClass.sources, and SourceManager.things.

Referenced by ImportFilesCached().

PrefetchWorkbook()

string ISheet[] ISheet[] fetched SourceImporter.PrefetchWorkbook ( string  file, string[]  prefetchNames  )

inlineprivate

Definition at line 247 of file SourceImporter.cs.

    {
        using FileStream @is = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
        XSSFWorkbook xSSFWorkbook = new XSSFWorkbook((Stream)@is);
        List<ISheet> list = new List<ISheet>();
        List<ISheet> list2 = new List<ISheet>();
        for (int i = 0; i < xSSFWorkbook.NumberOfSheets; i++)
        {
            ISheet sheetAt = xSSFWorkbook.GetSheetAt(i);
            if (FindSourceByName(sheetAt.SheetName) != null && prefetchNames.Contains(sheetAt.SheetName))
            {
                list2.Add(sheetAt);
            }
            else
            {
                list.Add(sheetAt);
            }
        }
        Debug.Log("#source workbook-prefetch " + file.ShortPath());
        return (file: file, sheets: list.ToArray(), fetched: list2.ToArray());
    }

Referenced by ImportFilesCached().

Member Data Documentation

_sourceMapping

readonly IReadOnlyDictionary<string, SourceData> SourceImporter._sourceMapping

private

Definition at line 12 of file SourceImporter.cs.

Referenced by FindSourceByName(), and SourceImporter().

file

string SourceImporter.file

private

Definition at line 247 of file SourceImporter.cs.

Referenced by ImportFilesCached(), and LoadBySheetName().

fileProviders

Dictionary<string, EMod> SourceImporter.fileProviders = new Dictionary<string, EMod>(PathComparer.Default)

Definition at line 14 of file SourceImporter.cs.

Referenced by ImportFilesCached().

sheets

string ISheet [] SourceImporter.sheets

private

Definition at line 247 of file SourceImporter.cs.

Referenced by ImportFilesCached().

SourceData

SourceImporter.SourceData

private

Definition at line 39 of file SourceImporter.cs.

---

The documentation for this class was generated from the following file:

• Elin/SourceImporter.cs