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