bindingObjects.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_BINDING_OBJECTS_HPP_INCLUDED
#define _STRUS_BINDING_OBJECTS_HPP_INCLUDED
#include <limits>
#include <string>
#include <vector>
#include <map>
#include <cstring>
#include <stdexcept>
#include <boost/shared_ptr.hpp>

#ifdef DOXYGEN_LANG
#include "swig.hpp"
// ... doxygen needs this for creating alternative interface descriptions for different languages
#if defined DOXYGEN_JAVA
namespace net {
namespace strus {
namespace api {
#elif defined DOXYGEN_PYTHON
namespace strus {
#endif
#elif (defined STRUS_BOOST_PYTHON)
typedef boost::python::api::object FunctionObject;
typedef boost::python::api::object DataBlob;
typedef boost::python::api::object StringObject;
typedef std::string String;
typedef std::wstring WString;
typedef std::vector<int> IndexVector;
typedef std::vector<double> FloatVector;
typedef std::vector<std::string> StringVector;
#else
#define String std::string
#define WString std::wstring
#define IndexVector std::vector<int>
#define StringVector std::vector<std::string>
#define FloatVector std::vector<double>
#if !defined DOXYGEN_PHP && !defined DOXYGEN_PYTHON
#define NormalizerVector std::vector<Normalizer>
#endif
#define TermVector std::vector<Term>
#define QueryTermVector std::vector<QueryTerm>
#define RankVector std::vector<Rank>
#define VecRankVector std::vector<VecRank>
#define SummaryElementVector std::vector<SummaryElement>
#define AttributeVector std::vector<Attribute>
#define MetaDataVector std::vector<MetaData>
#define DocumentFrequencyChangeVector std::vector<DocumentFrequencyChange> 
#endif
typedef int Index;
typedef long GlobalCounter;

#ifndef DOXYGEN_LANG
class Reference
{
public:
#ifdef STRUS_BOOST_PYTHON
        Reference()
                :m_deleter(0){}
#endif
        typedef void (*Deleter)( void* obj);

        explicit Reference( Deleter deleter_)
                :m_ptr(),m_deleter(deleter_){}

        Reference( const Reference& o)
                :m_ptr(o.m_ptr),m_deleter(o.m_deleter){}

        ~Reference(){}

        void reset( void* obj_=0)
        {
                m_ptr.reset( obj_, m_deleter);
        }

        Reference& operator = (const Reference& o)
        {
                m_ptr = o.m_ptr;
                m_deleter = o.m_deleter;
                return *this;
        }

        const void* get() const                         {return m_ptr.get();}
        void* get()                                     {return m_ptr.get();}

private:
        boost::shared_ptr<void> m_ptr;
        void (*m_deleter)( void* obj);
};
#endif


#if defined DOXYGEN_PHP || defined DOXYGEN_PYTHON
#error DOXYGEN_PYTHON
class Tokenizer
{
};
#else
class Tokenizer
{
public:
        Tokenizer(){}
        Tokenizer( const Tokenizer& o)
                :m_name(o.m_name),m_arguments(o.m_arguments){}
        Tokenizer( const String& name_, const StringVector& arg_)
                :m_name(name_),m_arguments(arg_){}
        Tokenizer( const String& name_, const String& arg_)
                :m_name(name_)
        {
                m_arguments.push_back( arg_);
        }
        Tokenizer( const String& name_, const String& arg1_, const String& arg2_)
                :m_name(name_),m_arguments()
        {
                m_arguments.push_back( arg1_);
                m_arguments.push_back( arg2_);
        }
        Tokenizer( const String& name_)
                :m_name(name_),m_arguments(){}

        const String& name() const                              {return m_name;}
        const StringVector& arguments() const                   {return m_arguments;}

        void setName( const String& name_)                      {m_name = name_;}
        void addArgument( const String& arg_)                   {m_arguments.push_back( arg_);}
        void addArgumentInt( long arg_);
        void addArgumentFloat( double arg_);

private:
        std::string m_name;
        std::vector<std::string> m_arguments;
};
#endif


#if defined DOXYGEN_PHP || defined DOXYGEN_PYTHON
class Normalizer
{
};
#else
class Normalizer
{
public:
        Normalizer(){}
        Normalizer( const Normalizer& o)
                :m_name(o.m_name),m_arguments(o.m_arguments){}
        Normalizer( const String& name_, const StringVector& arg_)
                :m_name(name_),m_arguments(arg_){}
        Normalizer( const String& name_, const String& arg_)
                :m_name(name_)
        {
                m_arguments.push_back( arg_);
        }
        Normalizer( const String& name_, const String& arg1_, const String& arg2_)
                :m_name(name_),m_arguments()
        {
                m_arguments.push_back( arg1_);
                m_arguments.push_back( arg2_);
        }
        Normalizer( const String& name_)
                :m_name(name_),m_arguments(){}

        ~Normalizer(){}

        const String& name() const                      {return m_name;}
        const StringVector& arguments() const           {return m_arguments;}

        void setName( const String& name_)              {m_name = name_;}
        void addArgument( const String& arg_)           {m_arguments.push_back( arg_);}
        void addArgumentInt( long arg_);
        void addArgumentFloat( double arg_);

private:
        friend class QueryAnalyzer;
        friend class DocumentAnalyzer;

        std::string m_name;
        std::vector<std::string> m_arguments;
};
#endif

#ifdef STRUS_BOOST_PYTHON
typedef std::vector<Normalizer> NormalizerVector;
#endif
#if defined DOXYGEN_PHP || defined DOXYGEN_PYTHON
class NormalizerVector
{
};
#endif

#if defined DOXYGEN_PHP || defined DOXYGEN_PYTHON
class Aggregator
{
};
#else
class Aggregator
{
public:
        Aggregator(){}
        Aggregator( const Aggregator& o)
                :m_name(o.m_name),m_arguments(o.m_arguments){}
        Aggregator( const String& name_, const StringVector& arg_)
                :m_name(name_),m_arguments(arg_){}
        Aggregator( const String& name_, const String& arg_)
                :m_name(name_)
        {
                m_arguments.push_back( arg_);
        }
        Aggregator( const String& name_, const String& arg1_, const String& arg2_)
                :m_name(name_),m_arguments()
        {
                m_arguments.push_back( arg1_);
                m_arguments.push_back( arg2_);
        }
        Aggregator( const String& name_)
                :m_name(name_),m_arguments(){}

        ~Aggregator(){}

        const String& name() const                      {return m_name;}
        const StringVector& arguments() const           {return m_arguments;}

        void setName( const String& name_)              {m_name = name_;}
        void addArgument( const String& arg_)           {m_arguments.push_back( arg_);}
        void addArgumentInt( long arg_);
        void addArgumentFloat( double arg_);

private:
        friend class DocumentAnalyzer;

