almemoryfastaccess/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 <alvalue/detail/alfunctorconvert.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 TVariablePtrArray::iterator       ITVariablePtrArray;
    typedef TVariablePtrArray::const_iterator CITVariablePtrArray;

  public:
    ALMemoryFastAccess();

    ~ALMemoryFastAccess();


    static void StopAllAccess(void);

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

    template <typename C>
    void insertObject(const std::string &pName,
                      C pObject)
    {
      // serialize object and put binary data in ALValue because ALMemory only support ALValue
      AL::detail::converter<C> conv;
      ALValue bData  = conv.convertToALValue(pObject);
      insertBuffer(pName, bData);
    }

    template <typename C>
    static C getObject(const std::string &pName)
    {
      ALValue *val =  getBuffer(pName);

      // convert memory buffer to object
      AL::detail::converter<C> conv;
      C retObject = conv.convertFromALValue(*val);
      return retObject;
    }

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

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

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

#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;


    ALValue           fCommandToGetData;
    ALValue           fCommandToSetData;

#ifdef DEBUG

    bool              fbDisableCheking_Debug;
#endif

    static bool       static_bStopAllAccess;
  };

} // !namespace AL
#endif  // _LIBALMEMORYFASTACCESS_ALMEMORYFASTACCESS_ALMEMORYFASTACCESS_H_