cRandom.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRandom_H
#define _INC_cRandom_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSingleton.h"
#include "IUnknown.h"
 
namespace Gray
{
        DECLARE_INTERFACE(IRandomNoise)
        {
                IGNORE_WARN_INTERFACE(IRandomNoise);
                virtual HRESULT GetNoise(void* pData, size_t iSize) = 0;        
        };
 
        class GRAYCORE_LINK cRandomBase : public IRandomNoise
        {
 
        public:
                typedef UINT SEED_t;            
 
                cRandomBase() noexcept
                {
                }
                virtual ~cRandomBase()
                {
                }
 
                virtual void InitSeed(const void* pData, size_t iSize) = 0;     // all implementations must support this.
                void InitSeed(IRandomNoise* pSrc, size_t iSize);
                void InitSeedDefault(size_t iSize = sizeof(int));
                void InitSeedUns(UINT iSeed);   // SEED_t
 
                virtual HRESULT GetNoise(void* pData, size_t iSize) override;   
 
                // Type helpers.
                virtual UINT get_RandUns();             // UINT_MAX // SEED_t
                bool GetRandBool()
                {
                        return GetRandUX(2) == 1 ;
                }
 
                virtual UINT GetRandUX(UINT nScale); // get integer random number in desired interval. (Non inclusive)
                int GetRandIRange(int iRangeLo, int iRangeHi);    // output random int
 
                UNITTEST_FRIEND(cRandom);
        };
 
        class GRAYCORE_LINK cRandomPerf : public IRandomNoise, public cSingleton < cRandomPerf >
        {
 
        public:
                cRandomPerf();
                static void GRAYCALL GetNoisePerf(void* pData, size_t iSize);
                virtual HRESULT GetNoise(void* pData, size_t iSize) override    // fill array with random. return # filled.
                {
                        GetNoisePerf(pData, iSize);
                        return (HRESULT)iSize;
                }
        };
 
        class GRAYCORE_LINK cRandomOS : public cRandomBase, public cSingleton < cRandomOS >
        {
        private:
                virtual void InitSeed(const void* pData, size_t iSize)
                {
                        // No way to seed this.
                        UNREFERENCED_PARAMETER(pData);
                        UNREFERENCED_PARAMETER(iSize);
                }
 
        public:
                cRandomOS();
                virtual ~cRandomOS();
 
                static HRESULT GRAYCALL GetNoiseOS(void* pData, size_t iSize);
 
                virtual HRESULT GetNoise(void* pData, size_t iSize) override;   // fill array with random. return # filled.
                virtual UINT get_RandUns();             // UINT_MAX
 
                CHEAPOBJECT_IMPL;
        };
 
        class GRAYCORE_LINK cRandomBlock : public IRandomNoise
        {
 
        public:
                cMemBlock m_Src;                // a block of 'random' test data. 
                size_t m_nOffset;               // How far have we read in m_Src? recycle when at end ?
 
        public:
                cRandomBlock(const void* pData, size_t nSize) noexcept
                        : m_Src(pData, nSize)
                        , m_nOffset(0)
                {
                }
                virtual HRESULT GetNoise(void* pData, size_t len) override      // IRandomNoise
                {
                        if (m_Src.get_Data() == nullptr)
                        {
                                // No m_Src supplied so fill with fixed data.
                                cMem::Fill(pData, len, 0x2a);
                                m_nOffset += len;
                        }
                        else
                        {
                                // todo repeat like cMem::CopyRepeat() ?
                                ::memcpy(pData, m_Src.GetOffset(m_nOffset), len);
                                m_nOffset += len;
                                ASSERT(m_Src.IsValidIndex2(m_nOffset));         // Don't overflow!
                        }
                        return (HRESULT)len;
                }
        };
 
        class GRAYCORE_LINK cRandomDef : public cRandomBase
        {
 
        public:
                static const SEED_t k_RAND_MAX = 0x7fff;        
 
        private:
                SEED_t m_nSeed; 
 
        public:
                cRandomDef(SEED_t nSeed = 1);
                virtual ~cRandomDef();
 
                SEED_t GetRandNext();
 
                virtual void InitSeed(const void* pData, size_t iSize) override;        // Start a repeatable seeded series
                virtual UINT GetRandUX(UINT nScale) override; // k_RAND_MAX is not always the same as UINT.
        };
 
        extern GRAYCORE_LINK cRandomDef g_Rand; 
};
#endif