TextInterfaceElement.h

//-*-C++-*-
 
/***************************************************************************
 *
 *   Copyright (C) 2003 - 2022 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/psrchive/Util/units/TextInterfaceElement.h
 
#ifndef __TextInterfaceElement_h
#define __TextInterfaceElement_h
 
#include "TextInterfaceAttribute.h"
 
namespace TextInterface
{


  template<class C, class Get, class Size>
  class ElementGet : public Attribute<C>
  {
  public:

    ElementGet (const std::string& _name, Get _get, Size _size)
      { name = _name; get = _get; size = _size; }

    Attribute<C>* clone () const { return new ElementGet(*this); }

    std::string get_name () const { return name + "*"; }

    std::string get_description () const { return description; }

    void set_description (const std::string& d) { description = d; }

    std::string get_detailed_description () const
    { return detailed_description; }

    void set_detailed_description (const std::string& d)
    { detailed_description = d; }

    std::string get_value (const C* ptr) const;

    void set_value (C*, const std::string&)
      { throw Error (InvalidState, "ElementGet::set_value", 
                     name + " cannot be set"); }

    bool matches (const std::string& name) const;
 
    void set_modifiers (const std::string& modifiers) const
    {
      tostring_precision = fromstring<unsigned> (modifiers);
    }
 
    void reset_modifiers () const
    {
      tostring_precision = 0;
    }
    
  protected:

    std::string name;

    std::string description;

    std::string detailed_description;

    Get get;

    Size size;

    mutable std::string range;
 
  };

  template<class C, class Type, class Get, class Set, class Size>
    class ElementGetSet : public ElementGet<C, Get, Size> {
 
  public:

    ElementGetSet (const std::string& _name, Get _get, Set _set, Size _size)
      : ElementGet<C,Get,Size> (_name, _get, _size) { set = _set; }

    Attribute<C>* clone () const { return new ElementGetSet(*this); }

    void set_value (C* ptr, const std::string& value);
 
  protected:

    Set set;
 
  };


  template<class C, class Type>
  class VAllocator {
 
  public:

    template<class Get, class Size>
      ElementGet<C,Get,Size>* 
      operator () (const std::string& n, Get g, Size z)
      { return new ElementGet<C,Get,Size> (n, g, z); }
    
    template<class Get, class Set, class Size>
      ElementGetSet<C,Type,Get,Set,Size>* 
      operator () (const std::string& n, Get g, Set s, Size z)
      { return new ElementGetSet<C,Type,Get,Set,Size> (n, g, s, z); }
    
    template<class Get, class Size>
      ElementGet<C,Get,Size>* 
      operator () (const std::string& n, const std::string& d, Get g, Size z)
      {
        ElementGet<C,Get,Size>* get = operator () (n,g,z);
        get->set_description (d); return get;
      }

    template<class Get, class Set, class Size>
      ElementGetSet<C,Type,Get,Set,Size>* 
      operator () (const std::string& n, const std::string& d,
                   Get g, Set s, Size z)
      {
        ElementGetSet<C,Type,Get,Set,Size>* get = operator () (n,g,s,z);
        get->set_description (d); return get;
      }
 
  };

  extern bool label_elements;
 
}
 
template<class C,class Get,class Size>
 bool TextInterface::ElementGet<C,Get,Size>::matches
  (const std::string& var) const
{
#ifdef _DEBUG
  std::cerr << "TextInterface::ElementGet::matches" << std::endl;
#endif
 
  if (!match (name, var, &range))
    return false;
 
  return true;
}
 
template<class C, class G, class S> 
std::string TextInterface::ElementGet<C,G,S>::get_value (const C* ptr) const
{
#ifdef _DEBUG
  std::cerr << "TextInterface::ElementGet::get_value name=" << name 
            << " range=" << range << std::endl;
#endif
 
  std::vector<unsigned> ind;
  parse_indeces (ind, range, (ptr->*(size))());
  std::string result;
 
  if (!this->parent)
    throw Error (InvalidState, "ElementGet["+name+"]", "no parent");
 
  for (unsigned i=0; i<ind.size(); i++)
  {
    // place a delimiter between elements
    if (i)
      result += this->parent->get_delimiter();
 
    if (label_elements && ind.size() > 1)
      result += tostring(ind[i]) + ")";  // label the elements
 
    result += tostring( (ptr->*get)(ind[i]) );
  }
 
  return result;
}
 
template<class C, class T, class G, class S, class Z>
void TextInterface::ElementGetSet<C,T,G,S,Z>::set_value (C* ptr,
                                                         const std::string& v)
{
  std::vector<unsigned> ind;
  parse_indeces (ind, this->range, (ptr->*(this->size))());
 
  for (unsigned i=0; i<ind.size(); i++)
    (ptr->*set)(ind[i], fromstring<T>(v));
}
 
#endif