repo_bson_builder.h

/*
*  Copyright(C) 2015 3D Repo Ltd
*
*  This program is free software : you can redistribute it and / or modify
*  it under the terms of the GNU Affero General Public License as
*  published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
*  You should have received a copy of the GNU Affero General Public License
*  along with this program.If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once

#if defined(_WIN32) || defined(_WIN64)
#include <WinSock2.h>
#include <Windows.h>

#define strcasecmp _stricmp
#endif

#include <string>
#include <mongo/bson/bson.h>
#include "../repo_node_utils.h"
#include "repo_bson.h"

namespace repo {
    namespace core {
        namespace model {
            class RepoBSONBuilder : public mongo::BSONObjBuilder
            {
            public:
                RepoBSONBuilder();
                ~RepoBSONBuilder();

                template <class T>
                void appendArray(
                    const std::string &label,
                    const std::vector<T> &vec)
                {
                    RepoBSONBuilder array;
                    for (unsigned int i = 0; i < vec.size(); ++i)
                        array.append(std::to_string(i), vec[i]);
                    mongo::BSONObjBuilder::appendArray(label, array.obj());
                }

                void appendArray(
                    const std::string &label,
                    const RepoBSON &bson)
                {
                    mongo::BSONObjBuilder::appendArray(label, bson);
                }

                template<class T>
                void append(
                    const std::string &label,
                    const T &item)
                {
                    mongo::BSONObjBuilder::append(label, item);
                }

                void appendArrayPair(
                    const std::string &label,
                    const std::list<std::pair<std::string, std::string> > &list,
                    const std::string &fstLabel,
                    const std::string &sndLabel
                    );

                template <class T>
                void appendBinary(
                    const std::string &label,
                    const T           *data,
                    const uint32_t  &byteCount)
                {
                    if (data && 0 < byteCount)
                    {
                        // Store data as a binary blob
                        try{
                            appendBinData(
                                label, byteCount, mongo::BinDataGeneral,
                                (void *)data);
                        }
                        catch (std::exception &e)
                        {
                            repoError << "Failed: " << e.what();
                            exit(-1);
                        }
                    }
                    else
                    {
                        repoWarning << "Trying to append a binary of size 0 into a bson. Skipping..";
                    }
                }

                void appendTimeStamp(std::string label){
                    appendTime(label, time(NULL) * 1000);
                }

                void appendTime(std::string label, const int64_t &ts){
                    mongo::Date_t date = mongo::Date_t(ts);
                    mongo::BSONObjBuilder::append(label, date);
                }

                RepoBSON obj();

            private:
                void appendUUID(
                    const std::string &label,
                    const repoUUID &uuid);
            };

            // Template specialization
            template<> void RepoBSONBuilder::append < repoUUID >
                (
                    const std::string &label,
                    const repoUUID &uuid
                    );

                template<> void RepoBSONBuilder::append < repo_vector_t >
                    (
                        const std::string &label,
                        const repo_vector_t &vec
                        );
        }// end namespace model
    } // end namespace core
} // end namespace repo