itkTreeChangeEvent.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkTreeChangeEvent_h
#define __itkTreeChangeEvent_h

#include "itkMacro.h"
#include "itkEventObject.h"
#include "itkTreeIteratorBase.h"

namespace itk
{
template< class TTreeType >
class TreeChangeEvent:public ModifiedEvent
{
public:

  typedef TreeChangeEvent Self;
  typedef ModifiedEvent   Superclass;

  TreeChangeEvent() { m_ChangePosition = NULL; }

  TreeChangeEvent(const TreeIteratorBase< TTreeType > & position) { m_ChangePosition = &position; }

  virtual ~TreeChangeEvent() {}

  virtual const char * GetEventName() const { return "TreeChangeEvent"; }

  virtual bool CheckEvent(const::itk::EventObject *e) const { return (dynamic_cast< const Self * >( e ) != NULL); }

  virtual::itk::EventObject * MakeObject() const { return new Self(*m_ChangePosition); }

  const TreeIteratorBase< TTreeType > & GetChangePosition() const { return *m_ChangePosition; }

  // cppcheck-suppress uninitVar
  TreeChangeEvent(const Self & s):itk::ModifiedEvent(s) {}
protected:

  const TreeIteratorBase< TTreeType > *m_ChangePosition;
private:
  void operator=(const Self &);
};

template< class TTreeType >
class TreeNodeChangeEvent:public TreeChangeEvent< TTreeType >
{
public:
  typedef TreeNodeChangeEvent          Self;
  typedef TreeChangeEvent< TTreeType > Superclass;

  TreeNodeChangeEvent() {}

  TreeNodeChangeEvent(const TreeIteratorBase< TTreeType > & position):
    TreeChangeEvent< TTreeType >(position) {}

  virtual const char * GetEventName() const { return "TreeNodeChangeEvent"; }

  virtual bool CheckEvent(const::itk::EventObject *e) const { return dynamic_cast< const Self * >( e ); }

  virtual::itk::EventObject * MakeObject() const { return new Self(*this->m_ChangePosition); }

  TreeNodeChangeEvent(const Self & s):TreeChangeEvent< TTreeType >(s) {}
private:
  void operator=(const Self &);
};

template< class TTreeType >
class TreeAddEvent:public TreeChangeEvent< TTreeType >
{
public:

  typedef TreeAddEvent                 Self;
  typedef TreeChangeEvent< TTreeType > Superclass;

  TreeAddEvent() {}

  TreeAddEvent(const TreeIteratorBase< TTreeType > & position):
    TreeChangeEvent< TTreeType >(position) {}

  virtual const char * GetEventName() const { return "TreeAddEvent"; }

  virtual bool CheckEvent(const::itk::EventObject *e) const { return (dynamic_cast< const Self * >( e ) != NULL); }

  virtual::itk::EventObject * MakeObject() const { return new Self(*this->m_ChangePosition); }

  TreeAddEvent(const Self & s):TreeChangeEvent< TTreeType >(s) {}
private:
  void operator=(const Self &);
};

template< class TTreeType >
class TreeRemoveEvent:public TreeChangeEvent< TTreeType >
{
public:

  typedef TreeRemoveEvent              Self;
  typedef TreeChangeEvent< TTreeType > Superclass;

  TreeRemoveEvent(){}

  TreeRemoveEvent(const TreeIteratorBase< TTreeType > & position):
    TreeChangeEvent< TTreeType >(position) {}

  virtual const char * GetEventName() const { return "TreeRemoveEvent"; }

  virtual bool CheckEvent(const::itk::EventObject *e) const { return (dynamic_cast< const Self * >( e ) != NULL); }

  virtual::itk::EventObject * MakeObject() const { return new Self(*this->m_ChangePosition); }

  TreeRemoveEvent(const Self & s):TreeChangeEvent< TTreeType >(s) {}
private:
  void operator=(const Self &);
};

template< class TTreeType >
class TreePruneEvent:public TreeRemoveEvent< TTreeType >
{
public:
  typedef TreePruneEvent               Self;
  typedef TreeRemoveEvent< TTreeType > Superclass;

  TreePruneEvent(){}

  TreePruneEvent(const TreeIteratorBase< TTreeType > & position):
  TreeRemoveEvent< TTreeType >(position) {}

  virtual const char * GetEventName() const { return "TreePruneEvent"; }

  virtual bool CheckEvent(const::itk::EventObject *e) const { return (dynamic_cast< const Self * >( e ) != NULL); }

  virtual::itk::EventObject * MakeObject() const { return new Self(*this->m_ChangePosition); }

  TreePruneEvent(const Self & s):TreeRemoveEvent< TTreeType >(s) {}
private:
  void operator=(const Self &);
};
} // namespace itk

#endif