document.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_ANALYZER_DOCUMENT_HPP_INCLUDED
#define _STRUS_ANALYZER_DOCUMENT_HPP_INCLUDED
#include "strus/numericVariant.hpp"
#include "strus/analyzer/documentTerm.hpp"
#include "strus/analyzer/documentAttribute.hpp"
#include "strus/analyzer/documentMetaData.hpp"
#include <string>
#include <vector>

namespace strus {
namespace analyzer {

class Document
{
public:
        Document(){}
#if __cplusplus >= 201103L
        Document( Document&& ) = default;
        Document( const Document& ) = default;
        Document& operator= ( Document&& ) = default;
        Document& operator= ( const Document& ) = default;
#else
        Document( const Document& o)
                :m_subdoctypename(o.m_subdoctypename)
                ,m_metadata(o.m_metadata)
                ,m_attributes(o.m_attributes)
                ,m_searchIndexTerms(o.m_searchIndexTerms)
                ,m_forwardIndexTerms(o.m_forwardIndexTerms){}
#endif

        const std::string& subDocumentTypeName() const                  {return m_subdoctypename;}
        const std::vector<DocumentAttribute>& attributes() const        {return m_attributes;}
        const std::vector<DocumentMetaData>& metadata() const           {return m_metadata;}
        const std::vector<DocumentTerm>& searchIndexTerms() const       {return m_searchIndexTerms;}
        const std::vector<DocumentTerm>& forwardIndexTerms() const      {return m_forwardIndexTerms;}

        void setSubDocumentTypeName( const std::string& n)
        {
                m_subdoctypename = n;
        }
        void setAttribute( const std::string& t, const std::string& v)
        {
                m_attributes.push_back( DocumentAttribute( t,v));
        }

        void setMetaData( const std::string& t, const NumericVariant& v)
        {
                m_metadata.push_back( DocumentMetaData( t,v));
        }

        void addSearchIndexTerm( const std::string& t, const std::string& v, unsigned int p)
        {
                m_searchIndexTerms.push_back( DocumentTerm( t, v, p));
        }

        void addSearchIndexTerms( const std::vector<DocumentTerm>& terms)
        {
                m_searchIndexTerms.insert( m_searchIndexTerms.end(), terms.begin(), terms.end());
        }

        void addForwardIndexTerm( const std::string& t, const std::string& v, unsigned int p)
        {
                m_forwardIndexTerms.push_back( DocumentTerm( t, v, p));
        }

        void addForwardIndexTerms( const std::vector<DocumentTerm>& terms)
        {
                m_forwardIndexTerms.insert( m_forwardIndexTerms.end(), terms.begin(), terms.end());
        }

        void clear()
        {
                m_subdoctypename.clear();
                m_metadata.clear();
                m_attributes.clear();
                m_searchIndexTerms.clear();
                m_forwardIndexTerms.clear();
        }

        void swap( Document& o)
        {
                m_subdoctypename.swap(o.m_subdoctypename);
                m_metadata.swap(o.m_metadata);
                m_attributes.swap(o.m_attributes);
                m_searchIndexTerms.swap(o.m_searchIndexTerms);
                m_forwardIndexTerms.swap(o.m_forwardIndexTerms);
        }

private:
        std::string m_subdoctypename;
        std::vector<DocumentMetaData> m_metadata;
        std::vector<DocumentAttribute> m_attributes;
        std::vector<DocumentTerm> m_searchIndexTerms;
        std::vector<DocumentTerm> m_forwardIndexTerms;
};

}}//namespace
#endif