PythonDictConverter Class Reference

Inheritance diagram for PythonDictConverter:

Public Types
using	key_t = std::string
using	any_t = std::any

Public Member Functions
	PythonDictConverter ()
PyObject *	result () const

Private Member Functions
void	enter_table (key_t const &key, any_t const &any)
void	enter_sequence (key_t const &key, any_t const &any)
void	atom (key_t const &key, any_t const &any)
void	exit_table (key_t const &key, any_t const &any)
void	exit_sequence (key_t const &key, any_t const &any)
void	add_object (key_t const &key, PyObject *pyobj)

Private Attributes
std::vector< PyObject * >	_stack

Detailed Description

Definition at line 115 of file fclmodule.cxx.

Member Typedef Documentation

using PythonDictConverter::any_t = std::any

Definition at line 120 of file fclmodule.cxx.

using PythonDictConverter::key_t = std::string

Definition at line 119 of file fclmodule.cxx.

Constructor & Destructor Documentation

PythonDictConverter::PythonDictConverter

(

)

Definition at line 151 of file fclmodule.cxx.

{
  // Initialize result stack with an empty python dictionary.
  // This dictionary will represent the parameter set.

  _stack.emplace_back(PyDict_New());
}

Member Function Documentation

void PythonDictConverter::add_object ( key_t const &  key, PyObject *  pyobj  )

private

Definition at line 335 of file fclmodule.cxx.

{
  // Get the current parent object.

  if(_stack.size() == 0)
    throw cet::exception("fclmodule") << "No parent object." << std::endl;
  PyObject* parent = _stack.back();

  if(PyDict_Check(parent)) {

    // Insert object into dicionary.

    PyObject* keyobj = cxx_str_to_python(key);
    PyDict_SetItem(parent, keyobj, pyobj);
    Py_DECREF(pyobj);
  }
  else if(PyList_Check(parent)) {

    // Append object to list.

    PyList_Append(parent, pyobj);
    Py_DECREF(pyobj);
  }
  else {

    // Oops.

    throw cet::exception("fclmodule") << "Parent object is not dictionary or list." << std::endl;
  }
}

void PythonDictConverter::atom ( key_t const &  key, any_t const &  any  )

private

Definition at line 226 of file fclmodule.cxx.

{
  PyObject* pyval = 0;

  // Extract atom as string.

  const std::string& atom = std::any_cast<const std::string&>(any);

  // Get lower case version of argument string.

  std::string lcatom(atom);
  std::transform(lcatom.begin(), lcatom.end(), lcatom.begin(),
                 [](unsigned char c){return std::tolower(c);});

  // Check for boolean.

  if(lcatom == std::string("true") || lcatom == std::string("\"true\"")) {
    pyval = Py_True;
    Py_INCREF(pyval);
  }
  else if(lcatom == std::string("false") || lcatom == std::string("\"false\"")) {
    pyval = Py_False;
    Py_INCREF(pyval);
  }

  // Check for quoted string.

  size_t n = atom.size();
  if(pyval == 0 && n >= 2 && atom[0] == '"' && atom[n-1] == '"') {
    std::string s = atom.substr(1, n-2);
    pyval = cxx_str_to_python(s);
  }  

  // Check for int.

  if(pyval == 0) {
    std::istringstream iss(atom);
    long i;
    iss >> std::noskipws >> i;
    if(iss.eof() and !iss.fail())
      pyval = PyLong_FromLong(i);
  }

  // Check for float.

 if(pyval == 0) {
    std::istringstream iss(atom);
    double x;
    iss >> std::noskipws >> x;
    if(iss.eof() and !iss.fail())
      pyval = PyFloat_FromDouble(x);
  }
  
  // Last resort store a copy of the original string (unquoted string).

  if(pyval == 0)
    pyval = cxx_str_to_python(atom);

  // Done converting atom to python.
  // Add python object to parent container.

  add_object(key, pyval);
}

void PythonDictConverter::enter_sequence ( key_t const &  key, any_t const &  any  )

private

Definition at line 205 of file fclmodule.cxx.

{
  // Make a new empty python list for this sequence.

  PyObject* seq = PyList_New(0);

  // Insert the list into the current parent container.

  add_object(key, seq);

  // Make the newly created python dictionary the current parent container.

  _stack.emplace_back(seq);
}

void PythonDictConverter::enter_table ( key_t const &  key, any_t const &  any  )

private

Definition at line 184 of file fclmodule.cxx.

{
  // Make a new empty python dictionary for this table.

  PyObject* dict = PyDict_New();

  // Insert this dictionary into the current parent container.

  add_object(key, dict);

  // Make the newly created python dictionary the current parent container.

  _stack.emplace_back(dict);
}

void PythonDictConverter::exit_sequence ( key_t const &  key, any_t const &  any  )

private

Definition at line 314 of file fclmodule.cxx.

{
  // Do consistency checks.

  if(_stack.size() < 2)
    throw cet::exception("fclmodule") << "Result stack has wrong size: "
                                      << _stack.size() << std::endl;
  if(!PyList_Check(_stack.back()))
    throw cet::exception("fclmodule") << "Result stack has wrong type." << std::endl;

  // Pop the current parent (this sequence) off the result stack.

  _stack.pop_back();
}

void PythonDictConverter::exit_table ( key_t const &  key, any_t const &  any  )

private

Definition at line 296 of file fclmodule.cxx.

{
  // Do consistency checks.

  if(_stack.size() < 2)
    throw cet::exception("fclmodule") << "Result stack has wrong size: "
                                      << _stack.size() << std::endl;
  if(!PyDict_Check(_stack.back()))
    throw cet::exception("fclmodule") << "Result stack has wrong type." << std::endl;

  // Pop the current parent (this table) off the result stack.

  _stack.pop_back();
}

PyObject * PythonDictConverter::result

(

)

const

Definition at line 162 of file fclmodule.cxx.

{
   // Do consistency checks.

  if(_stack.size() != 1)
    throw cet::exception("fclmodule") << "Result stack has wrong size: "
                                      << _stack.size() << std::endl;
  if(!PyDict_Check(_stack[0]))
    throw cet::exception("fclmodule") << "Result stack has wrong type." << std::endl;

  // Everything OK.

  return _stack[0];
}

Member Data Documentation

std::vector<PyObject*> PythonDictConverter::_stack

private

Definition at line 148 of file fclmodule.cxx.

---

The documentation for this class was generated from the following file:

• fclmodule.cxx