public BaseSocketConnectionHost(HostType hostType, CallbackThreadType callbackThreadtype, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize, int idleCheckInterval, int idleTimeOutValue)
{
context = new SocketProviderContext
{
Active = false,
SyncActive = new object(),
SocketCreators = new List<BaseSocketConnectionCreator>(),
SocketConnections = new Dictionary<long, BaseSocketConnection>(),
BufferManager = BufferManager.CreateBufferManager(0, messageBufferSize),
SocketService = socketService,
IdleCheckInterval = idleCheckInterval,
IdleTimeOutValue = idleTimeOutValue,
CallbackThreadType = callbackThreadtype,
DelimiterType = delimiterType,
Delimiter = delimiter,
DelimiterEncrypt = new byte[] { 0xFE, 0xDC, 0xBA, 0x98, 0xBA, 0xDC, 0xFE },
MessageBufferSize = messageBufferSize,
SocketBufferSize = socketBufferSize,
HostType = hostType
};
fSocketConnectionsSync = new ReaderWriterLockSlim();
fWaitCreatorsDisposing = new ManualResetEvent(false);
fWaitConnectionsDisposing = new ManualResetEvent(false);
fWaitThreadsDisposing = new ManualResetEvent(false);
}
/// <summary>
/// Base creator for BaseSocketConnectionHost.
/// </summary>
/// <param name="hostType">
/// Host type.
/// </param>
/// <param name="socketService">
/// Socket service.
/// </param>
/// <param name="delimiterType">
/// Delimiter type.
/// </param>
/// <param name="delimiter">
/// Delimiter byte array.
/// </param>
/// <param name="socketBufferSize">
/// Socket buffer size.
/// </param>
/// <param name="messageBufferSize">
/// Max message buffer size.
/// </param>
/// <param name="idleCheckInterval">
/// Idle check interval timeout.
/// </param>
/// <param name="idleTimeOutValue">
/// Idle connection timeout.
/// </param>
public BaseSocketConnectionHost(HostType hostType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize, int idleCheckInterval, int idleTimeOutValue)
{
FHostType = hostType;
FConnectionId = 1000;
FSocketConnectionsSync = new ReaderWriterLock();
FSocketConnections = new Dictionary <long, BaseSocketConnection>();
FSocketCreators = new List <BaseSocketConnectionCreator>();
FSocketService = socketService;
FWaitCreatorsDisposing = new ManualResetEvent(false);
FWaitConnectionsDisposing = new ManualResetEvent(false);
FWaitThreadsDisposing = new ManualResetEvent(false);
FIdleCheckInterval = idleCheckInterval;
FIdleTimeOutValue = idleTimeOutValue;
if ((FIdleCheckInterval > 0) && (FIdleTimeOutValue > 0))
{
FIdleTimer = new Timer(new TimerCallback(CheckSocketConnections));
}
FDelimiter = delimiter;
FDelimiterType = delimiterType;
FMessageBufferSize = messageBufferSize;
FSocketBufferSize = socketBufferSize;
FActive = false;
FSyncActive = new Object();
}
/// <summary>
/// Determine the File Type and ensure that if the file is delimited the delimiter has been specified
/// </summary>
/// <returns>A boolean indicating whether the file was selected successfully</returns>
private bool CheckFileType()
{
bool fileSelectionOK = true;
FileInfo fileInfoDataFile = new FileInfo(DataFileTextBox.Text.Trim());
string[] csvExtensions = { ".csv", ".txt" };
if (fileInfoDataFile.Extension.ToLower() == ".dbf")
{
this.fileType = FileType.DBF;
}
else if (csvExtensions.Contains(fileInfoDataFile.Extension.ToLower()))
{
this.fileType = FileType.Delimited;
this.delimiterType = this.GetDelimiterType();
if (DelimiterCheckBox.SelectedIndex == -1)
{
fileSelectionOK = false;
MessageBox.Show("Please select a Delimiter", "Delimiter Missing");
}
}
else
{
fileSelectionOK = false;
MessageBox.Show("Invalid file extension");
}
return(fileSelectionOK);
}
public Delimiter(Ops delimiterOps, int delimiterOpsIndex, char delimiterType, int number, char?preceding, char?following, Delimiter previous)
{
DelimiterOps = delimiterOps;
DelimiterOpsIndex = delimiterOpsIndex;
DelimiterChar = delimiterType == '_' ? DelimiterType.Underscore : DelimiterType.Asterisk;
Number = number;
Previous = previous;
Next = null;
precedingWhitespace = preceding is null ? true : whitespaceRegex.IsMatch(((string)preceding.ToString()));
followingWhitespace = following is null ? true : whitespaceRegex.IsMatch(((string)following.ToString()));
precedingPunctuation = preceding is null ? false : punctuationRegex.IsMatch(((string)preceding.ToString()));
followingPunctuation = following is null ? false : punctuationRegex.IsMatch(((string)following.ToString()));
leftFlanking = false;
rightFlanking = false;
if (!followingWhitespace && (
!followingPunctuation || (followingPunctuation && (precedingPunctuation || precedingWhitespace))
))
{
leftFlanking = true;
}
if (!precedingWhitespace && (
!precedingPunctuation || (precedingPunctuation && (followingPunctuation || followingWhitespace))
))
{
rightFlanking = true;
}
SetOpenerOrCloser();
}
public FieldParser(FileType fileType, DelimiterType delimiterType, TextQualifierType textQualifierType, string otherDelimiter, string fixedFieldLengths)
{
this.fileType = fileType;
this.delimiterType = delimiterType;
this.textQualifierType = textQualifierType;
this.otherDelimiter = otherDelimiter;
this.fixedFieldLengths = fixedFieldLengths;
}
/// <summary>
/// Writes a delimited file using a default format.
/// </summary>
/// <param name="reporter"></param>
/// <param name="data"></param>
/// <param name="writer"></param>
/// <param name="delimiter_type"></param>
public static void WriteDelimitedFile(
IProgressReporter reporter,
string[][] data,
TextWriter writer,
DelimiterType delimiter_type)
{
WriteDelimitedFile(reporter, data, writer, delimiter_type, new DefaultDelimitedFormat());
}
public Delimiter(char segementSeperator, char elementSeperator, char compositeSeperator, char repetitionSeperator, DelimiterType delimiterType)
{
_segementSeperator = segementSeperator;
_elementSeperator = elementSeperator;
_compositeSeperator = compositeSeperator;
_repetitionSeperator = repetitionSeperator;
_delimiter = delimiterType;
}
public static void ValuesOf <TEnum>(DelimiterType delimiterType = DelimiterType.NewLine)
where TEnum : struct, Enum
{
var values = Enum.GetValues <TEnum>().Select(e
=> $"{e.ToString()} - {Convert.ToInt32(e)}");
Values(values);
}
/// <summary>
/// Gets the string value of the enum
/// </summary>
/// <param name="type">enum reference</param>
/// <returns>Returns the value string</returns>
public static string ValueOf(this DelimiterType type)
{
var fi = type.GetType().GetField(type.ToString());
var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
return(attributes.Length > 0 ? attributes[0].Description : type.ToString());
}
public bool IsSpecialSymbol(char character, DelimiterType position = DelimiterType.Start)
{
if (position == DelimiterType.Start)
{
return(startDelimiters.Contains(character));
}
return(endDelimiters.Contains(character));
}
private void ReadDelimitedFile(string fileName, DelimiterType type)
{
ImportDelimitedFile importer = new ImportDelimitedFile(type);
importer.ProcessLine += new EventHandler <ImportDelimitedEventArgs>(importer_ProcessLine);
textBox1.Text += string.Format("- Start {0} ------------------------------\r\n", type.ToString());
importer.Import(fileName);
textBox1.Text += string.Format("- End {0} --------------------------------\r\n\r\n", type.ToString());
}
public FlatFileDataManager(
BuiltInType builtInType,
CollectionType collectionType,
DelimiterType delimiterType,
string source)
{
BuiltInType = builtInType;
CollectionType = collectionType;
DelimiterType = delimiterType;
Source = source;
Initialize();
}
/// <summary>
/// Writes a delimited file using a default format.
/// </summary>
/// <param name="reporter"></param>
/// <param name="data"></param>
/// <param name="file"></param>
/// <param name="delimiter_type"></param>
public static void WriteDelimitedFile(
IProgressReporter reporter,
string[][] data,
FileInfo file,
DelimiterType delimiter_type)
{
StreamWriter writer = new StreamWriter(file.OpenWrite());
WriteDelimitedFile(reporter, data, writer, delimiter_type, new DefaultDelimitedFormat());
writer.Flush();
writer.Close();
}
/// <summary>
/// Retrieves a delimiter string from the locale data.
/// </summary>
/// <param name="type">
/// The type of delimiter string desired. Currently,
/// the valid choices are <see cref="DelimiterType.QuotationStart"/>, <see cref="DelimiterType.QuotationEnd"/>,
/// <see cref="DelimiterType.AlternateQuotationStart"/>, or <see cref="DelimiterType.AlternateQuotationEnd"/>.
/// </param>
/// <returns>The desired delimiter string.</returns>
/// <stable>ICU 3.4</stable>
public string GetDelimiter(DelimiterType type)
{
ICUResourceBundle delimitersBundle = (ICUResourceBundle)bundle.Get("delimiters");
// Only some of the quotation marks may be here. So we make sure that we do a multilevel fallback.
ICUResourceBundle stringBundle = delimitersBundle.GetWithFallback(DELIMITER_TYPES[(int)type]);
if (noSubstitute && !bundle.IsRoot && stringBundle.IsRoot)
{
return(null);
}
return(stringBundle.GetString());
}
public static void Values(IEnumerable <string> values, DelimiterType delimiterType = DelimiterType.NewLine)
{
var delimiter = delimiterType switch
{
DelimiterType.Comma => ", ",
DelimiterType.NewLine => Environment.NewLine,
_ => throw new ArgumentException(nameof(delimiterType))
};
Console.WriteLine(string.Join(delimiter, values));
}
}
/// <summary>
/// is the delimiter type for a literal?
/// </summary>
/// <param name="dt"></param>
/// <returns></returns>
public static bool IsForLiteral(this DelimiterType dt)
{
switch (dt)
{
case DelimiterType.Date:
case DelimiterType.Text:
case DelimiterType.FieldOrColumn:
return(true);
default:
return(false);
}
}
public bool IsDelimiter(char c, out DelimiterType type)
{
type = DelimiterType.No;
if (c == '\\' && !_isEscaping)
{
_previousIsDollar = false;
_isEscaping = true;
return(false);
}
if (c == '\'' && !_isInDoubleQuote && !_isEscaping)
{
_isInSingleQuote = !_isInSingleQuote;
}
else if (c == '"' && !_isInSingleQuote && !_isEscaping)
{
_isInDoubleQuote = !_isInDoubleQuote;
}
else if (c == '$' && !_isInSingleQuote && !_isEscaping)
{
_previousIsDollar = true;
type = DelimiterType.Start;
return(true);
}
else if (c == '%' && !_isEscaping)
{
if (_ancestorIsPercent)
{
_ancestorIsPercent = false;
type = DelimiterType.End;
}
else
{
_ancestorIsPercent = true;
type = DelimiterType.Start;
}
}
else if (c == '{' && _previousIsDollar)
{
_ancestorIsCurlyBracket = true;
type = DelimiterType.StartContinue;
}
else if (c == '}' && _ancestorIsCurlyBracket && !_isEscaping)
{
type = DelimiterType.End;
}
_isEscaping = false;
_previousIsDollar = false;
return(type != DelimiterType.No);
}
public static char GetDelimiter(DelimiterType delimiter)
{
switch (delimiter)
{
default:
case DelimiterType.Semicolon:
return(';');
case DelimiterType.Comma:
return(',');
case DelimiterType.Tab:
return('\t');
}
}
/// <summary>
/// is the character one that is used to delimit literal values?
/// </summary>
/// <param name="c"></param>
/// <param name="dt"></param>
/// <returns></returns>
public static bool IsLiteralDelimiter(this char c, out DelimiterType dt)
{
if (IsDelimiter(c, out dt))
{
switch (dt)
{
case DelimiterType.Text:
case DelimiterType.Date:
case DelimiterType.FieldOrColumn:
case DelimiterType.Block:
return(true);
}
}
return(false);
}
/// <summary>
/// determines if a specified character <paramref name="c"/> is considered a delimiter, and what type of delimiter it is.
/// dates are delimited by "#", text is delimited with " or ', fields/properties are delimited by [], blocks delimited by {}
/// </summary>
/// <param name="c">
/// the character to test
/// </param>
/// <param name="dt">
/// outputs the delimiter type, <see cref="DelimiterType"/>
/// </param>
/// <returns></returns>
public static bool IsDelimiter(this char c, out DelimiterType dt)
{
if (c.IsBlockDelimiter())
{
dt = DelimiterType.Block;
return(true);
}
if (c.IsColumnDelimiter())
{
dt = DelimiterType.FieldOrColumn;
return(true);
}
if (c.IsDateDelimiter())
{
dt = DelimiterType.Date;
return(true);
}
if (c.IsParamDelimiter())
{
dt = DelimiterType.Parameter;
return(true);
}
if (c.IsRowDelimiter())
{
dt = DelimiterType.Row;
return(true);
}
if (c.IsTextDelimiter())
{
dt = DelimiterType.Text;
return(true);
}
if (Char.IsWhiteSpace(c))
{
dt = DelimiterType.Whitespace;
return(true);
}
dt = DelimiterType.None;
return(false);
}
/// <summary>
/// Changes the type of this line.
/// Has only an effect if ContainsActiveInclude is true.
/// </summary>
public void SetDelimiterType(DelimiterType newDelimiterType)
{
if (LineDelimiterType != newDelimiterType && ContainsActiveInclude)
{
DelimiterSanityCheck();
if (newDelimiterType == DelimiterType.AngleBrackets)
{
StringBuilder sb = new StringBuilder(lineText);
sb[delimiter0] = '<';
sb[delimiter1] = '>';
lineText = sb.ToString();
}
else if (newDelimiterType == DelimiterType.Quotes)
{
StringBuilder sb = new StringBuilder(lineText);
sb[delimiter0] = '"';
sb[delimiter1] = '"';
lineText = sb.ToString();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="XMLGeneration"/> class
/// </summary>
/// <param name="mainWindowObject">The Object of the Application's Main Window</param>
/// <param name="xsdFileFullName">The Full Name of the embedded XSD File</param>
/// <param name="elementMappingFileFullName">The Full Name of the embedded Element Mapping File</param>
/// <param name="outputXMLFileName">The Name of the Output XML File</param>
/// <param name="outputXMLEncoding">The Encoding (UTF-8 or Unicode UTF-16) of the Output XML File</param>
/// <param name="fileType">The File Type</param>
/// <param name="delimiterType">The Delimiter Type</param>
/// <param name="dataFilePath">The Selected Data File Path</param>
public XMLGeneration(
MainWindow mainWindowObject,
string xsdFileFullName,
string elementMappingFileFullName,
string outputXMLFileName,
System.Text.Encoding outputXMLEncoding,
FileType fileType,
DelimiterType delimiterType,
string dataFilePath)
{
try
{
this.mainWindowObject = mainWindowObject;
this.outputXMLFileName = outputXMLFileName;
this.xsdFileFullName = xsdFileFullName;
this.elementMappingFileFullName = elementMappingFileFullName;
this.dataFilePath = dataFilePath;
this.delimiterType = delimiterType;
// Get the Data Rows
List <DataRow> rows;
switch (fileType)
{
case FileType.DBF:
rows = this.GetDBFDataRows();
this.SerializeRows(rows, outputXMLEncoding);
break;
case FileType.Delimited:
rows = this.GetDelimitedFileDataRows();
this.SerializeRows(rows, outputXMLEncoding);
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Returns the delimiter char for a delimiter type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static char GetDelimiterChar(DelimiterType type)
{
char delimiter;
switch (type)
{
case DelimiterType.CommaSeperated:
delimiter = ',';
break;
case DelimiterType.DotCommaSeperated:
delimiter = ';';
break;
case DelimiterType.TabSeperated:
delimiter = (char)9;
break;
default:
throw new NotImplementedException();
}
return(delimiter);
}
public static IEnumerable <string> CleanValues(
string values,
DelimiterType delimiterType)
{
var delimiter = delimiterType.GetDescription();
var cleanValues = values
.TrimStart().Trim().TrimEnd()
.Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
for (var i = 0; i < cleanValues.Count; i++)
{
cleanValues[i] = cleanValues[i]
.Replace(delimiter.ToString(CultureInfo.InvariantCulture), string.Empty)
.Replace("\r\n", string.Empty)
.Replace("\n", string.Empty)
.Replace("\r", string.Empty)
.Trim();
}
return(cleanValues);
}
/// <summary>
/// Reads a delimited file into an array of an array of strings.
/// </summary>
/// <param name="stream"></param>
/// <param name="delimiter"></param>
/// <param name="ignoreHeader"></param>
/// <returns></returns>
public static string[][] ReadDelimitedFileFromStream(
Stream stream,
DelimiterType delimiter,
bool ignoreHeader)
{
// converts the stream into a text reader.
TextReader tr = new StreamReader(stream);
// get the lines.
StringReader strReader = new StringReader(tr.ReadToEnd());
List <string> lines = new List <string>();
bool isheader = ignoreHeader;
while ((strReader.Peek() > -1))
{
if (isheader)
{
isheader = false;
strReader.ReadLine();
}
else
{
lines.Add(strReader.ReadLine());
}
}
// get the columns.
string[][] values = new string[lines.Count][];
char split = DelimitedFileHandler.GetDelimiterChar(delimiter);
for (int idx = 0; idx < lines.Count; idx++)
{
values[idx] = lines[idx].Split(split);
}
return(values);
}
public SocketClientSync(IPEndPoint host)
{
FReceivedEvent = new AutoResetEvent(false);
FExceptionEvent = new AutoResetEvent(false);
FSentEvent = new AutoResetEvent(false);
FConnectEvent = new AutoResetEvent(false);
FDisconnectEvent = new ManualResetEvent(false);
FReceivedQueue = new Queue <string>();
FConnectTimeout = 10000;
FSentTimeout = 10000;
FConnectedSync = new object();
FConnected = false;
FSocketClientEvents = new SocketClientSyncSocketService(this);
FCryptClientEvents = new SocketClientSyncCryptService(this);
FLocalEndPoint = null;
FRemoteEndPoint = host;
//----- Message Types!
FEncryptType = EncryptType.etNone;
FCompressionType = CompressionType.ctNone;
FDelimiterType = DelimiterType.dtNone;
//----- Proxy!
FProxyInfo = null;
//----- System.Net.Sockets.Socket delimiter and buffer size!
FDelimiter = null;
FMessageBufferSize = 4096;
FSocketBufferSize = 2048;
}
public static string[] ParseDataLineByDelimiter(string dataLine, DelimiterType selectedDelimiter, string userDelimiter)
{
string delimiter = "";
switch (selectedDelimiter)
{
case DelimiterType.Comma:
delimiter = ",";
break;
case DelimiterType.Tab:
delimiter = "\t";
break;
case DelimiterType.User:
delimiter = userDelimiter;
break;
default:
break;
}
string[] dataColumns = Regex.Split(dataLine, delimiter);
return(dataColumns);
}
public SocketClientSync(IPEndPoint host)
{
FReceivedEvent = new AutoResetEvent(false);
FExceptionEvent = new AutoResetEvent(false);
FSentEvent = new AutoResetEvent(false);
FConnectEvent = new AutoResetEvent(false);
FDisconnectEvent = new ManualResetEvent(false);
FReceivedQueue = new Queue<string>();
FConnectTimeout = 10000;
FSentTimeout = 10000;
FConnectedSync = new object();
FConnected = false;
FSocketClientEvents = new SocketClientSyncSocketService(this);
FCryptClientEvents = new SocketClientSyncCryptService(this);
FLocalEndPoint = null;
FRemoteEndPoint = host;
//----- Message Types!
FEncryptType = EncryptType.etNone;
FCompressionType = CompressionType.ctNone;
FDelimiterType = DelimiterType.dtNone;
//----- Proxy!
FProxyInfo = null;
//----- Socket delimiter and buffer size!
FDelimiter = null;
FMessageBufferSize = 4096;
FSocketBufferSize = 2048;
}
public Delimiter(DelimiterType form)
{
this.form = form;
}
/// <summary>
/// Delimited contents will be passed off to function to be evaluated
/// </summary>
/// <param name="function">function must take a next parameter of specified type</param>
internal ValueDelimiter(string end, DelimiterType type, ValueFunction function)
{
Init(end, type, function);
}
public DelimiterStateMachine(DelimiterType targetDelimiterType) : base(OtherText)
{
TargetDelimiterType = targetDelimiterType;
}
public SocketClient(ISocketService socketService, DelimiterType delimiterType, byte[] delimiter)
: base(HostType.htClient, socketService, delimiterType, delimiter, 2048, 8192, 0, 0)
{
//-----
}
public SocketServer(CallbackThreadType callbackThreadType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize, int idleCheckInterval, int idleTimeOutValue)
: base(HostType.htServer, callbackThreadType, socketService, delimiterType, delimiter, socketBufferSize, messageBufferSize, idleCheckInterval, idleTimeOutValue)
{
//-----
}
public BaseSocketConnectionHost(HostType hostType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter)
: this(hostType, CallbackThreadType.ctWorkerThread, socketService, delimiterType, delimiter, 1024, 1024, 1000, 1000)
{
}
/// <summary>
/// Writes a delimited file using the given format.
/// </summary>
/// <param name="reporter"></param>
/// <param name="data"></param>
/// <param name="writer"></param>
/// <param name="delimiter_type"></param>
/// <param name="format"></param>
public static void WriteDelimitedFile(
IProgressReporter reporter,
string[][] data,
TextWriter writer,
DelimiterType delimiter_type,
IDelimitedFormat format)
{
// get the delimiter character
char delimiter = GetDelimiterChar(delimiter_type);
// initialize the progress status.
ProgressStatus status = new ProgressStatus();
if (reporter != null)
{
status.TotalNumber = data.Length;
status.Status = ProgressStatus.ProgressStatusEnum.Busy;
status.CurrentNumber = 0;
status.Message = "Creating File...";
// report the status.
reporter.Report(status);
}
// export data
if (reporter != null)
{
status.Message = "Exporting... {progress}!";
}
for (int idx = 0; idx < data.Length; idx++)
{
string[] line = data[idx];
if (line != null &&
line.Length > 0)
{
for (int col_idx = 0; col_idx < line.Length; col_idx++)
{
if (format.DoExport(idx))
{
object field_data = line[col_idx];
string field_data_string = format.ConvertValue(col_idx, field_data);
writer.Write(field_data_string);
// only delimiter at the end
if (col_idx < line.Length - 1)
{
writer.Write(delimiter);
}
}
}
}
if (reporter != null)
{
status.CurrentNumber = idx + 1;
reporter.Report(status);
}
writer.WriteLine();
}
// report done
if (reporter != null)
{
status.Message = "Exporting Done!";
status.Status = ProgressStatus.ProgressStatusEnum.Succeeded;
reporter.Report(status);
}
}
public SocketClient(CallbackThreadType callbackThreadType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter)
: base(HostType.htClient, callbackThreadType, socketService, delimiterType, delimiter, 2048, 2048, 0, 0)
{
//-----
}
/// <summary>
/// Reads a delimited file into an array of an array of strings.
/// </summary>
/// <param name="stream"></param>
/// <param name="delimiter"></param>
/// <param name="ignoreHeader"></param>
/// <returns></returns>
public static string[][] ReadDelimitedFileFromStream(
Stream stream,
DelimiterType delimiter,
bool ignoreHeader)
{
// converts the stream into a text reader.
TextReader tr = new StreamReader(stream);
// get the lines.
StringReader strReader = new StringReader(tr.ReadToEnd());
List<string> lines = new List<string>();
bool isheader = ignoreHeader;
while ((strReader.Peek() > -1))
{
if (isheader)
{
isheader = false;
strReader.ReadLine();
}
else
{
lines.Add(strReader.ReadLine());
}
}
// get the columns.
string[][] values = new string[lines.Count][];
char split = DelimitedFileHandler.GetDelimiterChar(delimiter);
for (int idx = 0; idx < lines.Count; idx++)
{
values[idx] = lines[idx].Split(split);
}
return values;
}
/// <summary>
/// Reads a delimited file into an array of an array of strings.
/// </summary>
/// <param name="stream"></param>
/// <param name="delimiter"></param>
/// <returns></returns>
public static string[][] ReadDelimitedFileFromStream(
Stream stream,
DelimiterType delimiter)
{
return DelimitedFileHandler.ReadDelimitedFileFromStream(stream, delimiter, true);
}
public SocketServer(ISocketService socketService, DelimiterType delimiterType, byte[] delimiter)
: base(HostType.htServer, socketService, delimiterType, delimiter, 4096, 8192, 0, 0)
{
//-----
}
public SocketClient(ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize, int idleCheckInterval, int idleTimeOutValue)
: base(HostType.htClient, socketService, delimiterType, delimiter, socketBufferSize, messageBufferSize, idleCheckInterval, idleTimeOutValue)
{
//-----
}
public SocketClient(ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize)
: base(HostType.htClient, socketService, delimiterType, delimiter, socketBufferSize, messageBufferSize, 0, 0)
{
//-----
}
/// <summary>
/// Specify the end string for a delimiter
/// and whether contents should be tokenized or left as-is
/// </summary>
internal ValueDelimiter(string end, DelimiterType type)
{
Init(end, type, null);
}
/// <summary>
/// Writes a delimited file using a default format.
/// </summary>
/// <param name="reporter"></param>
/// <param name="data"></param>
/// <param name="writer"></param>
/// <param name="delimiter_type"></param>
public static void WriteDelimitedFile(
IProgressReporter reporter,
string[][] data,
TextWriter writer,
DelimiterType delimiter_type)
{
WriteDelimitedFile(reporter, data, writer, delimiter_type, new DefaultDelimitedFormat());
}
private void Init(string end, DelimiterType type, ValueFunction function)
{
Map meta = WritableMetadata;
meta[keyDelimEnd] = new ValueString(end);
meta[keyDelimType] = new ValueInt((int)type);
if (function != null)
meta[keyDelimFunction] = function;
}
/// <summary>
/// Writes a delimited file using a default format.
/// </summary>
/// <param name="reporter"></param>
/// <param name="data"></param>
/// <param name="file"></param>
/// <param name="delimiter_type"></param>
public static void WriteDelimitedFile(
IProgressReporter reporter,
string[][] data,
FileInfo file,
DelimiterType delimiter_type)
{
StreamWriter writer = new StreamWriter(file.OpenWrite());
WriteDelimitedFile(reporter, data, writer, delimiter_type, new DefaultDelimitedFormat());
writer.Flush();
writer.Close();
}
public void ValueOfTest(DelimiterType type, string expected)
{
type.ValueOf().Should().Be(expected);
}
/// <summary>
/// Returns the delimiter char for a delimiter type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static char GetDelimiterChar(DelimiterType type)
{
char delimiter;
switch (type)
{
case DelimiterType.CommaSeperated:
delimiter = ',';
break;
case DelimiterType.DotCommaSeperated:
delimiter = ';';
break;
case DelimiterType.TabSeperated:
delimiter = (char)9;
break;
default:
throw new NotImplementedException();
}
return delimiter;
}
public BaseSocketConnectionHost(HostType hostType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int idleCheckInterval, int idleTimeOutValue)
: this(hostType, CallbackThreadType.ctWorkerThread, socketService, delimiterType, delimiter, 1024, 1024, idleCheckInterval, idleTimeOutValue)
{
}
/// <summary>
/// Reads a delimited file.
/// </summary>
/// <param name="reporter"></param>
/// <param name="file"></param>
/// <param name="delimiter"></param>
/// <param name="firstRowHasHeaders"></param>
/// <returns></returns>
public static string[][] ReadDelimitedFile(
IProgressReporter reporter,
FileInfo file,
DelimiterType delimiter,
bool firstRowHasHeaders)
{
if (reporter == null)
{
reporter = EmptyProgressReporter.Instance;
}
char delimiterChar = DelimitedFileHandler.GetDelimiterChar(delimiter);
List<string[]> delimited_data_set;
//int iCounter = 0;
ProgressStatus status;
if (!file.Exists)
{
throw new FileNotFoundException(string.Format("Input file {0} not found!", file.FullName));
}
else
{
// Build dataset
delimited_data_set = new List<string[]>();
//Add the table 'Read the delimited file
System.Text.Encoding enc = null;
enc = System.Text.Encoding.GetEncoding("iso-8859-1");
FileStream fileStream = new FileStream(file.FullName,
FileMode.Open, FileAccess.Read, FileShare.Read);
StringBuilder strBuild = new StringBuilder(Convert.ToInt32(fileStream.Length));
// report the status.
status = new ProgressStatus();
status.Status = ProgressStatus.ProgressStatusEnum.Busy;
status.CurrentNumber = 0;
status.Message = "Opening file...";
reporter.Report(status);
for (int i = 0; i <= Convert.ToInt32(fileStream.Length) - 1; i++)
{
byte[] bytes = new byte[] {Convert.ToByte(fileStream.ReadByte())};
strBuild.Append(enc.GetString(bytes, 0, bytes.Length));
}
fileStream.Close();
string str = strBuild.ToString();
StringReader strReader = new StringReader(str);
List<string> lines = new List<string>();
while ((strReader.Peek() > -1)) {
lines.Add(strReader.ReadLine());
}
// Now add in the Rows
// report the status.
status = new ProgressStatus();
status.Status = ProgressStatus.ProgressStatusEnum.Busy;
status.CurrentNumber = 0;
status.Message = "Reading file...";
reporter.Report(status);
int startLine = 0;
if (firstRowHasHeaders)
{
startLine = 1;
}
//Loop while there are rows in the delimited file
for (int l = startLine; l < lines.Count; l++) {
string line = lines[l];
//Add the items to the DataSet
delimited_data_set.Add(line.Split(delimiterChar));
// report the status.
status = new ProgressStatus();
status.Status = ProgressStatus.ProgressStatusEnum.Busy;
status.CurrentNumber = l;
status.TotalNumber = lines.Count - 1;
status.Message = "Reading file...";
reporter.Report(status);
}
}
// report the status.
status = new ProgressStatus();
status.Status = ProgressStatus.ProgressStatusEnum.Succeeded;
status.CurrentNumber = 0;
status.Message = "Reading file...";
reporter.Report(status);
return delimited_data_set.ToArray<string[]>();
}
public DelimiterStateMachine() : base(OtherText)
{
TargetDelimiterType = DelimiterType.Unknown;
}
/// <summary>
/// Base creator for BaseSocketConnectionHost.
/// </summary>
/// <param name="hostType">
/// Host type.
/// </param>
/// <param name="socketService">
/// Socket service.
/// </param>
/// <param name="delimiterType">
/// Delimiter type.
/// </param>
/// <param name="delimiter">
/// Delimiter byte array.
/// </param>
/// <param name="socketBufferSize">
/// Socket buffer size.
/// </param>
/// <param name="messageBufferSize">
/// Max message buffer size.
/// </param>
/// <param name="idleCheckInterval">
/// Idle check interval timeout.
/// </param>
/// <param name="idleTimeOutValue">
/// Idle connection timeout.
/// </param>
public BaseSocketConnectionHost(HostType hostType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize, int idleCheckInterval, int idleTimeOutValue)
{
FHostType = hostType;
FConnectionId = 1000;
FSocketConnectionsSync = new ReaderWriterLock();
FSocketConnections = new Dictionary<long, BaseSocketConnection>();
FSocketCreators = new List<BaseSocketConnectionCreator>();
FSocketService = socketService;
FWaitCreatorsDisposing = new ManualResetEvent(false);
FWaitConnectionsDisposing = new ManualResetEvent(false);
FWaitThreadsDisposing = new ManualResetEvent(false);
FIdleCheckInterval = idleCheckInterval;
FIdleTimeOutValue = idleTimeOutValue;
if ( (FIdleCheckInterval > 0) && (FIdleTimeOutValue > 0) )
{
FIdleTimer = new Timer(new TimerCallback(CheckSocketConnections));
}
FDelimiter = delimiter;
FDelimiterType = delimiterType;
FMessageBufferSize = messageBufferSize;
FSocketBufferSize = socketBufferSize;
FActive = false;
FSyncActive = new Object();
}
public DelimiterStateMachine(State initial, DelimiterType targetDelimiterType) : base(initial)
{
TargetDelimiterType = targetDelimiterType;
}
public SocketServer(CallbackThreadType callbackThreadType, ISocketService socketService, DelimiterType delimiterType, byte[] delimiter, int socketBufferSize, int messageBufferSize)
: base(HostType.htServer, callbackThreadType, socketService, delimiterType, delimiter, socketBufferSize, messageBufferSize, 0, 0)
{
//-----
}