        std::string m_name;
        std::vector<std::string> m_arguments;
};
#endif

#if defined DOXYGEN_LANG
class Variant
{
};
#else
enum VariantType
{
        Variant_UNDEFINED,
        Variant_UINT,
        Variant_INT,
        Variant_FLOAT,
        Variant_TEXT
};

union VariantValue
{
        unsigned int UINT;
        int INT;
        double FLOAT;
        const char* TEXT;
};

class Variant
{
public:
        Variant();
        Variant( const Variant& o);
        Variant( unsigned int v);
        Variant( int v);
        Variant( double v);
        Variant( const String& v);
        Variant( const char* v);

        bool defined() const                            {return m_type != Variant_UNDEFINED;}
        VariantType type() const                        {return m_type;}
        unsigned long getUInt() const;
        long getInt() const;
        double getFloat() const;
        const char* getText() const;

        void init();
        void assign( const Variant& o);
        void assignUint( unsigned long v);
        void assignInt( long v);
        void assignFloat( double v);
        void assignText( const String& v);

        Variant& operator=( const Variant& o)
        {
                assign( o);
                return *this;
        }

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const Variant& o) const
        {
                return isEqual( o);
        }
        bool operator!=( const Variant& o) const
        {
                return !isEqual( o);
        }
#endif
private:
        bool isEqual( const Variant& o) const;

private:
        friend class Storage;
        friend class Summarizer;
        friend class WeightingFunction;
        friend class QueryEval;
        friend class DocumentAnalyzer;
        VariantType m_type;
        VariantValue m_value;
        std::string m_buf;
};
#endif


class Term
{
public:
        Term( const String& type_, const String& value_, const Index& position_, const Index& length_)
                :m_type(type_),m_value(value_),m_position(position_),m_length(length_){}
        Term( const Term& o)
                :m_type(o.m_type),m_value(o.m_value),m_position(o.m_position),m_length(o.m_length){}
        Term()
                :m_position(0),m_length(0){}

        const String& type() const                      {return m_type;}
        const String& value() const                     {return m_value;}
#if defined STRUS_BOOST_PYTHON || defined DOXYGEN_PYTHON
        WString ucvalue() const;
#endif
        Index position() const                          {return m_position;}
        Index length() const                            {return m_length;}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const Term& o) const
        {
                return m_type == o.m_type && m_value == o.m_value && m_position == o.m_position && m_length == o.m_length;
        }
        bool operator!=( const Term& o) const
        {
                return m_type != o.m_type || m_value != o.m_value || m_position != o.m_position || m_length != o.m_length;
        }
#endif
#ifndef SWIG
        bool operator < (const Term& o) const;
#endif
private:
        std::string m_type;
        std::string m_value;
        Index m_position;
        Index m_length;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<Term> TermVector;
#endif


class MetaData
{
public:
        MetaData( const String& name_, const Variant& value_)
                :m_name(name_),m_value(value_){}
        MetaData( const MetaData& o)
                :m_name(o.m_name),m_value(o.m_value){}
        MetaData()
                :m_name(0),m_value(){}

        const String& name() const                      {return m_name;}
        double value() const                            {return m_value.getFloat();}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const MetaData& o) const
        {
                return (m_name == o.m_name && m_value == o.m_value);
        }
        bool operator!=( const MetaData& o) const
        {
                return (m_name != o.m_name || m_value != o.m_value);
        }
#endif
private:
        std::string m_name;
        Variant m_value;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<MetaData> MetaDataVector;
#endif


class Attribute
{
public:
        Attribute( const String& name_, const String& value_)
                :m_name(name_),m_value(value_){}
        Attribute( const Attribute& o)
                :m_name(o.m_name),m_value(o.m_value){}
        Attribute()
                :m_name(0){}

        const String& name() const              {return m_name;}
        const String& value() const             {return m_value;}

#if defined STRUS_BOOST_PYTHON || defined DOXYGEN_PYTHON
        WString ucvalue() const;
#endif
        
#ifdef STRUS_BOOST_PYTHON
        bool operator==( const Attribute& o) const
        {
                return m_name == o.m_name && m_value == o.m_value;
        }
        bool operator!=( const Attribute& o) const
        {
                return m_name != o.m_name || m_value != o.m_value;
        }
#endif
private:
        std::string m_name;
        std::string m_value;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<Attribute> AttributeVector;
#endif


class DocumentClass
{
public:
        DocumentClass(){}
        explicit DocumentClass(
                        const String& mimeType_)        :m_mimeType(mimeType_){}
        DocumentClass(
                        const String& mimeType_,
                        const String& encoding_)        :m_mimeType(mimeType_),m_encoding(encoding_){}
        DocumentClass(
                        const String& mimeType_,
                        const String& encoding_,
                        const String& scheme_)          :m_mimeType(mimeType_),m_scheme(scheme_),m_encoding(encoding_){}
        DocumentClass( const DocumentClass& o)          :m_mimeType(o.m_mimeType),m_scheme(o.m_scheme),m_encoding(o.m_encoding){}

        bool valid() const                              {return !m_mimeType.empty();}

        void setMimeType( const String& mimeType_)      {m_mimeType = mimeType_;}
        void setScheme( const String& scheme_)          {m_scheme = scheme_;}
        void setEncoding( const String& encoding_)      {m_encoding = encoding_;}

        const String& mimeType() const                  {return m_mimeType;}
        const String& scheme() const                    {return m_scheme;}
        const String& encoding() const                  {return m_encoding;}

private:
        std::string m_mimeType;
        std::string m_scheme;
        std::string m_encoding;
};


class Document
{
public:
        Document(){}
        Document( const Document& o);

        void addSearchIndexTerm( const String& type, const String& value, const Index& position);
        void addForwardIndexTerm( const String& type, const String& value, const Index& position);
#ifndef DOXYGEN_JAVA
        void setMetaData( const String& name, const Variant& value);
#endif
#ifdef STRUS_BOOST_PYTHON
        void setMetaData_double( const String& name, double value)
        {
                setMetaData( name, value);
        }
        void setMetaData_int( const String& name, int value)
        {
                setMetaData( name, value);
        }
        void setMetaData_uint( const String& name, unsigned int value)
        {
                setMetaData( name, value);
        }
#endif
        void setMetaData( const String& name, double value);
        void setMetaData( const String& name, int value);
        void setMetaData( const String& name, unsigned int value);
        void setAttribute( const String& name, const String& value);
#ifdef STRUS_BOOST_PYTHON
        void setAttribute_obj( const String& name, const StringObject& value);
#endif
        void setUserAccessRight( const String& username);
        void setDocid( const String& docid_);

