// CkCsvW.h: interface for the CkCsvW class.
//
//////////////////////////////////////////////////////////////////////

// This header is generated for Chilkat 11.5.0

#ifndef _CkCsvW_H
#define _CkCsvW_H
	
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkWideCharBase.h"

class CkStringBuilderW;
class CkZipW;
class CkStringTableW;



#if !defined(__sun__) && !defined(__sun)
#pragma pack (push, 8)
#endif
 

// CLASS: CkCsvW
class CK_VISIBLE_PUBLIC CkCsvW  : public CkWideCharBase
{
	

	private:
	
	// Don't allow assignment or copying these objects.
	CkCsvW(const CkCsvW &);
	CkCsvW &operator=(const CkCsvW &);

    public:
	CkCsvW(void);
	virtual ~CkCsvW(void);

	

	static CkCsvW *createNew(void);
	

	
	void CK_VISIBLE_PRIVATE inject(void *impl);

	// May be called when finished with the object to free/dispose of any
	// internal resources held by the object. 
	void dispose(void);

	

	// BEGIN PUBLIC INTERFACE

	// ----------------------
	// Properties
	// ----------------------
	// If true, then the strings returned by GetCell and GetCellByName are
	// auto-trimmed of whitespace from both ends.
	bool get_AutoTrim(void);
	// If true, then the strings returned by GetCell and GetCellByName are
	// auto-trimmed of whitespace from both ends.
	void put_AutoTrim(bool newVal);

	// If true, then CRLF line endings are used when saving the CSV to a file or to a
	// string (i.e. for the methods SaveFile, SaveFile2, SaveToString). If false then
	// bare LF line-endings are used.
	bool get_Crlf(void);
	// If true, then CRLF line endings are used when saving the CSV to a file or to a
	// string (i.e. for the methods SaveFile, SaveFile2, SaveToString). If false then
	// bare LF line-endings are used.
	void put_Crlf(bool newVal);

	// The character that separates fields in a record. It is a comma by default. If
	// the Delimiter property is not explicitly set, the CSV component will detect the
	// delimiter when loading a CSV. (Semicolons are typically used in locales where
	// the comma is used as a decimal point.)
	// 
	// Note 1: If the default comma delimiter is not desired when creating a new CSV,
	// make sure to set this property before adding rows/columns to the CSV.
	// 
	// Note 2: If the application explicitly sets the delimiter to the vertical bar
	// character ( | ), and if the EnableQuotes property was never explicitly set, then
	// EnableQuotes will default to false. This is because when vertical bars are
	// used, quotes are most likely to be treated the same as other characters.
	// 
	void get_Delimiter(CkString &str);
	// The character that separates fields in a record. It is a comma by default. If
	// the Delimiter property is not explicitly set, the CSV component will detect the
	// delimiter when loading a CSV. (Semicolons are typically used in locales where
	// the comma is used as a decimal point.)
	// 
	// Note 1: If the default comma delimiter is not desired when creating a new CSV,
	// make sure to set this property before adding rows/columns to the CSV.
	// 
	// Note 2: If the application explicitly sets the delimiter to the vertical bar
	// character ( | ), and if the EnableQuotes property was never explicitly set, then
	// EnableQuotes will default to false. This is because when vertical bars are
	// used, quotes are most likely to be treated the same as other characters.
	// 
	const wchar_t *delimiter(void);
	// The character that separates fields in a record. It is a comma by default. If
	// the Delimiter property is not explicitly set, the CSV component will detect the
	// delimiter when loading a CSV. (Semicolons are typically used in locales where
	// the comma is used as a decimal point.)
	// 
	// Note 1: If the default comma delimiter is not desired when creating a new CSV,
	// make sure to set this property before adding rows/columns to the CSV.
	// 
	// Note 2: If the application explicitly sets the delimiter to the vertical bar
	// character ( | ), and if the EnableQuotes property was never explicitly set, then
	// EnableQuotes will default to false. This is because when vertical bars are
	// used, quotes are most likely to be treated the same as other characters.
	// 
	void put_Delimiter(const wchar_t *newVal);

	// If true, then the double-quote characters cause the quoted content, including
	// CR's, LF's, and delimiter chars to be treated as normal text when
	// reading/writing CSVs. The default is true.
	bool get_EnableQuotes(void);
	// If true, then the double-quote characters cause the quoted content, including
	// CR's, LF's, and delimiter chars to be treated as normal text when
	// reading/writing CSVs. The default is true.
	void put_EnableQuotes(bool newVal);

	// If true, then the backslash character is treated as an escape character when
	// reading/writing CSVs. The default is false.
	bool get_EscapeBackslash(void);
	// If true, then the backslash character is treated as an escape character when
	// reading/writing CSVs. The default is false.
	void put_EscapeBackslash(bool newVal);

