Option.C

Go to the documentation of this file.

#ifndef OPTION_C
#define OPTION_C
#include <TNamed.h>
#include <iomanip>
#ifndef __CINT__
# include <TString.h>
# include <TList.h>
# include <TObjArray.h>
# include <TObjString.h>
# include <TMath.h>
# include <iostream>
# include <iomanip>
# include <cstdarg>
# include <cstdio>
# include <sstream>
namespace {
  template <typename T>
  T& str2val(const char* str, T& v)
  {
    std::stringstream s(str);
    if (str[0] == '0') {
      s << std::oct;
      if (str[1] == 'x' || str[1] == 'X')
  s << std::hex;
    }
    s >> v;
    return v;
  }
  template <>
  bool& str2val(const char* str, bool& v)
  {
    if (str[0] == '1' ||
  str[0] == 'y' || str[0] == 'Y' ||
  str[0] == 't' || str[0] == 'T')
      return (v=true);
    if (str[0] == '0' ||
  str[0] == 'n' || str[0] == 'N' ||
  str[0] == 'f' || str[0] == 'F')
      return (v=false);
    std::stringstream s;
    s >> v;
    return v;
  }
}

#else
class TString;
class TList;
class TObjArray;
#endif

    
struct Option /* : public TNamed */
{
  Option(const TString& name, 
   const TString& arg, 
   const TString& description,
   const TString& value)
    : fName(name), fDescription(description), 
      fValue(value), fArg(arg), fIsSet(false)
  {}
  Option(const Option& other)
    : fName(other.fName), 
      fDescription(other.fDescription),
      fValue(other.fValue), 
      fArg(other.fArg), 
      fIsSet(other.fIsSet)
  {}
  Option& operator=(const Option& other)
  {
    if (&other == this) return *this;
    
    fName        = other.fName;
    fDescription = other.fDescription;
    fValue       = other.fValue;
    fArg         = other.fArg;
    fIsSet       = other.fIsSet;
    
    return *this;
  }
  void Set(const TString& val) 
  { 
    if (HasArg()) {
      fIsSet = true;
      fValue = val;
      // Info("Set", "Setting option %s with arg %s to %s", 
      // fName.Data(), fArg.Data(), fValue.Data());
      return;
    }

    // Info("Set", "Setting option %s with no arg", fName.Data());
    // Allow flags to get =true, =1, =false, =0 values
    if (!val.IsNull()) {
      fIsSet = str2val(val.Data(), fIsSet);
      fValue = val;
    }
    else {
      fIsSet = true;
      fValue = "true";
    }
  }
  void Set() 
  { 
    if (HasArg()) { 
      Error("Option::Set", "Option %s needs an argument", fName.Data());
      return;
    }
    Set("true");
  }
  void Reset() 
  { 
    fIsSet = false; 
    if (!HasArg()) fValue = "false";
  }
  const TString& Get() const { return fValue; }
  Bool_t IsSet() const { return fIsSet; }
  Bool_t HasArg() const { return !fArg.IsNull(); }
  Bool_t AsBool() const { return fIsSet; }
  Int_t AsInt() const { Int_t i; return str2val(fValue.Data(), i); }
  Long64_t AsLong() const { Long_t i; return str2val(fValue.Data(), i); } 
  Double_t AsDouble() const { Double_t d; return str2val(fValue.Data(),d); } 
  const char* AsString() const { return fValue.Data(); } 
  Int_t NameWidth() const { return fName.IsNull() ? 0 : fName.Length(); }
  Int_t ArgWidth() const { return fArg.IsNull() ? 0 : fArg.Length(); }
  void Help(std::ostream& o, Int_t w=-1) const
  {
    TString tmp(fName);
    if (HasArg()) { 
      tmp.Append("=");
      tmp.Append(fArg);
    }
    if (w <= 0) w = NameWidth() + ArgWidth() + 1;
    std::ios::fmtflags oldf = o.setf(std::ios::left);
    o << std::setw(w) << tmp << "  " << fDescription << " [";
    if (!HasArg()) o << (IsSet() ? "true" : "false");
    else           o << fValue;
    o << "]" << std::endl;
    o.setf(oldf);
  }
  void Show(std::ostream& o, Int_t w=-1) const 
  {
    if (w <= 0) w = NameWidth();
    std::ios::fmtflags oldf = o.setf(std::ios::left);
    o << std::setw(w) << fName << ": ";
    if (!HasArg()) o << (IsSet() ? "true" : "false");
    else           o << fValue;
    o << std::endl;
    o.setf(oldf);
  }
  void Store(std::ostream& o, bool quote=true) const 
  {
    o << fName;
    if (!HasArg()) return;
    o << "=" << (quote ? "\"" : "") << fValue << (quote ? "\"" : "");
  }
  TString fName;        // Name 
  TString fDescription; // Description
  TString fValue;       // Value 
  TString fArg;         // Argument dummy 
  Bool_t  fIsSet;       // True if this option was set 
  