        const TermVector& searchIndexTerms() const              {return m_searchIndexTerms;}
        const TermVector& forwardIndexTerms() const             {return m_forwardIndexTerms;}
        const MetaDataVector& metaData() const                  {return m_metaData;}
        const AttributeVector& attributes() const               {return m_attributes;}
        const StringVector& users() const                       {return m_users;}
        const String& docid() const                             {return m_docid;}

private:
        std::vector<Term> m_searchIndexTerms;
        std::vector<Term> m_forwardIndexTerms;
        std::vector<MetaData> m_metaData;
        std::vector<Attribute> m_attributes;
        std::vector<std::string> m_users;
        std::string m_docid;
};


class DocumentAnalyzeQueue;
class PatternMatcher;

class DocumentAnalyzer
{
public:
#ifdef STRUS_BOOST_PYTHON
        DocumentAnalyzer()
                :m_textproc(0){}
#endif
        DocumentAnalyzer( const DocumentAnalyzer& o);
        ~DocumentAnalyzer(){}

#if defined SWIGPHP
        // ... SWIG PHP implementation cannot handle signatures with typemaps and default parameters (!)
        void addSearchIndexFeature(
                const String& type,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers,
                const String& options);
#else
        void addSearchIndexFeature(
                const String& type,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers,
                const String& options=String());
#endif
#ifdef STRUS_BOOST_PYTHON
        void addSearchIndexFeature_4(
                const String& type,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_);

        void addSearchIndexFeature_5(
                const String& type,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_,
                const String& options);
#endif

#if defined SWIGPHP
        // ... SWIG PHP implementation cannot handle signatures with typemaps and default parameters (!)
        void addForwardIndexFeature(
                const String& type,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers,
                const String& options);
#else
        void addForwardIndexFeature(
                const String& type,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers,
                const String& options=String());
#endif
#ifdef STRUS_BOOST_PYTHON
        void addForwardIndexFeature_4(
                const String& type,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_);

        void addForwardIndexFeature_5(
                const String& type,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_,
                const String& options);
#endif

        void defineMetaData(
                const String& fieldname,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers);

#ifdef STRUS_BOOST_PYTHON
        void defineMetaData_obj(
                const String& fieldname,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_);
#endif

        void defineAggregatedMetaData(
                const String& fieldname,
                const Aggregator& function);

#ifdef STRUS_BOOST_PYTHON
        void defineAggregatedMetaData_obj(
                const String& fieldname,
                const FunctionObject& function_);
#endif

        void defineAttribute(
                const String& attribname,
                const String& selectexpr,
                const Tokenizer& tokenizer,
                const NormalizerVector& normalizers);

#ifdef STRUS_BOOST_PYTHON
        void defineAttribute_obj(
                const String& fieldname,
                const String& selectexpr,
                const FunctionObject& tokenizer_,
                const FunctionObject& normalizers_);
#endif
#if defined SWIGPHP
        // ... SWIG PHP implementation cannot handle signatures with typemaps and default parameters (!)
        void addSearchIndexFeatureFromPatternMatch(
                const String& type,
                const String& patternTypeName,
                const NormalizerVector& normalizers,
                const String& options);
#else
        void addSearchIndexFeatureFromPatternMatch(
                const String& type,
                const String& patternTypeName,
                const NormalizerVector& normalizers,
                const String& options=String());
#endif
#ifdef STRUS_BOOST_PYTHON
        void addSearchIndexFeatureFromPatternMatch_3(
                const String& type,
                const String& patternTypeName,
                const FunctionObject& normalizers_);

        void addSearchIndexFeatureFromPatternMatch_4(
                const String& type,
                const String& patternTypeName,
                const FunctionObject& normalizers_,
                const String& options);
#endif
#if defined SWIGPHP
        // ... SWIG PHP implementation cannot handle signatures with typemaps and default parameters (!)
        void addForwardIndexFeatureFromPatternMatch(
                const String& type,
                const String& patternTypeName,
                const NormalizerVector& normalizers,
                const String& options);
#else
        void addForwardIndexFeatureFromPatternMatch(
                const String& type,
                const String& patternTypeName,
                const NormalizerVector& normalizers,
                const String& options=String());
#endif
#ifdef STRUS_BOOST_PYTHON
        void addForwardIndexFeatureFromPatternMatch_3(
                const String& type,
                const String& patternTypeName,
                const FunctionObject& normalizers_);

        void addForwardIndexFeatureFromPatternMatch_4(
                const String& type,
                const String& patternTypeName,
                const FunctionObject& normalizers_,
                const String& options);
#endif
        void defineMetaDataFromPatternMatch(
                const String& fieldname,
                const String& patternTypeName,
                const NormalizerVector& normalizers);

#ifdef STRUS_BOOST_PYTHON
        void defineMetaDataFromPatternMatch_obj(
                const String& fieldname,
                const String& patternTypeName,
                const FunctionObject& normalizers_);
#endif
        void defineAttributeFromPatternMatch(
                const String& attribname,
                const String& patternTypeName,
                const NormalizerVector& normalizers);

#ifdef STRUS_BOOST_PYTHON
        void defineAttributeFromPatternMatch_obj(
                const String& fieldname,
                const String& patternTypeName,
                const FunctionObject& normalizers_);
#endif

        void definePatternMatcherPostProc(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const PatternMatcher& patterns);

        void definePatternMatcherPostProcFromFile(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const String& serializedPatternFile);

#ifdef STRUS_BOOST_PYTHON
        void definePatternMatcherPostProc_expr(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const FunctionObject& expr_);

        void definePatternMatcherPostProcFromFile_obj(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const StringObject& serializedPatternFile);
#endif

        void defineDocument(
                const String& subDocumentTypeName,
                const String& selectexpr);

        Document analyze( const String& content);

        Document analyze( const String& content, const DocumentClass& dclass);

#ifdef STRUS_BOOST_PYTHON
        Document analyze_obj_1( const StringObject& content);
        Document analyze_obj_2( const StringObject& content, const DocumentClass& dclass);
#endif

        DocumentAnalyzeQueue createQueue() const;

private:
        friend class Context;
        DocumentAnalyzer( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd, const String& segmentername, const void* textproc_);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_analyzer_impl;
        const void* m_textproc;
};


class DocumentAnalyzeQueue
{
public:
#ifdef STRUS_BOOST_PYTHON
        DocumentAnalyzeQueue()
                :m_result_queue_idx(0),m_analyzerctx_queue_idx(0),m_textproc(0){}
#endif
        DocumentAnalyzeQueue( const DocumentAnalyzeQueue& o);
        ~DocumentAnalyzeQueue(){}

        void push( const String& content);
        void push( const String& content, const DocumentClass& dclass);

#ifdef STRUS_BOOST_PYTHON
        void push_obj_1( const StringObject& content);
        void push_obj_2( const StringObject& content, const DocumentClass& dclass);
#endif
        bool hasMore() const;

        Document fetch();

private:
        void analyzeNext();

private:
        friend class DocumentAnalyzer;
        explicit DocumentAnalyzeQueue( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd, const Reference& analyzer, const void* textproc_);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_analyzer_impl;
        std::vector<Document> m_result_queue;
        std::size_t m_result_queue_idx;
        std::vector<Reference> m_analyzerctx_queue;
        std::size_t m_analyzerctx_queue_idx;
        const void* m_textproc;
};


class QueryAnalyzeContext;

class PatternMatcher
{
public:
        PatternMatcher( const PatternMatcher& o)
                :m_ops(o.m_ops),m_strings(o.m_strings),m_size(o.m_size){}
        PatternMatcher()
                :m_size(0){}

