pythonreader.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */

#ifndef SOMAIO_READER_PYTHONREADER_H
#define SOMAIO_READER_PYTHONREADER_H
//--- soma-io ----------------------------------------------------------------
#include <soma-io/config/soma_config.h>
//--- cartobase --------------------------------------------------------------
#include <cartobase/config/cartobase_config.h>
#include <cartobase/object/object.h>
#include <cartobase/object/syntax.h>
//--- system -----------------------------------------------------------------
#include <iostream>
//----------------------------------------------------------------------------

namespace soma
{
  class DataSource;

  class CARTOBASE_API PythonReader
  {
  public:
    typedef carto::GenericObject* (*Helper)( carto::GenericObject*, 
                                             const std::string &, 
                                             PythonReader & );
    typedef std::map<std::string, Helper> HelperSet;

    PythonReader( const std::string& filename ,
                  const carto::SyntaxSet& rules = carto::SyntaxSet(),
                  const HelperSet& helpers = HelperSet() );
    PythonReader( const carto::SyntaxSet& rules = carto::SyntaxSet(),
                  const HelperSet& helpers = HelperSet() );
    PythonReader( carto::rc_ptr<DataSource> ds, 
                  const carto::SyntaxSet& rules = carto::SyntaxSet(),
                  const HelperSet& helpers = HelperSet() );
    virtual ~PythonReader();

    virtual carto::GenericObject* read();
    virtual void read( carto::GenericObject & );
    virtual void read( carto::Object & );
    void readDictionary( carto::GenericObject & obj );
    void readDictionary2( carto::GenericObject & obj );
    void readIntDictionary2( carto::TypedObject<carto::IntDictionary> & obj );


    void open( const std::string& filename )
      __attribute__((__deprecated__("use attach() instead")));
    void close();
    void attach( std::istream & s, int line_num = 1 );
    void attach( carto::rc_ptr<DataSource> ds );
    void attach( const std::string& filename );
    carto::rc_ptr<DataSource> dataSource();
    virtual std::string name() const;
    int line() const;
    std::string lineString() const;
    bool operator!() const;
    bool is_open() const;
    bool eof() const;
    const HelperSet & helpers() const;
    HelperSet & helpers();
    const carto::SyntaxSet & syntaxes() const;
    carto::SyntaxSet & syntaxes();

    std::string readUntil(const std::string& s);
    void skipUntil(const std::string& s);
    std::string readWhile(const std::string& s);
    unsigned skipWhile(const std::string& s);
    carto::GenericObject* read( carto::GenericObject *parent, 
                                const std::string & semantic );
    std::string readVariableName();
    bool readSyntax( std::string & syntax );
    std::string readString( char separator, unsigned & charsread );

    static carto::GenericObject* dictHelper( carto::GenericObject *, 
                                             const std::string&, 
                                             PythonReader & r );

    static carto::GenericObject* propertySetHelper(carto::GenericObject *, 
                                                   const std::string&,
                                                   PythonReader & r );

    template<typename T>
    static carto::GenericObject* genericSequenceHelper( carto::GenericObject *, 
                                                        const std::string&,
                                                        PythonReader & r );

    template<typename T>
    static carto::GenericObject* genericDictHelper( carto::GenericObject *, 
                                                    const std::string&,
                                                    PythonReader & r );

  protected:
    void init( const HelperSet & helpers );

  private:
    struct Private;
    Private *d;
  };

}

namespace carto
{
  DECLARE_GENERIC_OBJECT_TYPE( soma::PythonReader::Helper )
  DECLARE_GENERIC_OBJECT_TYPE( soma::PythonReader::HelperSet )
}

#endif