common/remoteserver.h

Go to the documentation of this file.

/* Copyright (C) 2006,2007,2008,2009,2010 Olly Betts
 * Copyright (C) 2007,2009,2010 Lemur Consulting Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#ifndef XAPIAN_INCLUDED_REMOTESERVER_H
#define XAPIAN_INCLUDED_REMOTESERVER_H

#include "xapian/database.h"
#include "xapian/postingsource.h"
#include "xapian/registry.h"
#include "xapian/visibility.h"
#include "xapian/weight.h"

#include "remoteconnection.h"

#include <string>

class XAPIAN_VISIBILITY_DEFAULT RemoteServer : private RemoteConnection {
    void operator=(const RemoteServer &);

    RemoteServer(const RemoteServer &);

    Xapian::Database * db;

    Xapian::WritableDatabase * wdb;

    bool writable;

    double active_timeout;

    double idle_timeout;

    Xapian::Registry reg;

    message_type get_message(double timeout, std::string & result,
                             message_type required_type = MSG_MAX);

    void send_message(reply_type type, const std::string &message);

    void send_message(reply_type type, const std::string &message,
                      double end_time) {
        unsigned char type_as_char = static_cast<unsigned char>(type);
        RemoteConnection::send_message(type_as_char, message, end_time);
    }

    // all terms
    void msg_allterms(const std::string & message);

    // get document
    void msg_document(const std::string & message);

    // term exists?
    void msg_termexists(const std::string & message);

    // get collection freq
    void msg_collfreq(const std::string & message);

    // get termfreq
    void msg_termfreq(const std::string & message);

    // get value statistics
    void msg_valuestats(const std::string & message);

    // keep alive
    void msg_keepalive(const std::string & message);

    // get doclength
    void msg_doclength(const std::string & message);

    // set the query; return the mset
    void msg_query(const std::string & message);

    // get termlist
    void msg_termlist(const std::string & message);

    // get postlist
    void msg_postlist(const std::string & message);

    // get positionlist
    void msg_positionlist(const std::string &message);

    // get write access
    void msg_writeaccess(const std::string & message);

    // reopen
    void msg_reopen(const std::string & message);

    // get updated doccount and avlength
    void msg_update(const std::string &message);

    // commit
    void msg_commit(const std::string & message);

    // cancel
    void msg_cancel(const std::string &message);

    // add document
    void msg_adddocument(const std::string & message);

    // delete document
    void msg_deletedocument(const std::string & message);

    // delete document with unique term
    void msg_deletedocumentterm(const std::string & message);

    // replace document
    void msg_replacedocument(const std::string & message);

    // replace document with unique term
    void msg_replacedocumentterm(const std::string & message);

    // get metadata
    void msg_getmetadata(const std::string & message);

    // read metadata key list
    void msg_openmetadatakeylist(const std::string & message);

    // set metadata
    void msg_setmetadata(const std::string & message);

    // add a spelling
    void msg_addspelling(const std::string & message);

    // remove a spelling
    void msg_removespelling(const std::string & message);

  public:
    RemoteServer(const std::vector<std::string> &dbpaths,
                 int fdin, int fdout,
                 double active_timeout_,
                 double idle_timeout_,
                 bool writable = false);

    ~RemoteServer();

    void run();

    const Xapian::Registry & get_registry() const { return reg; }

    void set_registry(const Xapian::Registry & reg_) { reg = reg_; }
};

#endif // XAPIAN_INCLUDED_REMOTESERVER_H

---