	// Set to true prior to loading a CSV if the 1st record contains column names.
	// This allows the CSV parser to correctly load the column names and not treat them
	// as data.
	bool get_HasColumnNames(void);
	// Set to true prior to loading a CSV if the 1st record contains column names.
	// This allows the CSV parser to correctly load the column names and not treat them
	// as data.
	void put_HasColumnNames(bool newVal);

	// The number of columns in the 1st row , which may be the row containing column
	// names if HasColumnNames is true.
	// 
	// References:
	// 1: #HasColumnNames
	int get_NumColumns(void);

	// The number of data rows. If the CSV has column names, the 1st row is not
	// included in the count. Also, empty lines containing only whitespace characters
	// that follow the last non-empty row are not included.
	int get_NumRows(void);

	// This is a catch-all property to be used for uncommon needs. Chilkat may from
	// time to time define keywords, which if present, change behavior in some way. If
	// multiple keywords are needed, set this property to the comma separated list of
	// keywords.
	// 
	// The following keywords are defined:
	// 
	//     * QuotedCells (v9.5.0.96) Forces all cell contents to be double-quoted when
	//     emitting the CSV to a file or string
	//     * QuotedColumnNames (v9.5.0.96) Forces all column names to be double-quoted
	//     when emitting the CSV to a file or string
	//     * EMIT_BOM (v9.5.0.93) Causes Chilkat to emit the utf-8 BOM (byte order
	//     mark) when writing the CSV to a file (assuming the CSV is written using utf-8).
	void get_UncommonOptions(CkString &str);
	// This is a catch-all property to be used for uncommon needs. Chilkat may from
	// time to time define keywords, which if present, change behavior in some way. If
	// multiple keywords are needed, set this property to the comma separated list of
	// keywords.
	// 
	// The following keywords are defined:
	// 
	//     * QuotedCells (v9.5.0.96) Forces all cell contents to be double-quoted when
	//     emitting the CSV to a file or string
	//     * QuotedColumnNames (v9.5.0.96) Forces all column names to be double-quoted
	//     when emitting the CSV to a file or string
	//     * EMIT_BOM (v9.5.0.93) Causes Chilkat to emit the utf-8 BOM (byte order
	//     mark) when writing the CSV to a file (assuming the CSV is written using utf-8).
	const wchar_t *uncommonOptions(void);
	// This is a catch-all property to be used for uncommon needs. Chilkat may from
	// time to time define keywords, which if present, change behavior in some way. If
	// multiple keywords are needed, set this property to the comma separated list of
	// keywords.
	// 
	// The following keywords are defined:
	// 
	//     * QuotedCells (v9.5.0.96) Forces all cell contents to be double-quoted when
	//     emitting the CSV to a file or string
	//     * QuotedColumnNames (v9.5.0.96) Forces all column names to be double-quoted
	//     when emitting the CSV to a file or string
	//     * EMIT_BOM (v9.5.0.93) Causes Chilkat to emit the utf-8 BOM (byte order
	//     mark) when writing the CSV to a file (assuming the CSV is written using utf-8).
	void put_UncommonOptions(const wchar_t *newVal);

	// The standard date format to use when converting Excel (.xlsx) spreadsheets to
	// CSV. The default is "mm-dd-yy" , but can be changed to "d/m/yyyy" , or
	// "m/d/yyyy" , etc.
	void get_XlsxDateFormat(CkString &str);
	// The standard date format to use when converting Excel (.xlsx) spreadsheets to
	// CSV. The default is "mm-dd-yy" , but can be changed to "d/m/yyyy" , or
	// "m/d/yyyy" , etc.
	const wchar_t *xlsxDateFormat(void);
	// The standard date format to use when converting Excel (.xlsx) spreadsheets to
	// CSV. The default is "mm-dd-yy" , but can be changed to "d/m/yyyy" , or
	// "m/d/yyyy" , etc.
	void put_XlsxDateFormat(const wchar_t *newVal);



	// ----------------------
	// Methods
	// ----------------------
	// Deletes the Nth column. (The 1st column is at index 0.)
	bool DeleteColumn(int index);

	// Deletes a column specified by name.
	bool DeleteColumnByName(const wchar_t *columnName);

	// Deletes the entire Nth row. (The 1st row is at index 0.)
	bool DeleteRow(int index);

	// Returns the contents of the cell at row, col. Indexing begins at 0. (The
	// topmost/leftmost cell is at 0,0)
	bool GetCell(int row, int col, CkString &outStr);
	// Returns the contents of the cell at row, col. Indexing begins at 0. (The
	// topmost/leftmost cell is at 0,0)
	const wchar_t *getCell(int row, int col);
	// Returns the contents of the cell at row, col. Indexing begins at 0. (The
	// topmost/leftmost cell is at 0,0)
	const wchar_t *cell(int row, int col);

