Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Kitware
GitHub Repository: Kitware/CMake
 Path: blob/master/Source/cmArgumentParserTypes.h
4998 views
1
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

2
   file LICENSE.rst or https://cmake.org/licensing for details.  */

3
#pragma once

4


5
#include "cmConfigure.h" // IWYU pragma: keep

6


7
#if defined(__SUNPRO_CC) || defined(__EDG__)

8


9
#  include <string>

10
#  include <vector>

11


12
namespace ArgumentParser {

13


14
template <typename T>

15
struct Maybe;

16
template <>

17
struct Maybe<std::string> : public std::string

18
{

19
  using std::string::basic_string;

20
  using std::string::operator=;

21
};

22


23
template <typename T>

24
struct MaybeEmpty;

25
#  if defined(__LCC__) && (__EDG_VERSION__ >= 603)

26
template <>

27
struct MaybeEmpty<std::vector<std::string>> : public std::vector<std::string>

28
{

29
  using std::vector<std::string>::vector;

30
  using std::vector<std::string>::operator=;

31
};

32
#  endif

33
template <typename T>

34
struct MaybeEmpty<std::vector<T>> : public std::vector<T>

35
{

36
  using std::vector<T>::vector;

37
  using std::vector<T>::operator=;

38
};

39
template <>

40
struct MaybeEmpty<std::string> : public std::string

41
{

42
  using std::string::basic_string;

43
  using std::string::operator=;

44
};

45


46
template <typename T>

47
struct NonEmpty;

48
template <typename T>

49
struct NonEmpty<std::vector<T>> : public std::vector<T>

50
{

51
  using std::vector<T>::vector;

52
  using std::vector<T>::operator=;

53
};

54
template <>

55
struct NonEmpty<std::string> : public std::string

56
{

57
  using std::string::basic_string;

58
  using std::string::operator=;

59
};

60


61
} // namespace ArgumentParser

62


63
#else

64


65
namespace ArgumentParser {

66


67
template <typename T>

68
struct Maybe : public T

69
{

70
  using T::T;

71
  using T::operator=;

72
};

73


74
template <typename T>

75
struct MaybeEmpty : public T

76
{

77
  using T::T;

78
  using T::operator=;

79
};

80


81
template <typename T>

82
struct NonEmpty : public T

83
{

84
  using T::T;

85
  using T::operator=;

86
};

87


88
} // namespace ArgumentParser

89


90
#endif

91


92