cfl_types.h File Reference

#include <list>
#include <string>
#include <vector>
#include <map>
#include <utility>
#include <iostream>
#include <typeinfo>
#include <algorithm>
#include "cfl_definitions.h"
#include "cfl_token.h"
#include "cfl_tokenreader.h"
#include "cfl_tokenwriter.h"
#include "cfl_exception.h"

Go to the source code of this file.

Classes
class	faudes::Type
class	faudes::CastToType< T, bool >
class	faudes::CastToType< T, true >
class	faudes::CastToType< T, false >
class	faudes::AttrType
class	faudes::ExtType
class	faudes::Documentation
class	faudes::TypeDefinition

Namespaces
namespace	faudes

Macros
#define	FAUDES_TYPE_DECLARATION(ftype, ctype, cbase)
#define	FAUDES_TYPE_TDECLARATION(ftype, ctype, cbase)
#define	FAUDES_TYPE_IMPLEMENTATION_NEW(ftype, ctype, cbase)    ctype* ctype::New(void) const { return new ctype(); }
#define	FAUDES_TYPE_IMPLEMENTATION_NEWCOPY(ftype, ctype, cbase)    ctype* ctype::NewCpy(void) const { return new ctype(*this); }
#define	FAUDES_TYPE_IMPLEMENTATION_CAST(ftype, ctype, cbase)
#define	FAUDES_TYPE_IMPLEMENTATION_ASSIGN(ftype, ctype, cbase)
#define	FAUDES_TYPE_IMPLEMENTATION_MOVE(ftype, ctype, cbase)
#define	FAUDES_TYPE_IMPLEMENTATION_EQUAL(ftype, ctype, cbase)
#define	FAUDES_TYPE_TIMPLEMENTATION_NEW(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_TIMPLEMENTATION_NEWCOPY(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_TIMPLEMENTATION_CAST(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_TIMPLEMENTATION_ASSIGN(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_TIMPLEMENTATION_MOVE(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_TIMPLEMENTATION_EQUAL(ftype, ctype, cbase, ctemp)
#define	FAUDES_TYPE_IMPLEMENTATION(ftype, ctype, cbase)
#define	FAUDES_TYPE_TIMPLEMENTATION(ftype, ctype, cbase, ctemp)

Detailed Description

Runtime interface, faudes types

Definition in file cfl_types.h.

Macro Definition Documentation

FAUDES_TYPE_DECLARATION

#define FAUDES_TYPE_DECLARATION	(		ftype,
			ctype,
			cbase
	)

Value:

  public: virtual ctype* New(void) const;             \
  public: virtual ctype* NewCpy(void) const;            \
  public: virtual const Type* Cast(const Type* pOther) const; \
  public: virtual ctype& Copy(const Type& rSrc);      \
  public: virtual ctype& Move(Type& rSrc);      \
  public: virtual bool Equal(const Type& rOther) const; \
  public: ctype& operator=(const ctype& rSrc);    \
  public: ctype& operator=(ctype&& rSrc);   \
  public: bool operator==(const ctype& rOther) const; \
  public: bool operator!=(const ctype& rOther) const;

faudes type declaration macro

Definition at line 918 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION

#define FAUDES_TYPE_IMPLEMENTATION	(		ftype,
			ctype,
			cbase
	)

Value:

  ctype* ctype::New(void) const {     \
    return new ctype(); }  \
  ctype* ctype::NewCpy(void) const {      \
    return new ctype(*this); } \
  const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast< const ctype * >(pOther); } \
  ctype& ctype::Copy(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast< const ctype * >(&rSrc)) {  \
      this->DoCopy(*csattr);}     \
    else {    \
      cbase::Copy(rSrc);};  \
    return *this;} \
  ctype& ctype::operator=(const ctype& rSrc) { this->DoCopy(rSrc); return *this; } \
  ctype& ctype::Move(Type& rSrc) { \
    if(ctype* csattr=dynamic_cast< ctype * >(&rSrc)) {  \
      this->DoMove(*csattr);}     \
    else {    \
      cbase::Move(rSrc);};  \
    return *this;} \
  ctype& ctype::operator=(ctype&& rSrc) { this->DoMove(rSrc); return *this; } \
  bool ctype::Equal(const Type& rOther) const { \
    if(&rOther==this) return true; \
    if(typeid(rOther) != typeid(*this)) return false; \
    const ctype* csattr=dynamic_cast<const ctype*>(&rOther); \
    if(!csattr) return false; \
    if(!this->DoEqual(*csattr)) return false;   \
    return true;} \
  bool ctype::operator==(const ctype& rOther) const { return this->DoEqual(rOther); } \
  bool ctype::operator!=(const ctype& rOther) const { return !this->DoEqual(rOther); }

