SpeciesDB.h

Go to the documentation of this file.

/* species database -*- C++ -*- */
#ifndef _SPECIESDB_H_
#define _SPECIESDB_H_

#include <iostream>
#include <exception>
#include <map>
#include <list>
#include "common.h"
#include "ParseFile.h"

class Species : public std::map<std::string, std::string> {
public:
    static const char* SFIELDS[];
    const static char s_SPFLAGS[];
    enum SpFlags {
        FLIPPED=0x01, QUALITY=0x02, SCALE=0x04, SEL1=0x08, DEL=0x10,
        SEL2=0x20, SEL3=0x04, SEL4=0x80, SEL5=0x100
    };
    enum  SpCompare { CMP_EQUALS, CMP_CONTAINS, CMP_LESSER, CMP_GREATER };
    Species(dword _id=0, dword _flags=0) : id(_id), m_Flags(_flags) {}
    Species &operator=(const Species &rhs) {
        if(&rhs == this) return *this;
        std::map<std::string, std::string>::operator=(rhs);
        id = rhs.id;
        m_Flags = rhs.m_Flags;
        return *this;
    }
    void reset();
    bool hasFlag(dword flag) const;
    dword setFlag(dword flag);
    dword unsetFlag(dword flag);
    dword readFlagString(const std::string &flags);
    std::string getFlagString() const;
    bool select(const Species& sp,
                enum SpCompare how=Species::CMP_CONTAINS) const;
    dword getScale() const;
    friend ParseFile& operator>>(ParseFile &is, Species &sp);
    friend std::ostream& operator<<(std::ostream &os, const Species &sp);

    dword id;
    dword m_Flags;
};

class SpeciesDB : public std::map<dword, Species> {
public:
    SpeciesDB() {}
    SpeciesDB(const char* filename) {
        load(filename);
    }
    bool load(const char* filename);

    friend ParseFile& operator>>(ParseFile &is, SpeciesDB &sp);
    friend std::ostream& operator<<(std::ostream &os, const SpeciesDB &sp);
    const std::string& getDirectory() const { return m_Directory; }
    const std::string& getFilename() const { return m_Filename; }
    dword select(const Species& rhs,
                 enum Species::SpCompare how=Species::CMP_CONTAINS);
    dword select(const std::list<dword>& idlist);
    dword getSelectionID(int dir=0, bool wrap=true);
    dword loadSelection(const std::string& fname)
        { return loadSelection(fname, m_Selection); }
    dword writeSelection(const std::string& fname) const
        { return writeSelection(fname, m_Selection); }
    static dword loadSelection(const std::string& fname,std::list<dword>& sel);
    static dword writeSelection(const std::string& fname,
                                const std::list<dword>& sel);
protected:
    std::string                      m_Directory;
    std::string                      m_Filename;
    std::list<dword>                 m_Selection;
    std::list<dword>::iterator       m_CSel;
};

class DBSelector {
public:
    DBSelector(SpeciesDB &db) : m_DB(db), m_CSel(m_Selectors.begin()) {};
    DBSelector(SpeciesDB &db, const char* filename)
        : m_DB(db), m_CSel(m_Selectors.begin())
        { load(filename); }
    bool load(const char* filename);
    void update();
    Species& getCurSpecies()
        {
            std::map<dword,Species>::iterator n = m_DB.find(
                m_DB.getSelectionID());
            if(n != m_DB.end()) return n->second;
            else return m_CSpecies;
        }
    bool nextSelection(int dir=1, bool wrap=true);
    bool nextSelector(int walkdir=1, bool wrap=true, dword mincount=1);

public:
    SpeciesDB                   &m_DB;
    std::list<Species>               m_Selectors;
    std::list<Species>::iterator     m_CSel;
    Species                     m_CSpecies;
};

#ifdef _SP_DEFINE_
const char* Species::SFIELDS[] = {
    "species_id",
    "order",
    "family",
    "name",
    "cname",
    "type",
    "image",
    "flags",
    "scale",
    NULL
};
const char Species::s_SPFLAGS[] = "fqs1d2345\0x00";
#endif

#endif