	// The same as GetCell, but the column is specified by name instead of by index.
	bool GetCellByName(int rowIndex, const wchar_t *columnName, CkString &outStr);
	// The same as GetCell, but the column is specified by name instead of by index.
	const wchar_t *getCellByName(int rowIndex, const wchar_t *columnName);
	// The same as GetCell, but the column is specified by name instead of by index.
	const wchar_t *cellByName(int rowIndex, const wchar_t *columnName);

	// Returns the name of the Nth column.
	bool GetColumnName(int index, CkString &outStr);
	// Returns the name of the Nth column.
	const wchar_t *getColumnName(int index);
	// Returns the name of the Nth column.
	const wchar_t *columnName(int index);

	// Returns the column index for a given column. Returns -1 if no column exists with
	// the columnName.
	int GetIndex(const wchar_t *columnName);

	// Returns the number of columns for a specific row. If the row is larger than the
	// number of rows in the CSV, a zero is returned.
	int GetNumCols(int row);

	// Inserts a new and empty column before the Nth column. (The 1st column is at
	// index 0.)
	bool InsertColumn(int index);

	// Loads a CSV from a file. It is assumed that the CSV file contains ANSI
	// characters.
	bool LoadFile(const wchar_t *path);

	// Loads a CSV from a file. The charset specifies the character encoding of the CSV
	// file. A list of supported character encodings may be found on this page:
	// Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool LoadFile2(const wchar_t *filename, const wchar_t *charset);

	// Loads a CSV document from an in-memory string variable.
	bool LoadFromString(const wchar_t *csvData);

	// Compares the contents of an entire row to a wildcarded match pattern where * can
	// be used any number of times to match 0 or more of any character. Returns true
	// if a match was found, otherwise returns false. If caseSensitive is true, then the
	// pattern match is case sensitive, otherwise it is case insensitive.
	bool RowMatches(int rowIndex, const wchar_t *matchPattern, bool caseSensitive);

	// Saves a CSV to a file. The output file is written using the ANSI character
	// encoding.
	bool SaveFile(const wchar_t *path);

	// Saves a CSV to a file. The charset specifies the character encoding to use for the
	// CSV file. The text data is converted to this charset when saving. A list of
	// supported character encodings may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool SaveFile2(const wchar_t *filename, const wchar_t *charset);

	// Clears the contents of sb and writes the entire CSV into sb.
	bool SaveToSb(CkStringBuilderW &sb);

	// Returns the entire CSV as a string.
	bool SaveToString(CkString &outStr);
	// Returns the entire CSV as a string.
	const wchar_t *saveToString(void);

	// Sets the contents for a single cell in the CSV. The content may include any
	// characters including CRLF's, double-quotes, and the delimiter character. The
	// Save* methods automatically double-quote fields with special chars when saving.
	// The Load* methods automatically parse double-quoted and/or escaped fields
	// correctly when loading.
	bool SetCell(int row, int col, const wchar_t *content);

	// The same as SetCell, except the column is specified by name instead of by index.
	bool SetCellByName(int rowIndex, const wchar_t *columnName, const wchar_t *contentStr);

	// Sets the name of the Nth column. The first column is at index 0. This method
	// would only return false if an invalid index is passed (such as a negative
	// number).
	bool SetColumnName(int index, const wchar_t *columnName);

	// Sorts the rows in the CSV by the contents of a specific column. If ascending is
	// true, the sort is in ascending order, otherwise descending order. If caseSensitive is
	// true then the sorting is case sensitive.
	bool SortByColumn(const wchar_t *columnName, bool ascending, bool caseSensitive);

	// Sorts the rows in the CSV by the contents of a specific column index. If ascending is
	// true, the sort is in ascending order, otherwise descending order. If caseSensitive is
	// true then the sorting is case sensitive.
	bool SortByColumnIndex(int index, bool ascending, bool caseSensitive);

	// Returns the names of the sheets contained in the Excel spreadsheet. The xlsx is
	// the Zip object containing the already opened .xlsx file. The sheet names are
	// returned in sheetNames.
	bool XlsxGetSheets(CkZipW &xlsx, CkStringTableW &sheetNames);

	// Loads the named sheet in the Excel spreadsheet into this CSV object. The zip is
	// the Zip object containing the already opened .xlsx file. The sheetName is the name of
	// the sheet to load. To load the 1st (default) sheet, pass an empty string in
	// sheetName.
	bool XlsxLoadSheet(CkZipW &zip, const wchar_t *sheetName);





	// END PUBLIC INTERFACE


};
#if !defined(__sun__) && !defined(__sun)
#pragma pack (pop)
#endif
	
#endif