  // ClassDef(Option,1) // Option 
};

struct OptionList 
{
  // Linked list element
  struct Link 
  {
    Link*   fPrev;
    Link*   fNext;
    Option* fThis;
    Link() : fPrev(0), fNext(0), fThis(0) {}
    Link(Link* next, Option* opt)
      : fPrev(next ? next->fPrev : 0), // Set previous 
  fNext(next), // Set next link
  fThis(opt) // Set data
    {
      if (fPrev) fPrev->fNext = this; // Set forward link
      if (fNext) fNext->fPrev = this; // Set previous link
    }
    ~Link() { 
      if (fPrev) fPrev->fNext = fNext;
      if (fNext) fNext->fPrev = fPrev;
      delete fThis;
    }
    Link(const Link& o)
      : fPrev(o.fPrev), 
  fNext(o.fNext), 
  fThis(o.fThis)
    {
    }
    Link& operator=(const Link& o)
    {
      if (&o == this) return *this;
      fPrev = o.fPrev;
      fNext = o.fNext;
      fThis = o.fThis;
      return *this;
    } 
  };
  OptionList() : fList(0), fDesc("") { }
  OptionList(const OptionList& other) 
    : fList(0), fDesc(other.fDesc)
  { 
    // fList.SetOwner(); 
    // TIter next(&other.fList);
    // Option* o = 0;
    // while ((o = static_cast<Option*>(next()))) 
    //   fList.Add(new Option(*o));
    Copy(other);
  }
  ~OptionList() { Delete(); }