faudes type implementation macros, overall

Definition at line 1017 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_ASSIGN

#define FAUDES_TYPE_IMPLEMENTATION_ASSIGN	(		ftype,
			ctype,
			cbase
	)

Value:

  ctype& ctype::Copy(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast< const ctype * >(&rSrc)) {  \
      DoCopy(*csattr);}       \
    else {    \
      cbase::Copy(rSrc);};  \
    return *this;} \
  ctype& ctype::operator=(const ctype& rSrc) { DoCopy(rSrc); return *this; }

Definition at line 951 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_CAST

#define FAUDES_TYPE_IMPLEMENTATION_CAST	(		ftype,
			ctype,
			cbase
	)

Value:

  const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast< const ctype * >(pOther); }

Definition at line 948 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_EQUAL

#define FAUDES_TYPE_IMPLEMENTATION_EQUAL	(		ftype,
			ctype,
			cbase
	)

Value:

  bool ctype::Equal(const Type& rOther) const { \
    if(&rOther==this) return true; \
    if(typeid(rOther) != typeid(*this)) return false; \
    const ctype* csattr=dynamic_cast<const ctype*>(&rOther); \
    if(!csattr) return false; \
    if(!DoEqual(*csattr)) return false; \
    return true;} \
  bool ctype::operator==(const ctype& rOther) const { return DoEqual(rOther); } \
  bool ctype::operator!=(const ctype& rOther) const { return !DoEqual(rOther); }

Definition at line 967 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_MOVE

#define FAUDES_TYPE_IMPLEMENTATION_MOVE	(		ftype,
			ctype,
			cbase
	)

Value:

  ctype& ctype::Move(Type& rSrc) {          \
    if(ctype* csattr=dynamic_cast< ctype * >(&rSrc)) {  \
      DoMove(*csattr);}       \
    else {    \
      cbase::Move(rSrc);};  \
    return *this;} \
  ctype& ctype::operator=(ctype&& rSrc) { DoMove(rSrc); return *this; }

Definition at line 959 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_NEW

#define FAUDES_TYPE_IMPLEMENTATION_NEW	(		ftype,
			ctype,
			cbase
	)		ctype* ctype::New(void) const { return new ctype(); }

faudes type implementation macros

Definition at line 944 of file cfl_types.h.

FAUDES_TYPE_IMPLEMENTATION_NEWCOPY

#define FAUDES_TYPE_IMPLEMENTATION_NEWCOPY	(		ftype,
			ctype,
			cbase
	)		ctype* ctype::NewCpy(void) const { return new ctype(*this); }

Definition at line 946 of file cfl_types.h.

FAUDES_TYPE_TDECLARATION

#define FAUDES_TYPE_TDECLARATION	(		ftype,
			ctype,
			cbase
	)

Value:

  public: virtual ctype* New(void) const;             \
  public: virtual ctype* NewCpy(void) const;            \
  public: virtual const Type* Cast(const Type* pOther) const; \
  public: virtual ctype& Copy(const Type& rSrc);      \
  public: virtual ctype& Move(Type& rSrc);      \
  public: virtual bool Equal(const Type& rOther) const; \
  public: ctype& operator=(const ctype& rSrc);      \
  public: ctype& operator=(ctype&& rSrc);      \
  public: bool operator==(const ctype& rOther) const; \
  public: bool operator!=(const ctype& rOther) const;

faudes type declaration macro, template version

Definition at line 931 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION

