ldrtypes.h

/***************************************************************************
                          ldrtypes.h  -  description
                             -------------------
    begin                : Sun Jun 6 2004
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.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 LDRTYPES_H
#define LDRTYPES_H
 
 
#include <odinpara/ldrbase.h>
 
 
 
class LDRstring : public STD_string, public virtual LDRbase  {
 
 public:
 
  LDRstring () : STD_string() {}
 
  LDRstring (const STD_string& ss, const STD_string& name="");
 
 
  LDRstring (int i,const char c=' ') : STD_string(i,c) {}
 
  LDRstring (const char *charptr) : STD_string(charptr) {}
 
  LDRstring (const LDRstring& str) {LDRstring::operator = (str);}
 
  LDRstring& operator = (const STD_string& ss) {STD_string::operator = (ss); return *this;}
 
  LDRstring& operator = (const char *charptr) {STD_string::operator = (charptr); return *this;}
 
  LDRstring& operator = (const LDRstring& ss);
 
  friend STD_ostream& operator << (STD_ostream& s,const LDRstring& t) {return s << STD_string(t);}
 
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  STD_string get_parx_code(parxCodeType type) const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {if(parx_equivtype) return "char"; return "string";}
  LDRbase* create_copy() const {return new LDRstring(*this);}
  STD_string* cast(STD_string*) {return this;}
 
 
};
 
 
 
 
class LDRbool : public virtual LDRbase  {
 
 public:
 
  LDRbool () : val(false) {}
 
  LDRbool(bool flag, const STD_string& name="");
 
  LDRbool(const LDRbool& jb) {LDRbool::operator = (jb);}
 
  LDRbool& operator = (bool flag) {val=flag; return *this;}
 
  LDRbool& operator = (const STD_string& s) {parsevalstring(s); return *this;}
 
  LDRbool& operator = (const LDRbool& jb);
 
  operator bool () const {return val;}
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {if(parx_equivtype) return "YesNo"; return "bool";}
  LDRbase* create_copy() const {return new LDRbool(*this);}
  bool* cast(bool*) {return &val;}
 
 private:
  bool val;
};
 
 
 
class LDRenum : public virtual LDRbase  {
 
 public:
 
  LDRenum() {actual=entries.end();}
 
  LDRenum(const STD_string& first_entry, const STD_string& name="");
 
  LDRenum(const LDRenum& je) {LDRenum::operator = (je);}
 
 
  LDRenum& operator = (const char* item) {set_actual(STD_string(item)); return *this;}
 
  LDRenum& operator = (const STD_string& item) {set_actual(item); return *this;}
 
  LDRenum& operator = (int item) {set_actual(item); return *this;}
 
  LDRenum& operator = (const LDRenum& je);
 
  LDRenum& add_item(const STD_string& item, int index=-1);
 
  LDRenum& set_actual(const STD_string& item);
 
  LDRenum& set_actual(int index);
 
  LDRenum& 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;
 
  LDRenum& set_item_index(unsigned int index);
 
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  svector get_alternatives() const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {if(parx_equivtype) toupperstr(get_label()); return "enum";}
  LDRbase* create_copy() const {return new LDRenum(*this);}
  LDRenum* cast(LDRenum*) {return this;}
 
 private:
  STD_map<int,STD_string> entries;
  STD_map<int,STD_string>::const_iterator actual;
 
  STD_string parxtype_cache;
 
};
 
 
class LDRaction : public virtual LDRbase  {
 
 public:
 
  LDRaction() : state(false) {set_filemode(exclude);}
 
  LDRaction(bool init_state, const STD_string& name="");
 
  LDRaction(const LDRaction& ja) {LDRaction::operator = (ja);}
 
  LDRaction& operator = (const LDRaction& ja);
 
  operator bool () const;
 
  LDRaction& trigger_action() {state=true; return *this;}
  
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {return "action";}
  LDRbase* create_copy() const {return new LDRaction(*this);}
  LDRaction* cast(LDRaction*) {return this;}
 
 private:
  mutable bool state;
};
 
 
 
 
 
 
class LDRfileName : public LDRstring {
 
public:
 
  LDRfileName () {common_init();}
 
  LDRfileName (const STD_string& filename, const STD_string& name="");
 
  LDRfileName(const LDRfileName& jf);
 
  LDRfileName& operator = (const STD_string& filename);
 
  LDRfileName& operator = (const LDRfileName& 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;}
 
  LDRfileName& set_suffix(const STD_string& suff) {suffix_cache=suff; return *this;}
 
  STD_string get_defaultdir() const {return defaultdir;}
 
  LDRfileName& set_defaultdir(const STD_string& defdir);
 
 
  bool is_dir() const {return dir;}
 
  LDRfileName& set_dir(bool flag) {dir=flag; return *this;}
 
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string get_typeInfo(bool parx_equivtype=false) const {return "fileName";}
  LDRbase* create_copy() const {return new LDRfileName(*this);}
  LDRfileName* cast(LDRfileName*) {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 LDRformula : public LDRstring {
 
public:
 
  LDRformula () : LDRstring() {}
 
  LDRformula (const STD_string& formula, const STD_string& name="");
 
  LDRformula (const LDRformula& jf) {LDRformula::operator = (jf);}
 
  LDRformula& operator = (const STD_string& formula) {LDRstring::operator = (formula); return *this;}
 
  LDRformula& operator = (const LDRformula& jf);
 
  LDRformula& set_syntax(const STD_string& syn) {syntax=syn; return *this;}
 
  STD_string get_syntax() const {return syntax;}
 
  // overwriting virtual functions from LDRbase
  STD_string get_typeInfo(bool parx_equivtype=false) const {return "formula";}
  LDRbase* create_copy() const {return new LDRformula(*this);}
  LDRformula* cast(LDRformula*) {return this;}
 
private:
  STD_string syntax;
};
 
 
 
#endif