QCassandra.cpp

Go to the documentation of this file.

/*
 * Text:
 *      QCassandra.cpp
 *
 * Description:
 *      Handling of the cassandra::CassandraClient and corresponding transports,
 *      protocols, sockets, etc.
 *
 * Documentation:
 *      See each function below.
 *
 * License:
 *      Copyright (c) 2011 Made to Order Software Corp.
 *
 *      http://snapwebsites.org/
 *      contact@m2osw.com
 *
 *      Permission is hereby granted, free of charge, to any person obtaining a
 *      copy of this software and associated documentation files (the
 *      "Software"), to deal in the Software without restriction, including
 *      without limitation the rights to use, copy, modify, merge, publish,
 *      distribute, sublicense, and/or sell copies of the Software, and to
 *      permit persons to whom the Software is furnished to do so, subject to
 *      the following conditions:
 *
 *      The above copyright notice and this permission notice shall be included
 *      in all copies or substantial portions of the Software.
 *
 *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 *      OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "QCassandraPrivate.h"
#include <protocol/TBinaryProtocol.h>
#include <transport/TSocket.h>
#include <transport/TTransportUtils.h>

#include <QtCore/QDebug>

namespace QtCassandra
{

QCassandra::QCassandra()
    : f_private(new QCassandraPrivate(this)),
      //f_current_context(NULL) -- auto-init
      //f_contexts_read(false) -- auto-init
      //f_contexts() -- auto-init
      //f_cluster_name() -- auto-init
      //f_protocol_version() -- auto-init
      f_default_consistency_level(CONSISTENCY_LEVEL_ONE) // default is CONSISTENCY_LEVEL_DEFAULT
{
    // we are passing this to the private object that we control
    // so we make make sure it is used wisely; at this time it is
    // just saved in a variable member
}

QCassandra::~QCassandra()
{
}

QCassandraPrivate *QCassandra::getPrivate()
{
    return f_private.get();
}

bool QCassandra::connect(const QString& host, int port)
{
    // first make sure we're disconnected from the other cluster
    disconnect();

    // then we reconnect
    return f_private->connect(host, port);
}

void QCassandra::disconnect()
{
    f_private->disconnect();
    f_current_context.clear();
    f_contexts.clear();
    f_cluster_name = "";
    f_protocol_version = "";
}

bool QCassandra::isConnected() const
{
    return f_private->isConnected();
}

const QString& QCassandra::clusterName() const
{
    if(f_cluster_name.isEmpty()) {
        // retrieve the name of the cluster once
        const_cast<QString&>(f_cluster_name) = f_private->clusterName();
    }
    return f_cluster_name;
}

const QString& QCassandra::protocolVersion() const
{
    if(f_protocol_version.isEmpty()) {
        // retrieve the version of the protocol once
        const_cast<QString&>(f_protocol_version) = f_private->protocolVersion();
    }
    return f_protocol_version;
}

QSharedPointer<QCassandraContext> QCassandra::context(const QString& context_name)
{
    // get the list of existing contexts
    const QCassandraContexts& cs = contexts();

    // already exists?
    QCassandraContexts::const_iterator ci = cs.find(context_name);
    if(ci != cs.end()) {
        return ci.value();
    }

    // otherwise create a new one
    QSharedPointer<QCassandraContext> c(new QCassandraContext(this, context_name));
    f_contexts.insert(context_name, c);
    return c;
}

void QCassandra::setCurrentContext(QSharedPointer<QCassandraContext> c)
{
    // emit the change only if not the same context
    if(f_current_context != c) {
        f_private->setContext(c->contextName());
        // we save the current context only AFTER the call to setContext()
        // in case it throws (and then the current context would be wrong)
        f_current_context = c;
    }
}

void QCassandra::clearCurrentContextIf(const QCassandraContext& c)
{
    if(f_current_context == &c) {
        f_current_context.clear();
    }
}

const QCassandraContexts& QCassandra::contexts() const
{
    if(!f_contexts_read) {
        f_contexts_read = true;
        f_private->contexts();
    }
    return f_contexts;
}

QSharedPointer<QCassandraContext> QCassandra::findContext(const QString& context_name) const
{
    QCassandraContexts::const_iterator ci(f_contexts.find(context_name));
    if(ci == f_contexts.end()) {
        QSharedPointer<QCassandraContext> null;
        return null;
    }
    return *ci;
}

QCassandraContext& QCassandra::operator [] (const QString& context_name)
{
    QCassandraContext *context = findContext(context_name).data();
    if(context == NULL) {
        throw std::runtime_error("named context was not found, cannot return a reference");
    }

    return *context;
}

const QCassandraContext& QCassandra::operator [] (const QString& context_name) const
{
    const QCassandraContext *context = findContext(context_name).data();
    if(context == NULL) {
        throw std::runtime_error("named context was not found, cannot return a reference");
    }

    return *context;
}

void QCassandra::dropContext(const QString& context_name)
{
    QSharedPointer<QCassandraContext> c(context(context_name));

    // first do the context drop in Cassandra
    c->drop();

    // now unparent so the memory is returned to the user
    c->unparent();

    // forget about this context in the QCassandra object
    f_contexts.remove(context_name);
}

consistency_level_t QCassandra::defaultConsistencyLevel() const
{
    return f_default_consistency_level;
}

void QCassandra::setDefaultConsistencyLevel(consistency_level_t default_consistency_level)
{
    // make sure the consistency level exists
    if(default_consistency_level != CONSISTENCY_LEVEL_ONE
    && default_consistency_level != CONSISTENCY_LEVEL_QUORUM
    && default_consistency_level != CONSISTENCY_LEVEL_LOCAL_QUORUM
    && default_consistency_level != CONSISTENCY_LEVEL_EACH_QUORUM
    && default_consistency_level != CONSISTENCY_LEVEL_ALL
    && default_consistency_level != CONSISTENCY_LEVEL_ANY
    && default_consistency_level != CONSISTENCY_LEVEL_TWO
    && default_consistency_level != CONSISTENCY_LEVEL_THREE) {
        throw std::runtime_error("invalid default server consistency level");
    }

    f_default_consistency_level = default_consistency_level;
}

int QCassandra::versionMajor()
{
    return QT_CASSANDRA_LIBRARY_VERSION_MAJOR;
}

int QCassandra::versionMinor()
{
    return QT_CASSANDRA_LIBRARY_VERSION_MINOR;
}

int QCassandra::versionPatch()
{
    return QT_CASSANDRA_LIBRARY_VERSION_PATCH;
}

const char *QCassandra::version()
{
    return QT_CASSANDRA_LIBRARY_VERSION_STRING;
}

int64_t QCassandra::timeofday()
{
    struct timeval tv;

    // we ignore timezone as it can also generate an error
    gettimeofday(&tv, NULL);

    return static_cast<int64_t>(tv.tv_sec) * 1000000 + static_cast<int64_t>(tv.tv_usec);
}

} // namespace QtCassandra
// vim: ts=4 sw=4 et