  void Delete()
  { 
    Link* cur = fList;
    while (cur) {
      Link* tmp = cur->fNext;
      delete cur;
      cur = tmp;
      // Remove(cur->fThis->fName);
      // cur = tmp;
    }
    fList = 0;
  }
  OptionList& operator=(const OptionList& other) 
  { 
    if (&other == this) return *this;
    Delete();
    Copy(other);
    
    return *this; 
  }
  void SetDescription(const TString& d) { fDesc = d; }
  void Copy(const OptionList& other)
  {
    Delete();
    const Link* ocur = other.fList;
    Link*       cur  = fList;
    Link*       prev = fList;
    while (ocur) { 
      cur        = new Link;
      cur->fThis = new Option(*(ocur->fThis));
      cur->fNext = 0;
      cur->fPrev = prev;
      if (fList == 0) fList = cur;
      if (prev)       prev->fNext = cur;
      prev = cur;
      ocur = ocur->fNext;
    }
  }
  void DebugLink(const Link* link) const
  {
    std::cout << "Link=" << link;
    if (link) {
      std::cout << " prev=" << link->fPrev 
    << " next=" << link->fNext
    << " obj=" << link->fThis;
      if (link->fThis) 
        std::cout << " name=" << link->fThis->fName;
    }
    std::cout <<std::endl;
  }
  Option* Find(const TString& name) const
  {
    const Link* cur = fList;
    // DebugLink(cur);
    while (cur && cur->fThis) { 
      if (name.EqualTo(cur->fThis->fName)) return cur->fThis;
      cur = cur->fNext;
    }
    return 0;
  }
  Option* Add(const TString& name, 
        const TString& arg, 
        const TString& desc, 
        const TString& val="")
  {
    Option* o = Find(name);
    if (o) { 
      Warning("OptionList::Add", "Option %s already registered", name.Data());
      return o;
    }
    // Info("Add", "New option %s with arg %s (%s) and value %s",    
    //   name.Data(), arg.Data(), desc.Data(), val.Data());
    o = new Option(name, arg, desc, val);
    Link*  cur  = fList;
    if (!cur) { 
      cur = new Link;
      cur->fThis = o;
      cur->fNext = 0;
      cur->fPrev = 0;
      fList      = cur;
    }
    else {
      Link* n = 0;
      Link* l = 0;
      while (cur) { 
  if (cur->fThis->fName.CompareTo(name) < 0) { 
    l   = cur;
    cur = cur->fNext;
    continue;
  }
  n = new Link(cur, o);
  if (cur == fList) fList = n;
  break;
      }
      if (!n) { 
  n = new Link;
  l->fNext = n;
  n->fPrev = l;
  n->fNext = 0;
  n->fThis = o;
      }
    }
    return o;
  }
  Option* Add(const TString& name, 
        const TString& desc)
  {
    return Add(name, "", desc, "");
  }
  Option* Add(const TString& name, 
        const TString& desc,
        Bool_t         def)
  {
    Option* o = Add(name, "", desc, "");
    if (o) o->Set(def ? "true" : "false");
    return o;
  }
  Option* Add(const TString& name, 
        const TString& arg, 
        const TString& desc, 
        Int_t          val, 
        Bool_t         asHex=false)
  {
    if (asHex) {
      UInt_t uval = val;
      return Add(name, arg, desc, Form("0x%x", uval));
    }
    return Add(name, arg, desc, Form("%d", val));
  }
  Option* Add(const TString& name, 
        const TString& arg, 
        const TString& desc, 
        Long64_t       val, 
        Bool_t         asHex=false)
  {
    if (asHex) {
      ULong64_t uval = val;
      return Add(name, arg, desc, Form("0x%llx", uval));
    }
    return Add(name, arg, desc, Form("%lld", val));
  }
  Option* Add(const TString& name, 
        const TString& arg, 
        const TString& desc, 
        Double_t val)
  {
    return Add(name, arg, desc, Form("%lg", val));
  }

