# -*- Pyrex -*-
#
# ======================================================================
#
#                           Brad T. Aagaard
#                        U.S. Geological Survey
#
# {LicenseText}
#
# ======================================================================
#

#header{
#include "pylith/meshio/MeshIO.hh"
#include "pylith/meshio/MeshIOAscii.hh"
#include "pylith/meshio/MeshIOLagrit.hh"
#include "pylith/meshio/SolutionIO.hh"
#include "pylith/meshio/SolutionIOVTK.hh"

#if defined(ENABLE_CUBIT)
#include "pylith/meshio/MeshIOCubit.hh"
#endif

#include <stdexcept>
#include <assert.h>
#include <Python.h>
#}header

# ----------------------------------------------------------------------
cdef extern from "Python.h":
  object PyCObject_FromVoidPtr(void*, void (*destruct)(void*))
  void* PyCObject_AsVoidPtr(object)

cdef void* ptrFromHandle(obj):
  """Extract pointer from PyCObject."""
  return PyCObject_AsVoidPtr(obj.handle)

cdef extern from "stdlib.h":
  ctypedef unsigned long size_t
  void* malloc(size_t size)
  void free(void* mem)

cdef void MeshIO_destructor(void* obj):
  """
  Destroy MeshIO object.
  """
  # create shim for destructor
  #embed{ void MeshIO_destructor_cpp(void* pObj)
  pylith::meshio::MeshIO* io = (pylith::meshio::MeshIO*) pObj;
  delete io;
  #}embed
  MeshIO_destructor_cpp(obj)
  return

cdef void SolutionIO_destructor(void* obj):
  """
  Destroy SolutionIO object.
  """
  # create shim for destructor
  #embed{ void SolutionIO_destructor_cpp(void* pObj)
  pylith::meshio::SolutionIO* io = (pylith::meshio::SolutionIO*) pObj;
  delete io;
  #}embed
  SolutionIO_destructor_cpp(obj)
  return

