Filter Library

Camera

Interface Physics

Common.h

/*
 * Common.h - common types and defines.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004, Leiden Probe Microscopy.
 * Copyright (C) 2004, Universiteit Leiden.
 *
 * Authors: Martin J. Moene (original)
 *
 * $Id: Common.h 373 2006-03-10 11:47:06Z moene $
 */

#ifndef CFL_COMMON_H
#define CFL_COMMON_H
#define CFL_IN_COMMON_H

#include <cfl/config.h>                 // global configuration

/**
 * \addtogroup cfl_common Common
 * \brief common types and macro's.
 *
 * The file <tt><cfl/Common.h></tt> contains common types and macro's used
 * throughout the library.
 *
 * stdafx.h includes %Common.h so that this common information is available in
 * every source file.
 *
 * <tt>%Common.h</tt> in its turn includes the following headers:
 * - %Config.h to provide the global \ref cfl_configuration
 * - %QAFDebug.h to provide for Critical Errors Reporting with \ref cfl_assertion macros
 * - %PerfTimer.h to provide for \ref cfl_performance
 *
 * @{
 */

/**
 * use an otherwise unused argument or variable.
 */
#define CFL_USE(a) (a);

/**
 * array dimension; \deprecate replace dim() with dimensionof().
 */
#define dim(a) (sizeof(a)/sizeof((a)[0]))
//#define dim(a) (dimensionof(a))

/**
 * declare a new type and its pointer, const pointer, reference, and const reference types.
 */

#define DECLARE_TYPE( mydecl, mytype )  \
typedef mydecl         mytype;          \
typedef mytype *       mytype ## Ptr;   \
typedef const mytype * mytype ## Cptr;  \
typedef mytype &       mytype ## Ref;   \
typedef const mytype & mytype ## Cref;

/**
 * declare class, class pointer, const pointer, class reference and const class reference types for classes.
 */

#define DECLARE_CLASS( tag )            \
   class   tag;                         \
   typedef tag *       tag ## Ptr;      \
   typedef const tag * tag ## Cptr;     \
   typedef tag &       tag ## Ref;      \
   typedef const tag & tag ## Cref;


DECLARE_TYPE(   char, Char );           ///< convenience types (e.g. CharCptr)

DECLARE_TYPE( double, Time );           ///< for performance measurements

/// @} cfl_common              <<=== <<=== <<===   @} cfl_common

/**
 * Camera application registry subkey for filter settings.
 */
extern const char* gCflRegistrySubkey;

/**
 * \ingroup cfl_common Common
 * \brief algorithm performance measurement data.
 */

struct SPerformanceTestResult
{
   SPerformanceTestResult();            // default constructor
   Time timePrepare;                    ///< calculation before buffer handling
   Time timeBuffer;                     ///< buffer handling
   Time totalTime;                      ///< sum of above
};

/**
 * default constructor.
 */

inline SPerformanceTestResult::SPerformanceTestResult() :
   timePrepare(0), timeBuffer(0), totalTime(0)
{
   ; // do nothing
}

/**
 * \ingroup cfl_common Common
 * \brief intermediary object type for c_str_ptr().
 *
 * Objects of class c_str_ptr_Cwnd_proxy are used by conversion \e shim c_str_ptr()
 * to return a C-string (character pointer) for the specified window pointer. The
 * C-string only lives as long as the expression it is used in.
 *
 * So you may write:
 * \code
 * double value = _tcstod( c_str_ptr( *a_window_pointer ), NULL );
 * \endcode
 *
 * But you may not write:
 * \code
 * TCHAR* pstr  = c_str_ptr( *a_window_pointer );
 * double value = _tcstod( pstr, NULL );
 * \endcode
 *
 * The latter is invalid, because pstr is not valid anymore in the call to
 * _tcstod().
 *
 * To read more about shims, see <em>Shims - A Definition</em>, by M.D. Wilson
 * \ref wilson_shims "[SHIMS]".
 * The proxy class also uses move semantics on the copy-assignment constructor.
 * For more information, see <em>Move Constructors</em>, by M.D. Wilson
 * \ref wilson_mvctor "[MVCTOR]".
 *
 * The implementation of class c_str_ptr_Cwnd_proxy and shim c_str_ptr() were
 * obtained from the MFCSTL library \ref mfcstl "[MFCSTL]".
 */

class c_str_ptr_Cwnd_proxy
{
   typedef  c_str_ptr_Cwnd_proxy self;  ///< this type

public:
           ~c_str_ptr_Cwnd_proxy( );
            c_str_ptr_Cwnd_proxy( self &rhs );
   explicit c_str_ptr_Cwnd_proxy( const CWnd& wnd );

   operator TCHAR*() const;

protected:
    void operator= ( self const &rhs ); ///< prevent assignemnt

private:
   TCHAR* m_buffer;                     ///< the character buffer
};

/**
 * destructor.
 */

inline c_str_ptr_Cwnd_proxy::~c_str_ptr_Cwnd_proxy()
{
   delete[] m_buffer;
}

/**
 * move constructor.
 */

inline c_str_ptr_Cwnd_proxy::c_str_ptr_Cwnd_proxy( self &rhs ) :
   m_buffer( rhs.m_buffer )
{
   rhs.m_buffer = NULL;
}

/**
 * constructor.
 */

inline c_str_ptr_Cwnd_proxy::c_str_ptr_Cwnd_proxy( const CWnd& wnd )
{
   int length = wnd.GetWindowTextLength();

   m_buffer = new TCHAR[1 + length];

   wnd.GetWindowText( m_buffer, length + 1 );
}

/**
 * convert to character string.
 */

inline c_str_ptr_Cwnd_proxy::operator TCHAR*() const
{
   return m_buffer;
}

/*
 * Compiler Warning (level 4) C4239
 * nonstandard extension used : 'token' : conversion from 'type' to 'type'
 * This type conversion is not allowed by the C++ draft standard, but it is
 * permitted here as an extension. This warning is always followed by at least
 * one line of explanation describing the language rule being violated.
 */

#pragma warning( push )
#pragma warning( disable : 4239 )

/**
 * \ingroup cfl_common Common
 * \brief window text conversion shim; result can be used as TCHAR*;
 * see also c_str_ptr_Cwnd_proxy.
 */

inline c_str_ptr_Cwnd_proxy c_str_ptr( const CWnd& wnd )
{
   return c_str_ptr_Cwnd_proxy( wnd );
}

#pragma warning( pop )

#include <qafdebug/QafDebug.h>          // for Critical Errors Reporting with QAFDebug macros
#include <perftimer/PerfTimer.h>        // for class CPerfTimer

/// @} cfl_common

#undef CFL_IN_COMMON_H
#endif // #ifndef CFL_COMMON_H

/*
 * end of file
 */

---