        void pushTerm( const String& type_, const String& value_);

#ifdef STRUS_BOOST_PYTHON
        void pushTerm_obj( const String& type_, const StringObject& value_);
#endif

        void pushPattern( const String& name_);

#ifdef STRUS_BOOST_PYTHON
        void pushPattern_obj( const StringObject& name_);
#endif

        void pushExpression( const String& opname_, unsigned int argc_, int range_=0, unsigned int cardinality_=0);

#ifdef STRUS_BOOST_PYTHON
        void pushExpression_2( const String& opname_, unsigned int argc)
        {
                pushExpression( opname_, argc, 0, 0);
        }
        void pushExpression_3( const String& opname_, unsigned int argc, int range_)
        {
                pushExpression( opname_, argc, range_, 0);
        }
        void pushExpression_4( const String& opname_, unsigned int argc, int range_, unsigned int cardinality_)
        {
                pushExpression( opname_, argc, range_, cardinality_);
        }
#endif
        void definePattern( const String& name_, bool visible);
#ifdef STRUS_BOOST_PYTHON
        void definePattern_obj( const StringObject& name_, bool visible);
#endif

        void attachVariable( const String& name_);

#ifdef STRUS_BOOST_PYTHON
        void attachVariable_obj( const StringObject& name_);
#endif

        void add( const PatternMatcher& o);

        std::size_t size() const
        {
                return m_size;
        }

private:
        friend class Query;

        struct StackOp
        {
                enum Type
                {
                        PushTerm,
                        PushPattern,
                        PushExpression,
                        DefinePattern,
                        AttachVariable
                };
                enum ArgIndex
                {
                        Term_type=0x0,
                        Term_value=0x1,
                        Expression_opname=0x0,
                        Expression_argc=0x1,
                        Expression_range=0x2,
                        Expression_cardinality=0x3,
                        Variable_name=0x0,
                        Pattern_name=0x0,
                        Pattern_visible=0x1
                };
                Type type;
                int arg[4];

                StackOp( Type type_, int arg0_, int arg1_=0, int arg2_=0, int arg3_=0)
                        :type(type_)
                {
                        arg[0] = arg0_;
                        arg[1] = arg1_;
                        arg[2] = arg2_;
                        arg[3] = arg3_;
                }

                StackOp()
                        :type(PushTerm)
                {
                        std::memset( arg, 0, sizeof(arg));
                }
                StackOp( const StackOp& o)
                {
                        std::memcpy( this, &o, sizeof(*this));
                }
        };
        const std::vector<StackOp>& ops() const
        {
                return m_ops;
        }
        const std::string& strings() const
        {
                return m_strings;
        }

private:
        std::size_t allocid( const String& str);
#ifdef STRUS_BOOST_PYTHON
        std::size_t allocid_obj( const StringObject& str);
#endif

private:
        friend class QueryAnalyzer;
        friend class DocumentAnalyzer;
        friend class PatternMatchLoader;
        std::vector<StackOp> m_ops;
        std::string m_strings;
        std::size_t m_size;
};


class QueryAnalyzer
{
public:
#ifdef STRUS_BOOST_PYTHON
        QueryAnalyzer(){}
#endif
        QueryAnalyzer( const QueryAnalyzer& o);
        ~QueryAnalyzer(){}

        void addSearchIndexElement(
                        const String& featureType,
                        const String& fieldType,
                        const Tokenizer& tokenizer,
                        const NormalizerVector& normalizers);
#ifdef STRUS_BOOST_PYTHON
        void addSearchIndexElement_obj(
                        const String& featureType,
                        const String& fieldType,
                        const FunctionObject& tokenizer_,
                        const FunctionObject& normalizers_);
#endif
        void addSearchIndexElementFromPatternMatch(
                        const std::string& type,
                        const std::string& patternTypeName,
                        const NormalizerVector& normalizers);

#ifdef STRUS_BOOST_PYTHON
        void addSearchIndexElementFromPatternMatch_obj(
                        const String& type,
                        const String& patternTypeName,
                        const FunctionObject& normalizers_);
#endif

        void addPatternLexem(
                        const std::string& termtype,
                        const std::string& fieldtype,
                        const Tokenizer& tokenizer,
                        const NormalizerVector& normalizers);
#ifdef STRUS_BOOST_PYTHON
        void addPatternLexem_obj(
                        const String& featureType,
                        const String& fieldType,
                        const FunctionObject& tokenizer_,
                        const FunctionObject& normalizers_);
#endif

        void definePatternMatcherPostProc(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const PatternMatcher& patterns);

        void definePatternMatcherPostProcFromFile(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const String& serializedPatternFile);

#ifdef STRUS_BOOST_PYTHON
        void definePatternMatcherPostProc_expr(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const FunctionObject& expr_);

        void definePatternMatcherPostProcFromFile_obj(
                        const String& patternTypeName,
                        const String& patternMatcherModule,
                        const StringObject& serializedPatternFile);
#endif

        TermVector analyzeField(
                        const String& fieldType,
                        const String& fieldContent);

#ifdef STRUS_BOOST_PYTHON
        TermVector analyzeField_obj(
                        const String& fieldType,
                        const StringObject& fieldContent);
#endif

        QueryAnalyzeContext createContext() const;

private:
        friend class Context;
        QueryAnalyzer( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_analyzer_impl;
};


class QueryTerm :public Term
{
public:
        QueryTerm( const Index& field_, const String& type_, const String& value_, const Index& position_, const Index& length_)
                :Term(type_,value_,position_, length_),m_field(field_){}
        QueryTerm( const QueryTerm& o)
                :Term(o),m_field(o.m_field){}
        QueryTerm()
                :Term(),m_field(0){}

        unsigned int field() const                      {return m_field;}
        const String& type() const                      {return Term::type();}
        const String& value() const                     {return Term::value();}
#if defined STRUS_BOOST_PYTHON || defined DOXYGEN_PYTHON
        WString ucvalue() const                         {return Term::ucvalue();}
#endif
        Index position() const                          {return Term::position();}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const QueryTerm& o) const      {return Term::operator==( o);}
        bool operator!=( const QueryTerm& o) const      {return Term::operator!=( o);}
#endif

private:
        Index m_field;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<QueryTerm> QueryTermVector;
#endif


class QueryAnalyzeContext
{
public:
#ifdef STRUS_BOOST_PYTHON
        QueryAnalyzeContext(){}
#endif
        QueryAnalyzeContext( const QueryAnalyzeContext& o);
        ~QueryAnalyzeContext(){}

        void putField(
                        unsigned int fieldNo, 
                        const String& fieldType,
                        const String& fieldContent);
#ifdef STRUS_BOOST_PYTHON
        void putField_obj( unsigned int fieldNo, const String& fieldType, const StringObject& fieldContent);
#endif

        QueryTermVector analyze();

private:
        friend class QueryAnalyzer;
        explicit QueryAnalyzeContext( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd, const Reference& analyzer);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_analyzer_impl;
        Reference m_analyzer_ctx_impl;
};

class StatisticsIterator;
class StorageTransaction;
class DocumentBrowser;

class StorageClient
{
public:
#ifdef STRUS_BOOST_PYTHON
        StorageClient(){}
#endif
        StorageClient( const StorageClient& o);