# ----------------------------------------------------------------------
cdef class MeshIO:

  cdef void* thisptr # Pointer to C++ object
  cdef readonly object handle # PyCObject holding pointer to C++ object
  cdef readonly object name # Identifier for object base type

  def __init__(self):
    """
    Constructor.
    """
    self.handle = None
    self.thisptr = NULL
    self.name = "pylith_meshio_MeshIO"
    return


  def read(self, mesh):
    """
    Read mesh from file.
    """
    # create shim for method 'read'
    #embed{ void MeshIO_read(void* objVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != meshVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::meshio::MeshIO*) objVptr)->read(mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if mesh.name != "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    MeshIO_read(self.thisptr, ptrFromHandle(mesh))
    return


  def write(self, mesh):
    """
    Read write to file.
    """
    # create shim for method 'write'
    #embed{ void MeshIO_write(void* objVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::meshio::MeshIO*) objVptr)->write(mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if not mesh.name == "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    MeshIO_write(self.thisptr, ptrFromHandle(mesh))
    return


  def _createHandle(self):
    """Wrap pointer to C++ object in PyCObject."""
    return PyCObject_FromVoidPtr(self.thisptr, MeshIO_destructor)


  property interpolate:
    def __set__(self, flag):
      """Set interpolate."""
      # create shim for method 'interpolate'
      #embed{ void MeshIO_interpolate_set(void* objVptr, int flag)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIO*) objVptr)->interpolate(flag);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIO_interpolate_set(self.thisptr, flag)

    def __get__(self):
      """Get interpolate."""
      # create shim for method 'interpolate'
      #embed{ int MeshIO_interpolate_get(void* objVptr)
      int result = 0;
      try {
        assert(0 != objVptr);
        result = ((pylith::meshio::MeshIO*) objVptr)->interpolate();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIO_interpolate_get(self.thisptr)


  property debug:
    def __set__(self, flag):
      """Set debug."""
      # create shim for method 'debug'
      #embed{ void MeshIO_debug_set(void* objVptr, int flag)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIO*) objVptr)->debug(flag);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIO_debug_set(self.thisptr, flag)

    def __get__(self):
      """Get debug."""
      # create shim for method 'debug'
      #embed{ int MeshIO_debug_get(void* objVptr)
      int result = 0;
      try {
        assert(0 != objVptr);
        result = ((pylith::meshio::MeshIO*) objVptr)->debug();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIO_debug_get(self.thisptr)


# ----------------------------------------------------------------------
cdef class MeshIOAscii(MeshIO):

  def __init__(self):
    """Constructor."""
    # create shim for constructor
    #embed{ void* MeshIOAscii_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::meshio::MeshIOAscii);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    MeshIO.__init__(self)
    self.thisptr = MeshIOAscii_constructor()
    self.handle = self._createHandle()
    return


  property filename:
    def __set__(self, name):
      """Set filename."""
      # create shim for method 'filename'
      #embed{ void MeshIOAscii_filename_set(void* objVptr, char* name)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIOAscii*) objVptr)->filename(name);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIOAscii_filename_set(self.thisptr, name)

    def __get__(self):
      """Get filename."""
      # create shim for method 'filename'
      #embed{ char* MeshIOAscii_filename_get(void* objVptr)
      char* result = 0;
      try {
        assert(0 != objVptr);
        result = (char*) ((pylith::meshio::MeshIOAscii*) objVptr)->filename();
        assert(0 != result);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIOAscii_filename_get(self.thisptr)


# ----------------------------------------------------------------------
cdef class MeshIOCubit(MeshIO):

  def __init__(self):
    """Constructor."""
    # create shim for constructor
    #embed{ void* MeshIOCubit_constructor()
    #if defined(ENABLE_CUBIT)
    void* result = 0;
    try {
      result = (void*)(new pylith::meshio::MeshIOCubit);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #else
    throw std::logic_error("Not configured to use CUBIT.");
    return 0;
    #endif
    #}embed

    MeshIO.__init__(self)
    self.thisptr = MeshIOCubit_constructor()
    self.handle = self._createHandle()
    return


  property filename:
    def __set__(self, name):
      """Set filename."""
      # create shim for method 'filename'
      #embed{ void MeshIOCubit_filename_set(void* objVptr, char* name)
      #if defined(ENABLE_CUBIT)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIOCubit*) objVptr)->filename(name);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #else
      throw std::logic_error("Not configured to use CUBIT.");
      #endif
      #}embed
      MeshIOCubit_filename_set(self.thisptr, name)

    def __get__(self):
      """Get filename."""
      # create shim for method 'filename'
      #embed{ char* MeshIOCubit_filename_get(void* objVptr)
      #if defined(ENABLE_CUBIT)
      char* result = 0;
      try {
        assert(0 != objVptr);
        result = (char*) ((pylith::meshio::MeshIOCubit*) objVptr)->filename();
        assert(0 != result);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #else
      throw std::logic_error("Not configured to use CUBIT.");
      return 0;
      #endif
      #}embed
      return MeshIOCubit_filename_get(self.thisptr)

# ----------------------------------------------------------------------
cdef class MeshIOLagrit(MeshIO):

  def __init__(self):
    """Constructor."""
    # create shim for constructor
    #embed{ void* MeshIOLagrit_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::meshio::MeshIOLagrit);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    MeshIO.__init__(self)
    self.thisptr = MeshIOLagrit_constructor()
    self.handle = self._createHandle()
    return


  property filenameGmv:
    def __set__(self, name):
      """Set filename."""
      # create shim for method 'filenameGmv'
      #embed{ void MeshIOLagrit_filenameGmv_set(void* objVptr, char* name)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIOLagrit*) objVptr)->filenameGmv(name);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIOLagrit_filenameGmv_set(self.thisptr, name)

    def __get__(self):
      """Get filename."""
      # create shim for method 'filenameGmv'
      #embed{ char* MeshIOLagrit_filenameGmv_get(void* objVptr)
      char* result = 0;
      try {
        assert(0 != objVptr);
        result = (char*) ((pylith::meshio::MeshIOLagrit*) objVptr)->filenameGmv();
        assert(0 != result);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIOLagrit_filenameGmv_get(self.thisptr)


  property filenamePset:
    def __set__(self, name):
      """Set filename."""
      # create shim for method 'filenamePset'
      #embed{ void MeshIOLagrit_filenamePset_set(void* objVptr, char* name)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIOLagrit*) objVptr)->filenamePset(name);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIOLagrit_filenamePset_set(self.thisptr, name)

    def __get__(self):
      """Get filename."""
      # create shim for method 'filenamePset'
      #embed{ char* MeshIOLagrit_filenamePset_get(void* objVptr)
      char* result = 0;
      try {
        assert(0 != objVptr);
        result = (char*) ((pylith::meshio::MeshIOLagrit*) objVptr)->filenamePset();
        assert(0 != result);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIOLagrit_filenamePset_get(self.thisptr)


  property flipEndian:
    def __set__(self, flag):
      """Set flip endian flag."""
      # create shim for method 'flipEndian'
      #embed{ void MeshIOLagrit_flipEndian_set(void* objVptr, int flag)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::MeshIOLagrit*) objVptr)->flipEndian(flag);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      MeshIOLagrit_flipEndian_set(self.thisptr, flag)

    def __get__(self):
      """Get flip endian flag."""
      # create shim for method 'flipEndian'
      #embed{ int MeshIOLagrit_flipEndian_get(void* objVptr)
      int result = 0;
      try {
        assert(0 != objVptr);
        result = ((pylith::meshio::MeshIOLagrit*) objVptr)->flipEndian();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return MeshIOLagrit_flipEndian_get(self.thisptr)


# ----------------------------------------------------------------------
cdef class SolutionIO:

  cdef void* thisptr # Pointer to C++ object
  cdef readonly object handle # PyCObject holding pointer to C++ object
  cdef readonly object name # Identifier for object base type

  def __init__(self):
    """
    Constructor.
    """
    self.handle = None
    self.thisptr = NULL
    self.name = "pylith_meshio_SolutionIO"
    return


  def open(self, mesh):
    """
    Open solution files.
    """
    # create shim for method 'open'
    #embed{ void SolutionIO_open(void* objVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != meshVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::meshio::SolutionIO*) objVptr)->open(*mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if mesh.name != "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    SolutionIO_open(self.thisptr, ptrFromHandle(mesh))
    return


  def close(self):
    """
    Close solution files.
    """
    # create shim for method 'close'
    #embed{ void SolutionIO_close(void* objVptr)
    try {
      assert(0 != objVptr);
      ((pylith::meshio::SolutionIO*) objVptr)->close();
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    SolutionIO_close(self.thisptr)
    return


  def writeTopology(self, mesh, cs):
    """
    Write solution topology to file.
    """
    # create shim for method 'writeTopology'
    #embed{ void SolutionIO_writeTopology(void* objVptr, void* meshVptr, void* csVptr)
    try {
      assert(0 != objVptr);
      assert(0 != meshVptr);
      assert(0 != csVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      spatialdata::geocoords::CoordSys* cs =
        (spatialdata::geocoords::CoordSys*) csVptr;
      ((pylith::meshio::SolutionIO*) objVptr)->writeTopology(*mesh, cs);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if not mesh.name == "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    if not cs.name == "spatialdata_geocoords_CoordSys":
      raise TypeError, \
            "Argument must be extension module type 'CoordSys'."
    SolutionIO_writeTopology(self.thisptr, ptrFromHandle(mesh), ptrFromHandle(cs))
    return


  def writeField(self, t, field, name, mesh):
    """
    Write solution field to file.
    """
    # create shim for method 'writeField'
    #embed{ void SolutionIO_writeField(void* objVptr, double t, void* fieldVptr, char* name, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != fieldVptr);
      assert(0 != name);
      assert(0 != meshVptr);
      ALE::Obj<pylith::real_section_type>* field =
        (ALE::Obj<pylith::real_section_type>*) fieldVptr;
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::meshio::SolutionIO*) objVptr)->writeField(t, *field, name,
                                                          *mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if not mesh.name == "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    cdef void* fieldVptr
    fieldVptr = PyCObject_AsVoidPtr(field)
    SolutionIO_writeField(self.thisptr, t, fieldVptr, name, ptrFromHandle(mesh))
    return


  def _createHandle(self):
    """Wrap pointer to C++ object in PyCObject."""
    return PyCObject_FromVoidPtr(self.thisptr, SolutionIO_destructor)


  property coordsys:
    def __set__(self, cs):
      """Set coordinate system."""
      # create shim for method 'coordsys'
      #embed{ void SolutionIO_coordsys_set(void* objVptr, void* csVptr)
      try {
        assert(0 != objVptr);
        assert(0 != csVptr);
        spatialdata::geocoords::CoordSys* cs =
          (spatialdata::geocoords::CoordSys*) csVptr;
        ((pylith::meshio::SolutionIO*) objVptr)->coordsys(cs);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      SolutionIO_coordsys_set(self.thisptr, ptrFromHandle(cs))


# ----------------------------------------------------------------------
cdef class SolutionIOVTK(SolutionIO):

  def __init__(self):
    """Constructor."""
    # create shim for constructor
    #embed{ void* SolutionIOVTK_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::meshio::SolutionIOVTK);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    SolutionIO.__init__(self)
    self.thisptr = SolutionIOVTK_constructor()
    self.handle = self._createHandle()
    return


  property filename:
    def __set__(self, name):
      """Set filename."""
      # create shim for method 'filename'
      #embed{ void SolutionIOVTK_filename_set(void* objVptr, char* name)
      try {
        assert(0 != objVptr);
        ((pylith::meshio::SolutionIOVTK*) objVptr)->filename(name);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      SolutionIOVTK_filename_set(self.thisptr, name)

    def __get__(self):
      """Get filename."""
      # create shim for method 'filename'
      #embed{ char* SolutionIOVTK_filename_get(void* objVptr)
      char* result = 0;
      try {
        assert(0 != objVptr);
        result = (char*) ((pylith::meshio::SolutionIOVTK*) objVptr)->filename();
        assert(0 != result);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return SolutionIOVTK_filename_get(self.thisptr)


# End of file