CsvReader.cs

using System;
using System.Collections.Generic;
using System.Linq;
using ServiceStack.Text.Common;
using ServiceStack.Text.Jsv;

namespace ServiceStack.Text
{
    public class CsvReader
    {
        public static List<string> ParseLines(string csv)
        {
            var rows = new List<string>();
            if (string.IsNullOrEmpty(csv))
                return rows;

            var withinQuotes = false;
            var lastPos = 0;

            var i = -1;
            var len = csv.Length;
            while (++i < len)
            {
                var c = csv[i];
                if (c == JsWriter.QuoteChar)
                {
                    var isLiteralQuote = i + 1 < len && csv[i + 1] == JsWriter.QuoteChar;
                    if (isLiteralQuote)
                    {
                        i++;
                        continue;
                    }

                    withinQuotes = !withinQuotes;
                }

                if (withinQuotes)
                    continue;

                if (c == JsWriter.LineFeedChar)
                {
                    var str = i > 0 && csv[i - 1] == JsWriter.ReturnChar
                        ? csv.Substring(lastPos, i - lastPos - 1)
                        : csv.Substring(lastPos, i - lastPos);

                    if (str.Length > 0)
                        rows.Add(str);
                    lastPos = i + 1;
                }
            }

            if (i > lastPos)
            {
                var str = csv.Substring(lastPos, i - lastPos);
                if (str.Length > 0)
                    rows.Add(str);
            }

            return rows;
        }

        public static List<string> ParseFields(string line) => ParseFields(line, null);
        public static List<string> ParseFields(string line, Func<string,string> parseFn)
        {
            var to = new List<string>();
            if (string.IsNullOrEmpty(line))
                return to;

            var i = -1;
            var len = line.Length;
            while (++i <= len)
            {
                var value = EatValue(line, ref i);
                to.Add(parseFn != null ? parseFn(value.FromCsvField()) : value.FromCsvField());
            }

            return to;
        }

        //Originally from JsvTypeSerializer.EatValue()
        public static string EatValue(string value, ref int i)
        {
            var tokenStartPos = i;
            var valueLength = value.Length;
            if (i == valueLength) return null;

            var valueChar = value[i];
            var withinQuotes = false;
            var endsToEat = 1;
            var itemSeperator = CsvConfig.ItemSeperatorString.Length == 1
                ? CsvConfig.ItemSeperatorString[0]
                : JsWriter.ItemSeperator;

            if (valueChar == itemSeperator || valueChar == JsWriter.MapEndChar)
                return null;

            if (valueChar == JsWriter.QuoteChar) //Is Within Quotes, i.e. "..."
            {
                while (++i < valueLength)
                {
                    valueChar = value[i];

                    if (valueChar != JsWriter.QuoteChar) continue;

                    var isLiteralQuote = i + 1 < valueLength && value[i + 1] == JsWriter.QuoteChar;

                    i++; //skip quote
                    if (!isLiteralQuote)
                        break;
                }
                return value.Substring(tokenStartPos, i - tokenStartPos);
            }
            if (valueChar == JsWriter.MapStartChar) //Is Type/Map, i.e. {...}
            {
                while (++i < valueLength && endsToEat > 0)
                {
                    valueChar = value[i];

                    if (valueChar == JsWriter.QuoteChar)
                        withinQuotes = !withinQuotes;

                    if (withinQuotes)
                        continue;

                    if (valueChar == JsWriter.MapStartChar)
                        endsToEat++;

                    if (valueChar == JsWriter.MapEndChar)
                        endsToEat--;
                }
                if (endsToEat > 0)
                { 
                    //Unmatched start and end char, give up
                    i = tokenStartPos;
                    valueChar = value[i];
                }
                else
                    return value.Substring(tokenStartPos, i - tokenStartPos);
            }
            if (valueChar == JsWriter.ListStartChar) //Is List, i.e. [...]
            {
                while (++i < valueLength && endsToEat > 0)
                {
                    valueChar = value[i];

                    if (valueChar == JsWriter.QuoteChar)
                        withinQuotes = !withinQuotes;

                    if (withinQuotes)
                        continue;

                    if (valueChar == JsWriter.ListStartChar)
                        endsToEat++;

                    if (valueChar == JsWriter.ListEndChar)
                        endsToEat--;
                }
                if (endsToEat > 0)
                {
                    //Unmatched start and end char, give up
                    i = tokenStartPos;
                    valueChar = value[i];
                }
                else
                    return value.Substring(tokenStartPos, i - tokenStartPos);
            }

            //if value starts with MapStartChar, check MapEndChar to terminate
            char specEndChar = itemSeperator;
            if (value[tokenStartPos] == JsWriter.MapStartChar)
                specEndChar = JsWriter.MapEndChar;

            while (++i < valueLength) //Is Value
            {
                valueChar = value[i];

                if (valueChar == itemSeperator || valueChar == specEndChar)
                {
                    break;
                }
            }

            return value.Substring(tokenStartPos, i - tokenStartPos);
        }
    }

    public class CsvReader<T>
    {
        public static List<string> Headers { get; set; }

        internal static List<SetMemberDelegate<T>> PropertySetters;
        internal static Dictionary<string, SetMemberDelegate<T>> PropertySettersMap;

        internal static List<ParseStringDelegate> PropertyConverters;
        internal static Dictionary<string, ParseStringDelegate> PropertyConvertersMap;

        static CsvReader()
        {
            Reset();
        }