        ~StorageClient(){}

        Index nofDocumentsInserted() const;

        StorageTransaction createTransaction() const;

        StatisticsIterator createInitStatisticsIterator( bool sign) const;

        StatisticsIterator createUpdateStatisticsIterator() const;

        DocumentBrowser createDocumentBrowser();

        void close();

private:
        friend class Context;
        StorageClient( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd_, const String& config);

        friend class Query;
        friend class QueryEval;
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_storage_impl;
};


class StorageTransaction
{
public:
#ifdef STRUS_BOOST_PYTHON
        StorageTransaction(){}
#endif
        ~StorageTransaction(){}

        void insertDocument( const String& docid, const Document& doc);

        void deleteDocument( const String& docid);
#ifdef STRUS_BOOST_PYTHON
        void deleteDocument_obj( const StringObject& docid);
#endif

        void deleteUserAccessRights( const String& username);
#ifdef STRUS_BOOST_PYTHON
        void deleteUserAccessRights_obj( const StringObject& username);
#endif

        void commit();

        void rollback();

private:
        friend class StorageClient;
        StorageTransaction( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd_, const Reference& storage_);

        friend class Query;
        friend class QueryEval;
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_storage_impl;
        Reference m_transaction_impl;
};


class DocumentFrequencyChange
{
public:
        DocumentFrequencyChange( const String& type_, const String& value_, int increment_)
                :m_type(type_),m_value(value_),m_increment(increment_){}
        DocumentFrequencyChange( const DocumentFrequencyChange& o)
                :m_type(o.m_type),m_value(o.m_value),m_increment(o.m_increment){}
        DocumentFrequencyChange()
                :m_increment(0){}

        const String& type() const                      {return m_type;}
        const String& value() const                     {return m_value;}
#if defined STRUS_BOOST_PYTHON || defined DOXYGEN_PYTHON
        WString ucvalue() const;
#endif
        int increment() const                           {return m_increment;}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const DocumentFrequencyChange& o) const
        {
                return m_type == o.m_type && m_value == o.m_value && m_increment == o.m_increment;
        }
        bool operator!=( const DocumentFrequencyChange& o) const
        {
                return m_type != o.m_type || m_value != o.m_value || m_increment != o.m_increment;
        }
#endif

private:
        std::string m_type;
        std::string m_value;
        int m_increment;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<DocumentFrequencyChange> DocumentFrequencyChangeVector;
#endif


class StatisticsMessage
{
public:
#ifdef STRUS_BOOST_PYTHON
        StatisticsMessage(){}
#endif
        StatisticsMessage( const StatisticsMessage& o)
                :m_nofDocumentsInsertedChange(o.m_nofDocumentsInsertedChange)
                ,m_documentFrequencyChangeList(o.m_documentFrequencyChangeList){}

        StatisticsMessage( const std::vector<DocumentFrequencyChange>& dfchglist, int nofdocs)
                :m_nofDocumentsInsertedChange(nofdocs)
                ,m_documentFrequencyChangeList(dfchglist){}

        int nofDocumentsInsertedChange() const
        {
                return m_nofDocumentsInsertedChange;
        }

        const std::vector<DocumentFrequencyChange>& documentFrequencyChangeList() const
        {
                return m_documentFrequencyChangeList;
        }

private:
        int m_nofDocumentsInsertedChange;
        std::vector<DocumentFrequencyChange> m_documentFrequencyChangeList;
};


class StatisticsIterator
{
public:
#ifdef STRUS_BOOST_PYTHON
        StatisticsIterator(){}
#endif
        StatisticsIterator( const StatisticsIterator& o);

        String getNext();

private:
        friend class StorageClient;
        StatisticsIterator( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd_, const Reference& storage_, const Reference& iter_);

private:
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_storage_impl;
        Reference m_iter_impl;
};


class StatisticsProcessor
{
public:
#ifdef STRUS_BOOST_PYTHON
        StatisticsProcessor(){}
#endif
        StatisticsMessage decode( const String& blob) const;
#ifdef STRUS_BOOST_PYTHON
        StatisticsMessage decode_datablob( const DataBlob& blob) const;
#endif
        String encode( const StatisticsMessage& msg) const;

private:
        friend class Context;
        StatisticsProcessor( const Reference& objbuilder_, const Reference& trace_, const std::string& name_, const Reference& errorhnd_);

private:
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        const void* m_statsproc;
};


class VecRank
{
public:
        VecRank()
                :m_index(0),m_weight(0.0){}
        VecRank( Index index_, double weight_)
                :m_index(index_),m_weight(weight_){}
        VecRank( const VecRank& o)
                :m_index(o.m_index),m_weight(o.m_weight){}

        Index index() const                                     {return m_index;}
        double weight() const                                   {return m_weight;}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const VecRank& o) const
        {
                if (m_index != o.m_index) return false;
                double ww = (m_weight - o.m_weight);
                return (ww < 0.0)?(-ww < std::numeric_limits<double>::epsilon()):(ww < std::numeric_limits<double>::epsilon());
        }
        bool operator!=( const VecRank& o) const
        {
                return !operator==( o);
        }
#endif

private:
        Index m_index;
        double m_weight;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<VecRank> VecRankVector;
#endif

class VectorStorageSearcher
{
public:
#ifdef STRUS_BOOST_PYTHON
        VectorStorageSearcher(){}
#endif
        VectorStorageSearcher( const VectorStorageSearcher& o);

        ~VectorStorageSearcher(){}

        VecRankVector findSimilar( const FloatVector& vec, unsigned int maxNofResults) const;
#ifdef STRUS_BOOST_PYTHON
        VecRankVector findSimilar_obj( const FunctionObject& vec, unsigned int maxNofResults) const;
#endif

        VecRankVector findSimilarFromSelection( const IndexVector& featidxlist, const FloatVector& vec, unsigned int maxNofResults) const;
#ifdef STRUS_BOOST_PYTHON
        VecRankVector findSimilarFromSelection_obj( const FunctionObject& featidxlist, const FunctionObject& vec, unsigned int maxNofResults) const;
#endif

        void close();

private:
        friend class VectorStorageClient;
        VectorStorageSearcher( const Reference& storage, const Reference& trace, const Index& range_from, const Index& range_to, const Reference& errorhnd_);

        Reference m_errorhnd_impl;
        Reference m_searcher_impl;
        Reference m_trace_impl;
};

class VectorStorageTransaction;

class VectorStorageClient
{
public:
#ifdef STRUS_BOOST_PYTHON
        VectorStorageClient(){}
#endif
        VectorStorageClient( const VectorStorageClient& o);

        ~VectorStorageClient(){}

        VectorStorageSearcher createSearcher( const Index& range_from, const Index& range_to) const;

        VectorStorageTransaction createTransaction();
        
        StringVector conceptClassNames() const;

        IndexVector conceptFeatures( const String& conceptClass, const Index& conceptid) const;

