repo_bson.h

#pragma once

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

#define strcasecmp _stricmp
#endif

#include <mongo/bson/bson.h>
#include <unordered_map>

#include "../../../lib/repo_log.h"
#include "../../../repo_bouncer_global.h"
#include "../repo_model_global.h"
#include "../repo_node_utils.h"
#include "repo_bson_element.h"

#define REPO_BSON_MAX_BYTE_SIZE 16770000 //max size is 16MB,but leave a bit for buffer

namespace repo {
    namespace core {
        namespace model {
            //TODO: Eventually we should inherit from a generic BSON object.
            //work seems to have been started in here:https://github.com/jbenet/bson-cpp
            //alternatively we can use a c++ wrapper on https://github.com/mongodb/libbson
            class REPO_API_EXPORT RepoBSON : public mongo::BSONObj
            {
            public:

                RepoBSON() : mongo::BSONObj() {}

                RepoBSON(const mongo::BSONObj &obj,
                    const std::unordered_map<std::string, std::pair<std::string, std::vector<uint8_t>>> &binMapping =
                    std::unordered_map<std::string, std::pair<std::string, std::vector<uint8_t>>>());

                RepoBSON(mongo::BSONObjBuilder &builder) : mongo::BSONObj(builder.obj()) {}

                RepoBSON(const std::vector<char> &rawData) : mongo::BSONObj(rawData.data()) {}

                virtual ~RepoBSON() {}

                static RepoBSON fromJSON(const std::string &json);

                RepoBSON& operator=(RepoBSON otherCopy) {
                    swap(otherCopy);
                    return *this;
                }
                void swap(RepoBSON otherCopy)
                {
                    mongo::BSONObj::swap(otherCopy);
                    bigFiles = otherCopy.bigFiles;
                }

                static int64_t getCurrentTimestamp();

                RepoBSONElement getField(const std::string &label) const
                {
                    return RepoBSONElement(mongo::BSONObj::getField(label));
                }

                template <class T>
                bool getBinaryFieldAsVector(
                    const std::string &field,
                    std::vector<T> &vec) const

                {
                    bool success = false;

                    if (!hasField(field) || getField(field).type() == ElementType::STRING)
                    {
                        //Try to get it from file mapping.
                        std::vector<uint8_t> bin = getBigBinary(field);
                        if (bin.size() > 0)
                        {
                            vec.resize(bin.size() / sizeof(T));
                            memcpy(vec.data(), &bin[0], bin.size());
                            success = true;
                        }
                        else
                        {
                            repoError << "Trying to retrieve binary from a field that doesn't exist(" << field << ")";
                            return false;
                        }
                    }
                    else{
                        RepoBSONElement bse = getField(field);
                        if (bse.type() == ElementType::BINARY && bse.binDataType() == mongo::BinDataGeneral)
                        {
                            bse.value();
                            int length;
                            const char *binData = bse.binData(length);
                            if (length > 0)
                            {
                                vec.resize(length / sizeof(T));
                                memcpy(vec.data(), binData, length);
                                success = true;
                            }
                            else{
                                repoError << "RepoBSON::getBinaryFieldAsVector : "
                                    << "size of binary data (" << length << ") Unable to copy 0 bytes!";
                            }
                        }
                        else{
                            repoError << "RepoBSON::getBinaryFieldAsVector : bson element type is not BinDataGeneral!";
                        }
                    }

                    return success;
                }

                repoUUID getUUIDField(const std::string &label) const;

                std::vector<repoUUID> getUUIDFieldArray(const std::string &label) const;

                std::vector<float> getFloatArray(const std::string &label) const;

                std::vector<std::string> getStringArray(const std::string &label) const;

                int64_t getTimeStampField(const std::string &label) const;

                std::list<std::pair<std::string, std::string> > getListStringPairField(
                    const std::string &arrLabel,
                    const std::string &fstLabel,
                    const std::string &sndLabel) const;

                double getEmbeddedDouble(
                    const std::string &embeddedObjName,
                    const std::string &fieldName,
                    const double &defaultValue = 0) const;

                bool hasEmbeddedField(
                    const std::string &embeddedObjName,
                    const std::string &fieldName) const;

                bool hasBinField(const std::string &label) const
                {
                    return hasField(label) || bigFiles.find(label) != bigFiles.end();
                }

                virtual RepoBSON cloneAndAddFields(
                    const RepoBSON *changes) const;

            public:

                /*
                * ----------------- BIG FILE MANIPULATION ----------------------------------
                */

                RepoBSON cloneAndShrink() const;

                std::vector<uint8_t> getBigBinary(const std::string &key) const;

                std::vector<std::pair<std::string, std::string>> getFileList() const;

                std::unordered_map< std::string, std::pair<std::string, std::vector<uint8_t> > > getFilesMapping() const
                {
                    return bigFiles;
                }

                bool hasOversizeFiles() const
                {
                    return bigFiles.size() > 0;
                }

            protected:

                std::unordered_map< std::string, std::pair<std::string, std::vector<uint8_t> > > bigFiles;
            }; // end
        }// end namespace model
    } // end namespace core
} // end namespace repo