itkMetaDataObject.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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef __itkMetaDataObject_h
#define __itkMetaDataObject_h

#include "itkMetaDataDictionary.h"
#include "itkMacro.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(SizeValueType 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;
    }
    {
    if ( MetaDataObject< T > *TempMetaDataObject = dynamic_cast< MetaDataObject< T > * >( Dictionary[key].GetPointer() ) )
      {
      outval = TempMetaDataObject->GetMetaDataObjectValue();
      }
    else
      {
      return false;
      }
    }
  return true;
}

// 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) \

#if 0
// Define a specialization of the Print function
// for some basic types. We don't use the initial
// NATIVE_TYPE_METADATAPRINT macro because it lacks
// the inline keyword and it tries to specialize
// for const types which does not compile on MSVC
#define NATIVE_TYPE_METADATAPRINT_NOCONST(TYPE_NAME) \
  template< >                                        \
  inline void itk::MetaDataObject< TYPE_NAME >       \
  ::Print(std::ostream & os) const                   \
    {                                                \
    os << this->m_MetaDataObjectValue << std::endl;  \
    }

NATIVE_TYPE_METADATAPRINT_NOCONST(unsigned char)
NATIVE_TYPE_METADATAPRINT_NOCONST(short)
NATIVE_TYPE_METADATAPRINT_NOCONST(unsigned short)
NATIVE_TYPE_METADATAPRINT_NOCONST(int)
NATIVE_TYPE_METADATAPRINT_NOCONST(unsigned int)
NATIVE_TYPE_METADATAPRINT_NOCONST(long)
NATIVE_TYPE_METADATAPRINT_NOCONST(unsigned long)
NATIVE_TYPE_METADATAPRINT_NOCONST(float)
NATIVE_TYPE_METADATAPRINT_NOCONST(double)
NATIVE_TYPE_METADATAPRINT_NOCONST(std::string)

// undef the macro to clean up things
#undef NATIVE_TYPE_METADATAPRINT_NOCONST
#endif

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

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

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

#endif //itkMetaDataObject_h