itkMetaDataObject.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMetaDataObject.h,v $
  Language:  C++
  Date:      $Date: 2007-12-04 22:44:53 $
  Version:   $Revision: 1.21 $

  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>

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__))
      /*
       * from page 10.4.11 pg 256 of the Stroustrup book:
       * ========================================================================
       * The reinterpret_cast is the crudest and potentially nastiest of the type
       * conversion operators.  In most caes, it simply yeilds a value with the
       * same bit pattern as it's argument wit the type required .  Thus, it can
       * be used for the inherently implementation-depend, dangerous, and
       * occasionally absolutely necessary activity of converting interger values
       * to pointers, and  vice versa.
       */
      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

---