/*=============================================================================

  NOTE: THIS FILE WAS AUTOMATICALLY GENERATED BY THE ManagedITK PROJECT.

  Project:   ManagedITK
  Program:   Insight Segmentation & Registration Toolkit
  Module:    @NAMESPACE@Managed@MANAGED_BASE_NAME@.cxx
  Language:  C++/CLI
  Author:    Dan Mueller
  Date:      $Date: 2007-09-01 06:17:25 +1000 (Sat, 01 Sep 2007) $
  Revision:  $Revision: 2 $

  Copyright (c) Queensland University of Technology (QUT) 2007.
  All rights reserved.
  
  Portions of this code are covered under the ITK and VTK copyright.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
  
=============================================================================*/

#pragma once
#pragma warning( disable : 4635 ) // Disable warnings about XML doc comments

#ifndef __@NAMESPACE@Managed@MANAGED_BASE_NAME@_cxx
#define __@NAMESPACE@Managed@MANAGED_BASE_NAME@_cxx

// Use some managed namespaces
#using <mscorlib.dll>
#using <System.dll>
#using <ManagedITK.Common.dll>
using namespace System;
using namespace System::IO;
using namespace System::Reflection;
using namespace System::ComponentModel;
using namespace System::Diagnostics;

namespace @NAMESPACE@
{

@MANAGED_EXTRA_WRAPPER@

///<summary>
///This class is a managed interface for itk::@MANAGED_BASE_NAME@.
///</summary>
///<remarks>
///Both the wrapper and type classes derive from this interface.
///</remarks>
public interface class I@MANAGED_BASE_NAME@
{
    @MANAGED_PROPERTIES_INTERFACE@
    @MANAGED_METHODS_INTERFACE@
};


///<summary>
///This class is a managed wrapper for @NAMESPACE@::@MANAGED_BASE_NAME@.
///</summary>
///<remarks>
///The actual type instance can be specified by calling the New()
///method with the desired output image type.
///</remarks>
public ref class @NAMESPACE@@MANAGED_BASE_NAME@ :
    itk::itkNeighborhoodOperator, I@MANAGED_BASE_NAME@
{
private:
    itk::itkNeighborhoodOperator^ m_Instance;

public:
    ///<summary>Constructor.</summary>
    ///<param name="mangledType">A string specifying which instance type to create. Eg. "IUC2", "IF3", etc.</param>
	@NAMESPACE@@MANAGED_BASE_NAME@( System::String^ mangledType ) : itk::itkNeighborhoodOperator( )
    {
        this->m_MangledTypeString = mangledType;
        this->CreateInstance( nullptr );
    }
    
    ///<summary>Constructor.</summary>
    ///<param name="pixelType">The pixel type for which the neighborhood is defined.</param>
    ///<param name="dimension">The number of dimensions for which the neighborhood is defined.</param>
	@NAMESPACE@@MANAGED_BASE_NAME@( itk::itkPixelType^ pixelType, unsigned int dimension ) : itk::itkNeighborhoodOperator( )
    {
        this->m_MangledTypeString = pixelType->MangledTypeString + dimension.ToString();
        this->CreateInstance( nullptr );
    }
    
    @MANAGED_CONSTRUCTORS_WRAPPER@

    ///<summary>Dispose of the managed object.</summary>
    ~@NAMESPACE@@MANAGED_BASE_NAME@ ( )
    {
		if (!this->IsDisposed)
		{
            this->m_IsDisposed = true;
            delete m_Instance;
        }
    }
    
    ///<summary>Finalize the managed object.</summary>
    !@NAMESPACE@@MANAGED_BASE_NAME@ ( )
    {
        if (!this->IsDisposed)
            delete this;
    }
    
	///<summary>
	///Get/set the pointer to the native ITK object associated with
	///this wrapper instance.
	///</summary>
	///<returns>The pointer to the native ITK object.</returns>
	property void* NativePointer
    {
        virtual void* get() override { return this->m_Instance->NativePointer; }
        virtual void set ( void* value ) override { this->m_Instance->NativePointer = value; }
    }

    ///<summary>Get the size (the total length of the sides) of the neighborhood.</summary>
	property itk::itkSize^ Size
    {
        virtual itk::itkSize^ get() override { return this->m_Instance->Size; }
    }

	///<summary>Get/set the radius of the neighborhood.</summary>
	property itk::itkSize^ Radius
    {
        virtual itk::itkSize^ get() override { return this->m_Instance->Radius; }
        virtual void set(itk::itkSize^ value) override { this->m_Instance->Radius = value; }
    }
    
    ///<summary>Return a string representing the wrapped object.</summary>
	virtual String^ ToString ( ) override
	{
        return m_Instance->ToString( );
	}

	///<summary>Returns the radius of the neighborhood along a specified dimension.</summary>
	virtual unsigned long GetRadius(const unsigned long n) override
	{
        return this->m_Instance->GetRadius(n);
    }
	
	///<summary>Returns the size (total length) of the neighborhood along a specified dimension.</summary>
	virtual unsigned long GetSize(const unsigned long n) override
	{
        return this->m_Instance->GetSize(n);
    }

	///<summary>Returns the element at the center of the neighborhood.</summary>
	virtual itk::itkPixel^ GetCenterValue() override
	{
        return this->m_Instance->GetCenterValue();
    }

	///<summary>Returns the array index of the element at the given offset.</summary>
	virtual unsigned int GetNeighborhoodIndex(itk::itkOffset^ offset) override
	{
        return this->m_Instance->GetNeighborhoodIndex(offset);
    }

	///<summary>Returns the array index of the center element.</summary>
	virtual unsigned int GetCenterNeighborhoodIndex() override
	{
        return this->m_Instance->GetCenterNeighborhoodIndex();
    }

	///<summary>Returns pixel value in the buffer at the given index.</summary>
	virtual itk::itkPixel^ GetElement(unsigned int i) override
	{
        return this->m_Instance->GetElement(i);
    }

	///<summary>Allow index access to the buffer.</summary>
	virtual itk::itkPixel^ operator[] (unsigned int i) override
	{
        return this->m_Instance[i];
    }

	///<summary>Implement the IEnumerable interface.</summary>
	virtual System::Collections::IEnumerator^ GetEnumerator() override
	{
        return this->m_Instance->GetEnumerator();
    }

    ///<summary>Get/set the dimensional direction (dimension number) of a directional operator.</summary>
	property unsigned long Direction 
    { 
        virtual unsigned long get() override { return this->m_Instance->Direction; }
        virtual void set(unsigned long value) override { this->m_Instance->Direction = value; }
    }

	///<summary>
	///Creates the operator with length only in the specified direction. 
	///The radius of the operator will be 0 except along the axis on which
    ///the operator will work.
	///</summary>
	virtual void CreateDirectional() override
	{
        this->m_Instance->CreateDirectional();
    }
    @MANAGED_PROPERTIES_WRAPPER@ @MANAGED_METHODS_WRAPPER@

private:
	///<summary>Creates the correct type instance of the underlying native itk::NeighborhoodOperator.</summary>
	void CreateInstance( array<Object^>^ args )
	{
        this->m_IsDisposed = false;
        String^ nameInstanceType = "@NAMESPACE@.@NAMESPACE@@MANAGED_BASE_NAME@_" + this->MangledTypeString;
		
		try
		{
			Type^ typeInstance = Assembly::GetExecutingAssembly()->GetType(nameInstanceType);
			if (typeInstance == nullptr)
			    throw gcnew NullReferenceException("The type '" + nameInstanceType + "' could not be found in " + Assembly::GetExecutingAssembly()->GetName() );
			Object^ objInstance = Activator::CreateInstance(typeInstance, args);
			if (objInstance == nullptr)
			    throw gcnew NullReferenceException("Could not invoke constructor for '" + nameInstanceType + "'.");
            this->m_Instance = safe_cast<itk::itkNeighborhoodOperator^>(objInstance);
		}
		catch (Exception^ ex)
		{
			throw gcnew itk::itkInvalidWrappedTypeException("Could not create an instance of '" + nameInstanceType + "'. The given type may not be supported or may be invalid.", ex);
		}
    }

}; // end ref class

} // end namespace @MANAGED_BASE_NAME@

#endif