cfl_types.h File Reference

Runtime interface, faudes types. More...

#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
 Base class of all libFAUDES objects that participate in the run-time interface. More...
class  faudes::Documentation
 faudes type implementation macros, overall, debug version More...
class  faudes::TypeDefinition
 A TypeDefinition defines a faudes-type in that it specifies a faudes-type name to identify the type and a method NewObject() to instantiate objects of the respective type. More...

Namespaces

namespace  faudes
 

libFAUDES resides within the namespace faudes.


Defines

#define FAUDES_TYPE_DECLARATION_NEW(ftype, ctype, cbase)   public: virtual ctype* New(void) const;
 faudes type declaration macros, individual
#define FAUDES_TYPE_DECLARATION_COPY(ftype, ctype, cbase)   public: virtual ctype* Copy(void) const;
#define FAUDES_TYPE_DECLARATION_CAST(ftype, ctype, cbase)   public: virtual const Type* Cast(const Type* pOther) const;
#define FAUDES_TYPE_DECLARATION_ASSIGN(ftype, ctype, cbase)   public: virtual ctype& Assign(const Type& rSrc);
#define FAUDES_TYPE_DECLARATION_EQUAL(ftype, ctype, cbase)
#define FAUDES_TYPE_DECLARATION(ftype, ctype, cbase)
 faudes type declaration macro, overall
#define FAUDES_TYPE_TDECLARATION(ftype, ctype, cbase)
 faudes type declaration macro, template version
#define FAUDES_TYPE_IMPLEMENTATION_NEW(ftype, ctype, cbase)
 faudes type implementation macros, individual
#define FAUDES_TYPE_IMPLEMENTATION_COPY(ftype, ctype, cbase)
#define FAUDES_TYPE_IMPLEMENTATION_CAST(ftype, ctype, cbase)
#define FAUDES_TYPE_IMPLEMENTATION_ASSIGN(ftype, ctype, cbase)
#define FAUDES_TYPE_IMPLEMENTATION_EQUAL(ftype, ctype, cbase)
#define FAUDES_TYPE_IMPLEMENTATION(ftype, ctype, cbase)
 faudes type implementation macros, overall
#define FAUDES_TYPE_TIMPLEMENTATION_NEW(ftype, ctype, cbase, ctemp)
 faudes type implementation macros, individual, template version
#define FAUDES_TYPE_TIMPLEMENTATION_COPY(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_EQUAL(ftype, ctype, cbase, ctemp)
#define FAUDES_TYPE_TIMPLEMENTATION(ftype, ctype, cbase, ctemp)
 faudes type implementation macros, overall, template version

Detailed Description

Runtime interface, faudes types.

Definition in file cfl_types.h.


Define Documentation

#define FAUDES_TYPE_DECLARATION ( ftype,
ctype,
cbase   ) 
Value:
public: \
  virtual ctype* New(void) const; \
  virtual ctype* Copy(void) const; \
  virtual const Type* Cast(const Type* pOther) const; \
  virtual ctype& Assign(const Type& rSrc); \
  virtual bool Equal(const Type& rOther) const; \
  virtual ctype& operator=(const ctype& rSrc); \
  virtual bool operator==(const ctype& rOther) const; \
  virtual bool operator!=(const ctype& rOther) const;

faudes type declaration macro, overall

Definition at line 882 of file cfl_types.h.

#define FAUDES_TYPE_DECLARATION_ASSIGN ( ftype,
ctype,
cbase   )     public: virtual ctype& Assign(const Type& rSrc);

Definition at line 873 of file cfl_types.h.

#define FAUDES_TYPE_DECLARATION_CAST ( ftype,
ctype,
cbase   )     public: virtual const Type* Cast(const Type* pOther) const;

Definition at line 871 of file cfl_types.h.

#define FAUDES_TYPE_DECLARATION_COPY ( ftype,
ctype,
cbase   )     public: virtual ctype* Copy(void) const;

Definition at line 869 of file cfl_types.h.

#define FAUDES_TYPE_DECLARATION_EQUAL ( ftype,
ctype,
cbase   ) 
Value:
public: virtual bool Equal(const Type& rOther) const; \
  public: virtual ctype& operator=(const ctype& rSrc); \
  public: virtual bool operator==(const ctype& rOther) const; \
  public: virtual bool operator!=(const ctype& rOther) const;

Definition at line 875 of file cfl_types.h.

#define FAUDES_TYPE_DECLARATION_NEW ( ftype,
ctype,
cbase   )     public: virtual ctype* New(void) const;

