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
  {
  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 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);

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

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

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

    std::vector<float *> fFloatPtrs;
    std::vector<int *> fIntPtrs;

    bool fStopAllAccess;
  };

} // !namespace AL
#endif  // _LIBALMEMORYFASTACCESS_ALMEMORYFASTACCESS_ALMEMORYFASTACCESS_H_