RecordRingItem.h

Go to the documentation of this file.

//
// Copyright 2020, Jefferson Science Associates, LLC.
// Subject to the terms in the LICENSE file found in the top-level directory.
//
// EPSCI Group
// Thomas Jefferson National Accelerator Facility
// 12000, Jefferson Ave, Newport News, VA 23606
// (757)-269-7100


#ifndef EVIO_6_0_RECORDRINGITEM_H
#define EVIO_6_0_RECORDRINGITEM_H


#include <memory>
#include <atomic>
#include <functional>


#include "Disruptor/Sequence.h"
#include "RecordOutput.h"
#include "ByteOrder.h"
#include "Compressor.h"


namespace evio {

    class RecordRingItem {

    private:

        // These static members are NOT THREAD SAFE! Fortunately, the chances that an
        // application uses more than one RecordSupply is remote. The chances that
        // their construction occurs at the same time is even more remote.

        static ByteOrder factoryByteOrder;
        static int factoryMaxEventCount;
        static int factoryMaxBufferSize;
        static Compressor::CompressionType factoryCompressionType;

        static uint64_t idValue;


        std::shared_ptr<RecordOutput> record;

        ByteOrder order {ByteOrder::ENDIAN_LOCAL};

        int64_t sequence = 0UL;

        std::shared_ptr<Disruptor::ISequence> sequenceObj = nullptr;

        std::atomic<bool> splitFileAfterWriteBool{false};

        std::atomic<bool> forceToDiskBool{false};

        std::atomic<bool> checkDisk{false};

        std::atomic<bool> lastItem{false};

        bool alreadyReleased = false;

        uint64_t id = 0;


    public:


        static const std::function< std::shared_ptr<RecordRingItem> () >& eventFactory();

        static void setEventFactorySettings(ByteOrder & order, uint32_t maxEventCount, uint32_t maxBufferSize,
                                            Compressor::CompressionType & compressionType);


        RecordRingItem();
        RecordRingItem(const RecordRingItem & item);
        ~RecordRingItem() = default;

        RecordRingItem & operator=(const RecordRingItem & other) = delete;

        void reset();

        std::shared_ptr<RecordOutput> & getRecord();
        ByteOrder & getOrder();
        int64_t getSequence() const;
        std::shared_ptr<Disruptor::ISequence> & getSequenceObj();

        void fromProducer(int64_t seq);
        void fromConsumer(int64_t seq, std::shared_ptr<Disruptor::ISequence> & seqObj);

        bool splitFileAfterWrite();
        void splitFileAfterWrite(bool split);

        bool forceToDisk();
        void forceToDisk(bool force);

        bool isCheckDisk();
        void setCheckDisk(bool check);

        bool isLastItem();
        void setLastItem(bool last);

        bool isAlreadyReleased() const;
        void setAlreadyReleased(bool released);

        uint64_t getId() const;
        void setId(uint64_t idVal);

    };

}


#endif //EVIO_6_0_RECORDRINGITEM_H