formula.h

Go to the documentation of this file.

// -*- C++ -*-

/*
 * Gnome Chemistry Utils
 * formula.h
 *
 * Copyright (C) 2005-2010 Jean Bréfort <jean.brefort@normalesup.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#ifndef GCU_FORMULA_H
#define GCU_FORMULA_H

#include <string>
#include <map>
#include <list>
#include <stdexcept>
#include "isotope.h"
#include "macros.h"
#include "value.h"

namespace gcu
{

typedef enum {
        GCU_FORMULA_PARSE_GUESS,
        GCU_FORMULA_PARSE_ATOM,
        GCU_FORMULA_PARSE_RESIDUE,
        GCU_FORMULA_PARSE_ASK,
        GCU_FORMULA_PARSE_NO_CASE=8
} FormulaParseMode;

class parse_error: public std::exception
{
public:
    explicit
    parse_error (const std::string&  __arg, int start, int length);

    virtual
    ~parse_error () throw ();

    virtual const char*
    what () const throw ();
    const char*
    what (int& start, int& length) const throw ();

        void add_offset (int offset) {m_start += offset;}

private:
        std::string m_msg;
        int m_start, m_length;

};

class FormulaElt
{
public:
        FormulaElt ();
        virtual ~FormulaElt ();
        virtual std::string Markup ();
        virtual std::string Text ();
        virtual void BuildRawFormula (std::map<int, int> &raw) = 0;
        virtual int GetValence () = 0;
        int stoich;
        unsigned start;
        unsigned end;
};

class FormulaAtom: public FormulaElt
{
public:
        FormulaAtom (int Z);
        virtual ~FormulaAtom ();
        std::string Markup ();
        std::string Text ();
        void BuildRawFormula (std::map<int, int> &raw);
        int GetValence ();
        int elt;
};

class FormulaBlock: public FormulaElt
{
public:
        FormulaBlock ();
        virtual ~FormulaBlock ();
        std::string Markup ();
        std::string Text ();
        void BuildRawFormula (std::map<int, int> &raw);
        int GetValence ();
        std::list<FormulaElt *> children;
        int parenthesis;
};

class Residue;

class FormulaResidue: public FormulaElt
{
public:
        FormulaResidue (Residue const *res, char const *symbol, int Z);
        virtual ~FormulaResidue ();
        std::string Markup ();
        std::string Text ();
        void BuildRawFormula (std::map<int, int> &raw);
        int GetValence ();
        Residue const *residue;
        std::string Symbol;
GCU_RO_PROP (int, Z);
};


class Formula
{
public:
        Formula (std::string entry, FormulaParseMode mode = GCU_FORMULA_PARSE_GUESS) throw (parse_error);

        virtual ~Formula ();

        char const *GetMarkup ();
        std::map<int,int> &GetRawFormula ();
        char const *GetRawMarkup ();
        void SetFormula (std::string entry) throw (parse_error);
        void Clear ();
        DimensionalValue GetMolecularWeight (bool &artificial);
        void CalculateIsotopicPattern (IsotopicPattern &pattern);

        std::list<FormulaElt *> const &GetElements () const {return Details;}

private:
        bool BuildConnectivity ();
        void Parse (std::string &formula, std::list<FormulaElt *>&result) throw (parse_error);
        bool AnalString (char *sz, std::list<FormulaElt *> &result, bool &ambiguous, int offset);
        bool TryReplace (std::list<FormulaElt *> &result, std::list<FormulaElt *>::iterator it);

private:
        std::string Entry, Markup, RawMarkup;
        std::map<int,int> Raw;
        std::list<FormulaElt *> Details;
        DimensionalValue m_Weight;
        bool m_WeightCached;
        bool m_Artificial;
        bool m_ConnectivityCached;

GCU_PROP (FormulaParseMode, ParseMode);
};

}

#endif // GCU_FORMULA_H