TextInterfaceProxy.h

//-*-C++-*-
 
/***************************************************************************
 *
 *   Copyright (C) 2003 - 2016 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/psrchive/Util/units/TextInterfaceProxy.h
 
#ifndef __TextInterfaceProxy_h
#define __TextInterfaceProxy_h
 
#include "TextInterfaceAttribute.h"
#include "TextInterfaceAdapter.h"
 
#include "separate.h"
#include "stringtok.h"
 
namespace TextInterface
{
 
  template<class C, class P>
  class IsAProxy : public AttributeAdapter<C,P>
  {
 
  public:
    
    IsAProxy (const Attribute<P>* pa) 
      { this->value = pa->clone(); }
 
    IsAProxy (const IsAProxy& copy)
      { this->value = copy.value->clone(); }
 
    Attribute<C>* clone () const
      { return new IsAProxy(*this); }
 
    std::string get_value (const C* ptr) const 
    { if (!ptr) return "null";
      return this->value->get_value (ptr); }
 
    void set_value (C* ptr, const std::string& value)
    { if (ptr) this->value->set_value (ptr, value); }
  };
 
 
  template<class C, class M, class Get>
  class HasAProxy : public AttributeAdapter<C,M>
  {
 
  public:
 
    HasAProxy (const std::string& pre, const Attribute<M>* pa, Get g)
      { prefix = pre; this->value = pa->clone(); get = g; }
 
    HasAProxy (const HasAProxy& copy)
      { this->value=copy.value->clone(); get=copy.get; prefix=copy.prefix; }
 
    Attribute<C>* clone () const
      { return new HasAProxy(*this); }
 
    std::string get_name () const
      { 
        if (prefix.length())
          return prefix + ":" + this->value->get_name();
        else
          return this->value->get_name();
      }
 
    std::string get_value (const C* ptr) const 
    { if (!ptr) return "null";
      return this->value->get_value ((const_cast<C*>(ptr)->*get)()); }
 
    void set_value (C* ptr, const std::string& val)
    { if (ptr) this->value->set_value ((ptr->*get)(), val); }
 
    bool matches (const std::string& name) const
    { return TextInterface::matches (name, prefix, this->value); }
 
  protected:
 
    Get get;
 
    std::string prefix;
  };
 
 
  template<class V, class E, class Get, class Size>
  class VectorOfProxy : public AttributeAdapter<V,E>
  {
 
  public:
    
    VectorOfProxy (const std::string& p, const Attribute<E>* a, Get g, Size s)
      { prefix = p; this->value = a->clone(); get = g; size = s; }
 
    VectorOfProxy (const VectorOfProxy& copy)
      { this->value=copy.value->clone(); 
        get=copy.get; size=copy.size; prefix=copy.prefix; }
 
    Attribute<V>* clone () const
      { return new VectorOfProxy(*this); }
 
    std::string get_name () const
      { return prefix + "*:" + this->value->get_name(); }
 
    std::string get_value (const V* ptr) const;
 
    void set_value (V* ptr, const std::string& value);
 
    bool matches (const std::string& name) const;
 
  protected:
 
    Get get;
 
    Size size;
 
    std::string prefix;
 
    mutable std::string range;
 
  };
 
 
 
  template<class M, class K, class E, class Get>
  class MapOfProxy : public AttributeAdapter<M,E>
  {
 
  public:
    
    MapOfProxy (const std::string& pre, const Attribute<E>* pa, Get g)
      { prefix = pre; this->value = pa->clone(); get = g; }
 
    MapOfProxy (const MapOfProxy& copy)
      { prefix=copy.prefix; this->value=copy.value->clone(); get=copy.get;  }
 
    
    Attribute<M>* clone () const
      { return new MapOfProxy(*this); }
 
    std::string get_name () const
      { return prefix + "?:" + this->value->get_name(); }
 
    std::string get_value (const M* ptr) const;
 
    void set_value (M* ptr, const std::string& value);
 
    bool matches (const std::string& name) const;
 
  protected:
 
    Get get;
 
    std::string prefix;
 
    mutable std::string range;
 
    void get_indeces (std::vector<K>& keys,
                      const std::string& param) const;
 
  };
 
}
 
template<class V, class E, class G, class S> 
std::string
TextInterface::VectorOfProxy<V,E,G,S>::get_value (const V* ptr) const
{
  std::vector<unsigned> ind;
  parse_indeces (ind, range, (ptr->*size)());
  std::string result;
 
  if (!this->parent)
    throw Error (InvalidState, "VectorOfProxy["+prefix+"]", "no parent");
 
  for (unsigned i=0; i<ind.size(); i++)
  {
    // place a delimiter between elements
    if (i)
      result += this->parent->get_delimiter();
 
    // label the elements
    if (label_elements && ind.size() > 1)
      result += tostring(ind[i]) + ")";
 
    E* element = (const_cast<V*>(ptr)->*get)(ind[i]);
#ifdef _DEBUG
    std::cerr << "VectorOfProxy[" << prefix << "]::get_value (" 
              << ptr << ") element=" << element << std::endl;
#endif
    result += this->value->get_value (element);
  }
 
  return result;
}
 
template<class V, class E, class G, class S>
void TextInterface::VectorOfProxy<V,E,G,S>::set_value (V* ptr,
                                                       const std::string& val)
{
  std::vector<unsigned> ind;
  parse_indeces (ind, range, (ptr->*size)());
 
  for (unsigned i=0; i<ind.size(); i++) {
    E* element = (ptr->*get)(ind[i]);
#ifdef _DEBUG
    std::cerr << "VectorOfProxy[" << prefix << "]::set_value (" 
              << ptr << "," << val << ")" << std::endl;
#endif
    this->value->set_value (element, val);
  }
}
 
 
template<class C,class M,class Get,class Size>
 bool TextInterface::VectorOfProxy<C,M,Get,Size>::matches
  (const std::string& name) const
{
#ifdef _DEBUG
  std::cerr << "TextInterface::VectorOfProxy::matches" << std::endl;
#endif
 
  std::string remainder;
  if (!match (prefix, name, &range, &remainder))
    return false;
 
  return this->value->matches (remainder);
}
 
 
 
template<class M, class K, class E, class G> 
std::string
TextInterface::MapOfProxy<M,K,E,G>::get_value (const M* ptr) const
{
  std::vector<K> ind;
  get_indeces (ind, range);
  std::string result;
 
  if (!this->parent)
    throw Error (InvalidState, "MapOfProxy["+prefix+"]", "no parent");
 
  for (unsigned i=0; i<ind.size(); i++)
  {
    // place a delimiter between elements
    if (i)
      result += this->parent->get_delimiter();
 
    // label the elements
    if (label_elements && ind.size() > 1)
      result += tostring(ind[i]) + ")";
 
    E* element = (const_cast<M*>(ptr)->*get) (ind[i]);
    if (element)
      result += this->value->get_value (element);
  }
 
  return result;
}
 
template<class M, class K, class E, class G>
void TextInterface::MapOfProxy<M,K,E,G>::set_value (M* ptr,
                                                    const std::string& val)
{
  std::vector<K> ind;
  get_indeces (ind, range);
 
  for (unsigned i=0; i<ind.size(); i++)
    this->value->set_value ((ptr->*get)(ind[i]), val);
}
 
template<class M, class K, class E, class G>
void
TextInterface::MapOfProxy<M,K,E,G>::get_indeces (std::vector<K>& indeces,
                                                 const std::string& par) const
{
#ifdef _DEBUG
  std::cerr << "MapOfProxy::get_indeces " << par << std::endl;
#endif
 
  std::string::size_type length = par.length();
 
  std::string range = par;
 
  if (prefix.length()) {
    if (par[0] != '[' || par[length-1] != ']')
      return;
    range = par.substr (1, length-2);
  }
  else if (par == "?")
    return;
 
  std::vector<std::string> key_str;
  separate (range, key_str, ", ");
 
  indeces.resize (key_str.size());
  for (unsigned i=0; i<key_str.size(); i++)
    indeces[i] = fromstring<K>(key_str[i]);
}
 
template<class M, class K, class E, class G>
 bool TextInterface::MapOfProxy<M,K,E,G>::matches
  (const std::string& name) const
{
#ifdef _DEBUG
  std::cerr << "TextInterface::MapOfProxy::matches" << std::endl;
#endif
 
  std::string remainder;
  if (!match (prefix, name, &range, &remainder))
    return false;
 
  return this->value->matches (remainder);
}
 
#endif