MeVis/Foundation/Sources/ML/include/mlMemoryImage.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlMemoryImage_H
#define __mlMemoryImage_H

// ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlRuntime_H
#include "mlRuntime.h"
#endif
#ifndef __mlRuntimeSubClass_H
#include "mlRuntimeSubClass.h"
#endif
#ifndef __mlSubImage_H
#include "mlSubImage.h"
#endif

#include <mlMetaProfilePtr.h>


ML_START_NAMESPACE

class MemoryImageCurrentlyUsedMemoryTracker;
class Module;
class PagedImage;

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class ML_UNIX_ONLY_EXPORT(MLEXPORT) MemoryImage
{

public:

  //------------------------------------------------------

  //------------------------------------------------------
  inline MemoryImage() :
    _subImg(),
    _isValid(false),
    _userControlled(false),
    _calculationPending(false),
    _calculationPendingProcessingScope(-1),
    _currentlyUsedMemoryTracker(NULL)
  {
    ML_TRACE_IN( "MemoryImage::MemoryImage( )" );
  }

  MLEXPORT virtual ~MemoryImage();


  //------------------------------------------------------

  //------------------------------------------------------
  inline SubImage& getImage() { return _subImg;  }

  inline const SubImage& getImage() const { return _subImg;  }

  inline void setValid(bool valid)
  {
    ML_TRACE_IN( "MemoryImage::setValid( )" );
    ML_TRY
    {
      Lock lock(_mutex);
      _isValid = valid;
    }
    ML_CATCH_RETHROW;
  }

  inline bool isValid() const                 { Lock lock(_mutex); return _isValid; }

  inline MLint getSizeInBytes() const
  {
    ML_TRACE_IN( "MemoryImage::getSizeInBytes( )" );
    ML_TRY
    {
      return _subImg.getSizeInBytes();
    }
    ML_CATCH_RETHROW;
  }

  inline void setUserControlled(bool userControlled)
  {
    _userControlled = userControlled;
  }

  inline bool isUserControlled() const
  {
    return _userControlled;
  }

  inline void setCalculationPending(bool flag, int processingScope = -1)
  {
    Lock lock(_mutex);
    _calculationPending = flag;
    _calculationPendingProcessingScope = processingScope;
  }

  inline bool isCalculationPending(int processingScope) const
  {
    Lock lock(_mutex);
    return _calculationPending && (_calculationPendingProcessingScope == processingScope);
  }

  MLEXPORT std::string getAsString() const;

  MLEXPORT void clear();

  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
  MLEXPORT MLErrorCode update(PagedImage* image, const SubImageBox& roi, MLDataType newDataType) ML_RETURN_VALUE_SHOULD_BE_USED;

  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
  MLEXPORT void updateWithSubImage(const SubImage& image);

  MLEXPORT MLMetaProfilePtr& getMetaProfile() const;

private:
  void updateProfilingData();

  mutable Mutex _mutex;

  SubImage    _subImg;

  bool      _isValid;

  bool      _userControlled;

  bool      _calculationPending;

  int       _calculationPendingProcessingScope;

  MemoryImageCurrentlyUsedMemoryTracker* _currentlyUsedMemoryTracker;

  mutable MLMetaProfilePtr _metaProfilePtr;

  friend class MemoryImageCurrentlyUsedMemoryTracker;

#ifdef ML_DEPRECATED



public:

  MLEXPORT ML_DEPRECATED MLErrorCode update(Module *op, MLint outIndex, const SubImageBox &roi, MLDataType newDT);
  inline ML_DEPRECATED SubImage& getImg() { return getImage(); }
  inline ML_DEPRECATED const SubImage& getConstImg() const { return getImage(); }
  inline ML_DEPRECATED MLint getMemoryImgSize() const { return getSizeInBytes(); }
  inline MLEXPORT ML_DEPRECATED void clearMemoryImg() { clear(); }
  inline MLEXPORT ML_DEPRECATED void updateWithSubImg(const SubImage& image) { updateWithSubImage(image); }
  inline ML_DEPRECATED void setManualControl(bool flag) { return setUserControlled(flag); }
  inline ML_DEPRECATED bool getManualControl() const { return isUserControlled(); }


#endif // ML_DEPRECATED

};


#ifdef ML_DEPRECATED




ML_DEPRECATED typedef MemoryImage MemoryImg;
#endif // ML_DEPRECATED


ML_END_NAMESPACE



//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {

  inline ostream& operator<<(ostream& s, const ML_NAMESPACE::MemoryImage &mi)
  {
    return s << mi.getAsString().c_str();
  }

}


#endif // __mlMemoryImage_H