itkMetaDataObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMetaDataObject.h,v $
  Language:  C++
  Date:      $Date: 2009-06-14 09:20:22 $
  Version:   $Revision: 1.27 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  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.

=========================================================================*/
#ifndef __itkMetaDataObject_h
#define __itkMetaDataObject_h

#include "itkMetaDataDictionary.h"
#include "itkMacro.h"
#include "itkObjectFactory.h"
#include "itkCommand.h"
#include "itkFastMutexLock.h"

#include <string.h>
#include <cstring>

namespace itk
{
template <class MetaDataObjectType>
class ITK_EXPORT MetaDataObject: public MetaDataObjectBase
{
public:

  typedef MetaDataObject            Self;
  typedef MetaDataObjectBase        Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkFactorylessNewMacro(Self);

  itkTypeMacro(MetaDataObject, MetaDataObjectBase);

  MetaDataObject(void);

  virtual ~MetaDataObject(void);

  MetaDataObject(const MetaDataObjectType InitializerValue);

  MetaDataObject(const MetaDataObject<MetaDataObjectType> &TemplateObject);

  virtual const char * GetMetaDataObjectTypeName(void) const;

  virtual const std::type_info & GetMetaDataObjectTypeInfo(void) const;

  const MetaDataObjectType & GetMetaDataObjectValue(void) const;

  void SetMetaDataObjectValue(const MetaDataObjectType & NewValue );

  virtual void Print(std::ostream& os) const;
private:
  //This is made private to force the use of the MetaDataObject<MetaDataObjectType>::New() operator!
  //void * operator new(size_t nothing) {};//purposefully not implemented

  MetaDataObjectType m_MetaDataObjectValue;
};


template <class T>
inline void EncapsulateMetaData(MetaDataDictionary &Dictionary, const std::string & key, const T &invalue)
{
  typename MetaDataObject<T>::Pointer temp=MetaDataObject<T>::New();
  temp->SetMetaDataObjectValue(invalue);
  Dictionary[key] = temp;
}

template <class T>
inline void EncapsulateMetaData(MetaDataDictionary &Dictionary, const char *key, const T &invalue)
{
  EncapsulateMetaData(Dictionary, std::string(key), invalue);
}

template <class T>
inline bool ExposeMetaData(MetaDataDictionary &Dictionary, const std::string key, T &outval)
{
  if(!Dictionary.HasKey(key))
    {
    return false;
    }

  MetaDataObjectBase::Pointer baseObjectSmartPointer = Dictionary[key];
  
  if(strcmp(typeid(T).name(),baseObjectSmartPointer->GetMetaDataObjectTypeName()) != 0)
    {
    return false;
    }
  //The following is necessary for getting this to work on
  //kitware's SGI computers.  It is not necessary for
  //for IRIX 6.5.18m with MIPSPro 7.3.1.3m.
#if (defined(__sgi) && !defined(__GNUC__))

  outval =
    reinterpret_cast<MetaDataObject <T> *>(Dictionary[key].GetPointer())->GetMetaDataObjectValue();
#else
    {
    if(MetaDataObject <T> * TempMetaDataObject =dynamic_cast<MetaDataObject <T> *>(Dictionary[key].GetPointer()))
      {
      outval = TempMetaDataObject->GetMetaDataObjectValue();
      }
    else
      {
      return false;
      }
    }
#endif
  //                                 --------------- ^^^^^^^^^^^^
  //                                 SmartPointer    MetaDataObject<T>*
  return true;
}

//This is only necessary to make the borland compiler happy.  It should not be necesary for most compilers.
//This should not change the behavior, it just adds an extra level of complexity to using the ExposeMetaData
//with const char * keys.
template <class T>
inline bool ExposeMetaData(MetaDataDictionary &Dictionary, const char * const key, T &outval)
{
  return ExposeMetaData(Dictionary, std::string(key), outval);
}
// const versions of ExposeMetaData just to make life easier for enduser programmers, and to maintain backwards compatibility.
// The other option is to cast away constness in the main function.
template <class T>
inline bool ExposeMetaData(const MetaDataDictionary &Dictionary, const std::string key, T &outval)
{
  MetaDataDictionary NonConstVersion=Dictionary;
  return ExposeMetaData(NonConstVersion,key,outval);
}

template <class T>
inline bool ExposeMetaData(const MetaDataDictionary &Dictionary, const char * const key, T &outval)
{
  MetaDataDictionary NonConstVersion=Dictionary;
  return ExposeMetaData(Dictionary, std::string(key), outval);
}

} // end namespace itk

#define NATIVE_TYPE_METADATAPRINT(TYPE_NAME) \
template <> \
void \
  itk::MetaDataObject< TYPE_NAME > \
  ::Print(std::ostream& os) const \
{ \
  os << this->m_MetaDataObjectValue << std::endl; \
} \
template <> \
void \
  itk::MetaDataObject< const TYPE_NAME > \
  ::Print(std::ostream& os) const \
{ \
  os << this->m_MetaDataObjectValue << std::endl; \
}


#define ITK_OBJECT_TYPE_METADATAPRINT_1COMMA( TYPE_NAME_PART1 , TYPE_NAME_PART2 ) \
template <> \
void \
  itk::MetaDataObject< TYPE_NAME_PART1 , TYPE_NAME_PART2 > \
  ::Print(std::ostream& os) const \
{ \
  this->m_MetaDataObjectValue->Print(os); \
} \
template <> \
void \
  itk::MetaDataObject< const TYPE_NAME_PART1 , TYPE_NAME_PART2 > \
  ::Print(std::ostream& os) const \
{ \
  this->m_MetaDataObjectValue->Print(os); \
}


#define ITK_IMAGE_TYPE_METADATAPRINT(STORAGE_TYPE) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 1 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 2 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 3 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 4 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 5 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 6 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 7 >::Pointer) \
  ITK_OBJECT_TYPE_METADATAPRINT_1COMMA(itk::Image< STORAGE_TYPE , 8 >::Pointer) \

// Define instantiation macro for this template.
#define ITK_TEMPLATE_MetaDataObject(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT MetaDataObject< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef MetaDataObject< ITK_TEMPLATE_1 x > \
                                         MetaDataObject##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkMetaDataObject+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkMetaDataObject.txx"
#endif


#endif //itkMetaDataObject_h