        unsigned int nofConcepts( const String& conceptClass) const;

        IndexVector featureConcepts( const String& conceptClass, const Index& index) const;

        FloatVector featureVector( const Index& index) const;

        String featureName( const Index& index) const;

        Index featureIndex( const String& name) const;

        unsigned int nofFeatures() const;

        String config() const;

        void close();

private:
        friend class Context;
        VectorStorageClient( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd_, const String& config);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_vector_storage_impl;
        std::string m_config;
};

class VectorStorageTransaction
{
public:
#ifdef STRUS_BOOST_PYTHON
        VectorStorageTransaction(){}
#endif
        VectorStorageTransaction( const VectorStorageTransaction& o);

        ~VectorStorageTransaction(){}

        void addFeature( const String& name, const FloatVector& vec);
#ifdef STRUS_BOOST_PYTHON
        void addFeature_obj( const StringObject& name, const FunctionObject& vec);
#endif
        void defineFeatureConceptRelation( const String& relationTypeName, const Index& featidx, const Index& conidx);
#ifdef STRUS_BOOST_PYTHON
        void defineFeatureConceptRelation_obj( const StringObject& relationTypeName, const Index& featidx, const Index& conidx);
#endif

        bool commit();

        void rollback();

        void close();

private:
        friend class VectorStorageClient;
        VectorStorageTransaction( const Reference& objbuilder, const Reference& storage, const Reference& trace, const Reference& errorhnd_, const String& config);

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_vector_storage_impl;        
        Reference m_vector_transaction_impl;
};


class FunctionVariableConfig
{
public:
        FunctionVariableConfig(){}
        FunctionVariableConfig( const FunctionVariableConfig& o)
                :m_variables(o.m_variables){}

        void defineVariable( const String& name, double value)
        {
                m_variables[ name] = value;
        }

private:
        friend class Query;
        friend class QueryEval;
        std::map<std::string,double> m_variables;
};

class SummarizerConfig
{
public:
        SummarizerConfig(){}
        SummarizerConfig( const SummarizerConfig& o)
                :m_parameters(o.m_parameters),m_features(o.m_features){}

#ifndef DOXYGEN_JAVA
        void defineParameter( const String& name, const Variant& value)
        {
                m_parameters[ name] = value;
        }
#endif
        void defineParameter( const String& name, const char* value)
        {
                m_parameters[ name] = Variant(value);
        }

        void defineParameter( const String& name, int value)
        {
                m_parameters[ name] = value;
        }

        void defineParameter( const String& name, unsigned int value)
        {
                m_parameters[ name] = value;
        }

        void defineParameter( const String& name, double value)
        {
                m_parameters[ name] = value;
        }

        void defineFeature( const String& sumtype, const String& set)
        {
                m_features[ sumtype] = set;
        }

        void defineResultName( const String& origname, const String& newname)
        {
                m_resultnamemap[ origname] = newname;
        }

private:
        friend class QueryEval;
        std::map<std::string,Variant> m_parameters;
        std::map<std::string,std::string> m_features;
        std::map<std::string,std::string> m_resultnamemap;
};

class WeightingConfig
{
public:
        WeightingConfig(){}
        WeightingConfig( const WeightingConfig& o)
                :m_parameters(o.m_parameters){}

#ifndef DOXYGEN_JAVA
        void defineParameter( const String& name, const Variant& value)
        {
                m_parameters[ name] = value;
        }
#endif
        void defineParameter( const String& name, int value)
        {
                m_parameters[ name] = value;
        }

        void defineParameter( const String& name, unsigned int value)
        {
                m_parameters[ name] = value;
        }

        void defineParameter( const String& name, double value)
        {
                m_parameters[ name] = value;
        }

        void defineParameter( const String& name, const char* value)
        {
                m_parameters[ name] = Variant(value);
        }
#if !defined SWIGJAVA && !defined SWIGPHP
        void defineParameter( const String& name, const String& value)
        {
                m_parameters[ name] = Variant(value);
        }
#endif

        void defineFeature( const String& sumtype, const String& set)
        {
                m_features[ sumtype] = set;
        }

private:
        friend class QueryEval;
        std::map<std::string,Variant> m_parameters;
        std::map<std::string,std::string> m_features;
};

class Query;

class QueryEval
{
public:
#ifdef STRUS_BOOST_PYTHON
        QueryEval(){}
#endif
        QueryEval( const QueryEval& o);
        ~QueryEval(){}

        void addTerm(
                        const String& set_,
                        const String& type_,
                        const String& value_);

        void addSelectionFeature( const String& set_);

        void addRestrictionFeature( const String& set_);

        void addExclusionFeature( const String& set_);

        void addSummarizer(
                        const String& name,
                        const SummarizerConfig& config);

#ifdef STRUS_BOOST_PYTHON
        void addSummarizer_obj(
                        const String& name,
                        const FunctionObject& config_);
#endif

        void addWeightingFunction(
                        const String& name,
                        const WeightingConfig& config);

#ifdef STRUS_BOOST_PYTHON
        void addWeightingFunction_obj(
                        const String& name,
                        const FunctionObject& config_);
#endif
        void addWeightingFormula(
                        const String& source,
                        const FunctionVariableConfig& defaultParameter);
#ifdef STRUS_BOOST_PYTHON
        void addWeightingFormula_obj(
                        const StringObject& source,
                        const FunctionObject& defaultParameter_);
#endif

        Query createQuery( const StorageClient& storage) const;

private:
        friend class Context;
        QueryEval( const Reference& objbuilder, const Reference& trace, const Reference& errorhnd);

        friend class Query;
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_queryeval_impl;
        const void* m_queryproc;
};


class SummaryElement
{
public:
        SummaryElement()
                :m_weight(0.0),m_index(-1){}
        SummaryElement( const String& name_, const String& value_, double weight_, int index_)
                :m_name(name_),m_value(value_),m_weight(weight_),m_index(index_){}
        SummaryElement( const SummaryElement& o)
                :m_name(o.m_name),m_value(o.m_value),m_weight(o.m_weight),m_index(o.m_index){}

        const String& name() const              {return m_name;}
        const String& value() const             {return m_value;}
        double weight() const                   {return m_weight;}
        int index() const                       {return m_index;}

#if defined STRUS_BOOST_PYTHON || defined DOXYGEN_PYTHON
        WString ucvalue() const;

        bool operator==( const SummaryElement& o) const
        {
                if (m_name != o.m_name || m_value != o.m_value || m_index != o.m_index) return false;
                double ww = m_weight - o.m_weight;
                return (ww < 0.0)?(-ww<std::numeric_limits<double>::epsilon()):(ww<std::numeric_limits<double>::epsilon());
        }
        bool operator!=( const SummaryElement& o) const
        {
                return !operator==(o);
        }
#endif
private:
        friend class Query;
        std::string m_name;
        std::string m_value;
        double m_weight;
        int m_index;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<SummaryElement> SummaryElementVector;
#endif


class Rank
{
public:
        Rank()
                :m_docno(0),m_weight(0.0){}
        Rank( Index docno_, double weight_, const SummaryElementVector& summaryElements_)
                :m_docno(docno_),m_weight(weight_),m_summaryElements(summaryElements_){}
        Rank( const Rank& o)
                :m_docno(o.m_docno),m_weight(o.m_weight),m_summaryElements(o.m_summaryElements){}

