data.h

#ifndef _DATA_H_
#define _DATA_H_

#include <vector>
#include <string>
#include <map>
#include <libintl.h>
#include <iostream>

#include "typedef.h"
#include "error_codes.h"


class Data {
private:
        static const bool binary;
protected:

    virtual void read(std::istream& str) = 0;

     virtual void write(std::ostream& str) const = 0;

//  Data
/*  //! T can be constructed form this, but this can not be constructed from T.
    template <class T, typename... Args> 
    void 
    injection_ (T&) const { 
        injection_{}
    }
    template <class T> 
    void
    surjection_ (const T&) { }

    template<typename T, typename... Args> 
    T& convert(const Args &args ...)
    {
        
        args.injection_(T);
    }*/

public:
    static const std::string file_name;
    static const std::string table_name;

    virtual std::string header(void) const = 0;

    void read_binary(std::istream& str) {};
    void write_binary(std::ostream& str) const {};

    Data(){};
    Data(std::vector <std::string> &){};

    virtual const std::string get_file_name() const {return this->file_name;};
        virtual const std::string get_table_name() const {return this->table_name;};

    virtual const bool indexed() const {return false;};

        virtual const bool get_binary() const {return this->binary;};

    /* E.g. Column_name_1 integer, Column_name_2 integer, ...
     */ 
        virtual const std::string sql_header(void) const {return "";};
    /* E.g. Column_name_1, Column_name_2, ...
     */ 
        virtual const std::string sql_column_names(void) const {return "";};
    /* E.g. 1, 0, ...
     */ 
    virtual const std::string sql_values(void) const {return "";};
    /* E.g. 1, 0, ...
     */ 
    virtual void sql_read(std::istream &);

    /*
     *@}
         */

    friend std::ostream& operator << (std::ostream&, const Data &); 
    friend std::istream& operator >> (std::istream&, Data &);       

    /* If size() is undefined in the child class, then we don't want to 
     * read or write any at all, so we return 0.
     */
        virtual size_t size(void) const {return 0;};
    /*
     *@}
         */

    static Data * new_from_str (const std::string &, const std::vector<std::string> &);
//  static Data * new_empty (const std::string &);

//  virtual const enum tags(void) const {return "";};

};

/* Indexed_data can be stored in indexed files.
 */
class Indexed_data : public virtual Data {
protected:
    id1_t abs_pos_;
public:
    using Data::write_binary;
    using Data::read_binary;
    void write_pos(std::ostream& str) const
    {
        str.write((char *)(&abs_pos_), sizeof(id1_t) );
    }

    void read_pos(std::istream& str)
    {
        str.read((char *)(&abs_pos_), sizeof(id1_t) );
    }

    Indexed_data(){};
    Indexed_data(std::vector <std::string> &){};
    id1_t get_abs_pos (void) const;   

    void set_abs_pos (const id1_t &); 
    const bool indexed() const {return true;};
};


/* Indexed_data can be stored in indexed files.
 */

#define get_abs_pos1    get_abs_pos
#define set_abs_pos1    set_abs_pos

class Double_indexed_data : public virtual Data 
{
protected:
    id1_t abs_pos1_, abs_pos2_;
public:
    using Data::write_binary;
    using Data::read_binary;

    void write_pos(std::ostream& str) const
    {
        str.write((char *)(&abs_pos1_), sizeof(id1_t) );
        str.write((char *)(&abs_pos2_), sizeof(id1_t) );
    }

    void read_pos(std::istream& str)
    {
        str.read((char *)(&abs_pos1_), sizeof(id1_t) );
        str.read((char *)(&abs_pos2_), sizeof(id1_t) );
    }

    Double_indexed_data(){};
    Double_indexed_data(std::vector <std::string> &){};

    id1_t get_abs_pos (void) const;   
    id1_t get_abs_pos2 (void) const;      

    void set_abs_pos (const id1_t &); 
    void set_abs_pos2 (const id1_t &); 

    const bool indexed() const {return true;};
};

/*  This initializes m_data_ctor map which should not be visible
 *  outside of data.cc
 */
static struct Registry_initalizer {
    Registry_initalizer ();
    ~Registry_initalizer ();
} Registry_initalizer;


class Registration 
{
public:
    Registration (const std::string &str, Data*(*fn)(const std::vector <std::string> &) );
    ~Registration (void);
private:
    std::string name_;
};

std::vector <std::string> registry_list(void);

#endif