set_s.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    set_s.h
// Purpose:     Set of tuples (binding pattern b..b): Using C++ Standard T.Lib.
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 2016-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef SET_S_INCLUDED
#define SET_S_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef PAGE_INCLUDED
#include "../mem/page.h"
#endif

#ifndef MPOOL_INCLUDED
#include "../mem/mpool.h"
#endif

#ifndef RELSIZE_INCLUDED
#include "relsize.h"
#endif

#ifndef REL_INCLUDED
#include "rel.h"
#endif

#include <stddef.h>
#include <unordered_set>


//=============================================================================
// Private Constants:
//=============================================================================


//-----------------------------------------------------------------------------
// SET_S_MAGIC: Magic number (identifies objects of this class).
//-----------------------------------------------------------------------------

static const long SET_S_MAGIC = 0x5354530AL;    // 'STS\n'


//=============================================================================
// Helper Classes, Parameters to the C++11 unordered_set:
//=============================================================================

template<class T> class set_s_hash_c {
        public:
        size_t operator() (T const & x) const noexcept
        {
                // My row types all have a hash function:
                return x.hash();
        }
};

//=============================================================================
// Class Template for Sets (for Duplicate Check) - Using C++11 unordered_set:
//=============================================================================


template<class T> class set_s_c: public rel_c {
        public:

//-----------------------------------------------------------------------------
// Constructor, Destructor:
//-----------------------------------------------------------------------------

        // Constructor:
        set_s_c(str_t set_s_name);

        // Destructor:
        ~set_s_c();

//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        set_s_c(const set_s_c& obj);            // Not implemented
        set_s_c& operator=(const set_s_c& obj); // Not implemented


//=============================================================================
// (Object) Methods:
//=============================================================================

        public:

//-----------------------------------------------------------------------------
// insert: Insert an element into the set (returns true if successful).
//-----------------------------------------------------------------------------

        // This method returns true if the element was not already in the set
        // and was successfully inserted (i.e. if it is not a duplicate).
        // It returns false if the element was already in the set (duplicate).
        // It also returns false if it was impossible to insert the element
        // because there was not enough memory.
        // By pretending that it was a duplicate, recursion at least comes
        // to an end and the program terminates.
        // One should check the method mem_err() from time to time
        // (at least at the end) to see whether this problem occurred
        // or the result is reliable.
        // A memory error is also logged in the class err_c.
        // So even if one does not check mem_err() for every set object,
        // one will notice the error if one at least checks the global error
        // log or has enabled output of error messages.

        bool insert(T elem) {

                // Check this object:
                CHECK_VALID("set_s_c::insert");

                // Insert:
                //std::pair<std::unordered_set<T, set_s_hash_c<T> >::iterator,
                //      bool> result =
                //      Set.insert(elem);

                // Was the element actually inserted?
                //if(result.second) {
                if(Set.insert(elem).second) {
                        NumRows++;
                        return true;
                }
                else
                        return false;
        }

//-----------------------------------------------------------------------------
// contains: Check whether an element is contained in the set.
//-----------------------------------------------------------------------------

        bool contains(T elem) const {

                // Check this object:
                CHECK_VALID("set_s_c::contains");

                // Return result:
                return Set.count(elem) > 0;

                // Alternative:
                // std::unordered_set<T>::const_iterator it = Set.find(elem);
                // return it != Set.end();
        }

//-----------------------------------------------------------------------------
// size_value: Values of data-structure specific size measures.
//-----------------------------------------------------------------------------

        int size_value(relsize_t relsize) const {
                CHECK_VALID("set_s_c::size_value");
                CHECK(relsize_valid(relsize),
                                "set_s_c::size_value: invalid size measure");

                // Return value of selected size measure:
                switch(relsize) {
                        case RELSIZE_OBJ_SIZE:
                                return static_cast<int>(sizeof(set_s_c<T>));
                        default:
                                return -1;
                }
        }

//=============================================================================
// Debugging Support:
//=============================================================================

#if     VER_DEBUG
        public:
        // Integrity check:
        str_t   check() const;

        private:
        // Magic number (identifies objects of this class for debugging).
        long    Magic;          // Must be "SET_S_MAGIC".
#endif

#if     VER_DUMP
        public:
        // Display data structure:
        void dump(str_t headline = STR_NULL) const;
#endif


//=============================================================================
// Private Object Members:
//=============================================================================

        private:

        // C++11 Standard Library Object:
        std::unordered_set<T, set_s_hash_c<T> > Set;


//=============================================================================
// End of Class Template:
//=============================================================================

};


//=============================================================================
// End of Include File:
//=============================================================================

#endif