testframe.hpp

Go to the documentation of this file.

/*
  TESTFRAME.hpp  -  test data frame (stub) for checking Render engine functionality

   Copyright (C)
     2011, 2024       Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/

#ifndef STEAM_ENGINE_TESTFRAME_H
#define STEAM_ENGINE_TESTFRAME_H


#include "lib/integral.hpp"
#include "lib/hash-value.h"

#include <array>


namespace steam {
namespace engine {
namespace test   {
  
  using lib::HashVal;
  
  class TestFrame
    {
      enum StageOfLife {
          CREATED, EMITTED, DISCARDED
        };
      
      static constexpr size_t BUFFSIZ = 1024;
      using _Arr = std::array<char,BUFFSIZ>;
      using _A64 = std::array<uint64_t, BUFFSIZ/sizeof(uint64_t)>;

      struct Meta
        {
          HashVal _MARK_;
          HashVal checksum;
          uint64_t distinction;
          StageOfLife stage;
          
          Meta (uint seq, uint family);
          bool isPlausible()             const;
          bool operator== (Meta const&)  const;
        };
      
      alignas(uint64_t)
        std::byte buffer_[sizeof(_Arr)];
      
      Meta header_;
      
    public:
      static void reseed();
      
     ~TestFrame();
      TestFrame (uint seq=0, uint family=0);
      TestFrame (TestFrame const&);
      TestFrame& operator= (TestFrame const&);
      
      HashVal markChecksum();
      
      static bool isAlive (void* memLocation);
      
      static bool isDead (void* memLocation);
      
      bool isAlive()    const;
      bool isDead()     const;
      bool isSane()     const;
      bool isValid()    const;
      bool isPristine() const;
      
      bool operator== (void* memLocation) const;
      
      friend bool operator== (TestFrame const& f1, TestFrame const& f2) { return  f1.contentEquals(f2); }
      friend bool operator!= (TestFrame const& f1, TestFrame const& f2) { return !f1.contentEquals(f2); }

      _Arr&       data()         { return * std::launder (reinterpret_cast<_Arr* > (&buffer_));      }
      _Arr const& data()   const { return * std::launder (reinterpret_cast<_Arr const*> (&buffer_)); }
      _A64&       data64()       { return * std::launder (reinterpret_cast<_A64* > (&buffer_));      }
      _A64 const& data64() const { return * std::launder (reinterpret_cast<_A64 const*> (&buffer_)); }
      
    private:
      void buildData();
      Meta&       accessHeader();
      Meta const& accessHeader()  const;
      bool contentEquals (TestFrame const& o) const;
      bool matchDistinction()   const;
      StageOfLife currStage()   const;
      HashVal computeChecksum() const;
      bool hasValidChecksum()   const;
    };
  
  
  
  TestFrame& testData (uint seqNr =0, uint chanNr =0);
  
  
}}} // namespace steam::engine::test
#endif