campo-sirio/include/textset.h

#ifndef __TEXTSET_H
#define __TEXTSET_H

#ifndef __REPORT_H
#include <report.h>
#endif

///////////////////////////////////////////////////////////
// TText_recordset
// Classe virtuale per gestire file di testo generici
///////////////////////////////////////////////////////////

enum TQuery_type { _qt_none, _qt_select, _qt_create };

class TText_recordset : public TRecordset
{
  TRecnotype _curr;
  TString_array _rec;

protected:
  TString _query;
  TRecordset_column_info _info; // Informazioni sull'unica colonna esistente

protected:
  virtual TQuery_type parse_query(const char* query, TFilename& table);
  virtual bool load_file(const TFilename& n);
  TToken_string& row(TRecnotype n = -1) const;

public:
  virtual unsigned int columns() const { return 1; }
  virtual const TRecordset_column_info& column_info(unsigned int) const { return _info; }
  virtual const TRecordset_column_info& column_info(const char* column) const;
  virtual int find_column(const char* column) const;

  virtual TRecnotype items() const;
  virtual bool move_to(TRecnotype pos);
  virtual TRecnotype current_row() const { return _curr; }
  virtual void requery();
  virtual const TVariant& get(unsigned int column) const;

	TRecnotype last() const { return items() - 1;}

public:
  virtual const TString& query_text() const { return _query; }
  virtual void sort(COMPARE_FUNCTION f = NULL);

  virtual bool destroy(TRecnotype r = -1);
  virtual TRecnotype new_rec(const char* buf = NULL);
  virtual TRecnotype insert_rec(TRecnotype r, const char* buf = NULL);
  virtual bool set(unsigned int fld, const TVariant& var);
  virtual bool set(const char* fld, const TVariant& var);
  virtual bool exec(const char* query);

  virtual bool save_as_text(const char* path);
  virtual bool save_as(const char* path, TRecordsetExportFormat fmt = fmt_text);

  TText_recordset(const char* query);
};

///////////////////////////////////////////////////////////
// TCSV_recordset 
// Classe per file di testo con campi separati da virgola (o altro separatore)
///////////////////////////////////////////////////////////
 
class TCSV_recordset : public TText_recordset
{
  char _separator;
  TArray _trc;

protected:
  char separator() const { return _separator; }
  void set_separator(const char s) { CHECK(s != 0, "Invalid separator"); _separator = s; }
  virtual TQuery_type parse_query(const char* query, TFilename& table);
  unsigned int build_trc();

public:
  virtual unsigned int columns() const;
  virtual const TRecordset_column_info& column_info(unsigned int column) const;
  virtual const TVariant& get(unsigned int column) const;
  virtual TRecnotype new_rec(const char* buf = NULL);
  virtual bool set(unsigned int fld, const TVariant& var);
	virtual void destroy_column(const int ncol = -1, bool pack = true) { _trc.destroy(ncol, pack); }
	virtual void create_column(const char * name, TFieldtypes type = _alfafld);
  virtual bool load_file(const TFilename& n);

public:
  TCSV_recordset(const char* query);
};

///////////////////////////////////////////////////////////
// TAS400_recordset
// Classe per file di testo con record a lunghezza fissa
///////////////////////////////////////////////////////////

struct TAS400_column_info : public TRecordset_column_info
{
  TVariant _default;
  bool _required;

  TAS400_column_info() : _required(false) { }
};

class TAS400_recordset : public TText_recordset
{
protected:
  TAS400_column_info _key;
  TAssoc_array _trc;

protected:
  virtual TQuery_type parse_query(const char* query, TFilename& table);
  virtual bool load_file(const TFilename& n);
  virtual int find_column(const char* column) const;

  virtual bool save_as_text(const char* path);

  TAS400_column_info* parse_field(const char* column, int& c, bool create);
  virtual bool set_field(const TAS400_column_info& fi, const TVariant& var);
  virtual const TVariant& get_field(const TAS400_column_info& fi) const;
  
public:
  virtual TRecnotype new_rec(const char* buf = NULL);
  virtual bool set(const char* column, const TVariant& var);
  virtual bool set(unsigned int column, const TVariant& var);
  
  virtual unsigned int columns() const;
  virtual const TRecordset_column_info& column_info(unsigned int column) const;
  virtual const TRecordset_column_info& column_info(const char* colunmn) const;
  virtual const TVariant& get(unsigned int column) const;
  virtual const TVariant& get(const char* colunmn) const;

public:
  bool create_field(const char* name, int pos, int len, TFieldtypes t = _alfafld, 
                    bool required = false, const TVariant& def = NULL_VARIANT);

  int record_length() const { return _info._width; }
  int key_length() const    { return _key._width; }
  int key_position() const  { return _key._pos; }
  virtual const TString& rec_type(TRecnotype r = -1) const;

  TAS400_recordset(const char* query);
};

#endif