        Index docno() const                                     {return m_docno;}
        double weight() const                                   {return m_weight;}

        const SummaryElementVector& summaryElements() const     {return m_summaryElements;}

#ifdef STRUS_BOOST_PYTHON
        bool operator==( const Rank& o) const
        {
                if (m_docno != o.m_docno) return false;
                double ww = (m_weight - o.m_weight);
                return (ww < 0.0)?(-ww < std::numeric_limits<double>::epsilon()):(ww < std::numeric_limits<double>::epsilon());
        }
        bool operator!=( const Rank& o) const
        {
                return !operator==( o);
        }
#endif

private:
        friend class Query;
        Index m_docno;
        double m_weight;
        std::vector<SummaryElement> m_summaryElements;
};
#ifdef STRUS_BOOST_PYTHON
typedef std::vector<Rank> RankVector;
#endif


class QueryExpression
{
public:
        QueryExpression( const QueryExpression& o)
                :m_ops(o.m_ops),m_strings(o.m_strings),m_size(o.m_size){}
        QueryExpression()
                :m_size(0){}

        void pushTerm( const String& type_, const String& value_, const Index& length_);

        void pushDocField( const String& metadata_start_, const String& metadata_end_);

#ifdef STRUS_BOOST_PYTHON
        void pushTerm_obj( const String& type_, const StringObject& value_, const Index& length_);
#endif
        void pushExpression( const String& opname_, unsigned int argc_, int range_=0, unsigned int cardinality_=0);

#ifdef STRUS_BOOST_PYTHON
        void pushExpression_2( const String& opname_, unsigned int argc)
        {
                pushExpression( opname_, argc, 0, 0);
        }
        void pushExpression_3( const String& opname_, unsigned int argc, int range_)
        {
                pushExpression( opname_, argc, range_, 0);
        }
        void pushExpression_4( const String& opname_, unsigned int argc, int range_, unsigned int cardinality_)
        {
                pushExpression( opname_, argc, range_, cardinality_);
        }
#endif

        void attachVariable( const String& name_);
#ifdef STRUS_BOOST_PYTHON
        void attachVariable_obj( const StringObject& name_);
#endif

        void add( const QueryExpression& o);

        std::size_t size() const
        {
                return m_size;
        }

private:
        friend class Query;

        struct StackOp
        {
                enum Type
                {
                        PushTerm,
                        PushDocField,
                        PushExpression,
                        AttachVariable
                };
                enum ArgIndex
                {
                        Term_type=0x0,
                        Term_value=0x1,
                        Term_length=0x2,
                        Term_metastart=0x0,
                        Term_metaend=0x1,
                        Expression_opname=0x0,
                        Expression_argc=0x1,
                        Expression_range=0x2,
                        Expression_cardinality=0x3,
                        Variable_name=0x0
                };
                Type type;
                int arg[4];

                StackOp( Type type_, int arg0_, int arg1_=0, int arg2_=0, int arg3_=0)
                        :type(type_)
                {
                        arg[0] = arg0_;
                        arg[1] = arg1_;
                        arg[2] = arg2_;
                        arg[3] = arg3_;
                }

                StackOp()
                        :type(PushTerm)
                {
                        std::memset( arg, 0, sizeof(arg));
                }
                StackOp( const StackOp& o)
                {
                        std::memcpy( this, &o, sizeof(*this));
                }
        };
        std::size_t allocid( const String& str);
#ifdef STRUS_BOOST_PYTHON
        std::size_t allocid_obj( const StringObject& str);
#endif

private:
        std::vector<StackOp> m_ops;
        std::string m_strings;
        std::size_t m_size;
};


class TermStatistics
{
public:
        TermStatistics()
                :m_df(-1){}
        TermStatistics( GlobalCounter df_)
                :m_df(df_){}
        TermStatistics( const TermStatistics& o)
                :m_df(o.m_df){}

        GlobalCounter df() const                {return m_df;}
        void set_df( GlobalCounter df_)         {m_df = df_;}

private:
        GlobalCounter m_df;             
};

struct GlobalStatistics
{
        GlobalStatistics()
                :m_nofDocumentsInserted(-1){}
        explicit GlobalStatistics( GlobalCounter nofDocumentsInserted_)
                :m_nofDocumentsInserted(nofDocumentsInserted_){}
        GlobalStatistics( const GlobalStatistics& o)
                :m_nofDocumentsInserted(o.m_nofDocumentsInserted){}

        GlobalCounter nofdocs() const                           {return m_nofDocumentsInserted;}
        void set_nofdocs( GlobalCounter nofdocs_)               {m_nofDocumentsInserted = nofdocs_;}

private:
        GlobalCounter m_nofDocumentsInserted;   
};

class QueryResult
{
public:
        QueryResult()
                :m_evaluationPass(0),m_nofDocumentsRanked(0),m_nofDocumentsVisited(0){}

        unsigned int evaluationPass() const                     {return m_evaluationPass;}
        unsigned int nofDocumentsRanked() const                 {return m_nofDocumentsRanked;}
        unsigned int nofDocumentsVisited() const                {return m_nofDocumentsVisited;}

        const RankVector& ranks() const                         {return m_ranks;}

private:
        friend class Query;
        QueryResult( unsigned int evaluationPass_, unsigned int nofDocumentsRanked_, unsigned int nofDocumentsVisited_)
                :m_evaluationPass(evaluationPass_),m_nofDocumentsRanked(nofDocumentsRanked_),m_nofDocumentsVisited(nofDocumentsVisited_){}

private:
        unsigned int m_evaluationPass;                  
        unsigned int m_nofDocumentsRanked;              
        unsigned int m_nofDocumentsVisited;             
        RankVector m_ranks;                             
};

class Query
{
public:
#ifdef STRUS_BOOST_PYTHON
        Query(){}
#endif
        Query( const Query& o);
        ~Query(){}

#if defined SWIGPHP
        // ... SWIG PHP implementation cannot handle signatures with typemaps and default parameters (!)
        void defineFeature( const String& set_, const QueryExpression& expr_, double weight_);
#else
        void defineFeature( const String& set_, const QueryExpression& expr_, double weight_=1.0);
#endif
#ifdef STRUS_BOOST_PYTHON
        void defineFeature_2( const String& set_, const QueryExpression& expr_)
        {
                defineFeature( set_, expr_, 1.0);
        }

        void defineFeature_3( const String& set_, const QueryExpression& expr_, double weight_)
        {
                defineFeature( set_, expr_, weight_);
        }

        void defineFeature_expr_2( const String& set_, const FunctionObject& expr_);
        void defineFeature_expr_3( const String& set_, const FunctionObject& expr_, double weight_);
#endif

