Libs/Variables.cpp

   1 /*
   2 Cafu Engine, http://www.cafu.de/
   3 Copyright (c) Carsten Fuchs and other contributors.
   4 This project is licensed under the terms of the MIT license.
   5 */
   6
   7 #include "Variables.hpp"
   8 #include "Network/State.hpp"
   9
  10
  11 /****************/
  12 /*** VarBaseT ***/
  13 /****************/
  14
  15 bool cf::TypeSys::VarBaseT::HasFlag(const char* Flag) const
  16 {
  17     if (!m_Flags) return false;
  18
  19     for (unsigned int i = 0; m_Flags[i]; i++)
  20         if (strcmp(Flag, m_Flags[i]) == 0)
  21             return true;
  22
  23     return false;
  24 }
  25
  26
  27 const char* cf::TypeSys::VarBaseT::GetFlag(const char* Flag, unsigned int Nr, const char* Default) const
  28 {
  29     if (!m_Flags) return Default;
  30
  31     unsigned int i;
  32
  33     for (i = 0; m_Flags[i]; i++)
  34         if (strcmp(Flag, m_Flags[i]) == 0)
  35             break;
  36
  37     for (unsigned int j = i; m_Flags[j]; j++)
  38         if (j == i + Nr)
  39             return m_Flags[j];
  40
  41     return Default;
  42 }
  43
  44
  45 /***************/
  46 /*** VarT<T> ***/
  47 /***************/
  48
  49 template<class T>
  50 void cf::TypeSys::VarT<T>::Serialize(cf::Network::OutStreamT& Stream) const
  51 {
  52     Stream << Get();
  53 }
  54
  55
  56 // With g++, we cannot write cf::TypeSys::VarT<Vector3fT>::Serialize(...),
  57 // see search results for "g++ error specialization in different namespace" for details.
  58 namespace cf
  59 {
  60     namespace TypeSys
  61     {
  62         template<>  // Must specialize, because an OutStreamT cannot take a Vector2fT directly.
  63         void VarT<Vector2fT>::Serialize(cf::Network::OutStreamT& Stream) const
  64         {
  65             Stream << Get().x;
  66             Stream << Get().y;
  67         }
  68
  69         template<>  // Must specialize, because an OutStreamT cannot take a Vector3fT directly.
  70         void VarT<Vector3fT>::Serialize(cf::Network::OutStreamT& Stream) const
  71         {
  72             Stream << Get().x;
  73             Stream << Get().y;
  74             Stream << Get().z;
  75         }
  76
  77         template<>  // Must specialize, because an OutStreamT cannot take a Vector3dT directly.
  78         void VarT<Vector3dT>::Serialize(cf::Network::OutStreamT& Stream) const
  79         {
  80             Stream << Get().x;
  81             Stream << Get().y;
  82             Stream << Get().z;
  83         }
  84
  85         template<>  // Must specialize, because an OutStreamT cannot take a BoundingBox3dT directly.
  86         void VarT<BoundingBox3dT>::Serialize(cf::Network::OutStreamT& Stream) const
  87         {
  88             Stream << Get().Min.x;
  89             Stream << Get().Min.y;
  90             Stream << Get().Min.z;
  91
  92             Stream << Get().Max.x;
  93             Stream << Get().Max.y;
  94             Stream << Get().Max.z;
  95         }
  96     }
  97 }
  98
  99
 100 template<class T>
 101 void cf::TypeSys::VarT<T>::Deserialize(cf::Network::InStreamT& Stream)
 102 {
 103     T v;
 104
 105     Stream >> v;
 106
 107     // Derived classes may have overridden Set() to add "side-effects", such as updating graphical resources.
 108     // Therefore, we cannot write `m_Value = v;` in place of `Set(v);` here.
 109     Set(v);
 110 }
 111
 112
 113 // With g++, we cannot write cf::TypeSys::VarT<Vector3fT>::Deserialize(...),
 114 // see search results for "g++ error specialization in different namespace" for details.
 115 namespace cf
 116 {
 117     namespace TypeSys
 118     {
 119         template<>  // Must specialize, because an InStreamT cannot take a Vector2fT directly.
 120         void VarT<Vector2fT>::Deserialize(cf::Network::InStreamT& Stream)
 121         {
 122             Vector2fT v;
 123
 124             Stream >> v.x;
 125             Stream >> v.y;
 126
 127             // Derived classes may have overridden Set() to add "side-effects", such as updating graphical resources.
 128             // Therefore, we cannot write `m_Value = v;` in place of `Set(v);` here.
 129             Set(v);
 130         }
 131
 132         template<>  // Must specialize, because an InStreamT cannot take a Vector3fT directly.
 133         void VarT<Vector3fT>::Deserialize(cf::Network::InStreamT& Stream)
 134         {
 135             Vector3fT v;
 136
 137             Stream >> v.x;
 138             Stream >> v.y;
 139             Stream >> v.z;
 140
 141             // Derived classes may have overridden Set() to add "side-effects", such as updating graphical resources.
 142             // Therefore, we cannot write `m_Value = v;` in place of `Set(v);` here.
 143             Set(v);
 144         }
 145
 146         template<>  // Must specialize, because an InStreamT cannot take a Vector3dT directly.
 147         void VarT<Vector3dT>::Deserialize(cf::Network::InStreamT& Stream)
 148         {
 149             Vector3dT v;
 150
 151             Stream >> v.x;
 152             Stream >> v.y;
 153             Stream >> v.z;
 154
 155             // Derived classes may have overridden Set() to add "side-effects", such as updating graphical resources.
 156             // Therefore, we cannot write `m_Value = v;` in place of `Set(v);` here.
 157             Set(v);
 158         }
 159
 160         template<>  // Must specialize, because an InStreamT cannot take a BoundingBox3dT directly.
 161         void VarT<BoundingBox3dT>::Deserialize(cf::Network::InStreamT& Stream)
 162         {
 163             BoundingBox3dT BB;
 164
 165             Stream >> BB.Min.x;
 166             Stream >> BB.Min.y;
 167             Stream >> BB.Min.z;
 168
 169             Stream >> BB.Max.x;
 170             Stream >> BB.Max.y;
 171             Stream >> BB.Max.z;
 172
 173             // Derived classes may have overridden Set() to add "side-effects", such as updating graphical resources.
 174             // Therefore, we cannot write `m_Value = BB;` in place of `Set(BB);` here.
 175             Set(BB);
 176         }
 177     }
 178 }
 179
 180
 181 template<class T>
 182 void cf::TypeSys::VarT<T>::accept(VisitorT& Visitor)
 183 {
 184     Visitor.visit(*this);
 185 }
 186
 187
 188 template<class T>
 189 void cf::TypeSys::VarT<T>::accept(VisitorConstT& Visitor) const
 190 {
 191     Visitor.visit(*this);
 192 }
 193
 194
 195 /********************/
 196 /*** VarArrayT<T> ***/
 197 /********************/
 198
 199 template<class T>
 200 cf::TypeSys::VarArrayT<T>::VarArrayT(const char* Name, unsigned int InitSize, const T& InitValue, const char* Flags[])
 201     : VarBaseT(Name, Flags)
 202 {
 203     m_Array.PushBackEmptyExact(InitSize);
 204
 205     for (unsigned int i = 0; i < InitSize; i++)
 206         m_Array[i] = InitValue;
 207 }
 208
 209
 210 template<class T>
 211 void cf::TypeSys::VarArrayT<T>::Serialize(cf::Network::OutStreamT& Stream) const
 212 {
 213     Stream << m_Array;
 214 }
 215
 216
 217 template<class T>
 218 void cf::TypeSys::VarArrayT<T>::Deserialize(cf::Network::InStreamT& Stream)
 219 {
 220     // Contrary to `VarT::Deserialize()`, which calls `VarT::Set()` in order to account for
 221     // side-effects resulting from derived classes that have provided an override for `VarT::Set()`,
 222     // any such side-effects are not supported and not accounted for here.
 223     Stream >> m_Array;
 224 }
 225
 226
 227 template<class T>
 228 void cf::TypeSys::VarArrayT<T>::accept(VisitorT& Visitor)
 229 {
 230     Visitor.visit(*this);
 231 }
 232
 233
 234 template<class T>
 235 void cf::TypeSys::VarArrayT<T>::accept(VisitorConstT& Visitor) const
 236 {
 237     Visitor.visit(*this);
 238 }
 239
 240
 241 /***************/
 242 /*** VarManT ***/
 243 /***************/
 244
 245 void cf::TypeSys::VarManT::Add(VarBaseT* Var)
 246 {
 247     m_VarsArray.PushBack(Var);
 248     m_VarsMap[Var->GetName()] = Var;
 249 }
 250
 251
 252 void cf::TypeSys::VarManT::AddAlias(const char* Alias, VarBaseT* Var)
 253 {
 254     m_VarsMap[Alias] = Var;
 255 }
 256
 257
 258 /*******************************/
 259 /*** Template Instantiations ***/
 260 /*******************************/
 261
 262 template class cf::TypeSys::VarT<float>;
 263 template class cf::TypeSys::VarT<double>;
 264 template class cf::TypeSys::VarT<int>;
 265 template class cf::TypeSys::VarT<unsigned int>;
 266 template class cf::TypeSys::VarT<uint16_t>;
 267 template class cf::TypeSys::VarT<uint8_t>;
 268 template class cf::TypeSys::VarT<bool>;
 269 template class cf::TypeSys::VarT<std::string>;
 270 template class cf::TypeSys::VarT<Vector2fT>;
 271 template class cf::TypeSys::VarT<Vector3fT>;
 272 template class cf::TypeSys::VarT<Vector3dT>;
 273 template class cf::TypeSys::VarT<BoundingBox3dT>;
 274 template class cf::TypeSys::VarArrayT<uint32_t>;
 275 template class cf::TypeSys::VarArrayT<uint16_t>;
 276 template class cf::TypeSys::VarArrayT<uint8_t>;
 277 template class cf::TypeSys::VarArrayT<std::string>;