Esempio n. 1
0
    public static void ConvertCSV(string _input, out List <Entry> entries)
    {
        entries = new List <Entry>();

        var _output          = DataboxCSVReader.SplitCsvGrid(_input);
        var _fieldTypesIndex = 0;
        var _fieldNamesIndex = 0;

        for (int x = 0; x < _output.GetLength(0); x++)
        {
            for (int y = 0; y < _output.GetLength(1); y++)
            {
                //Debug.Log(_output[x, y]);

                if (_output[x, y] == fieldTypeKey)
                {
                    _fieldTypesIndex = y;
                }

                if (_output[x, y] == fieldNameKey)
                {
                    _fieldNamesIndex = y;
                }

                //// Entry names
                if (x == 0 && y != _fieldNamesIndex && y != _fieldTypesIndex)
                {
                    //Debug.Log("Entry: " + _output[x, y]);

                    var _entryYIndex = y;

                    if (!string.IsNullOrEmpty(_output[x, y]) && _output[x, y] != ignoreKey)
                    {
                        entries.Add(new Entry(_output[x, y]));


                        for (int x1 = 0; x1 < _output.GetLength(0); x1++)
                        {
                            for (int y1 = 0; y1 < _output.GetLength(1); y1++)
                            {
                                // field names
                                if (x1 > 0 && y1 == _fieldNamesIndex)
                                {
                                    if (!string.IsNullOrEmpty(_output[x1, y1]))
                                    {
                                        entries[entries.Count - 1].fields.Add(_output[x1, y1]);
                                    }
                                }
                                // field types
                                if (x1 > 0 && y1 == _fieldTypesIndex)
                                {
                                    if (!string.IsNullOrEmpty(_output[x1, y1]))
                                    {
                                        entries[entries.Count - 1].types.Add(_output[x1, y1]);
                                    }
                                }
                                // values
                                if (x1 > 0 && y1 == _entryYIndex && y1 != _fieldTypesIndex && y1 != _fieldNamesIndex)
                                {
                                    entries[entries.Count - 1].values.Add(_output[x1, y1]);
                                }
                            }
                        }
                    }
                }
            }
        }

        // cleanup
        for (int e = 0; e < entries.Count; e++)
        {
            for (int f = 0; f < entries[e].fields.Count; f++)
            {
                if (entries[e].fields[f] == ignoreKey)
                {
                    entries[e].types[f]  = ignoreKey;
                    entries[e].values[f] = ignoreKey;
                    entries[e].fields[f] = ignoreKey;
                }
            }

            for (int v = 0; v < entries[e].values.Count; v++)
            {
                if (string.IsNullOrEmpty(entries[e].values[v]))
                {
                    if (v < entries[e].types.Count)
                    {
                        entries[e].types[v] = ignoreKey;
                    }

                    if (v < entries[e].fields.Count)
                    {
                        entries[e].fields[v] = ignoreKey;
                    }

                    if (v < entries[e].values.Count)
                    {
                        entries[e].values[v] = ignoreKey;
                    }
                }
            }
        }

        // remove all entries which contains the ignore key
        for (int e = 0; e < entries.Count; e++)
        {
            for (int v = entries[e].values.Count - 1; v >= 0; v--)
            {
                if (entries[e].values[v].Contains(ignoreKey))
                {
                    entries[e].values.RemoveAt(v);
                }
            }

            for (int t = entries[e].types.Count - 1; t >= 0; t--)
            {
                if (entries[e].types[t].Contains(ignoreKey))
                {
                    entries[e].types.RemoveAt(t);
                }
            }

            for (int f = entries[e].fields.Count - 1; f >= 0; f--)
            {
                if (entries[e].fields[f].Contains(ignoreKey))
                {
                    entries[e].fields.RemoveAt(f);
                }
            }
        }
    }
Esempio n. 2
0
    public static void ConvertCSV(string _input, out List <Entry> entries)
    {
        entries = new List <Entry>();


        var _output = DataboxCSVReader.SplitCSV(_input);

        var _fieldTypesIndex = 0;
        var _fieldNamesIndex = 0;

        foreach (var row in _output.Keys)
        {
            for (int i = 0; i < _output[row].Count; i++)
            {
                if (_output[row][i] == fieldTypeKey)
                {
                    _fieldTypesIndex = i;
                }

                if (_output[row][i] == fieldNameKey)
                {
                    _fieldNamesIndex = i;
                }

                //// Entry names
                if (row == 0 && i != _fieldNamesIndex && i != _fieldTypesIndex)
                {
                    var _entryIndex = i;

                    if (!string.IsNullOrEmpty(_output[row][i]) && _output[row][i] != ignoreKey)
                    {
                        entries.Add(new Entry(_output[row][i]));

                        foreach (var row2 in _output.Keys)
                        {
                            for (int i2 = 0; i2 < _output[row2].Count; i2++)
                            {
                                // field names
                                if (row2 > 0 && i2 == _fieldNamesIndex)
                                {
                                    if (!string.IsNullOrEmpty(_output[row2][i2]))
                                    {
                                        entries[entries.Count - 1].fields.Add(_output[row2][i2]);
                                    }
                                }

                                // field types
                                if (row2 > 0 && i2 == _fieldTypesIndex)
                                {
                                    if (!string.IsNullOrEmpty(_output[row2][i2]))
                                    {
                                        entries[entries.Count - 1].types.Add(_output[row2][i2]);
                                    }
                                }
                                // values
                                if (row2 > 0 && i2 == _entryIndex && i2 != _fieldTypesIndex && i2 != _fieldNamesIndex)
                                {
                                    entries[entries.Count - 1].values.Add(_output[row2][i2]);
                                }
                            }
                        }
                    }
                }
            }
        }

        // cleanup
        for (int e = 0; e < entries.Count; e++)
        {
            for (int f = 0; f < entries[e].fields.Count; f++)
            {
                if (entries[e].fields[f] == ignoreKey)
                {
                    entries[e].types[f]  = ignoreKey;
                    entries[e].values[f] = ignoreKey;
                    entries[e].fields[f] = ignoreKey;
                }
            }

            for (int v = 0; v < entries[e].values.Count; v++)
            {
                if (string.IsNullOrEmpty(entries[e].values[v]))
                {
                    if (v < entries[e].types.Count)
                    {
                        entries[e].types[v] = ignoreKey;
                    }

                    if (v < entries[e].fields.Count)
                    {
                        entries[e].fields[v] = ignoreKey;
                    }

                    if (v < entries[e].values.Count)
                    {
                        entries[e].values[v] = ignoreKey;
                    }
                }
            }
        }

        // remove all entries which contains the ignore key
        for (int e = 0; e < entries.Count; e++)
        {
            for (int v = entries[e].values.Count - 1; v >= 0; v--)
            {
                if (entries[e].values[v].Contains(ignoreKey))
                {
                    entries[e].values.RemoveAt(v);
                }
            }

            for (int t = entries[e].types.Count - 1; t >= 0; t--)
            {
                if (entries[e].types[t].Contains(ignoreKey))
                {
                    entries[e].types.RemoveAt(t);
                }
            }

            for (int f = entries[e].fields.Count - 1; f >= 0; f--)
            {
                if (entries[e].fields[f].Contains(ignoreKey))
                {
                    entries[e].fields.RemoveAt(f);
                }
            }
        }
    }