  void Remove(const TString& name)
  {
    Link* cur = fList;
    while (cur) { 
      if (!cur->fThis->fName.EqualTo(name)) {
  cur = cur->fNext;
  continue;
      }
      if (fList == cur) fList = cur->fNext;
      delete cur;
      break;
    }
  }
  Bool_t Has(const TString& name) const
  {
    Option* o = Find(name);
    return (o && o->IsSet());
  }
  const TString& Get(const TString& name) const
  {
    static TString null("");
    Option* o = Find(name);
    if (!o) return null;
    return o->Get();
  }
  Bool_t GetF(const TString& name, const Char_t* format, ...) const
  {
    Option* o = Find(name);
    if (!o) return false;
    
    va_list ap;
    va_start(ap, format);
    int ret = vsscanf(o->fValue.Data(), format, ap);
    va_end(ap);
    
    return ret > 0;
  }
  Bool_t AsBool(const TString& name) const 
  {
    Option* o = Find(name);
    if (!o) return false;
    return o->AsBool();
  }
  Int_t AsInt(const TString& name, Int_t def=0) const
  {
    Option* o = Find(name);
    if (!o) return def;
    return o->AsInt();
  }
  Long64_t AsLong(const TString& name, Long64_t def=0) const
  {
    Option* o = Find(name);
    if (!o) return def;
    return o->AsLong();
  }
  Double_t AsDouble(const TString& name, Double_t def=0) const
  {
    Option* o = Find(name);
    if (!o) return def;
    return o->AsDouble();
  }
  const char* AsString(const TString& name, const TString& def="") const
  {
    Option* o = Find(name);
    if (!o) return def.Data();
    return o->AsString();
  }
  const TString& AsTString(const TString& name, const TString& def="") const
  {
    Option* o = Find(name);
    static TString ddef;
    ddef = def;
    if (!o) return ddef;
    return o->Get();
  }
  void SetF(const TString& name, const Char_t* format, ...)
  {
    Option* o = Find(name);
    if (!o) return;
    
    static char buf[1024];
    va_list ap;
    
    va_start(ap, format);
    vsnprintf(buf, 1023, format, ap);
    buf[1023] = '\0';
    va_end(ap);
    
    o->Set(buf);
  }
  void Set(const TString& name, const TString& value)
  {
    Option* o = Find(name);
    if (!o) return;
    o->Set(value);
  }
  void Set(const TString& name)
  {
    Option* o = Find(name);
    if (!o) return;
    o->Set();
  }   
  void Set(const TString& name, Int_t val, Bool_t asHex=false)
  {
    if (asHex) Set(name, Form("0x%x", val));
    else       Set(name, Form("%d", val));
  }
  void Set(const TString& name, Long64_t val, Bool_t asHex=false)
  {
    ULong64_t uval = val;
    if (asHex) Set(name, Form("0x%llx", uval));
    else       Set(name, Form("%lld", val));
  }
  void Set(const TString& name, Double_t val) 
  {
    Set(name, Form("%lg", val));
  }
  Bool_t Parse(const TString& tmp, const TString& delims)
  {
    TObjArray* opts = tmp.Tokenize(delims);
    // Info("OptionList::Parse", "Parsing options %s", tmp.Data());
    Bool_t ret = Parse(opts);
    opts->Delete();
    return ret;
  }
  Bool_t Parse(const TCollection* opts, Bool_t ignoreUnknown=false)
  {
    // Info("OptionList::Parse", "List of options");
    // opts->ls();
    TIter       next(opts);
    TObjString* o = 0;
    while ((o = static_cast<TObjString*>(next()))) { 
      TString& s   = o->String();
      TString  key = s;
      TString  val = "";
      Int_t    eq  = s.Index("=");
      if (eq != kNPOS) {
  key = s(0, eq);
  val = s(eq+1, s.Length()-eq-1);
      }

      // Info("OptionList::Parse", "Looking for key=%s", key.Data());
      Option*  opt = Find(key);
      if (!opt) { 
  if (!ignoreUnknown)
    Warning("OptionList::Parse", "Unknown option: \"%s\"", s.Data());
  continue;
      }
      if (opt->HasArg() && val.IsNull()) { 
  Warning("OptionList::Parse", 
    "Option %s needs an argument, using default %s", 
    key.Data(), opt->fValue.Data());
  val = opt->fValue;
  // return false;
      }
      opt->Set(val);
    }
    return true;
  }
  void Widest(Int_t& nWidth, Int_t& aWidth) const 
  {
    nWidth = 0;
    aWidth = 0;
    const Link* cur = fList;
    while (cur) { 
      Option* opt = cur->fThis;
      nWidth = TMath::Max(nWidth, opt->NameWidth());
      aWidth = TMath::Max(aWidth, opt->ArgWidth());
      cur = cur->fNext;
    }

    // while ((opt = static_cast<Option*>(next()))) {
    // }
  }
  void HelpDesc(std::ostream& o,
    const TString& prefix="",
    const Int_t max=70) const
  {
    if (fDesc.IsNull()) return;
    Int_t       indent= prefix.Length();
    Int_t       cur   = indent;
    TObjArray*  words = fDesc.Tokenize(" ");
    TObjString* word  = 0;
    TIter       next(words);
    o << std::endl << prefix;
    while ((word = static_cast<TObjString*>(next()))) {
      TString w = word->String();
      if (w.Contains("\n")) {
  Int_t idx = w.Index("\n");
  w.ReplaceAll("\n",Form("%s\n",prefix.Data()));
  o << w;
  cur = indent + (w.Length()-idx-1);
  w = "";
      }
      if (cur + w.Length() > max) {
  o << std::endl << prefix;
  cur = indent;
      }
      o << w << " ";
      cur += w.Length() + 1;
    }
    if (cur != indent) o << std::endl;
  }
    
