python_helpers.h

Go to the documentation of this file.

 
/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
#ifndef BIOPROCESSING_IO_PYTHON_HELPERS_H
#define BIOPROCESSING_IO_PYTHON_HELPERS_H
 
#include <string>
#include <vector>
 
#include <cartobase/object/property.h>
#include <cartobase/object/object.h>
#include <cartobase/object/pythonwriter.h>
#include <cartobase/object/pythonreader.h>
 
template <typename T >
carto::GenericObject* listHelper( carto::GenericObject* object, const std::string & semantic, soma::PythonReader & r )
{
  bool        end = false;
  std::string  id, type;
  soma::DataSource  & ds = *r.dataSource();
 
  if( !ds.isOpen() )
    return 0;
  r.skipWhile( " \t\n\\\r" );
  if( r.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  char    c = ds.getch(), mark;
  if( ds.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  if( c == '(' )
    mark = ')';
  else if( c == '[' )
    mark = ']';
  else
    {
      throw std::runtime_error( std::string( "PythonReader: Not a list/tuple: " )
                            + r.name() + ", line " + r.lineString() );
    }
 
  std::string synt = "", contsem = "";
  carto::GenericObject   *obj = new carto::ValueObject<T >;
 
  // Try to find syntaxed object for the type
  bool      genfallback = false;
  soma::PythonReader::HelperSet::const_iterator h = r.helpers().end();
  carto::SyntaxSet::const_iterator syntax = r.syntaxes().find( obj->type() );
  if( syntax == r.syntaxes().end() && !genfallback )
    {
      syntax = r.syntaxes().find( "__generic__" );
      genfallback = true;
    }
 
    if( syntax != r.syntaxes().end() )
      {
        synt = syntax->first; // update according to real syntax
        carto::Syntax::const_iterator property = syntax->second.find( "" );
        if( property == syntax->second.end() && !genfallback )
          {
            genfallback = true;
            carto::SyntaxSet::const_iterator syntax2 = r.syntaxes().find( "__generic__" );
            if( syntax2 != r.syntaxes().end() )
              {
                syntax = syntax2;
                property = syntax->second.find( "" );
              }
          }
        if( property == syntax->second.end() )
        {
          property = syntax->second.find( "__fallback__" );
        }
        if( property != syntax->second.end() )
          {
            contsem = property->second.type;
            h = r.helpers().find( contsem );
          }
      }
 
 
  try
    {
      do
        {
          r.skipWhile( " \t\n\\\r" );
          if( r.eof() )
            carto::io_error::launchErrnoExcept( ds.url() );
          c = ds.getch();
          if( ds.eof() )
            carto::io_error::launchErrnoExcept( ds.url() );
          if( c == ',' )  // separator
            {
              r.skipWhile( " \t\n\\\r" );
              if( r.eof() )
                carto::io_error::launchErrnoExcept( ds.url() );
              c = ds.getch();
              if( ds.eof() )
                carto::io_error::launchErrnoExcept( ds.url() );
            }
          if( c == mark )
            {
              end = true;
              break;  // end
            }
          ds.ungetch( c );
 
          carto::GenericObject* o1;
          if( h != r.helpers().end() )
          {
            // call the associated I/O function
            o1 = (h->second)( obj, contsem, r );
          }
          else
          {
            o1 = r.read( obj, contsem );
          }
 
          obj->GenericObject::value<T >().push_back( o1->GenericObject::value<typename T::value_type >() );
        }
      while( ds.isOpen() );
 
      return( obj );
    }
  catch( std::exception & e )
    {
      delete obj;
      throw;
    }
}
 
template <typename T>
carto::GenericObject* propertySetHelper(carto::GenericObject *, const std::string &,
                                        soma::PythonReader & r)
{
  std::string                synt;
  soma::DataSource    & ds = *r.dataSource();
  char      c;
 
  r.skipWhile( " \t\n\\\r" );
  if( r.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  c = ds.getch();
  if( ds.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  if ( c != '{' ) {
    std::cerr << "Attempt to read a dictionary not starting with '{'" << std::endl;
    return 0;
  }
  r.skipWhile( " \t\n\\\r" );
  if( r.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  c = ds.getch();
  if( ds.eof() )
    carto::io_error::launchErrnoExcept( ds.url() );
  if( c == 'u' )
  {
    c = ds.getch();
    if( ds.eof() )
      carto::io_error::launchErrnoExcept( ds.url() );
  }
 
  // expect attribute name
  switch( c )
    {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '.':
    case '-':
    case '+':
    case '\'':  // string identifier
    case '"': 
      {
        ds.ungetch( c );
        carto::GenericObject   *obj;
 
        obj = new carto::ValueObject<T>;
 
        try
          {
            r.readDictionary2( *obj );
          }
        catch( std::exception & e )
          {
            delete obj;
            throw;
          }
 
        return( obj );
      }
      break;
    case '}':
      return new carto::ValueObject<T>;
      break;
    }
  throw carto::parse_error( "unrecognized tag start", std::string() + c,
                            ds.url(), r.line() );
  return 0;
}
 
#endif