Skip to content
Sections
Personal tools
You are here: Home » BALLView » Documentation » 1.2 » group__Common_html
 
Main Page | Modules | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members

Common Definitions
[Foundation Classes]


Namespaces
namespace BALL::Constants
The constants namespace.
namespace BALL::Exception
Exception.
namespace BALL::RTTI
Simplified RunTime Type Identification.

Classes
class BALL::Exception::GeneralException
General exception class. More...
class BALL::HashFunction< T >
General Hash Function Template. More...
class BALL::Limits< T >
Numeric limits class. More...
class BALL::VersionInfo
Version information class. More...

[NOHEADER]
#define BALL_CREATE_DEEP(name)
Virtual construction macro.
#define BALL_CREATE(name)
Virtual construction macro.
#define BALL_DEFINE_CREATE(name)
Virtual cloning method definition macro.

Type aliases defined by BALL.
These predefined types are used in BALL for portability and comprehensibility.
typedef BALL_INDEX_TYPE BALL::Distance
Distance type.
typedef BALL_SIZE_TYPE BALL::Handle
Handle type.
typedef BALL_INDEX_TYPE BALL::Index
Index type.
typedef BALL_SIZE_TYPE BALL::Size
Size type.
typedef BALL_LONG64_TYPE BALL::LongIndex
Long signed int type.
typedef BALL_ULONG64_TYPE BALL::LongSize
Long unsigned int type.
typedef time_t BALL::Time
Time type.
typedef BALL_SIZE_TYPE BALL::HashIndex
HashIndex type.
typedef BALL_SIZE_TYPE BALL::Position
Position type.
typedef float BALL::Real
Real type.
typedef double BALL::DoubleReal
Double-precision real type.
typedef BALL_SIZE_TYPE BALL::Property
Unnamed property type.
typedef BALL_INDEX_TYPE BALL::ErrorCode
Error code property type.
typedef unsigned char BALL::Byte
Byte type.
typedef BALL_POINTERSIZEUINT_TYPE BALL::PointerSizeUInt
Unsigned int with the same size as a pointer.

Functions
BALL_EXPORT std::ostream & BALL::operator<< (std::ostream &os, const Exception::GeneralException &e)
Output operator for exceptions.
BALL_EXPORT string BALL::streamClassName (const std::type_info &t)
Returns a unique name for a class.

Detailed Description

This chapter contains all relevant information on very fundamental definitions and classes used throughout BALL (part of the Foundation Classes).

Define Documentation

#define BALL_CREATE ( name )

Value:

\
  virtual void* create(bool /* deep */ = true, bool empty = false) const\
  {\
    void* ptr;\
    if (empty == true)\
    {\
      ptr = (void*)new name;\
    }\
    else\
    {\
      ptr = (void*)new name(*this);\
    }\
    \
    return ptr;\
  }\
  \
  static void* createDefault()\
  {\
    return static_cast<void*>(new name);\
  }
Virtual construction macro.

This macro is used to define the virtual create method for classes that do not define a copy constructor taking a second argument (boolean, deep or shallow copy). On inclusion of this macro in the public interface of a class, the virtual creation method becomes available. The create method's signature is as follows: virtual void* create(bool deep = true, bool empty = false) const

The create method either creates an empty default object of the class (empty == true) or a copy of the object. The use of the create method requires a (public) default constructor (when creating an empty copy) and a copy constructor taking a reference to an object. The macro also implements a static method createDefault that returns a void pointer to a new instance of name.
Parameters:
name the class name
#define BALL_CREATE_DEEP ( name )

Value:

\
  virtual void* create(bool deep = true, bool empty = false) const\
  {\
    void* ptr;\
    if (empty == true)\
    {\
      ptr = (void*)new name;\
    }\
    else\
    {\
      ptr = (void*)new name(*this, deep);\
    }\
    \
    return ptr;\
  }\
  \
  static void* createDefault()\
  {\
    return static_cast<void*>(new name);\
  }
Virtual construction macro.

This macro is used to define the virtual create method. On inclusion of this macro in the public interface of a class, the virtual creation method becomes available. The create method's signature is as follows: virtual void* create(bool deep = true, bool empty = false) const