  void Help(std::ostream& o, const char* prefix="  ") const 
  {
    Int_t nWidth, aWidth;
    Widest(nWidth, aWidth);
    if (aWidth > 0) nWidth += aWidth+1;

    const Link* cur = fList;
    while (cur) { 
      Option* opt = cur->fThis;
      o << prefix;
      opt->Help(o, nWidth);
      cur = cur->fNext;
    }
    TString pre(prefix);
    pre.ReplaceAll("-", " ");
    pre.ReplaceAll(" ", "");
    if (!pre.IsNull()) pre.Append(" ");
    HelpDesc(o, pre);
  }
  void Show(std::ostream& o, const char* prefix="  ") const 
  {
    Int_t nWidth, aWidth;
    Widest(nWidth, aWidth);


    const Link* cur = fList;
    while (cur) { 
      Option* opt = cur->fThis;
      o << prefix;
      opt->Show(o, nWidth);
      cur = cur->fNext;
    }
  }
  void Store(std::ostream& o, const char* prefix="", 
       const char* delim=",", bool quote=true, 
       bool onlySet=false) const 
  {
    Int_t nWidth, aWidth;
    Widest(nWidth, aWidth);

    const Link* cur = fList;
    while (cur) { 
      Option* opt = cur->fThis;
      if ((!opt->HasArg() || onlySet) && !opt->IsSet()) {
  cur = cur->fNext;
  continue;
      }
      o << prefix;
      opt->Store(o, quote);
      o << delim;
      cur = cur->fNext;
    }
  }
  // Our linked list
  Link* fList;
  TString fDesc;
  
  static void Test(const char* opts="")
  {
    OptionList l;
    l.Add("int", "NUMBER", "Integer", "42");
    l.Add("float", "NUMBER", "Floating point", "3.14");
    l.Add("bool", "Flag");
    l.Add("hex", "NUMBER", "Hexadecimal", "0xdead");
    l.Add("string", "STRING", "A string", "Hello, world");
    l.Show(std::cout, "\t");
    
    std::cout << "Find" << std::endl;
    Option* b = l.Find("bool");
    b->Set("true");
    b->Show(std::cout);

    std::cout << "SetF" << std::endl;
    l.SetF("float", "%f", 2.17);
    l.Show(std::cout, "\t");
    
    std::cout << "GetF" << std::endl;
    Float_t f;
    l.GetF("float", "%f", &f);
    std::cout << "\tf=" << f << std::endl;
    std::cout << "Remove" << std::endl;
    l.Remove("float");
    l.Show(std::cout, "\t");

    std::cout << "Set" << std::endl;
    l.Set("int", "10");
    l.Set("hex", 0xbeef, true);
    l.Set("bool", "false");
    l.Show(std::cout, "\t");

    std::cout << "Copy" << std::endl;
    OptionList c(l);
    c.Show(std::cout, "\t");

    std::cout << "Parse" << std::endl;
    c.Parse(opts,",");
    c.Show(std::cout, "\t");
    std::cout << "End of test" << std::endl;
  }
  // TList fList;
};

#endif