//-------------------------------------------------------- 
 | 
//    [Author]:           Fish 
 | 
//    [  Date ]:           #DateTime# 
 | 
//-------------------------------------------------------- 
 | 
  
 | 
using System.Collections.Generic; 
 | 
using System.IO; 
 | 
using System.Threading; 
 | 
using System; 
 | 
using UnityEngine; 
 | 
  
 | 
[XLua.LuaCallCSharp] 
 | 
public partial class #ClassName# 
 | 
{ 
 | 
  
 | 
    #Field# 
 | 
  
 | 
    public #ClassName#() 
 | 
    { 
 | 
    } 
 | 
  
 | 
    public #ClassName#(string input) 
 | 
    { 
 | 
        try 
 | 
        { 
 | 
            var tables = input.Split('\t'); 
 | 
  
 | 
            #Read# 
 | 
        } 
 | 
        catch (Exception ex) 
 | 
        { 
 | 
            DebugEx.Log(ex); 
 | 
        } 
 | 
    } 
 | 
  
 | 
    static Dictionary<string, #ClassName#> configs = new Dictionary<string, #ClassName#>(); 
 | 
    public static #ClassName# Get(string id) 
 | 
    {    
 | 
        if (!inited) 
 | 
        { 
 | 
            Debug.Log("#ClassName# 还未完成初始化。"); 
 | 
            return null; 
 | 
        } 
 | 
         
 | 
        if (configs.ContainsKey(id)) 
 | 
        { 
 | 
            return configs[id]; 
 | 
        } 
 | 
  
 | 
        #ClassName# config = null; 
 | 
        if (rawDatas.ContainsKey(id)) 
 | 
        { 
 | 
            config = configs[id] = new #ClassName#(rawDatas[id]); 
 | 
            rawDatas.Remove(id); 
 | 
        } 
 | 
  
 | 
        return config; 
 | 
    } 
 | 
  
 | 
    public static #ClassName# Get(int id) 
 | 
    { 
 | 
        return Get(id.ToString()); 
 | 
    } 
 | 
  
 | 
    public static List<string> GetKeys() 
 | 
    { 
 | 
        var keys = new List<string>(); 
 | 
        keys.AddRange(configs.Keys); 
 | 
        keys.AddRange(rawDatas.Keys); 
 | 
        return keys; 
 | 
    } 
 | 
  
 | 
    public static List<#ClassName#> GetValues() 
 | 
    { 
 | 
        var values = new List<#ClassName#>(); 
 | 
        values.AddRange(configs.Values); 
 | 
  
 | 
        var keys = new List<string>(rawDatas.Keys); 
 | 
        foreach (var key in keys) 
 | 
        { 
 | 
            values.Add(Get(key)); 
 | 
        } 
 | 
  
 | 
        return values; 
 | 
    } 
 | 
  
 | 
    public static bool Has(string id) 
 | 
    { 
 | 
        return configs.ContainsKey(id) || rawDatas.ContainsKey(id); 
 | 
    } 
 | 
  
 | 
    public static bool Has(int id) 
 | 
    { 
 | 
        return Has(id.ToString()); 
 | 
    } 
 | 
  
 | 
    public static bool inited { get; private set; } 
 | 
    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>(); 
 | 
    public static void Init(bool sync=false) 
 | 
    { 
 | 
        inited = false; 
 | 
        var path = string.Empty; 
 | 
        if (AssetSource.refdataFromEditor) 
 | 
        { 
 | 
            path = ResourcesPath.CONFIG_FODLER +"/#FileName#.txt"; 
 | 
        } 
 | 
        else 
 | 
        { 
 | 
            path = AssetVersionUtility.GetAssetFilePath("config/#FileName#.txt"); 
 | 
        } 
 | 
  
 | 
        var tempConfig = new #ClassName#(); 
 | 
        var preParse = tempConfig is IConfigPostProcess; 
 | 
  
 | 
        if (sync) 
 | 
        { 
 | 
            var lines = File.ReadAllLines(path); 
 | 
            if (!preParse) 
 | 
            { 
 | 
                rawDatas = new Dictionary<string, string>(lines.Length - 3); 
 | 
            } 
 | 
            for (int i = 3; i < lines.Length; i++) 
 | 
            { 
 | 
                try  
 | 
                { 
 | 
                    var line = lines[i]; 
 | 
                    var index = line.IndexOf("\t"); 
 | 
                    if (index == -1) 
 | 
                    { 
 | 
                        continue; 
 | 
                    } 
 | 
                    var id = line.Substring(0, index); 
 | 
  
 | 
                    if (preParse) 
 | 
                    { 
 | 
                        var config = new #ClassName#(line); 
 | 
                        configs[id] = config; 
 | 
                        (config as IConfigPostProcess).OnConfigParseCompleted(); 
 | 
                    } 
 | 
                    else 
 | 
                    { 
 | 
                        rawDatas[id] = line; 
 | 
                    } 
 | 
                } 
 | 
                catch (System.Exception ex) 
 | 
                { 
 | 
                    Debug.LogError(ex); 
 | 
                } 
 | 
            } 
 | 
            inited = true; 
 | 
        } 
 | 
        else 
 | 
        { 
 | 
            ThreadPool.QueueUserWorkItem((object _object) => 
 | 
            { 
 | 
                var lines = File.ReadAllLines(path); 
 | 
                if (!preParse) 
 | 
                { 
 | 
                    rawDatas = new Dictionary<string, string>(lines.Length - 3); 
 | 
                } 
 | 
                for (int i = 3; i < lines.Length; i++) 
 | 
                { 
 | 
                    try  
 | 
                    { 
 | 
                       var line = lines[i]; 
 | 
                        var index = line.IndexOf("\t"); 
 | 
                        if (index == -1) 
 | 
                        { 
 | 
                            continue; 
 | 
                        } 
 | 
                        var id = line.Substring(0, index); 
 | 
  
 | 
                        if (preParse) 
 | 
                        { 
 | 
                            var config = new #ClassName#(line); 
 | 
                            configs[id] = config; 
 | 
                            (config as IConfigPostProcess).OnConfigParseCompleted(); 
 | 
                        } 
 | 
                        else 
 | 
                        { 
 | 
                            rawDatas[id] = line; 
 | 
                        } 
 | 
                    } 
 | 
                    catch (System.Exception ex) 
 | 
                    { 
 | 
                        Debug.LogError(ex); 
 | 
                    } 
 | 
                } 
 | 
  
 | 
                inited = true; 
 | 
            }); 
 | 
        } 
 | 
    } 
 | 
  
 | 
} 
 |