bulkdata.hh

Go to the documentation of this file.

#ifndef _DRAMA2_BULKDATA_INC
#define _DRAMA2_BULKDATA_INC
 
/*
 * History:
     19-Feb-2015 - TJF - Original version
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
#include "DitsBulk.h"
//#define BULK_DEBUG1   // Uncomment to output debugging  on BulkData class
//#define BULK_DEBUG2   // Uncomment to output debugging  on BulkDataArg class
 
#if defined(BULK_DEBUG1) || defined(BULK_DEBUG2) 
#include <stdio.h>
#endif
 
namespace drama { 
 
    enum class ShareType {
        Default   = 0,                 
        Create    = DITS_SHARE_CREATE, 
#ifdef VxWorks
        Global    = DITS_SHARE_GLOBAL, 
#endif
#ifdef DUNIX
        MMap      = DITS_SHARE_MMAP,   
        SHMem     = DITS_SHARE_SHMEM   
#endif
    };
 
 
    class BulkData {
    private:
 
        /*
         * Pointer to the DRAMA task we are part of.
         */
        std::weak_ptr<Task> _theTask;
 
        // Do we call DitsReleaseShared when destroying this object?  Depends
        //   on how we were constructed.
        bool                    _releaseOnDestruct = true;
        // When calling DitsReleseShared, do we specify that the segment is
        //   to be deleted.
        bool                    _deleteOnDestruct = false;
        // DITS Shared memory details.
        DitsSharedMemInfoType _memInfo;
        // Address of memory itself.
        void *                _memAddress = nullptr;
        // Size of memory in bytes.
        unsigned long         _size = 0;
 
        // Clean up code called by destructor and move operators. 
        virtual void CleanUp() noexcept;
 
    protected:
        void * RawDataAddr() const {
            return  _memAddress;
        }
        unsigned long SizeBytes() const {
            return _size;
        }
 
 
    public:
        BulkData()  {
#ifdef BULK_DEBUG1                
            fprintf(stderr,"BulkData::Constructed empty item at address %p\n", 
                    static_cast<void *>(this));
#endif
        }
        BulkData(std::weak_ptr<Task> theTask,
                 long Size,
                 ShareType type=ShareType::Create,
                 bool Create = true,
                 bool DeleteOnDestruct = true,
                 void *Address=nullptr,
                 const std::string & Name="",
                 int Key=0);
 
 
        BulkData(std::weak_ptr<Task> theTask, const DitsBulkReportInfoType &info);
 
 
        virtual ~BulkData() {
#ifdef BULK_DEBUG1                
            fprintf(stderr,"BulkData:Destructor for item at address %p\n", 
                    static_cast<void *>(this));
#endif
            CleanUp();
        }
 
        BulkData& operator=(const BulkData &rhs) = delete;
        BulkData(const BulkData &source) = delete;
 
        BulkData& operator=(BulkData &&rhs) noexcept {
            if (this == &rhs) return (*this);
#ifdef BULK_DEBUG1                
            fprintf(stderr,"BulkData:Move assignment item at address %p to %p\n", 
                    static_cast<void *>(&rhs), static_cast<void *>(this));
#endif
            CleanUp();
 
            _theTask           = rhs._theTask; 
            _releaseOnDestruct = rhs._releaseOnDestruct;
            _deleteOnDestruct  = rhs._deleteOnDestruct;
            _memInfo           = rhs._memInfo;
            _memAddress        = rhs._memAddress;
            _size              = rhs._size;
            rhs._memAddress    = nullptr;
            return *this;
        }
        BulkData(BulkData &&source) noexcept :
            _theTask(std::move(source._theTask)),
            _releaseOnDestruct(std::move(source._releaseOnDestruct)),
            _deleteOnDestruct(std::move(source._deleteOnDestruct)),
            _memInfo(std::move(source._memInfo)),
            _memAddress(std::move(source._memAddress)),
            _size(std::move(source._size)) {
                source._memAddress = nullptr;
 
#ifdef BULK_DEBUG1                
                 fprintf(stderr,"BulkData:Move copy item at address %p to %p\n", 
                         static_cast<void *>(&source), static_cast<void *>(this));
#endif
 
        }
        template <typename T>
        T * Data(unsigned long *nitems=nullptr) {
            /*
             * Confirm the data type is a POD type.
             *   From C++20, std::is_pod<>() is depreciated, we can replace 
             *     by std::is_standard_layout<>::value && std::is_trivial<>::value
             */
            static_assert(
                (std::is_standard_layout<T>::value && std::is_trivial<T>::value) ,
                "The type T must be a standard layout and trivial (POD) type"); 
            
            //  Do we have a valid item.
            if (_memAddress == nullptr)
            {
                DramaTHROW(DRAMA2__BULK_INVALID, 
                           "Failed to create shared memory segement");
                
            }
            // Calculate the number of items.
            if (nitems)
            {
                *nitems = _size / sizeof(T);
            }
#ifdef BULK_DEBUG1                
            fprintf(stderr,"BulkData:Accessing %p, data %p, size %lu, item size %u\n",
                    static_cast<void *>(this),
                    _memAddress,
                    _size, sizeof(T));
#endif
 
 
            return static_cast<T *>(_memAddress);
        }
        
        DitsSharedMemInfoType & GetDitsSharedMemInfo() {
        
            if (_memAddress == nullptr)
            {
                DramaTHROW(DRAMA2__BULK_INVALID, 
                           "Failed to create shared memory segement");
                
            }
            return  _memInfo;
        }
 
           
    }; // class BulkData
 
    class BulkDataSds : public BulkData, public sds::Id {
 
    public:
        BulkDataSds() {
#ifdef BULK_DEBUG1                
            fprintf(stderr,"BulkDataSds::Constructed empty item at address %p\n", 
                    static_cast<void *>(this));
#endif
        }
        BulkDataSds(std::weak_ptr<Task> theTask,
                    const sds::Id &SdsTemplate,
                    ShareType type=ShareType::Create,
                    bool Create = true,
                    bool DeleteOnDestruct = true,
                    void *Address=nullptr,
                    const std::string & Name="",
                    int Key=0);
 
    }; // class BulkDataSds
 
    class BulkDataArg : public BulkData {
 
        std::weak_ptr<Task> _theTask;     // Pointer to the DRAMA task we are part of.
        bool _release = false;            // Should item be released by destructor.
        unsigned long _notifyBytes = 0;   // Suggested notification interval.
        DitsBulkReportInfoType _bulkInfo; // Bulk argument information
 
        // Clean up code called by destructor and move operators. 
        virtual void ArgCleanUp() noexcept;
    public:
        BulkDataArg()  {
#ifdef BULK_DEBUG2             
            fprintf(stderr,"BulkDataArg::Constructed empty item at address %p\n", 
                    static_cast<void *>(this));
#endif
        }
        virtual ~BulkDataArg();
 
        BulkDataArg(std::weak_ptr<Task> theTask);
 
        BulkDataArg& operator=(BulkDataArg &&rhs) noexcept {
#ifdef BULK_DEBUG2                
            fprintf(stderr,
                    "BulkDataArg:Move assignment item at address %p to %p\n", 
                    static_cast<void *>(&rhs), static_cast<void *>(this));
#endif
            if (this == &rhs) return (*this);
            ArgCleanUp();
            // This is how we move the parent class.
            BulkData::operator=(std::move(rhs));
 
            _theTask = rhs._theTask; 
            _release = rhs._release;
 
            return *this;
        }
        BulkDataArg(BulkDataArg &&source) noexcept : 
            BulkData(std::move(source)),
            _theTask(std::move(source._theTask)),
            _release(std::move(source._release)) {
#ifdef BULK_DEBUG2         
                 fprintf(stderr,
                         "BulkDataArg:Move copy item at address %p to %p\n", 
                         static_cast<void *>(&source), static_cast<void *>(this));
#endif
 
        }
        unsigned long GetNotifyBytes() const {
            return _notifyBytes;
        }
 
         void Report(unsigned bytes);
 
    }; // BulkDataArg
    
    class BulkDataArgSds : public BulkDataArg, public sds::Id {
    public:
        BulkDataArgSds() {
#ifdef BULK_DEBUG2                
            fprintf(stderr,"BulkDataArgSds::Constructed empty item at address %p\n", 
                    static_cast<void *>(this));
#endif
        }
 
        BulkDataArgSds(std::weak_ptr<Task> theTask);
 
 
    }; // BulkDataArgSds
} // namespace drama
 
#endif