[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vos/vosdefs.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/


#ifndef _VOSDEFS_HH_
#define _VOSDEFS_HH_

#include <vos/vutil/vutildefs.hh>

/** @namespace VOS Virtual Object System core library */

#ifdef USE_STRSTREAM
#include <strstream>
#else
#include <sstream>
#endif

#if defined(_WIN32) && defined(_MSC_VER)
# pragma warning (disable : 4250)
//# pragma warning (disable : 4290) // warns about throw()
# pragma warning (disable : 4995)
# pragma warning (disable : 4251)
# pragma warning (disable : 4003)
# pragma warning (disable : 4275)
#endif

#if defined(WIN32)
# ifdef VOS_EXPORTS
#  define VOS_API __declspec(dllexport)
# else
#  define VOS_API __declspec(dllimport)
# endif
#else
# ifdef HAVE_GCC_VISIBILITY
#  define VOS_API __attribute__ ((visibility("default")))
# else
#  define VOS_API
# endif
#endif

#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
# include <netinet/in.h>
# include <netinet/tcp.h>
# include <netdb.h>
#else
# ifdef HAVE_LIBWS2_32
#  include <winsock2.h>
#  include <ws2tcpip.h>
#  define VOS_USE_WINSOCK2
# else
# warning we do not have a header file for the socket functions, things will probably fail
# endif
#endif

#include <boost/thread/thread.hpp>

#ifndef HAVE_SNPRINTF
# include <vos/vutil/snprintf.hh>
#endif

#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <stdio.h>

#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#ifdef SSL_SUPPORT
#include <openssl/ssl.h>
#include <openssl/rand.h>
#include <openssl/err.h>
#else
#define X509 void
#define SSL_CTX void
#define X509_STORE_CTX void
#define SSL void
#endif

#ifndef SOL_TCP
#define SOL_TCP (getprotobyname("tcp")->p_proto)
#endif

// work around an annoying difference between winsock2.h and sys/socket.h
#ifdef HAVE_LIBWS2_32
# define SETSOCKOPT_PARAM4_CAST char*
#else
# define SETSOCKOPT_PARAM4_CAST int*
#endif


#if !defined(HAVE_SOCKLEN_T) && !defined(__socklen_t_defined)
//#warning socklen_t not defined. Defining it as int.
typedef int socklen_t;
#define __socklen_t_defined 1
#endif

/* seconds */
#define VOS_DEFAULT_TIMEOUT 45.0

#if defined(WIN32)
#define DLLEXPORT __declspec(dllexport)
#define DLLIMPORT __declspec(dllimport)
#else
# ifdef HAVE_GCC_VISIBILITY
#  define DLLEXPORT __attribute__ ((visibility("default")))
#  define DLLIMPORT __attribute__ ((visibility("default")))
# else
#  define DLLEXPORT
#  define DLLIMPORT
# endif
#endif

/** @def BEGIN_REGISTER_METAOBJECT_FACTORIES
    Use these macros to define a static registration class for
    a metaobject.  This lets you register metaobject factories automatically
    when your library is loaded.

    You must also use the REGISTERS_METAOBJECT_FACTORIES macro in a
    public header file as well.

    Example:
    @code
        BEGIN_REGISTER_METAOBJECT_FACTORIES(Example)
            Site::addLocalMetaObjectFactory(typeid(Example).name(), &LocalExample::new_LocalExample);
            Site::addLocalMetaObjectFactory(typeid(LocalExample).name(), &LocalExample::new_LocalExample);
            Site::addLocalMetaObjectFactory("example:example", &LocalExample::new_LocalExample);

            Site::addRemoteMetaObjectFactory(typeid(Example).name(), "example:example", &RemoteExample::new_RemoteExample);
            Site::addRemoteMetaObjectFactory(typeid(RemoteExample).name(), "example:example", &RemoteExample::new_RemoteExample);
            Site::addRemoteMetaObjectFactory("example:example", "example:example", &RemoteExample::new_RemoteExample);
        END_REGISTER_METAOBJECT_FACTORIES(Example)
      @endcode

      If your metaobject does not need seperate Local and Remote behavior,
      you only need one class, for which you can register the same remote
      and local factory.

      @param cl A symbol that uniquely identifies this registration (e.g. use
      the MetaObject class name)
    */
// @{
#define BEGIN_REGISTER_METAOBJECT_FACTORIES(cl)                              \
    class Register##cl {                                                \
    public:                                                            \
    Register##cl()                                                      \
    {

#define END_REGISTER_METAOBJECT_FACTORIES(cl)                                      \
    }                                                                   \
    };                                                                  \
    DLLEXPORT Register##cl Register##cl##_globalstatic;