The create method either creates an empty default object of the class (empty == true) or a copy of the object. The copy is either deep (deep == true) or shallow (deep == false). By default, the create methods returns a pointer to a deep copy of the object. The use of the create method requires a (public) default constructor (when creating an empty copy) or a copy constructor.
The macro also implements a static method createDefault that returns a void pointer to a new instance of name.
Parameters:
name the class name
#define BALL_DEFINE_CREATE ( name )

Value:

\
  virtual void* create(bool deep = true, bool empty = false) const;\
  static void* createDefault();
Virtual cloning method definition macro.

If the create method has to be implemented by the user, this macro just defines the create method and the createDefault method. The function signatures are:

                        virtual void* create(bool deep = true, bool empty = false) const;
                        static void* createDefault();

Typedef Documentation

typedef unsigned char BALL::Byte

Byte type.

Use this type to represent byte data (8 bit length). A Byte is always unsigned.

Size: 8 bit
persistent
typedef BALL_INDEX_TYPE BALL::Distance

Distance type.

Use this type to represent distances in indices. Signed.

Size: 32 bit
persistent
typedef double BALL::DoubleReal

Double-precision real type.

Use this type to represent double precision floating point numbers.

Size: 64 bit
persistent
typedef BALL_INDEX_TYPE BALL::ErrorCode

Error code property type.

Use this type to represent (signed) error codes.

Size: 32 bit
persistent
See also:
PropertyManager
typedef BALL_SIZE_TYPE BALL::Handle

Handle type.

Use this type to represent handles. Handles are used for the non-ambiguous identification of objects (e.g. object derived from Object ). Handles are unsigned.

Size: 32 bit
persistent
typedef BALL_SIZE_TYPE BALL::HashIndex

HashIndex type.

Use this type to access the result of a hash functions. HashIndex is unsigned.

Size: 32 bit
persistent
typedef BALL_INDEX_TYPE BALL::Index

Index type.

Use this type to represent indices (e.g. in strings or other sequences). Theses indices may be signed, contrary to the Size type.

Size: 32 bit
persistent
typedef BALL_LONG64_TYPE BALL::LongIndex

Long signed int type.

Use this type to represent very long (64 bit) indices. Theses indices may be signed, contrary to the LongSize type.

Size: 64 bit
persistent
typedef BALL_ULONG64_TYPE BALL::LongSize

Long unsigned int type.

Use this type to represent sizes of containers, sequences or alike. Variables of type LongSize are unsigned.

Size: 64 bit
persistent
typedef BALL_POINTERSIZEUINT_TYPE BALL::PointerSizeUInt

Unsigned int with the same size as a pointer.

Used for internal conversion issues mostly. Size: 32/64 bit (platform dependent)
typedef BALL_SIZE_TYPE BALL::Position

Position type.

Use this type to represent positions (e.g. in a container) that cannot be negative (contrary to Index ).

Size: 32 bit
persistent
typedef BALL_SIZE_TYPE BALL::Property

Unnamed property type.

Use this type to represent (unnamed) properties.

Size: 32 bit
persistent
See also:
PropertyManager
typedef float BALL::Real

Real type.

Use this type to represent standard floating point numbers.

Size: 32 bit
persistent
typedef BALL_SIZE_TYPE BALL::Size

Size type.

Use this type to represent sizes of containers, sequences or alike. Variables of type Size are unsigned.

Size: 32 bit
persistent
typedef time_t BALL::Time

Time type.

Use this type to represent a point in time (as a replaecement for time_t).

Size: platform dependent
not persistent

Function Documentation

BALL_EXPORT std::ostream& operator<< ( std::ostream & os,
const Exception::GeneralException & e
)

Output operator for exceptions.

All BALL exceptions can be printed to an arbitrary output stream. Information written contains the exception class, the error message, and the location (file, line number). The following code block can thus be used to catch any BALL exceptions and convert them to human readable information:

                                try
                                {
                                        .... // some code which potentially throws an exception
                                }
                                catch (Exception::GeneralException e)
                                {
                                        Log.error() << "caught exception: " << e << std::endl;
                                }
BALL_EXPORT string streamClassName ( const std::type_info & t )

Returns a unique name for a class.

This name contains no blanks. It is usually derived by substituting all blanks in the name (as returned by RTTI::getName()) with underscores ("_"). In the case of gcc, however a name demangling decodes the string first. This function is needed for object persistence.

Parameters:
t the type_info structure as returned by typeid
Returns:
string the coverted class name
 
 
Powered by Plone

This site conforms to the following standards: