Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jun 1, 2008, 1:10:46 AM (17 years ago)
Author:
rgrieder
Message:

SVN doesn't seem to like me. Reverted some really badly converted line endings.

Location:
code/branches/network/src/util
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • code/branches/network/src/util/ArgReader.cc

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:

  • code/branches/network/src/util/ArgReader.h

    r1494 r1495  
    1 /* *   ORXONOX - the hottest 3D action shooter ever to exist *                    > www.orxonox.net < * * *   License notice: * *   This program is free software; you can redistribute it and/or *   modify it under the terms of the GNU General Public License *   as published by the Free Software Foundation; either version 2 *   of the License, or (at your option) any later version. * *   This program 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 General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program; if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. * *   Author: *      Benjamin Knecht <beni_at_orxonox.net> *   Co-authors: *      ... * *//**
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Benjamin Knecht <beni_at_orxonox.net>
     24 *   Co-authors:
     25 *      ...
     26 *
     27 */
     28
     29/**
    230 @file  Argreader.h
    331 @brief reads arguments
    … …  
    836#define _ArgReader_H__
    937
    10 #include "UtilPrereqs.h"#include <string>
     38#include "UtilPrereqs.h"
     39
     40#include <string>
     41
    1142class _UtilExport ArgReader
    1243{

  • code/branches/network/src/util/Convert.h

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    2122 *   Author:
    2223 *      Benjamin Grauer
    23  *      Fabian 'x3n' Landau *   Co-authors: *      ...
     24 *      Fabian 'x3n' Landau
     25 *   Co-authors:
     26 *      ...
    2427 */
    2528
    … …  
    4649#pragma warning(disable:4100 4800)
    4750#endif
    48 //////////// MAIN ////////////// Enum to declare the wanted conversion preference in case of equal type-levelsenum ConversionPreference{    CP_PreferToType,    CP_PreferFromType,};// Helper classes to determine the preferred partial template specializationclass _ToType_   {};class _FromType_ {};class _Explicit_ {};// The default convert functionstemplate <class FromType, class ToType, class Type>struct ConverterSpecialized{    enum { specialized = false };    static bool convert(ToType* output, const FromType& input)    { return false; }};// The default convert function if both types are the sametemplate <class BothTypes>struct ConverterSpecialized<BothTypes, BothTypes, _Explicit_>{    enum { specialized = true };    static bool convert(BothTypes* output, const BothTypes& input)    { (*output) = input; return true; }};// The possible levels#define __low__  0 // Everything that is or behaves like a primitive type (an can be converted with a typecast to every other low-level type)#define __mid__  1 // Everything that has overloaded << and >> operators to operate on a std::stream#define __high__ 2 // Everything that doesn't fullfill the lowerlevel-requirements and therefore needs specialized conversions// Defines the levels of all types: Default is __high__ so you don't have to define every high-level typetemplate <class T> struct ConverterLevel           { enum { level = __high__ }; };template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };template <> struct ConverterLevel<orxonox::Degree> { enum { level = __mid__ }; };template <> struct ConverterLevel<int>             { enum { level = __low__ }; };template <> struct ConverterLevel<unsigned int>    { enum { level = __low__ }; };template <> struct ConverterLevel<char>            { enum { level = __low__ }; };template <> struct ConverterLevel<unsigned char>   { enum { level = __low__ }; };template <> struct ConverterLevel<short>           { enum { level = __low__ }; };template <> struct ConverterLevel<unsigned short>  { enum { level = __low__ }; };template <> struct ConverterLevel<long>            { enum { level = __low__ }; };template <> struct ConverterLevel<unsigned long>   { enum { level = __low__ }; };template <> struct ConverterLevel<float>           { enum { level = __low__ }; };template <> struct ConverterLevel<double>          { enum { level = __low__ }; };template <> struct ConverterLevel<long double>     { enum { level = __low__ }; };template <> struct ConverterLevel<bool>            { enum { level = __low__ }; };// Calculates the preference based on the levels of FromType and ToTypetemplate <int from, int to>struct ConverterPreference{    enum    {        // The maximum of both levels: element of {0, 1, 2}        // max 0: Both types are primitives or have a similar behaviour        // max 1: At least one type is not a primitive, but both can be put on a std::stream        // max 2: There is at least one generic type that needs specialized conversions        max = (from > to) ? from : to,        // The difference between both levels limited to +-1: element of {-1, 0, 1}        // diff -1: The FromType has higher level than the ToType        // diff  0: Both types have the same level        // diff  1: The ToType has higher level than the FromType        diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)    };};// The default conversion: This usually does nothingtemplate <int max, class FromType, class ToType>struct ConverterDefault{    static bool convert(ToType* output, const FromType& input)    {        return false;    }};// The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>template <class FromType, class ToType>struct ConverterDefault<0, FromType, ToType>{    static bool convert(ToType* output, const FromType& input)    {        (*output) = (ToType)input;        return true;    }};// Converter: Converts input of FromType into output of ToTypetemplate <int diff, int max, class FromType, class ToType, ConversionPreference pref>struct Converter{    static bool convert(ToType* output, const FromType& input)    {        return false;    }};// Converter: level{FromType} > level{ToType}template <int max, class FromType, class ToType, ConversionPreference pref>struct Converter<-1, max, FromType, ToType, pref>{   static bool convert(ToType* output, const FromType& input)    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };// Converter: level{FromType} < level{ToType}template <int max, class FromType, class ToType, ConversionPreference pref>struct Converter<1, max, FromType, ToType, pref>{   static bool convert(ToType* output, const FromType& input)    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };// Converter: level{FromType} = level{ToType}// CP_PreferToTypetemplate <int max, class FromType, class ToType>struct Converter<0, max, FromType, ToType, CP_PreferToType>{   static bool convert(ToType* output, const FromType& input)    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };// CP_PreferFromTypetemplate <int max, class FromType, class ToType>struct Converter<0, max, FromType, ToType, CP_PreferFromType>{   static bool convert(ToType* output, const FromType& input)    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };// Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreferencetemplate <class FromType, class ToType>static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType){    return (preference == CP_PreferToType) ?           Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,                     FromType,                     ToType,                     CP_PreferToType>::convert(output, input)         : Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,                     FromType,                     ToType,                     CP_PreferFromType>::convert(output, input);}//////////////////////// HELPER FUNCTIONS ////////////////////////// Helper function: Calls convertValue with and without default value and returns true if the conversion was successfultemplate<class FromType, class ToType>static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType){    return convertValue(output, input, preference);}template<class FromType, class ToType>static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType){    if (convertValue(output, input, preference))        return true;    (*output) = fallback;    return false;}// Helper function: Calls convertValue with and without default value and returns the converted valuetemplate<class FromType, class ToType>static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_PreferToType){    ToType output = ToType();    ConvertValue(&output, input, preference);    return output;}template<class FromType, class ToType>static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType){    ToType output = fallback;    ConvertValue(&output, input, fallback, preference);    return output;}
     51
     52
     53//////////
     54// MAIN //
     55//////////
     56
     57// Enum to declare the wanted conversion preference in case of equal type-levels
     58enum ConversionPreference
     59{
     60    CP_PreferToType,
     61    CP_PreferFromType,
     62};
     63
     64// Helper classes to determine the preferred partial template specialization
     65class _ToType_   {};
     66class _FromType_ {};
     67class _Explicit_ {};
     68
     69
     70// The default convert functions
     71template <class FromType, class ToType, class Type>
     72struct ConverterSpecialized
     73{
     74    enum { specialized = false };
     75    static bool convert(ToType* output, const FromType& input)
     76    { return false; }
     77};
     78
     79
     80// The default convert function if both types are the same
     81template <class BothTypes>
     82struct ConverterSpecialized<BothTypes, BothTypes, _Explicit_>
     83{
     84    enum { specialized = true };
     85    static bool convert(BothTypes* output, const BothTypes& input)
     86    { (*output) = input; return true; }
     87};
     88
     89
     90// The possible levels
     91#define __low__  0 // Everything that is or behaves like a primitive type (an can be converted with a typecast to every other low-level type)
     92#define __mid__  1 // Everything that has overloaded << and >> operators to operate on a std::stream
     93#define __high__ 2 // Everything that doesn't fullfill the lowerlevel-requirements and therefore needs specialized conversions
     94
     95// Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
     96template <class T> struct ConverterLevel           { enum { level = __high__ }; };
     97template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };
     98template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };
     99template <> struct ConverterLevel<orxonox::Degree> { enum { level = __mid__ }; };
     100template <> struct ConverterLevel<int>             { enum { level = __low__ }; };
     101template <> struct ConverterLevel<unsigned int>    { enum { level = __low__ }; };
     102template <> struct ConverterLevel<char>            { enum { level = __low__ }; };
     103template <> struct ConverterLevel<unsigned char>   { enum { level = __low__ }; };
     104template <> struct ConverterLevel<short>           { enum { level = __low__ }; };
     105template <> struct ConverterLevel<unsigned short>  { enum { level = __low__ }; };
     106template <> struct ConverterLevel<long>            { enum { level = __low__ }; };
     107template <> struct ConverterLevel<unsigned long>   { enum { level = __low__ }; };
     108template <> struct ConverterLevel<float>           { enum { level = __low__ }; };
     109template <> struct ConverterLevel<double>          { enum { level = __low__ }; };
     110template <> struct ConverterLevel<long double>     { enum { level = __low__ }; };
     111template <> struct ConverterLevel<bool>            { enum { level = __low__ }; };
     112
     113
     114// Calculates the preference based on the levels of FromType and ToType
     115template <int from, int to>
     116struct ConverterPreference
     117{
     118    enum
     119    {
     120        // The maximum of both levels: element of {0, 1, 2}
     121        // max 0: Both types are primitives or have a similar behaviour
     122        // max 1: At least one type is not a primitive, but both can be put on a std::stream
     123        // max 2: There is at least one generic type that needs specialized conversions
     124        max = (from > to) ? from : to,
     125
     126        // The difference between both levels limited to +-1: element of {-1, 0, 1}
     127        // diff -1: The FromType has higher level than the ToType
     128        // diff  0: Both types have the same level
     129        // diff  1: The ToType has higher level than the FromType
     130        diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)
     131    };
     132};
     133
     134
     135// The default conversion: This usually does nothing
     136template <int max, class FromType, class ToType>
     137struct ConverterDefault
     138{
     139    static bool convert(ToType* output, const FromType& input)
     140    {
     141        return false;
     142    }
     143};
     144// The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>
     145template <class FromType, class ToType>
     146struct ConverterDefault<0, FromType, ToType>
     147{
     148    static bool convert(ToType* output, const FromType& input)
     149    {
     150        (*output) = (ToType)input;
     151        return true;
     152    }
     153};
     154
     155
     156// Converter: Converts input of FromType into output of ToType
     157template <int diff, int max, class FromType, class ToType, ConversionPreference pref>
     158struct Converter
     159{
     160    static bool convert(ToType* output, const FromType& input)
     161    {
     162        return false;
     163    }
     164};
     165// Converter: level{FromType} > level{ToType}
     166template <int max, class FromType, class ToType, ConversionPreference pref>
     167struct Converter<-1, max, FromType, ToType, pref>
     168{   static bool convert(ToType* output, const FromType& input)
     169    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
     170// Converter: level{FromType} < level{ToType}
     171template <int max, class FromType, class ToType, ConversionPreference pref>
     172struct Converter<1, max, FromType, ToType, pref>
     173{   static bool convert(ToType* output, const FromType& input)
     174    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
     175// Converter: level{FromType} = level{ToType}
     176// CP_PreferToType
     177template <int max, class FromType, class ToType>
     178struct Converter<0, max, FromType, ToType, CP_PreferToType>
     179{   static bool convert(ToType* output, const FromType& input)
     180    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
     181// CP_PreferFromType
     182template <int max, class FromType, class ToType>
     183struct Converter<0, max, FromType, ToType, CP_PreferFromType>
     184{   static bool convert(ToType* output, const FromType& input)
     185    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
     186
     187
     188// Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreference
     189template <class FromType, class ToType>
     190static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
     191{
     192    return (preference == CP_PreferToType) ?
     193           Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
     194                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
     195                     FromType,
     196                     ToType,
     197                     CP_PreferToType>::convert(output, input)
     198         : Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
     199                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
     200                     FromType,
     201                     ToType,
     202                     CP_PreferFromType>::convert(output, input);
     203}
     204
     205
     206//////////////////////
     207// HELPER FUNCTIONS //
     208//////////////////////
     209
     210// Helper function: Calls convertValue with and without default value and returns true if the conversion was successful
     211template<class FromType, class ToType>
     212static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
     213{
     214    return convertValue(output, input, preference);
     215}
     216template<class FromType, class ToType>
     217static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
     218{
     219    if (convertValue(output, input, preference))
     220        return true;
     221
     222    (*output) = fallback;
     223    return false;
     224}
     225
     226// Helper function: Calls convertValue with and without default value and returns the converted value
     227template<class FromType, class ToType>
     228static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_PreferToType)
     229{
     230    ToType output = ToType();
     231    ConvertValue(&output, input, preference);
     232    return output;
     233}
     234template<class FromType, class ToType>
     235static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
     236{
     237    ToType output = fallback;
     238    ConvertValue(&output, input, fallback, preference);
     239    return output;
     240}
     241
     242
    49243/////////////////////
    50244// SPECIALIZATIONS //
    51245/////////////////////
    52 /////////////// SAMPLES ////////////////*// convert everything to xyztemplate <class FromType>struct ConverterSpecialized<FromType, xyz, _ToType_>{    enum { specialized = true };    static bool convert(xyz* output, const FromType& input)    { return ...; }};// convert xyz to everythingtemplate <class ToType>struct ConverterSpecialized<xyz, ToType, _FromType_>{    enum { specialized = true };    static bool convert(ToType* output, const xyz& input)    { return ...; }};// convert abc to xyztemplate <>struct ConverterSpecialized<abc, xyz, _Explicit_>{    enum { specialized = true };    static bool convert(xyz* output, const abc& input)    { return ...; }};*/////////////// STRING //////////////// convert to stringtemplate <class FromType>struct ConverterSpecialized<FromType, std::string, _ToType_>{    enum { specialized = true };    static bool convert(std::string* output, const FromType& input)    {        std::ostringstream oss;        if (oss << input)        {            (*output) = oss.str();            return true;        }        else            return false;    }};// convert from stringtemplate <class ToType>struct ConverterSpecialized<std::string, ToType, _FromType_>{    enum { specialized = true };    static bool convert(ToType* output, const std::string& input)    {        std::istringstream iss(input);        if (iss >> (*output))            return true;        else            return false;    }};////////////////// MULTITYPES //////////////////// convert from MultiTypePrimitivetemplate <class ToType>struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>{    enum { specialized = true };    static bool convert(ToType* output, const MultiTypePrimitive& input)    {        if (input.getType() == MT_void)            return ConvertValue(output, input.getVoid());        else if (input.getType() == MT_int)            return ConvertValue(output, input.getInt());        else if (input.getType() == MT_uint)            return ConvertValue(output, input.getUnsignedInt());        else if (input.getType() == MT_char)            return ConvertValue(output, input.getChar());        else if (input.getType() == MT_uchar)            return ConvertValue(output, input.getUnsignedChar());        else if (input.getType() == MT_short)            return ConvertValue(output, input.getShort());        else if (input.getType() == MT_ushort)            return ConvertValue(output, input.getUnsignedShort());        else if (input.getType() == MT_long)            return ConvertValue(output, input.getLong());        else if (input.getType() == MT_ulong)            return ConvertValue(output, input.getUnsignedLong());        else if (input.getType() == MT_float)            return ConvertValue(output, input.getFloat());        else if (input.getType() == MT_double)            return ConvertValue(output, input.getDouble());        else if (input.getType() == MT_longdouble)            return ConvertValue(output, input.getLongDouble());        else if (input.getType() == MT_bool)            return ConvertValue(output, input.getBool());        else            return false;    }};// convert from MultiTypeStringtemplate <class ToType>struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>{    enum { specialized = true };    static bool convert(ToType* output, const MultiTypeString& input)    {        if (input.getType() == MT_constchar)            return ConvertValue(output, input.getConstChar());        else if (input.getType() == MT_string)            return ConvertValue(output, input.getString());        else            return ConvertValue(output, (MultiTypePrimitive)input);    }};// convert from MultiTypeMathtemplate <class ToType>struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>{    enum { specialized = true };    static bool convert(ToType* output, const MultiTypeMath& input)    {        if (input.getType() == MT_vector2)            return ConvertValue(output, input.getVector2());        else if (input.getType() == MT_vector3)            return ConvertValue(output, input.getVector3());        else if (input.getType() == MT_vector4)            return ConvertValue(output, input.getVector4());        else if (input.getType() == MT_quaternion)            return ConvertValue(output, input.getQuaternion());        else if (input.getType() == MT_colourvalue)            return ConvertValue(output, input.getColourValue());        else if (input.getType() == MT_radian)            return ConvertValue(output, input.getRadian());        else if (input.getType() == MT_degree)            return ConvertValue(output, input.getDegree());        else            return ConvertValue(output, (MultiTypeString)input);    }};
     246
     247/////////////
     248// SAMPLES //
     249/////////////
     250/*
     251// convert everything to xyz
     252template <class FromType>
     253struct ConverterSpecialized<FromType, xyz, _ToType_>
     254{
     255    enum { specialized = true };
     256    static bool convert(xyz* output, const FromType& input)
     257    { return ...; }
     258};
     259
     260// convert xyz to everything
     261template <class ToType>
     262struct ConverterSpecialized<xyz, ToType, _FromType_>
     263{
     264    enum { specialized = true };
     265    static bool convert(ToType* output, const xyz& input)
     266    { return ...; }
     267};
     268
     269// convert abc to xyz
     270template <>
     271struct ConverterSpecialized<abc, xyz, _Explicit_>
     272{
     273    enum { specialized = true };
     274    static bool convert(xyz* output, const abc& input)
     275    { return ...; }
     276};
     277*/
     278
     279////////////
     280// STRING //
     281////////////
     282
     283// convert to string
     284template <class FromType>
     285struct ConverterSpecialized<FromType, std::string, _ToType_>
     286{
     287    enum { specialized = true };
     288    static bool convert(std::string* output, const FromType& input)
     289    {
     290        std::ostringstream oss;
     291        if (oss << input)
     292        {
     293            (*output) = oss.str();
     294            return true;
     295        }
     296        else
     297            return false;
     298    }
     299};
     300
     301// convert from string
     302template <class ToType>
     303struct ConverterSpecialized<std::string, ToType, _FromType_>
     304{
     305    enum { specialized = true };
     306    static bool convert(ToType* output, const std::string& input)
     307    {
     308        std::istringstream iss(input);
     309        if (iss >> (*output))
     310            return true;
     311        else
     312            return false;
     313    }
     314};
     315
     316
     317////////////////
     318// MULTITYPES //
     319////////////////
     320
     321// convert from MultiTypePrimitive
     322template <class ToType>
     323struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>
     324{
     325    enum { specialized = true };
     326    static bool convert(ToType* output, const MultiTypePrimitive& input)
     327    {
     328        if (input.getType() == MT_void)
     329            return ConvertValue(output, input.getVoid());
     330        else if (input.getType() == MT_int)
     331            return ConvertValue(output, input.getInt());
     332        else if (input.getType() == MT_uint)
     333            return ConvertValue(output, input.getUnsignedInt());
     334        else if (input.getType() == MT_char)
     335            return ConvertValue(output, input.getChar());
     336        else if (input.getType() == MT_uchar)
     337            return ConvertValue(output, input.getUnsignedChar());
     338        else if (input.getType() == MT_short)
     339            return ConvertValue(output, input.getShort());
     340        else if (input.getType() == MT_ushort)
     341            return ConvertValue(output, input.getUnsignedShort());
     342        else if (input.getType() == MT_long)
     343            return ConvertValue(output, input.getLong());
     344        else if (input.getType() == MT_ulong)
     345            return ConvertValue(output, input.getUnsignedLong());
     346        else if (input.getType() == MT_float)
     347            return ConvertValue(output, input.getFloat());
     348        else if (input.getType() == MT_double)
     349            return ConvertValue(output, input.getDouble());
     350        else if (input.getType() == MT_longdouble)
     351            return ConvertValue(output, input.getLongDouble());
     352        else if (input.getType() == MT_bool)
     353            return ConvertValue(output, input.getBool());
     354        else
     355            return false;
     356    }
     357};
     358
     359// convert from MultiTypeString
     360template <class ToType>
     361struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>
     362{
     363    enum { specialized = true };
     364    static bool convert(ToType* output, const MultiTypeString& input)
     365    {
     366        if (input.getType() == MT_constchar)
     367            return ConvertValue(output, input.getConstChar());
     368        else if (input.getType() == MT_string)
     369            return ConvertValue(output, input.getString());
     370        else
     371            return ConvertValue(output, (MultiTypePrimitive)input);
     372    }
     373};
     374
     375// convert from MultiTypeMath
     376template <class ToType>
     377struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>
     378{
     379    enum { specialized = true };
     380    static bool convert(ToType* output, const MultiTypeMath& input)
     381    {
     382        if (input.getType() == MT_vector2)
     383            return ConvertValue(output, input.getVector2());
     384        else if (input.getType() == MT_vector3)
     385            return ConvertValue(output, input.getVector3());
     386        else if (input.getType() == MT_vector4)
     387            return ConvertValue(output, input.getVector4());
     388        else if (input.getType() == MT_quaternion)
     389            return ConvertValue(output, input.getQuaternion());
     390        else if (input.getType() == MT_colourvalue)
     391            return ConvertValue(output, input.getColourValue());
     392        else if (input.getType() == MT_radian)
     393            return ConvertValue(output, input.getRadian());
     394        else if (input.getType() == MT_degree)
     395            return ConvertValue(output, input.getDegree());
     396        else
     397            return ConvertValue(output, (MultiTypeString)input);
     398    }
     399};
     400
     401
    53402////////////////////
    54403// MATH TO STRING //
    55404////////////////////
    56 // Vector2 to std::stringtemplate <>struct ConverterSpecialized<orxonox::Vector2, std::string, _Explicit_>{    enum { specialized = true };    static bool convert(std::string* output, const orxonox::Vector2& input)    {        std::ostringstream ostream;        if (ostream << input.x << "," << input.y)        {            (*output) = ostream.str();            return true;        }        return false;    }};// Vector3 to std::stringtemplate <>struct ConverterSpecialized<orxonox::Vector3, std::string, _Explicit_>{    enum { specialized = true };    static bool convert(std::string* output, const orxonox::Vector3& input)    {        std::ostringstream ostream;        if (ostream << input.x << "," << input.y << "," << input.z)        {            (*output) = ostream.str();            return true;        }        return false;    }};// Vector4 to std::stringtemplate <>struct ConverterSpecialized<orxonox::Vector4, std::string, _Explicit_>{    enum { specialized = true };    static bool convert(std::string* output, const orxonox::Vector4& input)    {        std::ostringstream ostream;        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)        {            (*output) = ostream.str();            return true;        }        return false;    }};// Quaternion to std::stringtemplate <>struct ConverterSpecialized<orxonox::Quaternion, std::string, _Explicit_>{    enum { specialized = true };    static bool convert(std::string* output, const orxonox::Quaternion& input)    {        std::ostringstream ostream;        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)        {            (*output) = ostream.str();            return true;        }        return false;    }};// ColourValue to std::stringtemplate <>struct ConverterSpecialized<orxonox::ColourValue, std::string, _Explicit_>{    enum { specialized = true };    static bool convert(std::string* output, const orxonox::ColourValue& input)    {        std::ostringstream ostream;        if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)        {            (*output) = ostream.str();            return true;        }        return false;    }};////////////////////
     405
     406// Vector2 to std::string
     407template <>
     408struct ConverterSpecialized<orxonox::Vector2, std::string, _Explicit_>
     409{
     410    enum { specialized = true };
     411    static bool convert(std::string* output, const orxonox::Vector2& input)
     412    {
     413        std::ostringstream ostream;
     414        if (ostream << input.x << "," << input.y)
     415        {
     416            (*output) = ostream.str();
     417            return true;
     418        }
     419        return false;
     420    }
     421};
     422
     423// Vector3 to std::string
     424template <>
     425struct ConverterSpecialized<orxonox::Vector3, std::string, _Explicit_>
     426{
     427    enum { specialized = true };
     428    static bool convert(std::string* output, const orxonox::Vector3& input)
     429    {
     430        std::ostringstream ostream;
     431        if (ostream << input.x << "," << input.y << "," << input.z)
     432        {
     433            (*output) = ostream.str();
     434            return true;
     435        }
     436        return false;
     437    }
     438};
     439
     440// Vector4 to std::string
     441template <>
     442struct ConverterSpecialized<orxonox::Vector4, std::string, _Explicit_>
     443{
     444    enum { specialized = true };
     445    static bool convert(std::string* output, const orxonox::Vector4& input)
     446    {
     447        std::ostringstream ostream;
     448        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
     449        {
     450            (*output) = ostream.str();
     451            return true;
     452        }
     453        return false;
     454    }
     455};
     456
     457// Quaternion to std::string
     458template <>
     459struct ConverterSpecialized<orxonox::Quaternion, std::string, _Explicit_>
     460{
     461    enum { specialized = true };
     462    static bool convert(std::string* output, const orxonox::Quaternion& input)
     463    {
     464        std::ostringstream ostream;
     465        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
     466        {
     467            (*output) = ostream.str();
     468            return true;
     469        }
     470        return false;
     471    }
     472};
     473
     474// ColourValue to std::string
     475template <>
     476struct ConverterSpecialized<orxonox::ColourValue, std::string, _Explicit_>
     477{
     478    enum { specialized = true };
     479    static bool convert(std::string* output, const orxonox::ColourValue& input)
     480    {
     481        std::ostringstream ostream;
     482        if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
     483        {
     484            (*output) = ostream.str();
     485            return true;
     486        }
     487        return false;
     488    }
     489};
     490
     491
     492////////////////////
    57493// STRING TO MATH //
    58494////////////////////
    59 // std::string to Vector2template <>struct ConverterSpecialized<std::string, orxonox::Vector2, _Explicit_>{    enum { specialized = true };    static bool convert(orxonox::Vector2* output, const std::string& input)    {        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');        if (tokens.size() >= 2)        {            if (!ConvertValue(&(output->x), tokens[0]))                return false;            if (!ConvertValue(&(output->y), tokens[1]))                return false;            return true;        }        return false;    }};// std::string to Vector3template <>struct ConverterSpecialized<std::string, orxonox::Vector3, _Explicit_>{    enum { specialized = true };    static bool convert(orxonox::Vector3* output, const std::string& input)    {        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');        if (tokens.size() >= 3)        {            if (!ConvertValue(&(output->x), tokens[0]))                return false;            if (!ConvertValue(&(output->y), tokens[1]))                return false;            if (!ConvertValue(&(output->z), tokens[2]))                return false;            return true;        }        return false;    }};// std::string to Vector4template <>struct ConverterSpecialized<std::string, orxonox::Vector4, _Explicit_>{    enum { specialized = true };    static bool convert(orxonox::Vector4* output, const std::string& input)    {        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');        if (tokens.size() >= 4)        {            if (!ConvertValue(&(output->x), tokens[0]))                return false;            if (!ConvertValue(&(output->y), tokens[1]))                return false;            if (!ConvertValue(&(output->z), tokens[2]))                return false;            if (!ConvertValue(&(output->w), tokens[3]))                return false;            return true;        }        return false;    }};// std::string to Quaterniontemplate <>struct ConverterSpecialized<std::string, orxonox::Quaternion, _Explicit_>{    enum { specialized = true };    static bool convert(orxonox::Quaternion* output, const std::string& input)    {        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');        if (tokens.size() >= 4)        {            if (!ConvertValue(&(output->w), tokens[0]))                return false;            if (!ConvertValue(&(output->x), tokens[1]))                return false;            if (!ConvertValue(&(output->y), tokens[2]))                return false;            if (!ConvertValue(&(output->z), tokens[3]))                return false;            return true;        }        return false;    }};// std::string to ColourValuetemplate <>struct ConverterSpecialized<std::string, orxonox::ColourValue, _Explicit_>{    enum { specialized = true };    static bool convert(orxonox::ColourValue* output, const std::string& input)    {        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');        if (tokens.size() >= 4)        {            if (!ConvertValue(&(output->r), tokens[0]))                return false;            if (!ConvertValue(&(output->g), tokens[1]))                return false;            if (!ConvertValue(&(output->b), tokens[2]))                return false;            if (!ConvertValue(&(output->a), tokens[3]))                return false;            return true;        }        return false;    }};#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     495
     496// std::string to Vector2
     497template <>
     498struct ConverterSpecialized<std::string, orxonox::Vector2, _Explicit_>
     499{
     500    enum { specialized = true };
     501    static bool convert(orxonox::Vector2* output, const std::string& input)
     502    {
     503        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
     504        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
     505
     506        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
     507        if (tokens.size() >= 2)
     508        {
     509            if (!ConvertValue(&(output->x), tokens[0]))
     510                return false;
     511            if (!ConvertValue(&(output->y), tokens[1]))
     512                return false;
     513
     514            return true;
     515        }
     516        return false;
     517    }
     518};
     519
     520// std::string to Vector3
     521template <>
     522struct ConverterSpecialized<std::string, orxonox::Vector3, _Explicit_>
     523{
     524    enum { specialized = true };
     525    static bool convert(orxonox::Vector3* output, const std::string& input)
     526    {
     527        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
     528        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
     529
     530        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
     531        if (tokens.size() >= 3)
     532        {
     533            if (!ConvertValue(&(output->x), tokens[0]))
     534                return false;
     535            if (!ConvertValue(&(output->y), tokens[1]))
     536                return false;
     537            if (!ConvertValue(&(output->z), tokens[2]))
     538                return false;
     539
     540            return true;
     541        }
     542        return false;
     543    }
     544};
     545
     546// std::string to Vector4
     547template <>
     548struct ConverterSpecialized<std::string, orxonox::Vector4, _Explicit_>
     549{
     550    enum { specialized = true };
     551    static bool convert(orxonox::Vector4* output, const std::string& input)
     552    {
     553        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
     554        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
     555
     556        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
     557        if (tokens.size() >= 4)
     558        {
     559            if (!ConvertValue(&(output->x), tokens[0]))
     560                return false;
     561            if (!ConvertValue(&(output->y), tokens[1]))
     562                return false;
     563            if (!ConvertValue(&(output->z), tokens[2]))
     564                return false;
     565            if (!ConvertValue(&(output->w), tokens[3]))
     566                return false;
     567
     568            return true;
     569        }
     570        return false;
     571    }
     572};
     573
     574// std::string to Quaternion
     575template <>
     576struct ConverterSpecialized<std::string, orxonox::Quaternion, _Explicit_>
     577{
     578    enum { specialized = true };
     579    static bool convert(orxonox::Quaternion* output, const std::string& input)
     580    {
     581        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
     582        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
     583
     584        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
     585        if (tokens.size() >= 4)
     586        {
     587            if (!ConvertValue(&(output->w), tokens[0]))
     588                return false;
     589            if (!ConvertValue(&(output->x), tokens[1]))
     590                return false;
     591            if (!ConvertValue(&(output->y), tokens[2]))
     592                return false;
     593            if (!ConvertValue(&(output->z), tokens[3]))
     594                return false;
     595
     596            return true;
     597        }
     598        return false;
     599    }
     600};
     601
     602// std::string to ColourValue
     603template <>
     604struct ConverterSpecialized<std::string, orxonox::ColourValue, _Explicit_>
     605{
     606    enum { specialized = true };
     607    static bool convert(orxonox::ColourValue* output, const std::string& input)
     608    {
     609        unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
     610        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
     611
     612        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
     613        if (tokens.size() >= 4)
     614        {
     615            if (!ConvertValue(&(output->r), tokens[0]))
     616                return false;
     617            if (!ConvertValue(&(output->g), tokens[1]))
     618                return false;
     619            if (!ConvertValue(&(output->b), tokens[2]))
     620                return false;
     621            if (!ConvertValue(&(output->a), tokens[3]))
     622                return false;
     623
     624            return true;
     625        }
     626        return false;
     627    }
     628};
     629
     630#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
    60631#pragma warning(pop)
    61632#endif
     633
    62634#endif /* _Convert_H__ */

  • code/branches/network/src/util/ExprParser.cc

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    3031  @brief Declaration of FloatParser
    3132*/
    32 #include "ExprParser.h"#include <cmath>#include <cstring>// macros for easier if, else statements#define CASE_1(var) if (!strcmp(SWITCH,var))#define CASE(var) else if (!strcmp(SWITCH,var))#define CASE_ELSE else//! skip white spaces#define PARSE_BLANKS while (*reading_stream == ' ') ++reading_stream;ExprParser::ExprParser(const std::string& str){  this->failed_ = false;  this->reading_stream = str.c_str();  if (str.size() == 0 || *reading_stream == '\0')  {    this->failed_ = true;    this->result_ = 0.0;  }  else  {    this->result_ = parse_expr_8();    this->remains_ = reading_stream;  }}//Private functions:/******************/double ExprParser::parse_argument(){   double value = parse_expr_8();   if (*reading_stream == ',')   {      ++reading_stream;      return value;   }   else   {     this->failed_ = true;     return 0;   }}double ExprParser::parse_last_argument(){   double value = parse_expr_8();   if (*reading_stream == ')')   {      ++reading_stream;      return value;   }   else   {     this->failed_ = true;     return 0;   }}double ExprParser::parse_expr_8(){   double value = parse_expr_7();   for(;;)   {      switch (op)      {         case oder:            value = parse_expr_7() || value;            break;         default: return value;      }   };}double ExprParser::parse_expr_7(){   double value = parse_expr_6();   for(;;)   {      switch (op)      {         case und:            value = value && parse_expr_6();            break;         default: return value;      }   };}double ExprParser::parse_expr_6(){   double value = parse_expr_5();   for(;;)   {      switch (op)      {         case gleich:            value = (value == parse_expr_5());            break;         case ungleich:            value = (value != parse_expr_5());            break;         default:            return value;      }   };}double ExprParser::parse_expr_5(){   double value = parse_expr_4();   for(;;)   {      switch (op)      {         case kleiner:            value = (value < parse_expr_4());            break;         case kleinergleich:            value = (value <= parse_expr_4());            break;         case groesser:            value = (value > parse_expr_4());            break;         case groessergleich:            value = (value >= parse_expr_4());            break;         default:            return value;      }   };}double ExprParser::parse_expr_4(){   double value = parse_expr_3();   for(;;)   {      switch (op)      {         case b_plus:            value += parse_expr_3();            break;         case b_minus:            value -= parse_expr_3();            break;         default:            return value;      }   };}double ExprParser::parse_expr_3(){   double value = parse_expr_2();   for(;;)   {      switch (op)      {         case mal:            value *= parse_expr_2();            break;         case durch:            value /= parse_expr_2();            break;         case modulo:         {            double temp = parse_expr_2();            value = value - floor(value/temp)*temp;            break;         }         default:            return value;      }   };}double ExprParser::parse_expr_2(){   double value = parse_expr_1();   while (*reading_stream != '\0')   {      op = parse_binary_operator();      switch (op)      {         case hoch:            value = pow(value,parse_expr_1());            break;         default:            return value;      }   };   op = undef;   return value;}double ExprParser::parse_expr_1(){   PARSE_BLANKS   double value;   unary_operator op = parse_unary_operator();   PARSE_BLANKS   if (*reading_stream == '\0')   {     // end of string     this->failed_ = true;     return 0;   }   else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)   {  // number      value = strtod(reading_stream, const_cast<char**>(&reading_stream));   }   else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)   {  // variable or function      char* word = new char[256];      parse_word(word);      PARSE_BLANKS      if (*reading_stream == '(')      {         ++reading_stream;#define SWITCH word         CASE_1("sin")            value = sin(parse_last_argument());         CASE("asin")            value = asin(parse_last_argument());         CASE("sinh")            value = sinh(parse_last_argument());         CASE("asinh")         {            value = parse_last_argument();            value = log(sqrt(pow(value, 2) + 1) + value);         }         CASE("cos")            value = cos(parse_last_argument());         CASE("acos")            value = acos(parse_last_argument());         CASE("cosh")            value = cosh(parse_last_argument());         CASE("acosh")         {            value = parse_last_argument();            value = log(sqrt(pow(value, 2) - 1) + value);         }         CASE("tan")            value = tan(parse_last_argument());         CASE("atan")            value = atan(parse_last_argument());         CASE("atan2")            value = atan2(parse_argument(),parse_last_argument());         CASE("tanh")            value = tanh(parse_last_argument());         CASE("atanh")         {            value = parse_last_argument();            value = 0.5*log((value + 1)/(value - 1));         }         CASE("int")            value = floor(parse_last_argument());         CASE("floor")            value = floor(parse_last_argument());         CASE("ceil")            value = ceil(parse_last_argument());         CASE("abs")            value = fabs(parse_last_argument());         CASE("exp")            value = exp(parse_last_argument());         CASE("log")            value = log10(parse_last_argument());         CASE("ln")            value = log(parse_last_argument());         CASE("sign")         {            value = parse_last_argument();            value = (value>0 ? 1 : (value<0 ? -1 : 0));         }         CASE("sqrt")            value = sqrt(parse_last_argument());         CASE("degrees")            value = parse_last_argument()*180/3.1415926535897932;         CASE("radians")            value = parse_last_argument()*3.1415926535897932/180;         CASE("mod")         {            value = parse_argument();            double value2 = parse_last_argument();            value = value - floor(value/value2)*value2;         }         CASE("pow")            value = pow(parse_argument(),parse_last_argument());         CASE("div")            value = floor(parse_argument()/parse_last_argument());         CASE("max")           value = std::max(parse_argument(),parse_last_argument());         CASE("min")           value = std::min(parse_argument(),parse_last_argument());         CASE_ELSE         {           this->failed_ = true;           delete[] word;           return 0;         }      }      else      {#define SWITCH word         CASE_1("pi")           value = 3.1415926535897932;         CASE("e")           value = 2.7182818284590452;         CASE_ELSE         {           this->failed_ = true;           delete[] word;           return 0;         }      }      delete[] word;   }   else if (*reading_stream == 40)   {  // expresion in paranthesis      ++reading_stream;      value = parse_last_argument();   }   else   {     this->failed_ = true;     return 0;   }   PARSE_BLANKS   switch (op)   {      case u_nicht: return !value;      case u_plus:  return  value;      case u_minus: return -value;      default:        {          this->failed_ = true;          return 0;        }   }}char* ExprParser::parse_word(char* str){   char* word = str;   int counter = 0;   while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)   {      *word++ = *reading_stream++;      counter++;      if (counter > 255)      {        this->failed_ = true;        return '\0';      }   };   *word = '\0';   return str;}ExprParser::binary_operator ExprParser::parse_binary_operator(){   binary_operator op;   switch (*reading_stream)   {      case '+': op = b_plus; break;      case '-': op = b_minus; break;      case '*': op = mal; break;      case '/': op = durch; break;      case '^': op = hoch; break;      case '%': op = modulo; break;      case '&': op = und; break;      case '|': op = oder; break;      case '=': op = gleich; break;      case '!': op = b_nicht; break;      case '<': op = kleiner; break;      case '>': op = groesser; break;      default: return undef;   }   if (*++reading_stream == '=')   {      if (op > 9)      {         ++reading_stream;         return (binary_operator)(op + 3);      }      else      {         --reading_stream;         return undef;      }   }   else      return op;}ExprParser::unary_operator ExprParser::parse_unary_operator(){   switch (*reading_stream)   {      case '!':         ++reading_stream;         return u_nicht;      case '+':         ++reading_stream;         return u_plus;      case '-':         ++reading_stream;         return u_minus;      default :         return u_plus;   }}
     33
     34#include "ExprParser.h"
     35#include <cmath>
     36#include <cstring>
     37
     38// macros for easier if, else statements
     39#define CASE_1(var) if (!strcmp(SWITCH,var))
     40#define CASE(var) else if (!strcmp(SWITCH,var))
     41#define CASE_ELSE else
     42
     43//! skip white spaces
     44#define PARSE_BLANKS while (*reading_stream == ' ') ++reading_stream;
     45
     46ExprParser::ExprParser(const std::string& str)
     47{
     48  this->failed_ = false;
     49  this->reading_stream = str.c_str();
     50  if (str.size() == 0 || *reading_stream == '\0')
     51  {
     52    this->failed_ = true;
     53    this->result_ = 0.0;
     54  }
     55  else
     56  {
     57    this->result_ = parse_expr_8();
     58    this->remains_ = reading_stream;
     59  }
     60}
     61
     62//Private functions:
     63/******************/
     64double ExprParser::parse_argument()
     65{
     66   double value = parse_expr_8();
     67   if (*reading_stream == ',')
     68   {
     69      ++reading_stream;
     70      return value;
     71   }
     72   else
     73   {
     74     this->failed_ = true;
     75     return 0;
     76   }
     77}
     78
     79double ExprParser::parse_last_argument()
     80{
     81   double value = parse_expr_8();
     82   if (*reading_stream == ')')
     83   {
     84      ++reading_stream;
     85      return value;
     86   }
     87   else
     88   {
     89     this->failed_ = true;
     90     return 0;
     91   }
     92}
     93
     94double ExprParser::parse_expr_8()
     95{
     96   double value = parse_expr_7();
     97   for(;;)
     98   {
     99      switch (op)
     100      {
     101         case oder:
     102            value = parse_expr_7() || value;
     103            break;
     104         default: return value;
     105      }
     106   };
     107}
     108
     109
     110double ExprParser::parse_expr_7()
     111{
     112   double value = parse_expr_6();
     113   for(;;)
     114   {
     115      switch (op)
     116      {
     117         case und:
     118            value = value && parse_expr_6();
     119            break;
     120         default: return value;
     121      }
     122   };
     123}
     124
     125double ExprParser::parse_expr_6()
     126{
     127   double value = parse_expr_5();
     128   for(;;)
     129   {
     130      switch (op)
     131      {
     132         case gleich:
     133            value = (value == parse_expr_5());
     134            break;
     135         case ungleich:
     136            value = (value != parse_expr_5());
     137            break;
     138         default:
     139            return value;
     140      }
     141   };
     142}
     143
     144double ExprParser::parse_expr_5()
     145{
     146   double value = parse_expr_4();
     147   for(;;)
     148   {
     149      switch (op)
     150      {
     151         case kleiner:
     152            value = (value < parse_expr_4());
     153            break;
     154         case kleinergleich:
     155            value = (value <= parse_expr_4());
     156            break;
     157         case groesser:
     158            value = (value > parse_expr_4());
     159            break;
     160         case groessergleich:
     161            value = (value >= parse_expr_4());
     162            break;
     163         default:
     164            return value;
     165      }
     166   };
     167}
     168
     169double ExprParser::parse_expr_4()
     170{
     171   double value = parse_expr_3();
     172   for(;;)
     173   {
     174      switch (op)
     175      {
     176         case b_plus:
     177            value += parse_expr_3();
     178            break;
     179         case b_minus:
     180            value -= parse_expr_3();
     181            break;
     182         default:
     183            return value;
     184      }
     185   };
     186}
     187
     188double ExprParser::parse_expr_3()
     189{
     190   double value = parse_expr_2();
     191   for(;;)
     192   {
     193      switch (op)
     194      {
     195         case mal:
     196            value *= parse_expr_2();
     197            break;
     198         case durch:
     199            value /= parse_expr_2();
     200            break;
     201         case modulo:
     202         {
     203            double temp = parse_expr_2();
     204            value = value - floor(value/temp)*temp;
     205            break;
     206         }
     207         default:
     208            return value;
     209      }
     210   };
     211}
     212
     213double ExprParser::parse_expr_2()
     214{
     215   double value = parse_expr_1();
     216   while (*reading_stream != '\0')
     217   {
     218      op = parse_binary_operator();
     219      switch (op)
     220      {
     221         case hoch:
     222            value = pow(value,parse_expr_1());
     223            break;
     224         default:
     225            return value;
     226      }
     227   };
     228   op = undef;
     229   return value;
     230}
     231
     232double ExprParser::parse_expr_1()
     233{
     234   PARSE_BLANKS
     235   double value;
     236
     237   unary_operator op = parse_unary_operator();
     238   PARSE_BLANKS
     239
     240   if (*reading_stream == '\0')
     241   {
     242     // end of string
     243     this->failed_ = true;
     244     return 0;
     245   }
     246   else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)
     247   {  // number
     248      value = strtod(reading_stream, const_cast<char**>(&reading_stream));
     249   }
     250   else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
     251   {  // variable or function
     252      char* word = new char[256];
     253      parse_word(word);
     254      PARSE_BLANKS
     255      if (*reading_stream == '(')
     256      {
     257         ++reading_stream;
     258#define SWITCH word
     259         CASE_1("sin")
     260            value = sin(parse_last_argument());
     261         CASE("asin")
     262            value = asin(parse_last_argument());
     263         CASE("sinh")
     264            value = sinh(parse_last_argument());
     265         CASE("asinh")
     266         {
     267            value = parse_last_argument();
     268            value = log(sqrt(pow(value, 2) + 1) + value);
     269         }
     270         CASE("cos")
     271            value = cos(parse_last_argument());
     272         CASE("acos")
     273            value = acos(parse_last_argument());
     274         CASE("cosh")
     275            value = cosh(parse_last_argument());
     276         CASE("acosh")
     277         {
     278            value = parse_last_argument();
     279            value = log(sqrt(pow(value, 2) - 1) + value);
     280         }
     281         CASE("tan")
     282            value = tan(parse_last_argument());
     283         CASE("atan")
     284            value = atan(parse_last_argument());
     285         CASE("atan2")
     286            value = atan2(parse_argument(),parse_last_argument());
     287         CASE("tanh")
     288            value = tanh(parse_last_argument());
     289         CASE("atanh")
     290         {
     291            value = parse_last_argument();
     292            value = 0.5*log((value + 1)/(value - 1));
     293         }
     294         CASE("int")
     295            value = floor(parse_last_argument());
     296         CASE("floor")
     297            value = floor(parse_last_argument());
     298         CASE("ceil")
     299            value = ceil(parse_last_argument());
     300         CASE("abs")
     301            value = fabs(parse_last_argument());
     302         CASE("exp")
     303            value = exp(parse_last_argument());
     304         CASE("log")
     305            value = log10(parse_last_argument());
     306         CASE("ln")
     307            value = log(parse_last_argument());
     308         CASE("sign")
     309         {
     310            value = parse_last_argument();
     311            value = (value>0 ? 1 : (value<0 ? -1 : 0));
     312         }
     313         CASE("sqrt")
     314            value = sqrt(parse_last_argument());
     315         CASE("degrees")
     316            value = parse_last_argument()*180/3.1415926535897932;
     317         CASE("radians")
     318            value = parse_last_argument()*3.1415926535897932/180;
     319         CASE("mod")
     320         {
     321            value = parse_argument();
     322            double value2 = parse_last_argument();
     323            value = value - floor(value/value2)*value2;
     324         }
     325         CASE("pow")
     326            value = pow(parse_argument(),parse_last_argument());
     327         CASE("div")
     328            value = floor(parse_argument()/parse_last_argument());
     329         CASE("max")
     330           value = std::max(parse_argument(),parse_last_argument());
     331         CASE("min")
     332           value = std::min(parse_argument(),parse_last_argument());
     333         CASE_ELSE
     334         {
     335           this->failed_ = true;
     336           delete[] word;
     337           return 0;
     338         }
     339      }
     340      else
     341      {
     342#define SWITCH word
     343         CASE_1("pi")
     344           value = 3.1415926535897932;
     345         CASE("e")
     346           value = 2.7182818284590452;
     347         CASE_ELSE
     348         {
     349           this->failed_ = true;
     350           delete[] word;
     351           return 0;
     352         }
     353      }
     354      delete[] word;
     355   }
     356   else if (*reading_stream == 40)
     357   {  // expresion in paranthesis
     358      ++reading_stream;
     359      value = parse_last_argument();
     360   }
     361   else
     362   {
     363     this->failed_ = true;
     364     return 0;
     365   }
     366
     367   PARSE_BLANKS
     368   switch (op)
     369   {
     370      case u_nicht: return !value;
     371      case u_plus:  return  value;
     372      case u_minus: return -value;
     373      default:
     374        {
     375          this->failed_ = true;
     376          return 0;
     377        }
     378   }
     379}
     380
     381char* ExprParser::parse_word(char* str)
     382{
     383   char* word = str;
     384   int counter = 0;
     385   while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
     386   {
     387      *word++ = *reading_stream++;
     388      counter++;
     389      if (counter > 255)
     390      {
     391        this->failed_ = true;
     392        return '\0';
     393      }
     394   };
     395   *word = '\0';
     396   return str;
     397}
     398
     399ExprParser::binary_operator ExprParser::parse_binary_operator()
     400{
     401   binary_operator op;
     402   switch (*reading_stream)
     403   {
     404      case '+': op = b_plus; break;
     405      case '-': op = b_minus; break;
     406      case '*': op = mal; break;
     407      case '/': op = durch; break;
     408      case '^': op = hoch; break;
     409      case '%': op = modulo; break;
     410      case '&': op = und; break;
     411      case '|': op = oder; break;
     412      case '=': op = gleich; break;
     413      case '!': op = b_nicht; break;
     414      case '<': op = kleiner; break;
     415      case '>': op = groesser; break;
     416      default: return undef;
     417   }
     418   if (*++reading_stream == '=')
     419   {
     420      if (op > 9)
     421      {
     422         ++reading_stream;
     423         return (binary_operator)(op + 3);
     424      }
     425      else
     426      {
     427         --reading_stream;
     428         return undef;
     429      }
     430   }
     431   else
     432      return op;
     433}
     434
     435ExprParser::unary_operator ExprParser::parse_unary_operator()
     436{
     437   switch (*reading_stream)
     438   {
     439      case '!':
     440         ++reading_stream;
     441         return u_nicht;
     442      case '+':
     443         ++reading_stream;
     444         return u_plus;
     445      case '-':
     446         ++reading_stream;
     447         return u_minus;
     448      default :
     449         return u_plus;
     450   }
     451}

  • code/branches/network/src/util/ExprParser.h

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    3031  @brief Declaration of FloatParser
    3132*/
    32 #ifndef _FloatParser_H__#define _FloatParser_H__#include "UtilPrereqs.h"#include <string>class _UtilExport ExprParser{public:  enum binary_operator  {    b_plus,    b_minus,    mal,    durch,    modulo,    hoch,    undef,    oder,    und,    gleich,    b_nicht,    kleiner,    groesser,    ungleich,    kleinergleich,    groessergleich  };  enum unary_operator  {    u_plus,    u_minus,    u_nicht  };  ExprParser(const std::string& str);  std::string& getRemains() { return  this->remains_; }  double       getResult()  { return  this->result_; }  bool         getSuccess() { return !this->failed_; }private:  double parse_expr_1();  double parse_expr_2();  double parse_expr_3();  double parse_expr_4();  double parse_expr_5();  double parse_expr_6();  double parse_expr_7();  double parse_expr_8();  char* parse_word(char* str);  binary_operator parse_binary_operator();  unary_operator parse_unary_operator();  double parse_argument();  double parse_last_argument();  binary_operator op;  const char* reading_stream;  bool failed_;  double result_;  std::string remains_;};//Endzeichen für float expression: ')', '}', ']', ',', ';'_UtilExport bool parse_float(char* const, char**, double*);//Endzeichen angegeben_UtilExport bool parse_float(char* const, char**, char, double*);//Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)_UtilExport bool parse_vector_float(char* const, char**, bool, double*);#endif /* _FloatParser_H__ */
     33
     34#ifndef _FloatParser_H__
     35#define _FloatParser_H__
     36
     37#include "UtilPrereqs.h"
     38#include <string>
     39
     40class _UtilExport ExprParser
     41{
     42public:
     43  enum binary_operator
     44  {
     45    b_plus,
     46    b_minus,
     47    mal,
     48    durch,
     49    modulo,
     50    hoch,
     51    undef,
     52    oder,
     53    und,
     54    gleich,
     55    b_nicht,
     56    kleiner,
     57    groesser,
     58    ungleich,
     59    kleinergleich,
     60    groessergleich
     61  };
     62
     63  enum unary_operator
     64  {
     65    u_plus,
     66    u_minus,
     67    u_nicht
     68  };
     69
     70
     71  ExprParser(const std::string& str);
     72  std::string& getRemains() { return  this->remains_; }
     73  double       getResult()  { return  this->result_; }
     74  bool         getSuccess() { return !this->failed_; }
     75
     76private:
     77  double parse_expr_1();
     78  double parse_expr_2();
     79  double parse_expr_3();
     80  double parse_expr_4();
     81  double parse_expr_5();
     82  double parse_expr_6();
     83  double parse_expr_7();
     84  double parse_expr_8();
     85  char* parse_word(char* str);
     86  binary_operator parse_binary_operator();
     87  unary_operator parse_unary_operator();
     88
     89  double parse_argument();
     90  double parse_last_argument();
     91
     92  binary_operator op;
     93  const char* reading_stream;
     94  bool failed_;
     95  double result_;
     96  std::string remains_;
     97
     98};
     99
     100//Endzeichen für float expression: ')', '}', ']', ',', ';'
     101_UtilExport bool parse_float(char* const, char**, double*);
     102//Endzeichen angegeben
     103_UtilExport bool parse_float(char* const, char**, char, double*);
     104//Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
     105_UtilExport bool parse_vector_float(char* const, char**, bool, double*);
     106
     107#endif /* _FloatParser_H__ */

  • code/branches/network/src/util/MultiTypeMath.h

    r1494 r1495  
    1 /* *   ORXONOX - the hottest 3D action shooter ever to exist *                    > www.orxonox.net < * * *   License notice: * *   This program is free software; you can redistribute it and/or *   modify it under the terms of the GNU General Public License *   as published by the Free Software Foundation; either version 2 *   of the License, or (at your option) any later version. * *   This program 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 General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program; if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. * *   Author: *      Fabian 'x3n' Landau *   Co-authors: *      ... * *   Inspiration: MultiType by Benjamin Grauer */#ifndef _MultiTypeMath_H__#define _MultiTypeMath_H__#include "UtilPrereqs.h"#include "MultiTypeString.h"#include "Math.h"// disable annoying warning about multiple assignment operators
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Fabian 'x3n' Landau
     24 *   Co-authors:
     25 *      ...
     26 *
     27 *   Inspiration: MultiType by Benjamin Grauer
     28 */
     29
     30#ifndef _MultiTypeMath_H__
     31#define _MultiTypeMath_H__
     32
     33#include "UtilPrereqs.h"
     34
     35#include "MultiTypeString.h"
     36#include "Math.h"
     37
     38// disable annoying warning about multiple assignment operators
    239#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
    340#pragma warning(push)
    441#pragma warning(disable:4522)
    542#endif
    6 class _UtilExport MultiTypeMath : public MultiTypeString{    public:        MultiTypeMath(MultiType type = MT_null);        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}        inline MultiTypeMath(int            value) : MultiTypeString(value) {}        inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}        inline MultiTypeMath(char           value) : MultiTypeString(value) {}        inline MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}        inline MultiTypeMath(short          value) : MultiTypeString(value) {}        inline MultiTypeMath(unsigned short value) : MultiTypeString(value) {}        inline MultiTypeMath(long           value) : MultiTypeString(value) {}        inline MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}        inline MultiTypeMath(float          value) : MultiTypeString(value) {}        inline MultiTypeMath(double         value) : MultiTypeString(value) {}        inline MultiTypeMath(long double    value) : MultiTypeString(value) {}        inline MultiTypeMath(bool           value) : MultiTypeString(value) {}        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}        inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::Vector4&     value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }        inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }        inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }        inline MultiTypeMath(const MultiTypeString& mts)        { this->setValue(mts);   }        inline MultiTypeMath(const MultiTypePrimitive& mtp)     { this->setValue(mtp);   }        virtual inline ~MultiTypeMath() {}        using MultiTypeString::operator=;        inline MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::Vector4&     value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }        inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }        inline MultiTypeMath& operator=(const MultiTypeString& mts)        { this->setValue(mts);   return *this; }        inline MultiTypeMath& operator=(const MultiTypePrimitive mtp)      { this->setValue(mtp);   return *this; }        using MultiTypeString::operator==;        inline bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }        inline bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }        inline bool operator==(const orxonox::Vector4&     value) const { return (this->vector4_     == value); }        inline bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }        inline bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }        inline bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }        inline bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }        bool operator==(const MultiTypeMath& mtm) const;        bool operator==(const MultiTypeString& mts) const;        bool operator==(const MultiTypePrimitive& mtp) const;        using MultiTypeString::operator!=;        inline bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }        inline bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }        inline bool operator!=(const orxonox::Vector4&     value) const { return (this->vector4_     != value); }        inline bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }        inline bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }        inline bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }        inline bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }        bool operator!=(const MultiTypeMath& mtm) const;        bool operator!=(const MultiTypeString& mts) const;        bool operator!=(const MultiTypePrimitive& mtp) const;        virtual operator void*()                const;        virtual operator int()                  const;        virtual operator unsigned int()         const;        virtual operator char()                 const;        virtual operator unsigned char()        const;        virtual operator short()                const;        virtual operator unsigned short()       const;        virtual operator long()                 const;        virtual operator unsigned long()        const;        virtual operator float ()               const;        virtual operator double ()              const;        virtual operator long double()          const;        virtual operator bool()                 const;        virtual operator std::string()          const;        virtual operator const char*()          const;        virtual operator orxonox::Vector2()     const;        virtual operator orxonox::Vector3()     const;        virtual operator orxonox::Vector4()     const;        virtual operator orxonox::ColourValue() const;        virtual operator orxonox::Quaternion()  const;        virtual operator orxonox::Radian()      const;        virtual operator orxonox::Degree()      const;        using MultiTypeString::setValue;        inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }        inline void setValue(const orxonox::Vector4&     value) { this->type_ = MT_vector4;     this->vector4_     = value; }        inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }        inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }        inline void setValue(const orxonox::Radian&      value) { this->type_ = MT_radian;      this->radian_      = value; }        inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }        void setValue(const MultiTypeMath& mtm);        void setValue(const MultiTypeString& mts);        void setValue(const MultiTypePrimitive& mtp);        inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }        inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }        inline orxonox::Vector4     getVector4()     const { return this->vector4_;     }        inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }        inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }        inline orxonox::Radian      getRadian()      const { return this->radian_;      }        inline orxonox::Degree      getDegree()      const { return this->degree_;      }        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }        inline orxonox::Vector4&     getVector4()     { return this->vector4_;     }        inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }        inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }        inline orxonox::Radian&      getRadian()      { return this->radian_;      }        inline orxonox::Degree&      getDegree()      { return this->degree_;      }        using MultiTypeString::getValue;        inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }        inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }        inline void getValue(orxonox::Vector4*     variable) const { (*variable) = orxonox::Vector4     (this->vector4_);     }        inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }        inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }        inline void getValue(orxonox::Radian*      variable) const { (*variable) = orxonox::Radian      (this->radian_);      }        inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }        virtual std::string getTypename() const;        virtual std::string toString() const;        virtual bool fromString(const std::string value);        virtual bool assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue = MultiTypeMath());    protected:        orxonox::Vector2      vector2_;        orxonox::Vector3      vector3_;        orxonox::Vector4      vector4_;        orxonox::ColourValue  colourvalue_;        orxonox::Quaternion   quaternion_;        orxonox::Radian       radian_;        orxonox::Degree       degree_;};_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     43
     44class _UtilExport MultiTypeMath : public MultiTypeString
     45{
     46    public:
     47        MultiTypeMath(MultiType type = MT_null);
     48        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}
     49        inline MultiTypeMath(int            value) : MultiTypeString(value) {}
     50        inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
     51        inline MultiTypeMath(char           value) : MultiTypeString(value) {}
     52        inline MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}
     53        inline MultiTypeMath(short          value) : MultiTypeString(value) {}
     54        inline MultiTypeMath(unsigned short value) : MultiTypeString(value) {}
     55        inline MultiTypeMath(long           value) : MultiTypeString(value) {}
     56        inline MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}
     57        inline MultiTypeMath(float          value) : MultiTypeString(value) {}
     58        inline MultiTypeMath(double         value) : MultiTypeString(value) {}
     59        inline MultiTypeMath(long double    value) : MultiTypeString(value) {}
     60        inline MultiTypeMath(bool           value) : MultiTypeString(value) {}
     61        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}
     62        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}
     63        inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
     64        inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
     65        inline MultiTypeMath(const orxonox::Vector4&     value) { this->setValue(value); }
     66        inline MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
     67        inline MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
     68        inline MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
     69        inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
     70        inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }
     71        inline MultiTypeMath(const MultiTypeString& mts)        { this->setValue(mts);   }
     72        inline MultiTypeMath(const MultiTypePrimitive& mtp)     { this->setValue(mtp);   }
     73        virtual inline ~MultiTypeMath() {}
     74
     75        using MultiTypeString::operator=;
     76        inline MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
     77        inline MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
     78        inline MultiTypeMath& operator=(const orxonox::Vector4&     value) { this->setValue(value); return *this; }
     79        inline MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
     80        inline MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
     81        inline MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
     82        inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
     83        inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }
     84        inline MultiTypeMath& operator=(const MultiTypeString& mts)        { this->setValue(mts);   return *this; }
     85        inline MultiTypeMath& operator=(const MultiTypePrimitive mtp)      { this->setValue(mtp);   return *this; }
     86
     87        using MultiTypeString::operator==;
     88        inline bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
     89        inline bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
     90        inline bool operator==(const orxonox::Vector4&     value) const { return (this->vector4_     == value); }
     91        inline bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
     92        inline bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
     93        inline bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }
     94        inline bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
     95        bool operator==(const MultiTypeMath& mtm) const;
     96        bool operator==(const MultiTypeString& mts) const;
     97        bool operator==(const MultiTypePrimitive& mtp) const;
     98
     99        using MultiTypeString::operator!=;
     100        inline bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
     101        inline bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
     102        inline bool operator!=(const orxonox::Vector4&     value) const { return (this->vector4_     != value); }
     103        inline bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
     104        inline bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
     105        inline bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }
     106        inline bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
     107        bool operator!=(const MultiTypeMath& mtm) const;
     108        bool operator!=(const MultiTypeString& mts) const;
     109        bool operator!=(const MultiTypePrimitive& mtp) const;
     110
     111        virtual operator void*()                const;
     112        virtual operator int()                  const;
     113        virtual operator unsigned int()         const;
     114        virtual operator char()                 const;
     115        virtual operator unsigned char()        const;
     116        virtual operator short()                const;
     117        virtual operator unsigned short()       const;
     118        virtual operator long()                 const;
     119        virtual operator unsigned long()        const;
     120        virtual operator float ()               const;
     121        virtual operator double ()              const;
     122        virtual operator long double()          const;
     123        virtual operator bool()                 const;
     124        virtual operator std::string()          const;
     125        virtual operator const char*()          const;
     126        virtual operator orxonox::Vector2()     const;
     127        virtual operator orxonox::Vector3()     const;
     128        virtual operator orxonox::Vector4()     const;
     129        virtual operator orxonox::ColourValue() const;
     130        virtual operator orxonox::Quaternion()  const;
     131        virtual operator orxonox::Radian()      const;
     132        virtual operator orxonox::Degree()      const;
     133
     134        using MultiTypeString::setValue;
     135        inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
     136        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
     137        inline void setValue(const orxonox::Vector4&     value) { this->type_ = MT_vector4;     this->vector4_     = value; }
     138        inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
     139        inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }
     140        inline void setValue(const orxonox::Radian&      value) { this->type_ = MT_radian;      this->radian_      = value; }
     141        inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
     142        void setValue(const MultiTypeMath& mtm);
     143        void setValue(const MultiTypeString& mts);
     144        void setValue(const MultiTypePrimitive& mtp);
     145
     146        inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }
     147        inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }
     148        inline orxonox::Vector4     getVector4()     const { return this->vector4_;     }
     149        inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }
     150        inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }
     151        inline orxonox::Radian      getRadian()      const { return this->radian_;      }
     152        inline orxonox::Degree      getDegree()      const { return this->degree_;      }
     153
     154        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
     155        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
     156        inline orxonox::Vector4&     getVector4()     { return this->vector4_;     }
     157        inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }
     158        inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }
     159        inline orxonox::Radian&      getRadian()      { return this->radian_;      }
     160        inline orxonox::Degree&      getDegree()      { return this->degree_;      }
     161
     162        using MultiTypeString::getValue;
     163        inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }
     164        inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }
     165        inline void getValue(orxonox::Vector4*     variable) const { (*variable) = orxonox::Vector4     (this->vector4_);     }
     166        inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }
     167        inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }
     168        inline void getValue(orxonox::Radian*      variable) const { (*variable) = orxonox::Radian      (this->radian_);      }
     169        inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
     170
     171        virtual std::string getTypename() const;
     172
     173        virtual std::string toString() const;
     174        virtual bool fromString(const std::string value);
     175
     176        virtual bool assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue = MultiTypeMath());
     177
     178    protected:
     179        orxonox::Vector2      vector2_;
     180        orxonox::Vector3      vector3_;
     181        orxonox::Vector4      vector4_;
     182        orxonox::ColourValue  colourvalue_;
     183        orxonox::Quaternion   quaternion_;
     184        orxonox::Radian       radian_;
     185        orxonox::Degree       degree_;
     186};
     187
     188_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
     189
     190#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
    7191#pragma warning(pop)
    8 #endif#endif /* _MultiTypeMath_H__ */
     192#endif
     193
     194#endif /* _MultiTypeMath_H__ */

  • code/branches/network/src/util/MultiTypeString.h

    r1494 r1495  
    1 /* *   ORXONOX - the hottest 3D action shooter ever to exist *                    > www.orxonox.net < * * *   License notice: * *   This program is free software; you can redistribute it and/or *   modify it under the terms of the GNU General Public License *   as published by the Free Software Foundation; either version 2 *   of the License, or (at your option) any later version. * *   This program 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 General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program; if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. * *   Author: *      Fabian 'x3n' Landau *   Co-authors: *      ... * *   Inspiration: MultiType by Benjamin Grauer */#ifndef _MultiTypeString_H__#define _MultiTypeString_H__#include "UtilPrereqs.h"#include <string>#include <iostream>#include "MultiTypePrimitive.h"// disable annoying warning about multiple assignment operators
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Fabian 'x3n' Landau
     24 *   Co-authors:
     25 *      ...
     26 *
     27 *   Inspiration: MultiType by Benjamin Grauer
     28 */
     29
     30#ifndef _MultiTypeString_H__
     31#define _MultiTypeString_H__
     32
     33#include "UtilPrereqs.h"
     34
     35#include <string>
     36#include <iostream>
     37
     38#include "MultiTypePrimitive.h"
     39
     40// disable annoying warning about multiple assignment operators
    241#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
    342#pragma warning(push)
    443#pragma warning(disable:4522)
    544#endif
    6 class _UtilExport MultiTypeString : public MultiTypePrimitive{    public:        MultiTypeString(MultiType type = MT_null);        inline MultiTypeString(void*          value) : MultiTypePrimitive(value) {}        inline MultiTypeString(int            value) : MultiTypePrimitive(value) {}        inline MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}        inline MultiTypeString(char           value) : MultiTypePrimitive(value) {}        inline MultiTypeString(unsigned char  value) : MultiTypePrimitive(value) {}        inline MultiTypeString(short          value) : MultiTypePrimitive(value) {}        inline MultiTypeString(unsigned short value) : MultiTypePrimitive(value) {}        inline MultiTypeString(long           value) : MultiTypePrimitive(value) {}        inline MultiTypeString(unsigned long  value) : MultiTypePrimitive(value) {}        inline MultiTypeString(float          value) : MultiTypePrimitive(value) {}        inline MultiTypeString(double         value) : MultiTypePrimitive(value) {}        inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}        inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}        inline MultiTypeString(const char*             value) { this->setValue(value); }        inline MultiTypeString(const std::string&      value) { this->setValue(value); }        inline MultiTypeString(const MultiTypeString&    mts)  { this->setValue(mts);   }        inline MultiTypeString(const MultiTypePrimitive& mtp)  { this->setValue(mtp);   }        virtual inline ~MultiTypeString() {}        using MultiTypePrimitive::operator=;        inline MultiTypeString& operator=(const char*             value) { this->setValue(value); return *this; }        inline MultiTypeString& operator=(const std::string&      value) { this->setValue(value); return *this; }        inline MultiTypeString& operator=(const MultiTypeString&    mts) { this->setValue(mts);   return *this; }        inline MultiTypeString& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp);   return *this; }        using MultiTypePrimitive::operator==;        inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }        inline bool operator==(const std::string& value) const { return (this->string_ == value);              }        bool operator==(const MultiTypeString&    mts) const;        bool operator==(const MultiTypePrimitive& mtp) const;        using MultiTypePrimitive::operator!=;        inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }        inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }        bool operator!=(const MultiTypeString&    mts) const;        bool operator!=(const MultiTypePrimitive& mtp) const;        virtual operator void*()          const;        virtual operator int()            const;        virtual operator unsigned int()   const;        virtual operator char()           const;        virtual operator unsigned char()  const;        virtual operator short()          const;        virtual operator unsigned short() const;        virtual operator long()           const;        virtual operator unsigned long()  const;        virtual operator float ()         const;        virtual operator double ()        const;        virtual operator long double()    const;        virtual operator bool()           const;        virtual operator std::string()    const;        virtual operator const char*()    const;        using MultiTypePrimitive::setValue;        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }        void setValue(const MultiTypeString&    mts);        void setValue(const MultiTypePrimitive& mtp);        inline std::string getString()     const { return this->string_;         }        inline const char*  getConstChar() const { return this->string_.c_str(); }        inline std::string& getString()    { return this->string_;         }        inline const char*  getConstChar() { return this->string_.c_str(); }        using MultiTypePrimitive::getValue;        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }        virtual std::string getTypename() const;        virtual std::string toString() const;        virtual bool fromString(const std::string value);        virtual bool assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue = MultiTypeString());    protected:        std::string      string_;};_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     45
     46class _UtilExport MultiTypeString : public MultiTypePrimitive
     47{
     48    public:
     49        MultiTypeString(MultiType type = MT_null);
     50        inline MultiTypeString(void*          value) : MultiTypePrimitive(value) {}
     51        inline MultiTypeString(int            value) : MultiTypePrimitive(value) {}
     52        inline MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
     53        inline MultiTypeString(char           value) : MultiTypePrimitive(value) {}
     54        inline MultiTypeString(unsigned char  value) : MultiTypePrimitive(value) {}
     55        inline MultiTypeString(short          value) : MultiTypePrimitive(value) {}
     56        inline MultiTypeString(unsigned short value) : MultiTypePrimitive(value) {}
     57        inline MultiTypeString(long           value) : MultiTypePrimitive(value) {}
     58        inline MultiTypeString(unsigned long  value) : MultiTypePrimitive(value) {}
     59        inline MultiTypeString(float          value) : MultiTypePrimitive(value) {}
     60        inline MultiTypeString(double         value) : MultiTypePrimitive(value) {}
     61        inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
     62        inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
     63        inline MultiTypeString(const char*             value) { this->setValue(value); }
     64        inline MultiTypeString(const std::string&      value) { this->setValue(value); }
     65        inline MultiTypeString(const MultiTypeString&    mts)  { this->setValue(mts);   }
     66        inline MultiTypeString(const MultiTypePrimitive& mtp)  { this->setValue(mtp);   }
     67        virtual inline ~MultiTypeString() {}
     68
     69        using MultiTypePrimitive::operator=;
     70        inline MultiTypeString& operator=(const char*             value) { this->setValue(value); return *this; }
     71        inline MultiTypeString& operator=(const std::string&      value) { this->setValue(value); return *this; }
     72        inline MultiTypeString& operator=(const MultiTypeString&    mts) { this->setValue(mts);   return *this; }
     73        inline MultiTypeString& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp);   return *this; }
     74
     75        using MultiTypePrimitive::operator==;
     76        inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
     77        inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
     78        bool operator==(const MultiTypeString&    mts) const;
     79        bool operator==(const MultiTypePrimitive& mtp) const;
     80
     81        using MultiTypePrimitive::operator!=;
     82        inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
     83        inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
     84        bool operator!=(const MultiTypeString&    mts) const;
     85        bool operator!=(const MultiTypePrimitive& mtp) const;
     86
     87        virtual operator void*()          const;
     88        virtual operator int()            const;
     89        virtual operator unsigned int()   const;
     90        virtual operator char()           const;
     91        virtual operator unsigned char()  const;
     92        virtual operator short()          const;
     93        virtual operator unsigned short() const;
     94        virtual operator long()           const;
     95        virtual operator unsigned long()  const;
     96        virtual operator float ()         const;
     97        virtual operator double ()        const;
     98        virtual operator long double()    const;
     99        virtual operator bool()           const;
     100        virtual operator std::string()    const;
     101        virtual operator const char*()    const;
     102
     103        using MultiTypePrimitive::setValue;
     104        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
     105        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
     106        void setValue(const MultiTypeString&    mts);
     107        void setValue(const MultiTypePrimitive& mtp);
     108
     109        inline std::string getString()     const { return this->string_;         }
     110        inline const char*  getConstChar() const { return this->string_.c_str(); }
     111
     112        inline std::string& getString()    { return this->string_;         }
     113        inline const char*  getConstChar() { return this->string_.c_str(); }
     114
     115        using MultiTypePrimitive::getValue;
     116        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
     117        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
     118
     119        virtual std::string getTypename() const;
     120
     121        virtual std::string toString() const;
     122        virtual bool fromString(const std::string value);
     123
     124        virtual bool assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue = MultiTypeString());
     125
     126    protected:
     127        std::string      string_;
     128};
     129
     130_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);
     131
     132#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
    7133#pragma warning(pop)
    8 #endif#endif /* _MultiTypeString_H__ */
     134#endif
     135
     136#endif /* _MultiTypeString_H__ */

  • code/branches/network/src/util/OrxonoxPlatform.h

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    2526 *
    2627 */
     28
    2729/**
    2830 @file
    … …  
    3032        copy of the file found in the Ogre source code (OgrePlatform.h).
    3133 */
    32 #ifndef _OrxonoxPlatform_H__#define _OrxonoxPlatform_H__/* Initial platform/compiler-related stuff to set.*/#define ORXONOX_PLATFORM_WIN32 1#define ORXONOX_PLATFORM_LINUX 2#define ORXONOX_PLATFORM_APPLE 3#define ORXONOX_COMPILER_MSVC 1#define ORXONOX_COMPILER_GNUC 2#define ORXONOX_COMPILER_BORL 3#define ORXONOX_ENDIAN_LITTLE 1#define ORXONOX_ENDIAN_BIG 2#define ORXONOX_ARCHITECTURE_32 1#define ORXONOX_ARCHITECTURE_64 2/* Finds the compiler type and version.*/#if defined( _MSC_VER )#  define ORXONOX_COMPILER ORXONOX_COMPILER_MSVC#  define ORXONOX_COMP_VER _MSC_VER#elif defined( __GNUC__ )#  define ORXONOX_COMPILER ORXONOX_COMPILER_GNUC#  define ORXONOX_COMP_VER (((__GNUC__)*100) + \        (__GNUC_MINOR__*10) + \        __GNUC_PATCHLEVEL__)#elif defined( __BORLANDC__ )#  define ORXONOX_COMPILER ORXONOX_COMPILER_BORL#  define ORXONOX_COMP_VER __BCPLUSPLUS__#else#  pragma error "No known compiler. Abort! Abort!"#endif/* See if we can use __forceinline or if we need to use __inline instead */#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC#  if ORXONOX_COMP_VER >= 1200#    define FORCEINLINE __forceinline#  endif#elif defined(__MINGW32__)#  if !defined(FORCEINLINE)#    define FORCEINLINE __inline#  endif#else#  define FORCEINLINE __inline#endif/* Finds the current platform */#if defined( __WIN32__ ) || defined( _WIN32 )#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_WIN32#elif defined( __APPLE_CC__)#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_APPLE#else#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_LINUX#endif    /* Find the arch type */#if defined(__x86_64__) || defined(_M_X64) || defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || defined(__s390x__)#  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_64#else#  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_32#endif// For generating compiler warnings - should work on any compiler// As a side note, if you start your message with 'Warning: ', the MSVC// IDE actually does catch a warning :)// FIXME: Try this on linux box. Doesn't work with msvc//#define ORXONOX_QUOTE_INPLACE(x) # x//#define ORXONOX_QUOTE(x) ORXONOX_QUOTE_INPLACE(x)//#define ORXONOX_WARN( x )  message( __FILE__ "(" QUOTE( __LINE__ ) ") : " x "\n" )//----------------------------------------------------------------------------// Windows Settings#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32// Win32 compilers use _DEBUG for specifying debug builds.#  ifdef _DEBUG#    define ORXONOX_DEBUG_MODE 1#  else#    define ORXONOX_DEBUG_MODE 0#  endif// Disable unicode support on MingW at the moment, poorly supported in stdlibc++// STLPORT fixes this though so allow if found// MinGW C++ Toolkit supports unicode and sets the define __MINGW32_TOOLKIT_UNICODE__ in _mingw.h#  if defined( __MINGW32__ ) && !defined(_STLPORT_VERSION)#    include<_mingw.h>#    if defined(__MINGW32_TOOLBOX_UNICODE__)#      define ORXONOX_UNICODE_SUPPORT 1#    else#      define ORXONOX_UNICODE_SUPPORT 0#    endif#  else#    define ORXONOX_UNICODE_SUPPORT 1#  endif#endif /* Platform Win32 *///----------------------------------------------------------------------------//----------------------------------------------------------------------------// Linux/Apple Settings#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_LINUX || ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE// A quick define to overcome different names for the same function#  define stricmp strcasecmp// Unlike the Win32 compilers, Linux compilers seem to use DEBUG for when// specifying a debug build.// (??? this is wrong, on Linux debug builds aren't marked in any way unless// you mark it yourself any way you like it -- zap ???)#  ifdef DEBUG#    define ORXONOX_DEBUG_MODE 1#  else#    define ORXONOX_DEBUG_MODE 0#  endif/* FIXME: Check what this actually is and whether we need it or not#  if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE#    define ORXONOX_PLATFORM_LIB "OrxonoxPlatform.bundle"#  else// ORXONOX_PLATFORM_LINUX#    define ORXONOX_PLATFORM_LIB "libOrxonoxPlatform.so"#  endif*/// Always enable unicode support for the moment// Perhaps disable in old versions of gcc if necessary#  define ORXONOX_UNICODE_SUPPORT 1#endif /* Patform Linux/Apple *///For apple, we always have a custom config.h file#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE#  include "config.h"#endif//----------------------------------------------------------------------------//----------------------------------------------------------------------------// Endian Settings// check for BIG_ENDIAN config flag, set ORXONOX_ENDIAN correctly#ifdef ORXONOX_CONFIG_BIG_ENDIAN#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_BIG#else#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_LITTLE#endif//-----------------------------------------------------------------------
     34
     35#ifndef _OrxonoxPlatform_H__
     36#define _OrxonoxPlatform_H__
     37
     38/* Initial platform/compiler-related stuff to set.
     39*/
     40#define ORXONOX_PLATFORM_WIN32 1
     41#define ORXONOX_PLATFORM_LINUX 2
     42#define ORXONOX_PLATFORM_APPLE 3
     43
     44#define ORXONOX_COMPILER_MSVC 1
     45#define ORXONOX_COMPILER_GNUC 2
     46#define ORXONOX_COMPILER_BORL 3
     47
     48#define ORXONOX_ENDIAN_LITTLE 1
     49#define ORXONOX_ENDIAN_BIG 2
     50
     51#define ORXONOX_ARCHITECTURE_32 1
     52#define ORXONOX_ARCHITECTURE_64 2
     53
     54/* Finds the compiler type and version.
     55*/
     56#if defined( _MSC_VER )
     57#  define ORXONOX_COMPILER ORXONOX_COMPILER_MSVC
     58#  define ORXONOX_COMP_VER _MSC_VER
     59
     60#elif defined( __GNUC__ )
     61#  define ORXONOX_COMPILER ORXONOX_COMPILER_GNUC
     62#  define ORXONOX_COMP_VER (((__GNUC__)*100) + \
     63        (__GNUC_MINOR__*10) + \
     64        __GNUC_PATCHLEVEL__)
     65
     66#elif defined( __BORLANDC__ )
     67#  define ORXONOX_COMPILER ORXONOX_COMPILER_BORL
     68#  define ORXONOX_COMP_VER __BCPLUSPLUS__
     69
     70#else
     71#  pragma error "No known compiler. Abort! Abort!"
     72
     73#endif
     74
     75/* See if we can use __forceinline or if we need to use __inline instead */
     76#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     77#  if ORXONOX_COMP_VER >= 1200
     78#    define FORCEINLINE __forceinline
     79#  endif
     80#elif defined(__MINGW32__)
     81#  if !defined(FORCEINLINE)
     82#    define FORCEINLINE __inline
     83#  endif
     84#else
     85#  define FORCEINLINE __inline
     86#endif
     87
     88/* Finds the current platform */
     89
     90#if defined( __WIN32__ ) || defined( _WIN32 )
     91#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_WIN32
     92
     93#elif defined( __APPLE_CC__)
     94#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_APPLE
     95
     96#else
     97#  define ORXONOX_PLATFORM ORXONOX_PLATFORM_LINUX
     98#endif
     99
     100    /* Find the arch type */
     101#if defined(__x86_64__) || defined(_M_X64) || defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || defined(__s390x__)
     102#  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_64
     103#else
     104#  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_32
     105#endif
     106
     107// For generating compiler warnings - should work on any compiler
     108// As a side note, if you start your message with 'Warning: ', the MSVC
     109// IDE actually does catch a warning :)
     110// FIXME: Try this on linux box. Doesn't work with msvc
     111//#define ORXONOX_QUOTE_INPLACE(x) # x
     112//#define ORXONOX_QUOTE(x) ORXONOX_QUOTE_INPLACE(x)
     113//#define ORXONOX_WARN( x )  message( __FILE__ "(" QUOTE( __LINE__ ) ") : " x "\n" )
     114
     115//----------------------------------------------------------------------------
     116// Windows Settings
     117#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
     118
     119// Win32 compilers use _DEBUG for specifying debug builds.
     120#  ifdef _DEBUG
     121#    define ORXONOX_DEBUG_MODE 1
     122#  else
     123#    define ORXONOX_DEBUG_MODE 0
     124#  endif
     125
     126// Disable unicode support on MingW at the moment, poorly supported in stdlibc++
     127// STLPORT fixes this though so allow if found
     128// MinGW C++ Toolkit supports unicode and sets the define __MINGW32_TOOLKIT_UNICODE__ in _mingw.h
     129#  if defined( __MINGW32__ ) && !defined(_STLPORT_VERSION)
     130#    include<_mingw.h>
     131#    if defined(__MINGW32_TOOLBOX_UNICODE__)
     132#      define ORXONOX_UNICODE_SUPPORT 1
     133#    else
     134#      define ORXONOX_UNICODE_SUPPORT 0
     135#    endif
     136#  else
     137#    define ORXONOX_UNICODE_SUPPORT 1
     138#  endif
     139
     140#endif /* Platform Win32 */
     141//----------------------------------------------------------------------------
     142
     143//----------------------------------------------------------------------------
     144// Linux/Apple Settings
     145#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_LINUX || ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
     146
     147
     148// A quick define to overcome different names for the same function
     149#  define stricmp strcasecmp
     150
     151// Unlike the Win32 compilers, Linux compilers seem to use DEBUG for when
     152// specifying a debug build.
     153// (??? this is wrong, on Linux debug builds aren't marked in any way unless
     154// you mark it yourself any way you like it -- zap ???)
     155#  ifdef DEBUG
     156#    define ORXONOX_DEBUG_MODE 1
     157#  else
     158#    define ORXONOX_DEBUG_MODE 0
     159#  endif
     160
     161/* FIXME: Check what this actually is and whether we need it or not
     162#  if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
     163#    define ORXONOX_PLATFORM_LIB "OrxonoxPlatform.bundle"
     164#  else
     165// ORXONOX_PLATFORM_LINUX
     166#    define ORXONOX_PLATFORM_LIB "libOrxonoxPlatform.so"
     167#  endif
     168*/
     169
     170// Always enable unicode support for the moment
     171// Perhaps disable in old versions of gcc if necessary
     172#  define ORXONOX_UNICODE_SUPPORT 1
     173
     174#endif /* Patform Linux/Apple */
     175
     176//For apple, we always have a custom config.h file
     177#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
     178#  include "config.h"
     179#endif
     180
     181//----------------------------------------------------------------------------
     182
     183//----------------------------------------------------------------------------
     184// Endian Settings
     185// check for BIG_ENDIAN config flag, set ORXONOX_ENDIAN correctly
     186#ifdef ORXONOX_CONFIG_BIG_ENDIAN
     187#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_BIG
     188#else
     189#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_LITTLE
     190#endif
     191
     192//-----------------------------------------------------------------------
    33193// fixed width integers
    34194//-----------------------------------------------------------------------
    35 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVCtypedef __int8            int8_t;
     195#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     196typedef __int8            int8_t;
    36197typedef __int16           int16_t;
    37198typedef __int32           int32_t;
    … …  
    41202typedef unsigned __int32  uint32_t;
    42203typedef unsigned __int64  uint64_t;
    43 #else# include "inttypes.h"#endifnamespace orxonox {#ifdef ORXONOX_DOUBLE_PRECISIONtypedef double Real;#elsetypedef float Real;#endif}#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC// Turn off warnings generated by long std templates// This warns about truncation to 255 characters in debug/browse info//#   pragma warning (disable : 4786)// Turn off warnings generated by long std templates// This warns about truncation to 255 characters in debug/browse info//#   pragma warning (disable : 4503)// disable: conversion from 'double' to 'float', possible loss of data// disable: conversion from 'ogg_int64_t' to 'long', possible loss of data// This has been dealt with in base_properties of the solution since the// warning primarily occurs in library header files (which are mostly// included before OrxonoxPlatform.h is)//#   pragma warning (disable : 4244)// disable: "conversion from 'size_t' to 'unsigned int', possible loss of data//#   pragma warning (disable : 4267)// disable: "truncation from 'double' to 'float'//#   pragma warning (disable : 4305)// set to level 4: "<type> needs to have dll-interface to be used by clients'// Happens on STL member variables which are not public therefore is ok#   pragma warning (disable : 4251)// disable: 'MultiTypeString' : multiple assignment operators specified// Used in MultiType and works fine so far//#   pragma warning (disable : 4522)// disable: "non dll-interface class used as base for dll-interface class"// Happens when deriving from Singleton because bug in compiler ignores// template export//#   pragma warning (disable : 4275)// disable: "C++ Exception Specification ignored"// This is because MSVC 6 did not implement all the C++ exception// specifications in the ANSI C++ draft.//#   pragma warning( disable : 4290 )// disable: "no suitable definition provided for explicit template// instantiation request" Occurs in VC7 for no justifiable reason on all// #includes of Singleton//#   pragma warning( disable: 4661)// disable: deprecation warnings when using CRT calls in VC8// These show up on all C runtime lib code in VC8, disable since they clutter// the warnings with things we may not be able to do anything about (e.g.// generated code from nvparse etc). I doubt very much that these calls// will ever be actually removed from VC anyway, it would break too much code.//# pragma warning( disable: 4996)// disable: "conditional expression constant", always occurs on// ORXONOX_MUTEX_CONDITIONAL when no threading enabled//#   pragma warning (disable : 201)// Define the english written operators like and, or, xor#include <iso646.h>#endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC */// include visual leak detector to search for memory leaks//#include <vld.h>#endif /* _OrxonoxPlatform_H__ */
     204#else
     205# include "inttypes.h"
     206#endif
     207
     208namespace orxonox {
     209#ifdef ORXONOX_DOUBLE_PRECISION
     210typedef double Real;
     211#else
     212typedef float Real;
     213#endif
     214}
     215
     216
     217#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
     218// Turn off warnings generated by long std templates
     219// This warns about truncation to 255 characters in debug/browse info
     220//#   pragma warning (disable : 4786)
     221
     222// Turn off warnings generated by long std templates
     223// This warns about truncation to 255 characters in debug/browse info
     224//#   pragma warning (disable : 4503)
     225
     226// disable: conversion from 'double' to 'float', possible loss of data
     227// disable: conversion from 'ogg_int64_t' to 'long', possible loss of data
     228// This has been dealt with in base_properties of the solution since the
     229// warning primarily occurs in library header files (which are mostly
     230// included before OrxonoxPlatform.h is)
     231//#   pragma warning (disable : 4244)
     232
     233// disable: "conversion from 'size_t' to 'unsigned int', possible loss of data
     234//#   pragma warning (disable : 4267)
     235
     236// disable: "truncation from 'double' to 'float'
     237//#   pragma warning (disable : 4305)
     238
     239// set to level 4: "<type> needs to have dll-interface to be used by clients'
     240// Happens on STL member variables which are not public therefore is ok
     241#   pragma warning (disable : 4251)
     242
     243// disable: 'MultiTypeString' : multiple assignment operators specified
     244// Used in MultiType and works fine so far
     245//#   pragma warning (disable : 4522)
     246
     247// disable: "non dll-interface class used as base for dll-interface class"
     248// Happens when deriving from Singleton because bug in compiler ignores
     249// template export
     250//#   pragma warning (disable : 4275)
     251
     252// disable: "C++ Exception Specification ignored"
     253// This is because MSVC 6 did not implement all the C++ exception
     254// specifications in the ANSI C++ draft.
     255//#   pragma warning( disable : 4290 )
     256
     257// disable: "no suitable definition provided for explicit template
     258// instantiation request" Occurs in VC7 for no justifiable reason on all
     259// #includes of Singleton
     260//#   pragma warning( disable: 4661)
     261
     262// disable: deprecation warnings when using CRT calls in VC8
     263// These show up on all C runtime lib code in VC8, disable since they clutter
     264// the warnings with things we may not be able to do anything about (e.g.
     265// generated code from nvparse etc). I doubt very much that these calls
     266// will ever be actually removed from VC anyway, it would break too much code.
     267//#     pragma warning( disable: 4996)
     268
     269// disable: "conditional expression constant", always occurs on
     270// ORXONOX_MUTEX_CONDITIONAL when no threading enabled
     271//#   pragma warning (disable : 201)
     272
     273
     274// Define the english written operators like and, or, xor
     275#include <iso646.h>
     276
     277#endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC */
     278
     279// include visual leak detector to search for memory leaks
     280//#include <vld.h>
     281
     282#endif /* _OrxonoxPlatform_H__ */

  • code/branches/network/src/util/Sleep.h

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    2526 *
    2627 */
     28
    2729/**
    2830 @file  Sleep.h
    … …  
    3234#include "UtilPrereqs.h"
    3335
    34 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32#  ifndef WIN32_LEAN_AND_MEAN#    define WIN32_LEAN_AND_MEAN#  endif#  include <windows.h>
     36#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
     37#  ifndef WIN32_LEAN_AND_MEAN
     38#    define WIN32_LEAN_AND_MEAN
     39#  endif
     40#  include <windows.h>
    3541inline void usleep(DWORD dwMicroseconds)
    3642{

  • code/branches/network/src/util/SubString.cc

    r1494 r1495  
    1 /* *   ORXONOX - the hottest 3D action shooter ever to exist *                    > www.orxonox.net < * * *   License notice: * *   This program is free software; you can redistribute it and/or *   modify it under the terms of the GNU General Public License *   as published by the Free Software Foundation; either version 2 *   of the License, or (at your option) any later version. * *   This program 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 General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program; if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. * *   Author: *      Christian Meyer *   Co-authors: *      Benjamin Grauer *////  splitLine//  STL string tokenizer////  Created by Clemens Wacha.//  Version 1.0//  Copyright (c) 2005 Clemens Wacha. All rights reserved.// */
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Christian Meyer
     24 *   Co-authors:
     25 *      Benjamin Grauer
     26 *
     27//
     28//  splitLine
     29//  STL string tokenizer
     30//
     31//  Created by Clemens Wacha.
     32//  Version 1.0
     33//  Copyright (c) 2005 Clemens Wacha. All rights reserved.
     34//
     35 */
     36
    237#include "SubString.h"
    338
    … …  
    3267SubString::SubString(const std::string& string,
    3368                     const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
    34                      char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,                     char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
     69                     char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
     70                     char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
    3571{
    3672  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
    … …  
    4480SubString::SubString(const SubString& subString, unsigned int subSetBegin)
    4581{
    46   for (unsigned int i = subSetBegin; i < subString.size(); i++)  {
    47     this->strings.push_back(subString[i]);    this->bInSafemode.push_back(subString.isInSafemode(i));  }
     82  for (unsigned int i = subSetBegin; i < subString.size(); i++)
     83  {
     84    this->strings.push_back(subString[i]);
     85    this->bInSafemode.push_back(subString.isInSafemode(i));
     86  }
    4887}
    4988
    … …  
    5796SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
    5897{
    59   for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)  {
    60     this->strings.push_back(subString[i]);    this->bInSafemode.push_back(subString.isInSafemode(i));  }
     98  for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
     99  {
     100    this->strings.push_back(subString[i]);
     101    this->bInSafemode.push_back(subString.isInSafemode(i));
     102  }
    61103}
    62104
    … …  
    68110SubString::SubString(unsigned int argc, const char** argv)
    69111{
    70   for(unsigned int i = 0; i < argc; ++i)  {
    71     this->strings.push_back(std::string(argv[i]));    this->bInSafemode.push_back(false);  }
     112  for(unsigned int i = 0; i < argc; ++i)
     113  {
     114    this->strings.push_back(std::string(argv[i]));
     115    this->bInSafemode.push_back(false);
     116  }
    72117}
    73118
    … …  
    94139SubString& SubString::operator=(const SubString& subString)
    95140{
    96   this->strings = subString.strings;  this->bInSafemode = subString.bInSafemode;
     141  this->strings = subString.strings;
     142  this->bInSafemode = subString.bInSafemode;
    97143  return *this;
    98144}
    … …  
    155201SubString& SubString::operator+=(const SubString& subString)
    156202{
    157   for (unsigned int i = 0; i < subString.size(); i++)  {
    158     this->strings.push_back(subString[i]);    this->bInSafemode.push_back(subString.isInSafemode(i));  }
     203  for (unsigned int i = 0; i < subString.size(); i++)
     204  {
     205    this->strings.push_back(subString[i]);
     206    this->bInSafemode.push_back(subString.isInSafemode(i));
     207  }
    159208  return *this;
    160209}
    … …  
    168217unsigned int SubString::split(const std::string& string, char splitter)
    169218{
    170   this->strings.clear();  this->bInSafemode.clear();
     219  this->strings.clear();
     220  this->bInSafemode.clear();
    171221  char split[2];
    172222  split[0] = splitter;
    … …  
    189239unsigned int SubString::split(const std::string& string,
    190240                              const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
    191                               char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,                              char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
    192 {
    193   this->strings.clear();  this->bInSafemode.clear();
     241                              char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
     242                              char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
     243{
     244  this->strings.clear();
     245  this->bInSafemode.clear();
    194246  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
    195247  return this->strings.size();
    … …  
    257309 * @param emptyEntries: if empty Strings are added to the List of Strings.
    258310 * @param escape_char: Escape carater (escapes splitters)
    259  * @param safemode_char: the beginning of the safemode is marked with this * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token * @param openparenthesis_char the beginning of a safemode is marked with this * @param closeparenthesis_char the ending of a safemode is marked with this * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
     311 * @param safemode_char: the beginning of the safemode is marked with this
     312 * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
     313 * @param openparenthesis_char the beginning of a safemode is marked with this
     314 * @param closeparenthesis_char the ending of a safemode is marked with this
     315 * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
    260316 * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
    261317 * @param start_state: the Initial state on how to parse the String.
    … …  
    267323 */
    268324SubString::SPLIT_LINE_STATE
    269 SubString::splitLine(std::vector<std::string>& ret,                     std::vector<bool>& bInSafemode,
     325SubString::splitLine(std::vector<std::string>& ret,
     326                     std::vector<bool>& bInSafemode,
    270327                     const std::string& line,
    271328                     const std::string& delimiters,
    272329                     const std::string& delimiterNeighbours,
    273330                     bool emptyEntries,
    274                      char escape_char,                     bool removeExcapeChar,
    275                      char safemode_char,                     bool removeSafemodeChar,                     char openparenthesis_char,                     char closeparenthesis_char,                     bool removeParenthesisChars,
     331                     char escape_char,
     332                     bool removeExcapeChar,
     333                     char safemode_char,
     334                     bool removeSafemodeChar,
     335                     char openparenthesis_char,
     336                     char closeparenthesis_char,
     337                     bool removeParenthesisChars,
    276338                     char comment_char,
    277339                     SPLIT_LINE_STATE start_state)
    … …  
    281343  unsigned int fallBackNeighbours = 0;
    282344
    283   std::string token;  bool inSafemode = false;
    284 
    285   if(start_state != SL_NORMAL && ret.size() > 0)  {    token = ret[ret.size()-1];
    286     ret.pop_back();  }  if(start_state != SL_NORMAL && bInSafemode.size() > 0)  {    inSafemode = bInSafemode[bInSafemode.size()-1];    bInSafemode.pop_back();  }
     345  std::string token;
     346  bool inSafemode = false;
     347
     348  if(start_state != SL_NORMAL && ret.size() > 0)
     349  {
     350    token = ret[ret.size()-1];
     351    ret.pop_back();
     352  }
     353  if(start_state != SL_NORMAL && bInSafemode.size() > 0)
     354  {
     355    inSafemode = bInSafemode[bInSafemode.size()-1];
     356    bInSafemode.pop_back();
     357  }
     358
    287359  while(i < line.size())
    288360  {
    … …  
    292364        if(line[i] == escape_char)
    293365        {
    294           state = SL_ESCAPE;          if (!removeExcapeChar)            token += line[i];
     366          state = SL_ESCAPE;
     367          if (!removeExcapeChar)
     368            token += line[i];
    295369        }
    296370        else if(line[i] == safemode_char)
    297371        {
    298           state = SL_SAFEMODE;          inSafemode = true;          if (!removeSafemodeChar)            token += line[i];
    299         }        else if(line[i] == openparenthesis_char)        {          state = SL_PARENTHESES;          inSafemode = true;          if (!removeParenthesisChars)            token += line[i];        }
     372          state = SL_SAFEMODE;
     373          inSafemode = true;
     374          if (!removeSafemodeChar)
     375            token += line[i];
     376        }
     377        else if(line[i] == openparenthesis_char)
     378        {
     379          state = SL_PARENTHESES;
     380          inSafemode = true;
     381          if (!removeParenthesisChars)
     382            token += line[i];
     383        }
    300384        else if(line[i] == comment_char)
    301385        {
    … …  
    305389          if(emptyEntries || token.size() > 0)
    306390          {
    307             ret.push_back(token);            token.clear();            bInSafemode.push_back(inSafemode);            inSafemode = false;          }
     391            ret.push_back(token);
     392            token.clear();
     393            bInSafemode.push_back(inSafemode);
     394            inSafemode = false;
     395          }
    308396          token += line[i];       // EAT
    309397          state = SL_COMMENT;
    … …  
    319407            ret.push_back(token);
    320408            token.clear();
    321             bInSafemode.push_back(inSafemode);            inSafemode = false;          }
     409            bInSafemode.push_back(inSafemode);
     410            inSafemode = false;
     411          }
    322412          state = SL_NORMAL;
    323413        }
    … …  
    339429        }
    340430        break;
    341       case SL_ESCAPE:        if (!removeSafemodeChar)          token += line[i];        else        {
     431      case SL_ESCAPE:
     432        if (!removeSafemodeChar)
     433          token += line[i];
     434        else
     435        {
    342436          if(line[i] == 'n') token += '\n';
    343437          else if(line[i] == 't') token += '\t';
    … …  
    348442          else if(line[i] == 'a') token += '\a';
    349443          else if(line[i] == '?') token += '\?';
    350           else token += line[i];  // EAT        }
     444          else token += line[i];  // EAT
     445        }
    351446        state = SL_NORMAL;
    352447        break;
    … …  
    355450        {
    356451          state = SL_NORMAL;
    357           if (!removeSafemodeChar)            token += line[i];        }
     452          if (!removeSafemodeChar)
     453            token += line[i];
     454        }
    358455        else if(line[i] == escape_char)
    359456        {
    … …  
    364461          token += line[i];       // EAT
    365462        }
    366         break;      case SL_SAFEESCAPE:
     463        break;
     464
     465      case SL_SAFEESCAPE:
    367466        if(line[i] == 'n') token += '\n';
    368467        else if(line[i] == 't') token += '\t';
    … …  
    376475        state = SL_SAFEMODE;
    377476        break;
    378       case SL_PARENTHESES:        if(line[i] == closeparenthesis_char)        {          state = SL_NORMAL;          if (!removeParenthesisChars)            token += line[i];        }        else if(line[i] == escape_char)        {          state = SL_PARENTHESESESCAPE;        }        else        {          token += line[i];       // EAT        }        break;      case SL_PARENTHESESESCAPE:        if(line[i] == 'n') token += '\n';        else if(line[i] == 't') token += '\t';        else if(line[i] == 'v') token += '\v';        else if(line[i] == 'b') token += '\b';        else if(line[i] == 'r') token += '\r';        else if(line[i] == 'f') token += '\f';        else if(line[i] == 'a') token += '\a';        else if(line[i] == '?') token += '\?';        else token += line[i];  // EAT        state = SL_PARENTHESES;        break;
     477
     478      case SL_PARENTHESES:
     479        if(line[i] == closeparenthesis_char)
     480        {
     481          state = SL_NORMAL;
     482          if (!removeParenthesisChars)
     483            token += line[i];
     484        }
     485        else if(line[i] == escape_char)
     486        {
     487          state = SL_PARENTHESESESCAPE;
     488        }
     489        else
     490        {
     491          token += line[i];       // EAT
     492        }
     493        break;
     494
     495      case SL_PARENTHESESESCAPE:
     496        if(line[i] == 'n') token += '\n';
     497        else if(line[i] == 't') token += '\t';
     498        else if(line[i] == 'v') token += '\v';
     499        else if(line[i] == 'b') token += '\b';
     500        else if(line[i] == 'r') token += '\r';
     501        else if(line[i] == 'f') token += '\f';
     502        else if(line[i] == 'a') token += '\a';
     503        else if(line[i] == '?') token += '\?';
     504        else token += line[i];  // EAT
     505        state = SL_PARENTHESES;
     506        break;
     507
    379508      case SL_COMMENT:
    380509        if(line[i] == '\n')
    … …  
    385514            ret.push_back(token);
    386515            token.clear();
    387             bInSafemode.push_back(inSafemode);            inSafemode = false;          }
     516            bInSafemode.push_back(inSafemode);
     517            inSafemode = false;
     518          }
    388519          state = SL_NORMAL;
    389520        }
    … …  
    408539    ret.push_back(token);
    409540    token.clear();
    410     bInSafemode.push_back(inSafemode);    inSafemode = false;  }
     541    bInSafemode.push_back(inSafemode);
     542    inSafemode = false;
     543  }
    411544  return(state);
    412545}

  • code/branches/network/src/util/SubString.h

    r1494 r1495  
    1 /* *   ORXONOX - the hottest 3D action shooter ever to exist *                    > www.orxonox.net < * * *   License notice: * *   This program is free software; you can redistribute it and/or *   modify it under the terms of the GNU General Public License *   as published by the Free Software Foundation; either version 2 *   of the License, or (at your option) any later version. * *   This program 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 General Public License for more details. * *   You should have received a copy of the GNU General Public License *   along with this program; if not, write to the Free Software *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA. * *   Author: *      Christian Meyer *   Co-authors: *      Benjamin Grauer *      Fabian 'x3n' Landau *//  splitLine//  STL string tokenizer////  Created by Clemens Wacha.//  Version 1.0//  Copyright (c) 2005 Clemens Wacha. All rights reserved. * Extended by Fabian 'x3n' Landau with the SL_PARENTHESES mode. */ /*!
     1/*
     2 *   ORXONOX - the hottest 3D action shooter ever to exist
     3 *                    > www.orxonox.net <
     4 *
     5 *
     6 *   License notice:
     7 *
     8 *   This program is free software; you can redistribute it and/or
     9 *   modify it under the terms of the GNU General Public License
     10 *   as published by the Free Software Foundation; either version 2
     11 *   of the License, or (at your option) any later version.
     12 *
     13 *   This program is distributed in the hope that it will be useful,
     14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 *   GNU General Public License for more details.
     17 *
     18 *   You should have received a copy of the GNU General Public License
     19 *   along with this program; if not, write to the Free Software
     20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     21 *
     22 *   Author:
     23 *      Christian Meyer
     24 *   Co-authors:
     25 *      Benjamin Grauer
     26 *      Fabian 'x3n' Landau
     27 *
     28
     29//  splitLine
     30//  STL string tokenizer
     31//
     32//  Created by Clemens Wacha.
     33//  Version 1.0
     34//  Copyright (c) 2005 Clemens Wacha. All rights reserved.
     35
     36 * Extended by Fabian 'x3n' Landau with the SL_PARENTHESES mode.
     37 */
     38
     39 /*!
    240 * @file substring.h
    341 * @brief a small class to get the parts of a string separated by commas
    … …  
    2260
    2361#include "UtilPrereqs.h"
     62
    2463#include <vector>
    2564#include <string>
    … …  
    3978    SL_SAFEMODE,          //!< In safe mode (between "" mostly).
    4079    SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
    41     SL_COMMENT,           //!< In Comment mode.    SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')    SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
     80    SL_COMMENT,           //!< In Comment mode.
     81    SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')
     82    SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
    4283  } SPLIT_LINE_STATE;
    4384
    … …  
    4889  SubString(const std::string& string,
    4990            const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
    50             char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,            char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
     91            char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
     92            char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
    5193  SubString(unsigned int argc, const char** argv);
    5294  /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
    … …  
    71113  unsigned int split(const std::string& string,
    72114                     const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
    73                      char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,                     char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
     115                     char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
     116                     char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
    74117  std::string join(const std::string& delimiter = " ") const;
    75118  ////////////////////////////////////////
    … …  
    87130  inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
    88131  /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
    89   inline const std::string& getString(unsigned int i) const { return (*this)[i]; };  /** @brief Returns true if the token is in safemode. @param i the i'th token */  inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
     132  inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
     133  /** @brief Returns true if the token is in safemode. @param i the i'th token */
     134  inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
    90135  /** @brief Returns the front of the StringList. */
    91136  inline const std::string& front() const { return this->strings.front(); };
    … …  
    96141
    97142  // the almighty algorithm.
    98   static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,                                    std::vector<bool>& bInSafemode,
     143  static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
     144                                    std::vector<bool>& bInSafemode,
    99145                                    const std::string& line,
    100146                                    const std::string& delimiters = SubString::WhiteSpaces,
    101147                                    const std::string& delimiterNeighbours = "",
    102148                                    bool emptyEntries = false,
    103                                     char escape_char = '\\',                                    bool removeExcapeChar = true,
     149                                    char escape_char = '\\',
     150                                    bool removeExcapeChar = true,
    104151                                    char safemode_char = '"',
    105                                     bool removeSafemodeChar = true,                                    char openparenthesis_char = '(',                                    char closeparenthesis_char = ')',                                    bool removeParenthesisChars = true,                                    char comment_char = '\0',
     152                                    bool removeSafemodeChar = true,
     153                                    char openparenthesis_char = '(',
     154                                    char closeparenthesis_char = ')',
     155                                    bool removeParenthesisChars = true,
     156                                    char comment_char = '\0',
    106157                                    SPLIT_LINE_STATE start_state = SL_NORMAL);
    107158  // debugging.
    … …  
    114165
    115166private:
    116   std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings  std::vector<bool>         bInSafemode;
     167  std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
     168  std::vector<bool>         bInSafemode;
    117169};
    118170

  • code/branches/network/src/util/UtilPrereqs.h

    r1494 r1495  
    11/*
    22 *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *                    > www.orxonox.net < *
     3 *                    > www.orxonox.net <
     4 *
    45 *
    56 *   License notice:
    … …  
    3031  @brief Contains all the necessary forward declarations for all classes and structs.
    3132*/
     33
    3234#ifndef _UtilPrereqs_H__
    3335#define _UtilPrereqs_H__
    … …  
    5860// Forward declarations
    5961//-----------------------------------------------------------------------
    60 class ArgReader;class Convert;class MultiTypePrimitive;class MultiTypeString;class MultiTypeMath;template <class T>class String2Number;class SubString;
     62class ArgReader;
     63class Convert;
     64class MultiTypePrimitive;
     65class MultiTypeString;
     66class MultiTypeMath;
     67template <class T>
     68class String2Number;
     69class SubString;
    6170
    6271#endif /* _UtilPrereqs_H__ */
Note: See TracChangeset for help on using the changeset viewer.