Collection.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX 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, see <http://www.gnu.org/licenses/>.
*
* @package    MemoryX::CommonStorage
* @author     Alexey Kozlov ( kozlov at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "Collection.h"
 
#include <IceUtil/UUID.h>
 
#include <mongo/client/dbclient.h>
 
namespace memoryx
{
    // Collection implementation
    Collection::Collection(const CommonStoragePtr& dbConn, const std::string& collNS) :
        dbConn(dbConn)
    {
        ns = collNS;
        iceId.name = IceUtil::generateUUID();
    }
 
    Ice::Identity
    Collection::getIceId() const
    {
        return iceId;
    }
 
    // inherited from Collection
    Ice::Int
    Collection::count(const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->count(ns);
    }
 
    DBStorableData
    Collection::findByMongoId(const std::string& id, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findByMongoId(ns, id);
    }
 
    DBStorableDataList
    Collection::findByFieldValue(const std::string& fieldName,
                                 const std::string& fieldValue,
                                 const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findByFieldValue(ns, fieldName, fieldValue);
    }
 
    DBStorableData
    Collection::findOneByFieldValue(const std::string& fieldName,
                                    const std::string& fieldValue,
                                    const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findOneByFieldValue(ns, fieldName, fieldValue);
    }
 
    DBStorableDataList
    Collection::findByFieldValueList(const std::string& fieldName,
                                     const NameList& fieldValueList,
                                     const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findByFieldValueList(ns, fieldName, fieldValueList);
    }
 
    DBStorableData
    Collection::findOneByQuery(const std::string& query, const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findOneByQuery(ns, query);
    }
 
    DBStorableDataList
    Collection::findByQuery(const std::string& query, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findByQuery(ns, query);
    }
 
    DBStorableDataList
    Collection::findByConstraintQuery(const std::string& query,
                                      const std::string& where,
                                      const Ice::Current&)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findByQuery(ns, query, where);
    }
 
    DBStorableDataList
    Collection::findAll(const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findAll(ns);
    }
 
    DBStorableData
    Collection::findAllUniqueByFieldName(const std::string& fieldName, const ::Ice::Current&)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findAllUniqueByFieldName(ns, fieldName);
    }
 
    EntityIdList
    Collection::findAllIds(const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findAllIds(ns);
    }
 
    NameList
    Collection::findAllFieldValues(const std::string& fieldName, const ::Ice::Current&)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->findAllFieldValues(ns, fieldName);
    }
 
    std::string
    Collection::insert(const DBStorableData& obj, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->insert(ns, obj);
    }
 
    std::vector<std::string>
    Collection::insertList(const DBStorableDataList& objectList, const Ice::Current&)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->insertList(ns, objectList);
    }
 
    bool
    Collection::update(const DBStorableData& obj, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->update(ns, obj, "_id");
    }
 
    bool
    Collection::updateWithUserKey(const DBStorableData& obj,
                                  const std::string& keyField,
                                  const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->update(ns, obj, keyField);
    }
 
    bool
    Collection::updateByQuery(const std::string& query,
                              const DBStorableData& obj,
                              const ::Ice::Current& c)
    {
        return dbConn->updateByQuery(ns, query, mongo::fromjson(obj.JSON));
    }
 
    std::string
    Collection::save(const DBStorableData& obj, const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->insert(ns, obj, true);
    }
 
    bool
    Collection::saveWithUserKey(const DBStorableData& obj,
                                const std::string& keyField,
                                const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->update(ns, obj, keyField, true);
    }
 
    bool
    Collection::removeByMongoId(const std::string& id, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->removeByMongoId(ns, id);
    }
 
    bool
    Collection::removeByFieldValue(const std::string& fieldName,
                                   const std::string& fieldValue,
                                   const Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->removeByFieldValue(ns, fieldName, fieldValue);
    }
 
    bool
    Collection::removeByQuery(const std::string& query, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->removeByQuery(ns, query);
    }
 
    bool
    Collection::clear(const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->clearCollection(ns);
    }
 
    bool
    Collection::ensureIndex(const std::string& fieldName, bool unique, const ::Ice::Current& c)
    {
        std::unique_lock lock(dbConnectionMutex);
        return dbConn->ensureIndex(ns, fieldName, unique);
    }
 
    std::string
    Collection::getNS(const ::Ice::Current& c)
    {
        return ns;
    }
} // namespace memoryx