#define FAUDES_TYPE_TIMPLEMENTATION	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp ctype* ctype::New(void) const {     \
    return new ctype(); }  \
  ctemp ctype* ctype::NewCpy(void) const {      \
    return new ctype(*this); } \
  ctemp const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast< const ctype * >(pOther); } \
  ctemp ctype& ctype::Copy(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast< const ctype * >(&rSrc)) {  \
      /* this->Clear(); */ this->DoCopy(*csattr);}      \
    else {    \
      cbase::Copy(rSrc);};  \
    return *this;} \
  ctemp ctype& ctype::operator=(const ctype& rSrc) { this->DoCopy(rSrc); return *this; } \
  ctemp ctype& ctype::Move(Type& rSrc) {        \
    if(ctype* csattr=dynamic_cast< ctype * >(&rSrc)) {  \
      this->DoMove(*csattr);}     \
    else {    \
      cbase::Move(rSrc);};  \
    return *this;} \
  ctemp ctype& ctype::operator=(ctype&& rSrc) { this->DoMove(rSrc); return *this; } \
  ctemp bool ctype::Equal(const Type& rOther) const { \
    if(&rOther==this) return true; \
    if(typeid(rOther) != typeid(*this)) return false; \
    const ctype* csattr=dynamic_cast<const ctype*>(&rOther); \
    if(!csattr) return false; \
    if(!this->DoEqual(*csattr)) return false;   \
    return true;} \
  ctemp bool ctype::operator==(const ctype& rOther) const { return this->DoEqual(rOther); } \
  ctemp bool ctype::operator!=(const ctype& rOther) const { return !this->DoEqual(rOther); }

faudes type implementation macros, overall

Definition at line 1050 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_ASSIGN

#define FAUDES_TYPE_TIMPLEMENTATION_ASSIGN	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp ctype& ctype::Copy(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast< const ctype * >(&rSrc)) {  \
      DoCopy(*csattr);}       \
    else {    \
      cbase::Copy(rSrc);};  \
    return *this;} \
  ctemp ctype& ctype::operator=(const ctype& rSrc) { DoCopy(rSrc); return *this; }

Definition at line 988 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_CAST

#define FAUDES_TYPE_TIMPLEMENTATION_CAST	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast< const ctype * >(pOther); }

Definition at line 985 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_EQUAL

#define FAUDES_TYPE_TIMPLEMENTATION_EQUAL	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp bool ctype::Equal(const Type& rOther) const { \
    if(&rOther==this) return true; \
    if(typeid(rOther) != typeid(*this)) return false; \
    const ctype* csattr=dynamic_cast<const ctype*>(&rOther); \
    if(!csattr) return false; \
    if(!DoEqual(*csattr)) return false;   \
    return true;} \
  ctemp bool ctype::operator==(const ctype& rOther) const { return DoEqual(rOther); } \
  ctemp bool ctype::operator!=(const ctype& rOther) const { return !DoEqual(rOther); }

Definition at line 1004 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_MOVE

#define FAUDES_TYPE_TIMPLEMENTATION_MOVE	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp ctype& ctype::Move(Type& rSrc) { \
    if(ctype* csattr=dynamic_cast< ctype * >(&rSrc)) {  \
      DoMove(*csattr);}       \
    else {    \
      cbase::Move(rSrc);};  \
    return *this;} \
  ctemp ctype& ctype::operator=(ctype&& rSrc) { DoMove(rSrc); return *this; }

Definition at line 996 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_NEW

#define FAUDES_TYPE_TIMPLEMENTATION_NEW	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp ctype* ctype::New(void) const {     \
    return new ctype(); }

faudes type implementation macros, template version

Definition at line 979 of file cfl_types.h.

FAUDES_TYPE_TIMPLEMENTATION_NEWCOPY

#define FAUDES_TYPE_TIMPLEMENTATION_NEWCOPY	(		ftype,
			ctype,
			cbase,
			ctemp
	)

Value:

  ctemp ctype* ctype::NewCpy(void) const {      \
    return new ctype(*this); }

Definition at line 982 of file cfl_types.h.