        void defineDocFieldFeature( const String& set_, const String& metadataStart, const String& metadataEnd);

#ifndef DOXYGEN_JAVA
        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        const Variant& value, bool newGroup);
#endif
        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        double value, bool newGroup);

        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        unsigned int value, bool newGroup);

        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        int value, bool newGroup);

#ifdef STRUS_BOOST_PYTHON
        void addMetaDataRestrictionCondition_double(
                        const char* compareOp, const String& name,
                        double value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }

        void addMetaDataRestrictionCondition_uint(
                        const char* compareOp, const String& name,
                        unsigned int value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }

        void addMetaDataRestrictionCondition_int(
                        const char* compareOp, const String& name,
                        int value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }
#endif
        void defineTermStatistics( const String& type_, const String& value_, const TermStatistics& stats_);

        void defineGlobalStatistics( const GlobalStatistics& stats_);

#ifdef STRUS_BOOST_PYTHON
        void defineTermStatistics_obj_struct( const String& type_, const StringObject& value_, const FunctionObject& stats_);
        void defineGlobalStatistics_struct( const FunctionObject& stats_);
#endif

        void addDocumentEvaluationSet( const IndexVector& docnolist_);
#ifdef STRUS_BOOST_PYTHON
        void addDocumentEvaluationSet_struct( const FunctionObject& docnolist_);
#endif

        void setMaxNofRanks( unsigned int maxNofRanks_);

        void setMinRank( unsigned int minRank_);

        void addUserName( const String& username_);

#ifdef STRUS_BOOST_PYTHON
        void addUserName_obj( const StringObject& username_);
#endif
        void setWeightingVariables(
                        const FunctionVariableConfig& parameter);
#ifdef STRUS_BOOST_PYTHON
        void setWeightingVariables_obj(
                        const FunctionObject& parameter_);
#endif

        QueryResult evaluate() const;

        String tostring() const;

private:
        friend class QueryEval;
        Query( const Reference& objbuilder_impl_, const Reference& trace_impl_, const Reference& errorhnd_, const Reference& storage_impl_, const Reference& queryeval_impl_, const Reference& query_impl_, const void* queryproc_)
                :m_errorhnd_impl(errorhnd_),m_trace_impl(trace_impl_),m_objbuilder_impl(objbuilder_impl_),m_storage_impl(storage_impl_),m_queryeval_impl(queryeval_impl_),m_query_impl(query_impl_),m_queryproc(queryproc_)
        {}

        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_storage_impl;
        Reference m_queryeval_impl;
        Reference m_query_impl;
        const void* m_queryproc;
};

class DocumentBrowser
{
public:
#ifdef STRUS_BOOST_PYTHON
        DocumentBrowser(){}
#endif
        DocumentBrowser( const DocumentBrowser& o);
        ~DocumentBrowser(){}

#ifndef DOXYGEN_JAVA
        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        const Variant& value, bool newGroup);
#endif
        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        double value, bool newGroup);

        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        unsigned int value, bool newGroup);

        void addMetaDataRestrictionCondition(
                        const char* compareOp, const String& name,
                        int value, bool newGroup);

#ifdef STRUS_BOOST_PYTHON
        void addMetaDataRestrictionCondition_double(
                        const char* compareOp, const String& name,
                        double value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }

        void addMetaDataRestrictionCondition_uint(
                        const char* compareOp, const String& name,
                        unsigned int value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }

        void addMetaDataRestrictionCondition_int(
                        const char* compareOp, const String& name,
                        int value, bool newGroup)
        {
                addMetaDataRestrictionCondition( compareOp, name, value, newGroup);
        }
#endif
        Index skipDoc( const Index& docno_);

        String attribute( const String& name);

private:
        friend class StorageClient;
        DocumentBrowser(
                const Reference& objbuilder_impl_,
                const Reference& trace_impl_,
                const Reference& storage_impl_,
                const Reference& errorhnd_);

private:
        Reference m_errorhnd_impl;
        Reference m_trace_impl;
        Reference m_objbuilder_impl;
        Reference m_storage_impl;
        Reference m_restriction_impl;
        Reference m_postingitr_impl;
        Reference m_attributereader_impl;
        Index m_docno;
};

class Context
{
public:
        Context();
        explicit Context( unsigned int maxNofThreads);
        explicit Context( unsigned int maxNofThreads, const String& tracecfg);
        explicit Context( const String& connectionstring);
        Context( const String& connectionstring, unsigned int maxNofThreads);
        Context( const Context& o);
        ~Context(){}

        void checkErrors() const;

        void loadModule( const String& name_);

        void addModulePath( const String& paths_);

#ifdef STRUS_BOOST_PYTHON
        void addModulePath_obj( const StringObject& paths_);
#endif

        void addResourcePath( const String& paths_);

#ifdef STRUS_BOOST_PYTHON
        void addResourcePath_obj( const StringObject& paths_);
#endif

        StatisticsProcessor createStatisticsProcessor( const String& name);

        StorageClient createStorageClient();

        StorageClient createStorageClient( const String& config_);

#ifdef STRUS_BOOST_PYTHON
        StorageClient createStorageClient_0();
        StorageClient createStorageClient_obj( const StringObject& config_);
#endif
        VectorStorageClient createVectorStorageClient();

        VectorStorageClient createVectorStorageClient( const String& config_);

#ifdef STRUS_BOOST_PYTHON
        VectorStorageClient createVectorStorageClient_0();
        VectorStorageClient createVectorStorageClient_obj( const StringObject& config_);
#endif

        void createStorage( const String& config_);

#ifdef STRUS_BOOST_PYTHON
        void createStorage_obj( const StringObject& config_);
#endif

        void createVectorStorage( const String& config_);

#ifdef STRUS_BOOST_PYTHON
        void createVectorStorage_obj( const StringObject& config_);
#endif
        void destroyStorage( const String& config_);

#ifdef STRUS_BOOST_PYTHON
        void destroyStorage_obj( const StringObject& config_);
#endif
        DocumentClass detectDocumentClass( const String& content);

#ifdef STRUS_BOOST_PYTHON
        DocumentClass detectDocumentClass_obj( const StringObject& content);
#endif
        DocumentAnalyzer createDocumentAnalyzer( const String& segmentername_="");

#ifdef STRUS_BOOST_PYTHON
        DocumentAnalyzer createDocumentAnalyzer_obj( const StringObject& segmentername_);

        DocumentAnalyzer createDocumentAnalyzer_0();
#endif

        QueryAnalyzer createQueryAnalyzer();

        QueryEval createQueryEval();

        void close();

private:
        void initStorageObjBuilder();
        void initAnalyzerObjBuilder();

private:
        Reference m_errorhnd_impl;
        Reference m_moduleloader_impl;
        Reference m_rpc_impl;
        Reference m_trace_impl;
        Reference m_storage_objbuilder_impl;
        Reference m_analyzer_objbuilder_impl;
        const void* m_textproc;
};

#ifdef DOXYGEN_LANG
#if defined DOXYGEN_JAVA
}}}
#elif defined DOXYGEN_PYTHON
}
#endif
#endif
#endif