TextInterfaceAttribute.h

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

  template<class C>
  class Attribute : public Value
  {
 
  public:

    Attribute () { }

    std::string get_value () const
      { if (!instance) return "N/A"; else return get_value (instance); }

    void set_value (const std::string& value)
      { if (instance) set_value (instance, value); }

    virtual Attribute* clone () const = 0;

    virtual std::string get_value (const C*) const = 0;

    virtual void set_value (C*, const std::string& value) = 0;

    virtual void set_description (const std::string&) = 0;

    virtual void set_detailed_description (const std::string&) = 0;

    mutable Reference::To<C,false> instance;
 
  };


  template<class Type>
  class ToStringPolicy
  {
  protected:
 
    mutable ToString tostr;
 
  public:
 
    void set_modifiers (const std::string& modifiers) const
    {
#ifdef _DEBUG
      std::cerr << "ToStringPolicy<Type=" << typeid(Type).name()
                << ">::set_modifiers " << modifiers << " tostr=" << (void*) &tostr << std::endl;
#endif
      tostr.set_precision ( fromstring<unsigned>(modifiers) );
    }
 
    void reset_modifiers () const
    { 
      tostr.reset_modifiers ();
    }
 
    std::string operator () (const Type& t) const
    {
#ifdef _DEBUG
      std::cerr << "ToStringPolicy<Type=" << typeid(Type).name()
                << ">::operator ()" << " tostr=" << (void*) &tostr << std::endl;
#endif
      return tostr( t );
    }
  };


  template<class C, class Get>
  class GetToStringPolicy : public ToStringPolicy<typename Get::result_type>
  {
  public:
    std::string operator () (const C* ptr, Get get) const
    {
#ifdef _DEBUG
      std::cerr << "GetToStringPolicy<C=" << typeid(C).name()
                << ">::operator (const C* ptr, Get get)" << " tostr=" << (void*) &this->tostr << std::endl;
#endif
      if (!ptr)
        return "";
      return this->tostr( get (ptr) );
    }
  };
 
  template<class C, class P, class Type>
  class GetToStringPolicy<C, Type (P::*)() const> : public ToStringPolicy<Type>
  {
  public:
    std::string operator () (const C* ptr, Type (P::*get)() const) const
    {
#ifdef _DEBUG
      std::cerr << "GetToStringPolicy<C=" << typeid(C).name()
                << ">::operator (const C* ptr, Type (P::*get)() const)" << " tostr=" << (void*) &this->tostr << std::endl;
#endif
      if (!ptr)
        return "";
      return this->tostr( (ptr->*get) () );
    }
  };
 
  template<class C, class Type>
  class GetToStringPolicy<C, Type (C*)> : public ToStringPolicy<Type>
  {
  public:
    std::string operator () (const C* ptr, Type (*func)(C*)) const
    {
#ifdef _DEBUG
     std::cerr << "GetToStringPolicy<Type=" << typeid(Type).name()
               << ">::operator (const C* ptr, Type (*func)(C*))" << " tostr=" << (void*) &this->tostr << std::endl;
#endif
      if (!ptr)
        return "";
      return this->tostr( (*func) (ptr) );
    }
  };


  template<class C, class Set>
  class SetFromStringPolicy
  {
  public:
    void operator () (C* ptr, Set set, const std::string& value)
      { (set) (ptr, fromstring<typename Set::second_argument_type>(value)); }
  };
 
  template<class C, class P, class T>
  class SetFromStringPolicy<C, void (P::*)(const T&)>
  {
  public:
    void operator () (C* ptr, void (P::*set)(const T&), const std::string& val)
      { (ptr->*set) (fromstring<T>(val)); }
  };
 
  template<class C, class P, class Type>
  class SetFromStringPolicy<C, void (P::*)(Type)>
  {
  public:
    void operator () (C* ptr, void (P::*set)(Type), const std::string& value)
      { (ptr->*set) (fromstring<Type>(value)); }
  };
 
  template<class C, class P, class T>
  class SetFromStringPolicy<C, void (*)(P*,const T&)>
  {
  public:
    void operator () (C* ptr, void (*set)(P*, const T&), const std::string& val)
      { (*set) (ptr, fromstring<T>(val)); }
  };
 
  template<class C, class P, class Type>
  class SetFromStringPolicy<C, void (*)(P*,Type)>
  {
  public:
    void operator () (C* ptr, void (*set)(P*,Type), const std::string& value)
      { (*set) (ptr, fromstring<Type>(value)); }
  };

  template<class C, class Get>
  class AttributeGet : public Attribute<C>
  {
 
  public:

    AttributeGet (const std::string& _name, Get _get) : get(_get)
      { name = _name; }

    Attribute<C>* clone () const { return new AttributeGet(*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
    { return tostring (ptr,get); }

    void set_value (C*, const std::string&)
    { throw Error (InvalidState, "AttributeGet::set_value", 
                   name + " cannot be set"); }
 
    void set_modifiers (const std::string& modifiers) const
    { tostring.set_modifiers (modifiers); }
 
    void reset_modifiers () const
    { tostring.reset_modifiers (); }
 
  protected:

    std::string name;

    std::string description;

    std::string detailed_description;

    Get get;
 
    GetToStringPolicy<C,Get> tostring;
  };

  template<class C, class Type, class Get, class Set>
  class AttributeGetSet : public AttributeGet<C, Get>
  {
 
  public:

    AttributeGetSet (const std::string& _name, Get _get, Set _set)
      : AttributeGet<C,Get> (_name, _get), set(_set) {  }

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

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

    Set set;
 
    SetFromStringPolicy<C,Set> from_string;
  };


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

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

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

  void parse_indeces (std::vector<unsigned>& indeces, const std::string&,
                      unsigned size);

  bool match (const std::string& name, const std::string& text,
              std::string* range, std::string* remainder = 0);
 
}
 
#endif