almemoryfastaccess.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALMEMORYFASTACCESS_ALMEMORYFASTACCESS_ALMEMORYFASTACCESS_H_
#define _LIBALMEMORYFASTACCESS_ALMEMORYFASTACCESS_ALMEMORYFASTACCESS_H_

#include <alvalue/alvalue.h>
#include <alproxies/almemoryproxy.h>

#include <boost/shared_ptr.hpp>

namespace AL
{
  class ALProxy;
  class ALBroker;

  class ALMemoryFastAccess
  {
    typedef std::vector<float *>              TVariablePtrArray;
    typedef std::vector<float *>              TFloatPtrArray;
    typedef std::vector<int *>                TIntPtrArray;
    typedef TVariablePtrArray::iterator       ITVariablePtrArray;
    typedef TVariablePtrArray::const_iterator CITVariablePtrArray;

  public:
    ALMemoryFastAccess();

    ~ALMemoryFastAccess();


    void StopAllAccess(void);

    void insertBuffer(const std::string &pName,
                      const ALValue &pBuff);

    void ConnectToVariables(const boost::shared_ptr<AL::ALBroker> pBroker,
                            const std::vector<std::string> &pListVariables,
                            bool bAllowNonExistantVariable = false);

    void ConnectToIntVariables(const boost::shared_ptr<AL::ALBroker> pBroker,
                               const std::vector<std::string> &pListVariables);

    static void *getDataPtr(boost::shared_ptr<AL::ALBroker> pBroker,
                            const std::string &pStrValue,
                            bool bAllowUnexistantVariable);

    template<typename T>
    static T *getSafeDataPtr(boost::shared_ptr<ALMemoryProxy> pMemoryProxy,
                             const std::string &pStrValue,
                             T pValue)
    {
      bool insertData = false;

      try
      {
        insertData = !pMemoryProxy->getData(pStrValue).isValid();
      }
      catch(const std::exception &)
      {
        // If the data doesn't exist in memory getData return an invalid ALValue
        // or throw. So in this case we try to insert data before getting pointer.
        insertData = true;
      }

      if(insertData)
      {
        pMemoryProxy->insertData(pStrValue, pValue);
      }

      return static_cast<T*>(pMemoryProxy->getDataPtr(pStrValue));
    }

    void directConnectToVariables(const boost::shared_ptr<AL::ALBroker> pBroker,
                                  const std::vector<std::string> &pListVariables,
                                  bool bAllowUnexistantVariable = false);

    void GetValues(std::vector<float> &pListValue) const;

    void SetValues(const std::vector<float> &pListValue);

    void GetValues(std::vector<int> &pListValue) const;

    void SetValues(const std::vector<int> &pListValue);

#ifdef DEBUG

    inline void DisableCheckOnNotExistingValueOrThings_Debug(void) { fbDisableCheking_Debug = true; };
#endif

    static bool InnerTest(const boost::shared_ptr<AL::ALBroker> pBroker);

  private:
    static ALValue* getBuffer(const std::string &pName);

    boost::shared_ptr<AL::ALProxy> fMemoryProxy;

    bool              fbIsLocal;
    TVariablePtrArray fListVariablePtr;
    TFloatPtrArray    fListFloatPtr;
    TIntPtrArray      fListIntPtr;


    ALValue           fCommandToGetData;
    ALValue           fCommandToSetData;

    bool       fStopAllAccess;

#ifdef DEBUG

    bool              fbDisableCheking_Debug;
#endif
  };

} // !namespace AL
#endif  // _LIBALMEMORYFASTACCESS_ALMEMORYFASTACCESS_ALMEMORYFASTACCESS_H_