jdxtypes.h

/***************************************************************************
                          jdxtypes.h  -  description
                             -------------------
    begin                : Sun Jun 6 2004
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef JDXTYPES_H
#define JDXTYPES_H


#include <odinpara/jdxbase.h>




class JDXstring : public STD_string, public virtual JcampDxClass  {

 public:

  JDXstring () : STD_string() {}

  JDXstring (const STD_string& ss,const STD_string& name="",bool userParameter=true,
             compatMode mode=notBroken,parameterMode parameter_mode=edit,
             const STD_string& parx_equivalent="");


  JDXstring (int i,const char c=' ') : STD_string(i,c) {}

  JDXstring (const char *charptr) : STD_string(charptr) {}

  JDXstring (const JDXstring& str) {JDXstring::operator = (str);}

  JDXstring& operator = (const STD_string& ss) {STD_string::operator = (ss); return *this;}

  JDXstring& operator = (const char *charptr) {STD_string::operator = (charptr); return *this;}

  JDXstring& operator = (const JDXstring& ss);

  friend STD_ostream& operator << (STD_ostream& s,const JDXstring& t) {return s << STD_string(t);}


  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  STD_string get_parx_code(parxCodeType type, const ParxEquiv& equiv) const;
  ParxEquiv get_parx_equiv() const {parx_equiv.type="char"; return parx_equiv;}
  const char* get_typeInfo() const {return "string";}
  JcampDxClass* create_copy() const {return new JDXstring(*this);}
  STD_string* cast(STD_string*) {return this;}

 private:
  mutable ParxEquiv parx_equiv;

};




class JDXbool : public virtual JcampDxClass  {

 public:

  JDXbool () : val(false) {}

  JDXbool(bool flag, const STD_string& name="",
          bool userParameter=true, compatMode mode=notBroken,
          parameterMode parameter_mode=edit,
          const STD_string& parx_equivalent="");

  JDXbool(const JDXbool& jb) {JDXbool::operator = (jb);}

  JDXbool& operator = (bool flag) {val=flag; return *this;}

  JDXbool& operator = (const STD_string& s) {parsevalstring(s); return *this;}

  JDXbool& operator = (const JDXbool& jb);

  operator bool () const {return val;}

  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  STD_string get_parx_code(parxCodeType type, const ParxEquiv& equiv) const;
  ParxEquiv get_parx_equiv() const {parx_equiv.type="YesNo"; return parx_equiv;}
  const char* get_typeInfo() const {return "bool";}
  JcampDxClass* create_copy() const {return new JDXbool(*this);}
  bool* cast(bool*) {return &val;}

 private:
  bool val;
  mutable ParxEquiv parx_equiv;
};



class JDXenum : public virtual JcampDxClass  {

 public:

  JDXenum() {actual=entries.end();}

  JDXenum(const STD_string& first_entry, const STD_string& name="",
          bool userParameter=true, compatMode mode=notBroken,
          parameterMode parameter_mode=edit, const STD_string& parx_equivalent="");

  JDXenum(const JDXenum& je) {JDXenum::operator = (je);}


  JDXenum& operator = (const char* item) {set_actual(STD_string(item)); return *this;}

  JDXenum& operator = (const STD_string& item) {set_actual(item); return *this;}

  JDXenum& operator = (int item) {set_actual(item); return *this;}

  JDXenum& operator = (const JDXenum& je);

  JDXenum& add_item(const STD_string& item, int index=-1);

  JDXenum& set_actual(const STD_string& item);

  JDXenum& set_actual(int index);

  JDXenum& clear();

  operator int () const;

  operator STD_string () const;

  bool operator == (const STD_string& s) const {return (operator STD_string ())==s;}

  bool operator == (const char* s) const {return (operator STD_string ())==STD_string(s);}

  bool operator == (int i) const {return (operator int ())==i;}

  bool operator != (const STD_string& s) const {return (operator STD_string ())!=s;}

  bool operator != (const char* s) const {return (operator STD_string ())!=STD_string(s);}

  bool operator != (int i) const {return (operator int ())!=i;}


  unsigned int n_items() const {return entries.size();}

  const STD_string& get_item(unsigned int index) const;

  unsigned int get_item_index() const;

  JDXenum& set_item_index(unsigned int index);


  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  svector get_alternatives() const;
  STD_string get_parx_code(parxCodeType type, const ParxEquiv& equiv) const;
  ParxEquiv get_parx_equiv() const;
  const char* get_typeInfo() const {return "enum";}
  JcampDxClass* create_copy() const {return new JDXenum(*this);}
  JDXenum* cast(JDXenum*) {return this;}

 private:
  STD_map<int,STD_string> entries;
  STD_map<int,STD_string>::const_iterator actual;
  mutable ParxEquiv parx_equiv;

  STD_string parxtype_cache;

};


class JDXaction : public virtual JcampDxClass  {

 public:

  JDXaction() : state(false) {set_filemode(exclude);}

  JDXaction(bool init_state, const STD_string& name="",
            bool userParameter=true, compatMode mode=notBroken,
            parameterMode parameter_mode=edit);

  JDXaction(const JDXaction& ja) {JDXaction::operator = (ja);}

  JDXaction& operator = (const JDXaction& ja);

  operator bool () const;

  JDXaction& trigger_action() {state=true; return *this;}
  
  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  const char* get_typeInfo() const {return "action";}
  JcampDxClass* create_copy() const {return new JDXaction(*this);}
  JDXaction* cast(JDXaction*) {return this;}

 private:
  mutable bool state;
};






class JDXfileName : public JDXstring {

public:

  JDXfileName () {common_init();}

  JDXfileName (const STD_string& filename, const STD_string& name="",
               bool userParameter=true, compatMode mode=notBroken,
               parameterMode parameter_mode=edit);

  JDXfileName(const JDXfileName& jf);

  JDXfileName& operator = (const STD_string& filename);

  JDXfileName& operator = (const JDXfileName& jf);

  bool exists() const;

  STD_string get_basename() const {return basename_cache;}

  STD_string get_basename_nosuffix() const;

  STD_string get_dirname() const {return dirname_cache;}

  STD_string get_suffix() const {return suffix_cache;}

  JDXfileName& set_suffix(const STD_string& suff) {suffix_cache=suff; return *this;}

  STD_string get_defaultdir() const {return defaultdir;}

  JDXfileName& set_defaultdir(const STD_string& defdir);


  bool is_dir() const {return dir;}

  JDXfileName& set_dir(bool flag) {dir=flag; return *this;}


  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  const char* get_typeInfo() const {return "fileName";}
  JcampDxClass* create_copy() const {return new JDXfileName(*this);}
  JDXfileName* cast(JDXfileName*) {return this;}

private:

  static void normalize(const STD_string& fname, bool dir, STD_string& result, STD_string& result_dirname, STD_string& result_basename, STD_string& result_suffix);

  void common_init() {dir=false;}

  STD_string defaultdir;
  STD_string dirname_cache;
  STD_string basename_cache;
  STD_string suffix_cache;

  bool dir;

};


class JDXformula : public JDXstring {

public:

  JDXformula () : JDXstring() {}

  JDXformula (const STD_string& formula, const STD_string& name="",
              bool userParameter=true, compatMode mode=notBroken,
              parameterMode parameter_mode=edit);

  JDXformula (const JDXformula& jf) {JDXformula::operator = (jf);}

  JDXformula& operator = (const STD_string& formula) {JDXstring::operator = (formula); return *this;}

  JDXformula& operator = (const JDXformula& jf);

  JDXformula& set_syntax(const STD_string& syn) {syntax=syn; return *this;}

  STD_string get_syntax() const {return syntax;}

  // overwriting virtual functions from JcampDxClass
  const char* get_typeInfo() const {return "formula";}
  JcampDxClass* create_copy() const {return new JDXformula(*this);}
  JDXformula* cast(JDXformula*) {return this;}

private:
  STD_string syntax;
};



#endif