mlField.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_FIELD_H
#define ML_FIELD_H
 
 
// ML-includes
#include "mlInitSystemML.h"
#include "mlRuntimeSubClass.h"
#include "mlFieldSensor.h"
 
#include <string>
#include <vector>
 
ML_START_NAMESPACE
 
class OutputConnectorField;
class BaseField;
class SoNodeField;
class NotifyField;
class FieldContainer;
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Field
{
 
public:
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  Field(const std::string& name = std::string());
 
  virtual ~Field();
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
  FieldContainer* getFieldContainer() const { return _fieldContainer; }
 
 
  //----------------------------------------------------------
  //----------------------------------------------------------
  const std::string& getName() const                  { return _name; }
 
  void               setName(const std::string& name) { _name = name; }
 
  std::string getFullName() const;
 
  //----------------------------------------------------------
  //----------------------------------------------------------
  bool isOutputOnly() const;
 
  void setOutputOnly(bool outputOnly = true);
 
  //----------------------------------------------------------
  //----------------------------------------------------------
 
  virtual void setStringValue(const std::string& value) =0;
 
  virtual std::string getStringValue() const =0;
 
  virtual MLint isValidValue(){ return 1; }
 
 
  void copyCStringValue(char* valueBuffer, MLint bufferSize);
 
  MLint getCStringValueSize(){ return static_cast<MLint>(getStringValue().size()); }
 
 
  //------------------------------------------------------------------------
  //------------------------------------------------------------------------
  void        attachFieldSensor(FieldSensor* sensor);
 
  void        detachFieldSensor(FieldSensor* sensor);
 
  void        detachFieldSensors();
 
  void                attachField(OutputConnectorField* targetField);
  void                attachField(BaseField* targetField);
  void                attachField(SoNodeField* targetField);
  void                attachField(NotifyField* targetField);
 
  void                attachField(Field* targetField, bool propagateValueOnConnect);
 
  void                detachField(Field* targetField);
 
  void                detachSourceFields();
 
  void                detachDestinationFields();
 
  void                detachAllFields();
 
  size_t              getNumDestinationFields();
 
  Field*              getDestinationField(size_t index);
 
  size_t              getNumSourceFields();
 
  Field*              getSourceField(size_t index);
 
  virtual void        touch(FieldSensor::Strength strength=FieldSensor::CHANGED);
 
  void enableNotifications(bool flag);
 
  bool areNotificationsEnabled();
 
  static void enableNotificationsGlobally(bool flag);
 
  static bool areNotificationsEnabledGlobally();
 
  static MLint& enableNotificationsCounterState();
 
protected:
  void attachSourceField(Field* field);
 
  void detachSourceField(Field* field);
 
  void detachFieldInternal(Field* field);
 
  virtual void setValueFromField(const Field& field);
 
  std::string _name;
 
  std::vector <FieldSensor*>     _sensors;
 
  std::vector <Field*>           _destinationFields;
 
  std::vector <Field*>           _sourceFields;
 
  FieldContainer*                _fieldContainer;
 
  struct Flags {
    unsigned int observersWereRemovedInsideTouch:1; 
    unsigned int insideTouch:1;           
    unsigned int notifyAttachmentsFlag:1; 
    unsigned int outputOnly:1;            
  };
 
  Flags                          _flags;
 
  static MLint                   _enableNotifications;
 
private:
  friend class FieldContainer;
 
  void setFieldContainer(FieldContainer* container) { _fieldContainer = container; }
 
  // disallow copying
  Field(const Field&) {}
  Field& operator=(const Field&) { return *this; }
 
  ML_ABSTRACT_ROOT_CLASS_HEADER(Field)
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  #define notifyAttachments touch
 
#if defined(WIN32) && !defined(ML_NO_DEPRECATED_WARNINGS)
  #pragma deprecated("notifyAttachments")
#endif
 
  inline ML_DEPRECATED void deactivateAttachments() { enableNotifications(false); }
  inline ML_DEPRECATED void activateAttachments() { enableNotifications(true); }
  inline ML_DEPRECATED MLint isActiveAttachments() { return areNotificationsEnabled(); }
  inline ML_DEPRECATED static void disableNotifications() { enableNotificationsGlobally(false); }
  inline ML_DEPRECATED static void enableNotifications() { enableNotificationsGlobally(true); }
  inline ML_DEPRECATED static MLint isEnabledNotifications() { return areNotificationsEnabledGlobally(); }
 
 
#endif
 
 
};
 
ML_END_NAMESPACE
 
 
//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std
{
 
  MLEXPORT std::ostream& operator<<(std::ostream& s, const ML_NAMESPACE::Field &v);
 
}
 
 
#endif // __mlField_H