// @}

#define BEGIN_REGISTER_EXTENDERS(cl) BEGIN_REGISTER_METAOBJECT_FACTORIES(cl)
#define END_REGISTER_EXTENDERS(cl) END_REGISTER_METAOBJECT_FACTORIES(cl)

/** Alternate macro for registering extender factories.
    Use this macro when you want to use the same MetaObject class for
    both local and remote objects, and don't need to do anything special
    at registration.  It creates a registration class named from
    a namespace and class name, containing a constructor which registers
    the same factory function for local and remote metaobject creation.

    You must also use the REGISTERS_METAOBJECT_FACTORIES macro in a
    public header file as well, using <ns>_<cl> as its argument (see below)

    @param ns   Namespace
    @param cl   Class name
    @param type Type string, should be the same string that getVOSType()
returns.
    @param factfn Static method that returns an instance of your class (as
        a VOS::MetaObject*), given a "super object" (of type VOS::VobjectBase*)
        and a type string.

    For example, imagine you have a metaobject class called ExampleClass.
    It is in a namespace called EG.  It might be declared in a header file like
    this:
    @code
        #include <vos/vos/vos.hh>
        ...
        namespace EG {
            class ExampleClass : public VOS::MetaObject {
            public:
                ExampleClass(VOS::VobjectBase* s);
                VOS::MetaObject* new_ExampleClass(VOS::VobjectBase* s, const std::string& t) {
                   return new ExampleClass(s);
                }
                ...
            };
        }
    @endcode

    Somewhere in the definition (i.e. in your ".cc" or ".cpp" file), include
    this macro call:
    @code
        REGISTER_METAOBJECT_FACTORIES(EG, ExampleClass, "example:example", &EG::ExampleClass::new_ExampleClass)
        }
    @endcode


    Now to the public header file, add this:
    @code
        ...
        REGISTERS_METAOBJECT_FACTORIES(EG_ExampleClass)
        ...
    @endcode
*/
#define REGISTER_METAOBJECT_FACTORIES(ns, cl, type, factfn) \
    class Register##ns##_##cl { \
    public: \
        Register##ns##_##cl() { \
            Site::addLocalMetaObjectFactory(typeid(ns::cl).name(), factfn); \
            Site::addLocalMetaObjectFactory(type, factfn); \
            Site::addRemoteMetaObjectFactory(typeid(ns::cl).name(), type, factfn); \
            Site::addRemoteMetaObjectFactory(type, type, factfn); \
        } \
    }; \
    DLLEXPORT Register##ns##_cl Register##ns##_cl##_globalstatic;

/** You must use this macro in a public header file for every use of
 * VOS_METAOBJECT_FACTORY or BEGIN_REGISTER_EXTENDERS. (It grabs a reference
 *  to the registration cleass, forcing the dynamic library loader to
 *  initialize it)
 * @param cl    Class name: use the same argument you used in defining the
 *              factory registration class.
 */
#define IMPORT_METAOBJECT_FACTORIES(cl)                        \
    class Register##cl { };                                    \
    extern DLLIMPORT Register##cl Register##cl##_globalstatic; \
    static Register##cl &Register##cl##_localref = Register##cl##_globalstatic;

#define REGISTERS_METAOBJECT_FACTORIES(cl) IMPORT_METAOBJECT_FACTORIES(cl)

#endif