faudes type declaration macros, individual

Definition at line 867 of file cfl_types.h.

#define FAUDES_TYPE_IMPLEMENTATION ( ftype,
ctype,
cbase   ) 
Value:
ctype* ctype::New(void) const {     \
    return new ctype(); }  \
  ctype* ctype::Copy(void) const {      \
    return new ctype(*this); }      \
  const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast<const ctype*>(pOther); } \
  ctype& ctype::Assign(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast<const ctype*>(&rSrc)) \
      { this->Clear(); DoAssign(*csattr); return *this;}      \
    cbase::Assign(rSrc); \
    return *this;} \
  ctype& ctype::operator=(const ctype& rSrc) { this->Clear(); DoAssign(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(!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); }

faudes type implementation macros, overall

Definition at line 936 of file cfl_types.h.

#define FAUDES_TYPE_IMPLEMENTATION_ASSIGN ( ftype,
ctype,
cbase   ) 
Value:
ctype& ctype::Assign(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast<const ctype*>(&rSrc)) { \
      this->Clear(); DoAssign(*csattr);} \
    else {    \
      cbase::Assign(rSrc);};  \
    return *this;} \
  ctype& ctype::operator=(const ctype& rSrc) { this->Clear(); DoAssign(rSrc); return *this; }

Definition at line 915 of file cfl_types.h.

#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 912 of file cfl_types.h.

#define FAUDES_TYPE_IMPLEMENTATION_COPY ( ftype,
ctype,
cbase   ) 
Value:
ctype* ctype::Copy(void) const {      \
    return new ctype(*this); }

Definition at line 909 of file cfl_types.h.

#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 923 of file cfl_types.h.

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

faudes type implementation macros, individual

Definition at line 906 of file cfl_types.h.

#define FAUDES_TYPE_TDECLARATION ( ftype,
ctype,
cbase   ) 
Value:
public: \
  virtual ctype* New(void) const; \
  virtual ctype* Copy(void) const; \
  virtual const Type* Cast(const Type* pOther) const; \
  virtual ctype& Assign(const Type& rSrc); \
  virtual bool Equal(const Type& rOther) const; \
  virtual ctype& operator=(const ctype& rSrc); \
  virtual bool operator==(const ctype& rOther) const; \
  virtual bool operator!=(const ctype& rOther) const;

faudes type declaration macro, template version

Definition at line 894 of file cfl_types.h.

#define FAUDES_TYPE_TIMPLEMENTATION ( ftype,
ctype,
cbase,
ctemp   ) 
Value:
ctemp ctype* ctype::New(void) const {   \
    return new ctype(); }  \
  ctemp ctype* ctype::Copy(void) const {      \
    return new ctype(*this); }  \
  ctemp const Type* ctype::Cast(const Type* pOther) const { \
    return dynamic_cast<const ctype*>(pOther);} \
  ctemp ctype& ctype::Assign(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast<const ctype*>(&rSrc)) \
      { this->Clear(); DoAssign(*csattr); return *this;}      \
    cbase::Assign(rSrc); \
    return *this;} \
  ctemp ctype& ctype::operator=(const ctype& rSrc) { this->Clear(); DoAssign(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, template version

Definition at line 992 of file cfl_types.h.

#define FAUDES_TYPE_TIMPLEMENTATION_ASSIGN ( ftype,
ctype,
cbase,
ctemp   ) 
Value:
ctemp ctype& ctype::Assign(const Type& rSrc) { \
    if(const ctype* csattr=dynamic_cast<const ctype*>(&rSrc)) { \
      this->Clear(); DoAssign(*csattr); return *this;}    \
    cbase::Assign(rSrc); \
    return *this;} \
  ctemp ctype& ctype::operator=(const ctype& rSrc) { this->Clear(); DoAssign(rSrc); return *this; }

Definition at line 972 of file cfl_types.h.

#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 969 of file cfl_types.h.

#define FAUDES_TYPE_TIMPLEMENTATION_COPY ( ftype,
ctype,
cbase,
ctemp   ) 
Value:
ctemp ctype* ctype::Copy(void) const {      \
    return new ctype(*this); }

Definition at line 966 of file cfl_types.h.

#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(!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); }

Definition at line 979 of file cfl_types.h.

#define FAUDES_TYPE_TIMPLEMENTATION_NEW ( ftype,
ctype,
cbase,
ctemp   ) 
Value:
ctemp ctype* ctype::New(void) const {     \
    return new ctype(); }

faudes type implementation macros, individual, template version

Definition at line 963 of file cfl_types.h.

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen