Variant.h
Go to the documentation of this file.
1 /*
2 * This file is part of ArmarX.
3 *
4 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5 *
6 * ArmarX is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * ArmarX is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 * @package ArmarXCore::core
19 * @author Kai Welke (welke@kit.edu)
20 * @date 2011
21 * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22 * GNU General Public License
23 */
24 
25 #pragma once
26 
27 #include <map>
28 #include <string>
29 #include <type_traits>
30 
31 #include <IceUtil/Handle.h>
32 
33 #include <ArmarXCore/interface/observers/VariantBase.h>
34 #include <ArmarXCore/interface/observers/VariantContainers.h>
35 #include <ArmarXCore/observers/exceptions/user/NotInitializedException.h>
36 #include <ArmarXCore/util/CPPUtility/GetTypeString.h>
37 
38 
39 namespace armarx
40 {
41  class Variant;
42  using VariantPtr = IceInternal::Handle<Variant>;
43 
44  using VariantTypeId = Ice::Int;
45 
46  template <typename T>
47  inline constexpr bool always_false = false;
48 
224  class Variant : virtual public VariantBase
225  {
226  public:
227  Variant();
228  Variant(const Variant& source);
229 
237  template <class T>
238  Variant(const T& var,
239  typename std::enable_if_t<!(std::is_base_of_v<VariantDataClass, T> ||
240  std::is_pointer_v<T>)>* t = nullptr)
241  {
242  invalidate();
243  set<T>(var);
244  }
245 
251  Variant(char const var[])
252  {
253  invalidate();
254  setString(var);
255  }
256 
264  template <class T>
265  Variant(const T& var,
266  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>>* t = nullptr)
267  {
268  invalidate();
269  setClass(var);
270  }
271 
279  template <class T>
280  Variant(const IceInternal::Handle<T>& var,
281  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>>* t = nullptr)
282  {
283  invalidate();
284  setClass(var);
285  }
286 
294  template <class T>
295  Variant(const T* var,
296  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>>* t = nullptr)
297  {
298  invalidate();
299  setClass(*var);
300  }
301 
302 
308  bool validate(const Ice::Current& c = Ice::emptyCurrent) const override;
309 
313  virtual VariantPtr clone() const;
314 
315 
316  // Setters
317 
325  void setType(VariantTypeId typeId, const Ice::Current& c = Ice::emptyCurrent) override;
326 
334  void setInt(int n, const Ice::Current& c = Ice::emptyCurrent) override;
335 
343  void setLong(long n, const Ice::Current& c = Ice::emptyCurrent) override;
344 
352  void setFloat(float f, const Ice::Current& c = Ice::emptyCurrent) override;
353 
361  void setDouble(double d, const Ice::Current& c = Ice::emptyCurrent) override;
362 
370  void setString(const std::string& s, const Ice::Current& c = Ice::emptyCurrent) override;
371 
379  void setBool(bool b, const Ice::Current& c = Ice::emptyCurrent) override;
380 
388  void setClass(const VariantDataClassPtr& variantDataClass);
389 
397  void setClass(const VariantDataClass& variantDataClass);
398 
399 
400  // Getters
401 
402 
411  int getInt(const Ice::Current& c = Ice::emptyCurrent) const override;
412 
421  long getLong(const Ice::Current& c = Ice::emptyCurrent) const override;
422 
431  float getFloat(const Ice::Current& c = Ice::emptyCurrent) const override;
432 
441  double getDouble(const Ice::Current& c = Ice::emptyCurrent) const override;
442 
451  std::string getString(const Ice::Current& c = Ice::emptyCurrent) const override;
452 
461  bool getBool(const Ice::Current& c = Ice::emptyCurrent) const override;
462 
470  template <class TVariantDataClass>
471  typename IceInternal::Handle<TVariantDataClass>
472  getClass() const
473  {
474  if (!getInitialized())
475  {
476  throw exceptions::user::NotInitializedException();
477  }
478 
479  IceInternal::Handle<TVariantDataClass> ptr;
480  ptr = IceInternal::Handle<TVariantDataClass>::dynamicCast(this->data);
481 
482  if (!ptr)
483  {
484  throw InvalidTypeException(
485  "Variant::getClass failed: actual type of value: " + data->ice_id() +
486  " stored type id: " + typeToString(getType()) +
487  ", desired type: " + GetType<TVariantDataClass>());
488  }
489 
490  return ptr;
491  }
492 
493 
494  // Helper setter method using templates
495 
505  template <typename T>
506  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>>
507  set(const VariantDataClassPtr& variantDataClass)
508  {
509  setClass(variantDataClass);
510  }
511 
522  template <typename T>
523  typename std::enable_if_t<!std::is_base_of_v<VariantDataClass, T>>
524  set(const T& value)
525  {
526  static_assert(std::is_base_of_v<VariantData, typename T::element_type>,
527  "Only basic types or from VariantDataClass derived classes can be "
528  "template parameters");
529  static int invType = hashTypeName(InvalidVariantData::ice_staticId());
530 
531  if (getType() == invType)
532  {
533  setType(hashTypeName(value->ice_id()));
534  }
535  else if (getType() != hashTypeName(value->ice_id()))
536  {
537  throw InvalidTypeException();
538  }
539 
540  data = T::dynamicCast(value->ice_clone());
541  }
542 
543  // Helper getter method using templates
554  template <typename T>
555  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, T>, IceInternal::Handle<T>>
556  get() const
557  {
558  return getClass<T>();
559  }
560 
561  template <typename T>
562  typename std::enable_if_t<std::is_base_of_v<VariantDataClass, typename T::element_type>, T>
563  get() const
564  {
565  return getClass<typename T::element_type>();
566  }
567 
577  template <typename T>
578  typename std::enable_if_t<(std::is_standard_layout_v<T> && std::is_trivial_v<T>) ||
579  std::is_same_v<std::string, T>,
580  T>
581  get() const
582  {
583  static_assert(always_false<T>,
584  "This function must not be called directly, it is only for primitive "
585  "types which have specializations");
586  }
587 
588  // Properties
589 
595  VariantTypeId getType(const Ice::Current& c = Ice::emptyCurrent) const override;
596 
602  std::string getTypeName(const Ice::Current& c = Ice::emptyCurrent) const override;
603 
607  bool getInitialized(const Ice::Current& c = Ice::emptyCurrent) const override;
608 
609 
610  // Operators
611 
612  Variant&
613  operator=(int n)
614  {
615  setInt(n);
616  return *this;
617  }
618  Variant&
619  operator=(long n)
620  {
621  setLong(n);
622  return *this;
623  }
624  Variant&
625  operator=(float f)
626  {
627  setFloat(f);
628  return *this;
629  }
630  Variant&
631  operator=(double d)
632  {
633  setDouble(d);
634  return *this;
635  }
636  Variant&
637  operator=(const std::string& s)
638  {
639  setString(s);
640  return *this;
641  }
642  Variant&
643  operator=(bool b)
644  {
645  setBool(b);
646  return *this;
647  }
648  Variant& operator=(const VariantDataClass& prototype);
649  Variant& operator=(const VariantDataClassPtr& prototype);
650  Variant& operator=(const Variant& prototype);
651 
652 
653  // Streaming operator
654 
655  friend std::ostream&
656  operator<<(std::ostream& stream, const Variant& rhs)
657  {
658  rhs.output(stream);
659  return stream;
660  }
661 
662  friend std::ostream&
663  operator<<(std::ostream& stream, const VariantPtr& rhs)
664  {
665  if (rhs)
666  {
667  rhs->output(stream);
668  }
669  else
670  {
671  stream << "Null VariantPtr";
672  }
673 
674  return stream;
675  }
676 
677 
678  // Static tools
679 
685  static std::string typeToString(VariantTypeId typeId);
686 
690  static const std::map<VariantTypeId, std::string>& getTypes();
691 
697  static VariantTypeId addTypeName(const std::string& typeName);
698 
702  template <typename Type>
703  static std::string
704  GetType()
705  {
706  std::string typeName = GetTypeString<Type>();
707 
708  if (typeName.size() > 1)
709  {
710  typeName = typeName.substr(0, typeName.size() - 1);
711  }
712 
713  return typeName;
714  }
715 
719  virtual std::string getOutputValueOnly() const;
720 
721  protected:
725  void output(std::ostream& stream) const;
726  mutable bool initialized;
727 
728 
729  private:
733  void invalidate();
734 
735  public:
739  static int hashTypeName(const std::string& typeName);
740 
741  private:
745  static std::map<VariantTypeId, std::string>& types();
746  };
747 
748  using StringVariantMap = std::map<std::string, Variant>;
749 
750  // *******************************************************
751  // Integral
752  // *******************************************************
753 
754  template <>
755  Variant::Variant(const std::int8_t& var, void* t);
756  template <>
757  std::int8_t Variant::get<std::int8_t>() const;
758  template <>
759  void Variant::set<std::int8_t>(const std::int8_t& value);
760 
761  template <>
762  Variant::Variant(const std::int16_t& var, void* t);
763  template <>
764  std::int16_t Variant::get<std::int16_t>() const;
765  template <>
766  void Variant::set<std::int16_t>(const std::int16_t& value);
767 
768  template <>
769  Variant::Variant(const std::int32_t& var, void* t);
770  template <>
771  std::int32_t Variant::get<std::int32_t>() const;
772  template <>
773  void Variant::set<std::int32_t>(const std::int32_t& value);
774 
775  template <>
776  Variant::Variant(const std::int64_t& var, void* t);
777  template <>
778  std::int64_t Variant::get<std::int64_t>() const;
779  template <>
780  void Variant::set<std::int64_t>(const std::int64_t& value);
781 
782  template <>
783  Variant::Variant(const std::uint8_t& var, void* t);
784  template <>
785  std::uint8_t Variant::get<std::uint8_t>() const;
786  template <>
787  void Variant::set<std::uint8_t>(const std::uint8_t& value);
788 
789  template <>
790  Variant::Variant(const std::uint8_t& var, void* t);
791  template <>
792  std::uint8_t Variant::get<std::uint8_t>() const;
793  template <>
794  void Variant::set<std::uint8_t>(const std::uint8_t& value);
795 
796  template <>
797  Variant::Variant(const std::uint16_t& var, void* t);
798  template <>
799  std::uint16_t Variant::get<std::uint16_t>() const;
800  template <>
801  void Variant::set<std::uint16_t>(const std::uint16_t& value);
802 
803  template <>
804  Variant::Variant(const std::uint32_t& var, void* t);
805  template <>
806  std::uint32_t Variant::get<std::uint32_t>() const;
807  template <>
808  void Variant::set<std::uint32_t>(const std::uint32_t& value);
809 
810  template <>
811  Variant::Variant(const std::uint64_t& var, void* t);
812  template <>
813  std::uint64_t Variant::get<std::uint64_t>() const;
814  template <>
815  void Variant::set<std::uint64_t>(const std::uint64_t& value);
816 
817  // *******************************************************
818  // Constructors
819  // *******************************************************
820  template <>
821  Variant::Variant(const float& var, void* t);
822  template <>
823  Variant::Variant(const double& var, void* t);
824  template <>
825  Variant::Variant(const bool& var, void* t);
826  template <>
827  Variant::Variant(const std::string& var, void* t);
828 
829  // *******************************************************
830  // Template specialization for getter and setter
831  // *******************************************************
832  template <>
833  bool Variant::get<bool>() const;
834  template <>
835  float Variant::get<float>() const;
836  template <>
837  double Variant::get<double>() const;
838  template <>
839  std::string Variant::get<std::string>() const;
840 
841  template <>
842  void Variant::set<bool>(const bool& value);
843  template <>
844  void Variant::set<float>(const float& value);
845  template <>
846  void Variant::set<double>(const double& value);
847  template <>
848  void Variant::set<std::string>(const std::string& value);
849 
850  // *******************************************************
851  // Explicit Instantiation Declaration
852  // *******************************************************
853 
854  extern template Variant::Variant(const std::int8_t& var, void* t);
855  extern template std::int8_t Variant::get<std::int8_t>() const;
856  extern template void Variant::set<std::int8_t>(const std::int8_t& value);
857 
858  extern template Variant::Variant(const std::int16_t& var, void* t);
859  extern template std::int16_t Variant::get<std::int16_t>() const;
860  extern template void Variant::set<std::int16_t>(const std::int16_t& value);
861 
862  extern template Variant::Variant(const std::int32_t& var, void* t);
863  extern template std::int32_t Variant::get<std::int32_t>() const;
864  extern template void Variant::set<std::int32_t>(const std::int32_t& value);
865 
866  extern template Variant::Variant(const std::int64_t& var, void* t);
867  extern template std::int64_t Variant::get<std::int64_t>() const;
868  extern template void Variant::set<std::int64_t>(const std::int64_t& value);
869 
870  extern template Variant::Variant(const std::uint8_t& var, void* t);
871  extern template std::uint8_t Variant::get<std::uint8_t>() const;
872  extern template void Variant::set<std::uint8_t>(const std::uint8_t& value);
873 
874  extern template Variant::Variant(const std::uint8_t& var, void* t);
875  extern template std::uint8_t Variant::get<std::uint8_t>() const;
876  extern template void Variant::set<std::uint8_t>(const std::uint8_t& value);
877 
878  extern template Variant::Variant(const std::uint16_t& var, void* t);
879  extern template std::uint16_t Variant::get<std::uint16_t>() const;
880  extern template void Variant::set<std::uint16_t>(const std::uint16_t& value);
881 
882  extern template Variant::Variant(const std::uint32_t& var, void* t);
883  extern template std::uint32_t Variant::get<std::uint32_t>() const;
884  extern template void Variant::set<std::uint32_t>(const std::uint32_t& value);
885 
886  extern template Variant::Variant(const std::uint64_t& var, void* t);
887  extern template std::uint64_t Variant::get<std::uint64_t>() const;
888  extern template void Variant::set<std::uint64_t>(const std::uint64_t& value);
889 
890  extern template Variant::Variant(const float& var, void* t);
891  extern template float Variant::get<float>() const;
892  extern template void Variant::set<float>(const float& value);
893 
894  extern template Variant::Variant(const double& var, void* t);
895  extern template double Variant::get<double>() const;
896  extern template void Variant::set<double>(const double& value);
897 
898  extern template Variant::Variant(const bool& var, void* t);
899  extern template bool Variant::get<bool>() const;
900  extern template void Variant::set<bool>(const bool& value);
901 
902  extern template Variant::Variant(const std::string& var, void* t);
903  extern template std::string Variant::get<std::string>() const;
904  extern template void Variant::set<std::string>(const std::string& value);
905 
906  std::ostream& operator<<(std::ostream& stream, const VariantDataClass& variant);
907 } // namespace armarx
908 // *******************************************************
909 // Types for basic variants
910 // *******************************************************
911 namespace armarx::VariantType
912 {
913  // These const variables are abbreviations to the function that provides the type id of Variants
914  const VariantTypeId Invalid = Variant::addTypeName("::armarx::InvalidVariantData");
915  const VariantTypeId Bool = Variant::addTypeName("::armarx::BoolVariantData");
916  const VariantTypeId Int = Variant::addTypeName("::armarx::IntVariantData");
917  const VariantTypeId Long = Variant::addTypeName("::armarx::LongVariantData");
918  const VariantTypeId Float = Variant::addTypeName("::armarx::FloatVariantData");
919  const VariantTypeId Double = Variant::addTypeName("::armarx::DoubleVariantData");
920  const VariantTypeId String = Variant::addTypeName("::armarx::StringVariantData");
921  bool IsBasicType(VariantTypeId id);
922 } // namespace armarx::VariantType
armarx::Variant
The Variant class is described here: Variants.
Definition: Variant.h:224
armarx::Variant::setClass
void setClass(const VariantDataClassPtr &variantDataClass)
Sets the Variant's value to variantDataClass.
Definition: Variant.cpp:374
armarx::Variant::getInitialized
bool getInitialized(const Ice::Current &c=Ice::emptyCurrent) const override
Tells if the Variant is properly initialized.
Definition: Variant.cpp:591
armarx::VariantType::Float
const VariantTypeId Float
Definition: Variant.h:918
armarx::Variant::operator=
Variant & operator=(float f)
Definition: Variant.h:625
armarx::Variant::setLong
void setLong(long n, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to n.
Definition: Variant.cpp:290
armarx::Variant::getDouble
double getDouble(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as double.
Definition: Variant.cpp:452
armarx::Variant::validate
bool validate(const Ice::Current &c=Ice::emptyCurrent) const override
Checks if the Variant is initialized and the stored value is valid with respect to the Variant's type...
Definition: Variant.cpp:601
armarx::Variant::operator<<
friend std::ostream & operator<<(std::ostream &stream, const Variant &rhs)
Definition: Variant.h:656
armarx::StringVariantMap
std::map< std::string, Variant > StringVariantMap
Definition: Variant.h:748
GetTypeString.h
armarx::Variant::getType
VariantTypeId getType(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's internal type.
Definition: Variant.cpp:574
armarx::Variant::operator=
Variant & operator=(double d)
Definition: Variant.h:631
armarx::Variant::get
std::enable_if_t<(std::is_standard_layout_v< T > &&std::is_trivial_v< T >)||std::is_same_v< std::string, T >, T > get() const
This getter is only called if a wrong template parameter is given (i.e: the type does not inherit fro...
Definition: Variant.h:581
armarx::Variant::clone
virtual VariantPtr clone() const
Returns a copy of the Variant.
Definition: Variant.cpp:255
armarx::Variant::setString
void setString(const std::string &s, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to s.
Definition: Variant.cpp:340
armarx::Variant::operator=
Variant & operator=(long n)
Definition: Variant.h:619
c
constexpr T c
Definition: UnscentedKalmanFilterTest.cpp:43
armarx::Variant::getTypes
static const std::map< VariantTypeId, std::string > & getTypes()
Returns the mapping of currently registered types.
Definition: Variant.cpp:746
armarx::VariantType::Bool
const VariantTypeId Bool
Definition: Variant.h:915
armarx::Variant::Variant
Variant()
Definition: Variant.cpp:235
armarx::Variant::get
std::enable_if_t< std::is_base_of_v< VariantDataClass, T >, IceInternal::Handle< T > > get() const
Template-based getter for the Variant's value.
Definition: Variant.h:556
armarx::Variant::getTypeName
std::string getTypeName(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's internal type.
Definition: Variant.cpp:579
armarx::Variant::Variant
Variant(const IceInternal::Handle< T > &var, typename std::enable_if_t< std::is_base_of_v< VariantDataClass, T >> *t=nullptr)
Construct a Variant from an IceHandle to a VariantDataClass instance.
Definition: Variant.h:280
armarx::Variant::getLong
long getLong(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as long.
Definition: Variant.cpp:417
armarx::Variant::setInt
void setInt(int n, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to n.
Definition: Variant.cpp:274
IceInternal::Handle< Variant >
armarx::VariantType::Double
const VariantTypeId Double
Definition: Variant.h:919
armarx::Variant::setDouble
void setDouble(double d, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to d.
Definition: Variant.cpp:323
cxxopts::value
std::shared_ptr< Value > value()
Definition: cxxopts.hpp:926
armarx::Variant::setBool
void setBool(bool b, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to b.
Definition: Variant.cpp:357
armarx::Variant::getString
std::string getString(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as string.
Definition: Variant.cpp:470
armarx::VariantType::Invalid
const VariantTypeId Invalid
Definition: Variant.h:914
armarx::Variant::getInt
int getInt(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as int.
Definition: Variant.cpp:400
armarx::Variant::setFloat
void setFloat(float f, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's value to f.
Definition: Variant.cpp:306
armarx::Variant::operator=
Variant & operator=(int n)
Definition: Variant.h:613
armarx::Variant::Variant
Variant(char const var[])
Construct a Variant from a string.
Definition: Variant.h:251
armarx::Variant::operator=
Variant & operator=(bool b)
Definition: Variant.h:643
armarx::Variant::set
std::enable_if_t< std::is_base_of_v< VariantDataClass, T > > set(const VariantDataClassPtr &variantDataClass)
Template-based setter for the Variant's value for VariantDataClass-instances.
Definition: Variant.h:507
armarx::Variant::get
std::enable_if_t< std::is_base_of_v< VariantDataClass, typename T::element_type >, T > get() const
Definition: Variant.h:563
armarx::Variant::typeToString
static std::string typeToString(VariantTypeId typeId)
Return the name of the registered type typeId.
Definition: Variant.cpp:732
armarx::VariantType::Long
const VariantTypeId Long
Definition: Variant.h:917
armarx::VariantType
Definition: ChannelRef.h:160
armarx::Variant::getFloat
float getFloat(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as float.
Definition: Variant.cpp:434
armarx::Variant::Variant
Variant(const T &var, typename std::enable_if_t<!(std::is_base_of_v< VariantDataClass, T >||std::is_pointer_v< T >)> *t=nullptr)
Construct a Variant from a non-VariantDataClass instance, e.g.
Definition: Variant.h:238
armarx::Variant::getOutputValueOnly
virtual std::string getOutputValueOnly() const
Returns the formatted content of the Variant as a string.
Definition: Variant.cpp:504
armarx::always_false
constexpr bool always_false
Definition: Variant.h:47
armarx::VariantTypeId
Ice::Int VariantTypeId
Definition: Variant.h:44
boost::source
Vertex source(const detail::edge_base< Directed, Vertex > &e, const PCG &)
Definition: point_cloud_graph.h:681
armarx::VariantType::IsBasicType
bool IsBasicType(VariantTypeId id)
Definition: Variant.cpp:772
NotInitializedException.h
armarx::exceptions::user::NotInitializedException
Definition: NotInitializedException.h:34
armarx::Variant::initialized
bool initialized
Definition: Variant.h:726
armarx::Variant::operator=
Variant & operator=(const std::string &s)
Definition: Variant.h:637
armarx::Variant::Variant
Variant(const T &var, typename std::enable_if_t< std::is_base_of_v< VariantDataClass, T >> *t=nullptr)
Construct a Variant from a reference to a VariantDataClass instance.
Definition: Variant.h:265
armarx::Variant::set
std::enable_if_t<!std::is_base_of_v< VariantDataClass, T > > set(const T &value)
Template-based setter for the Variant's value for non-VariantDataClass-instances.
Definition: Variant.h:524
armarx::Variant::setType
void setType(VariantTypeId typeId, const Ice::Current &c=Ice::emptyCurrent) override
Sets the Variant's type to typeId.
Definition: Variant.cpp:264
armarx::operator<<
std::ostream & operator<<(std::ostream &os, const PythonApplicationManager::Paths &paths)
Definition: PythonApplicationManager.cpp:221
armarx::Variant::GetType
static std::string GetType()
Template-based getter for a type name.
Definition: Variant.h:704
armarx::VariantType::Int
const VariantTypeId Int
Definition: Variant.h:916
armarx::Variant::hashTypeName
static int hashTypeName(const std::string &typeName)
Compute and return a hash value for a given type name.
Definition: Variant.cpp:699
armarx::Variant::Variant
Variant(const T *var, typename std::enable_if_t< std::is_base_of_v< VariantDataClass, T >> *t=nullptr)
Construct a Variant from a pointer to a VariantDataClass instance.
Definition: Variant.h:295
armarx::Variant::output
void output(std::ostream &stream) const
Outputs a formatted representation of the Variant to stream.
Definition: Variant.cpp:669
T
float T
Definition: UnscentedKalmanFilterTest.cpp:35
armarx::VariantType::String
const VariantTypeId String
Definition: Variant.h:920
armarx::Variant::getClass
IceInternal::Handle< TVariantDataClass > getClass() const
Return the Variant's value as TVariantDataClass.
Definition: Variant.h:472
armarx::Variant::getBool
bool getBool(const Ice::Current &c=Ice::emptyCurrent) const override
Return the Variant's value as bool.
Definition: Variant.cpp:487
armarx::ctrlutil::s
double s(double t, double s0, double v0, double a0, double j)
Definition: CtrlUtil.h:31
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
armarx::Variant::addTypeName
static VariantTypeId addTypeName(const std::string &typeName)
Register a new type for the use in a Variant.
Definition: Variant.cpp:751