        internal static void Reset()
        {
            Headers = new List<string>();

            PropertySetters = new List<SetMemberDelegate<T>>();
            PropertySettersMap = new Dictionary<string, SetMemberDelegate<T>>(PclExport.Instance.InvariantComparerIgnoreCase);

            PropertyConverters = new List<ParseStringDelegate>();
            PropertyConvertersMap = new Dictionary<string, ParseStringDelegate>(PclExport.Instance.InvariantComparerIgnoreCase);

            foreach (var propertyInfo in TypeConfig<T>.Properties)
            {
                if (!propertyInfo.CanWrite || propertyInfo.GetSetMethod(nonPublic:true) == null) continue;
                if (!TypeSerializer.CanCreateFromString(propertyInfo.PropertyType)) continue;

                var propertyName = propertyInfo.Name;
                var setter = propertyInfo.CreateSetter<T>();
                PropertySetters.Add(setter);

                var converter = JsvReader.GetParseFn(propertyInfo.PropertyType);
                PropertyConverters.Add(converter);

                var dcsDataMemberName = propertyInfo.GetDataMemberName();
                if (dcsDataMemberName != null)
                    propertyName = dcsDataMemberName;

                Headers.Add(propertyName);
                PropertySettersMap[propertyName] = setter;
                PropertyConvertersMap[propertyName] = converter;
            }
        }

        internal static void ConfigureCustomHeaders(Dictionary<string, string> customHeadersMap)
        {
            Reset();

            for (var i = Headers.Count - 1; i >= 0; i--)
            {
                var oldHeader = Headers[i];
                if (!customHeadersMap.TryGetValue(oldHeader, out var newHeader))
                {
                    Headers.RemoveAt(i);
                    PropertySetters.RemoveAt(i);
                }
                else
                {
                    Headers[i] = newHeader;

                    PropertySettersMap.TryGetValue(oldHeader, out var setter);
                    PropertySettersMap.Remove(oldHeader);
                    PropertySettersMap[newHeader] = setter;
                    
                    PropertyConvertersMap.TryGetValue(oldHeader, out var converter);
                    PropertyConvertersMap.Remove(oldHeader);
                    PropertyConvertersMap[newHeader] = converter;
                }
            }
        }

        private static List<T> GetSingleRow(IEnumerable<string> rows, Type recordType)
        {
            var row = new List<T>();
            foreach (var value in rows)
            {
                var to = recordType == typeof(string)
                   ? (T)(object)value
                   : TypeSerializer.DeserializeFromString<T>(value);

                row.Add(to);
            }
            return row;
        }

        public static List<T> GetRows(IEnumerable<string> records)
        {
            var rows = new List<T>();

            if (records == null) return rows;

            if (typeof(T).IsValueType || typeof(T) == typeof(string))
            {
                return GetSingleRow(records, typeof(T));
            }

            foreach (var record in records)
            {
                var to = typeof(T).CreateInstance<T>();
                foreach (var propertySetter in PropertySetters)
                {
                    propertySetter(to, record);
                }
                rows.Add(to);
            }

            return rows;
        }

        public static object ReadObject(string csv)
        {
            if (csv == null) return null; //AOT

            return Read(CsvReader.ParseLines(csv));
        }

        public static object ReadObjectRow(string csv)
        {
            if (csv == null) return null; //AOT

            return ReadRow(csv);
        }

        public static List<Dictionary<string, string>> ReadStringDictionary(IEnumerable<string> rows)
        {
            if (rows == null) return null; //AOT

            var to = new List<Dictionary<string, string>>();

            List<string> headers = null;
            foreach (var row in rows)
            {
                if (headers == null)
                {
                    headers = CsvReader.ParseFields(row);
                    continue;
                }

                var values = CsvReader.ParseFields(row);
                var map = new Dictionary<string, string>();
                for (int i = 0; i < headers.Count; i++)
                {
                    var header = headers[i];
                    map[header] = values[i];
                }

                to.Add(map);
            }

            return to;
        }

        public static List<T> Read(List<string> rows)
        {
            var to = new List<T>();
            if (rows == null || rows.Count == 0) return to; //AOT

            if (typeof(T).IsAssignableFrom(typeof(Dictionary<string, string>)))
            {
                return ReadStringDictionary(rows).ConvertAll(x => (T)(object)x);
            }

            if (typeof(T).IsAssignableFrom(typeof(List<string>)))
            {
                return new List<T>(rows.Select(x => (T)(object)CsvReader.ParseFields(x)));
            }

            List<string> headers = null;
            if (!CsvConfig<T>.OmitHeaders || Headers.Count == 0)
            {
                headers = CsvReader.ParseFields(rows[0], s => s.Trim());
            }

            if (typeof(T).IsValueType || typeof(T) == typeof(string))
            {
                return rows.Count == 1
                    ? GetSingleRow(CsvReader.ParseFields(rows[0]), typeof(T))
                    : GetSingleRow(rows, typeof(T));
            }

            for (var rowIndex = headers == null ? 0 : 1; rowIndex < rows.Count; rowIndex++)
            {
                var row = rows[rowIndex];
                var o = typeof(T).CreateInstance<T>();

                var fields = CsvReader.ParseFields(row);
                for (int i = 0; i < fields.Count; i++)
                {
                    var setter = i < PropertySetters.Count ? PropertySetters[i] : null;
                    if (headers != null)
                        PropertySettersMap.TryGetValue(headers[i], out setter);

                    if (setter == null)
                        continue;

                    var converter = i < PropertyConverters.Count ? PropertyConverters[i] : null;
                    if (headers != null)
                        PropertyConvertersMap.TryGetValue(headers[i], out converter);

                    if (converter == null)
                        continue;

                    var field = fields[i];
                    var convertedValue = converter(field);
                    setter(o, convertedValue);
                }

                to.Add(o);
            }

            return to;
        }

        public static T ReadRow(string value)
        {
            if (value == null) return default(T); //AOT

            return Read(CsvReader.ParseLines(value)).FirstOrDefault();
        }

    }
}