source: HiSusy/trunk/Delphes-3.0.0/external/fastjet/internal/IsBase.hh @ 1

Last change on this file since 1 was 1, checked in by zerwas, 11 years ago

first import of structure, PYTHIA8 and DELPHES

File size: 5.6 KB
Line 
1//STARTHEADER
2// $Id: IsBase.hh 2622 2011-10-05 22:13:23Z soyez $
3//
4// Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
5//
6//----------------------------------------------------------------------
7// This file is part of FastJet.
8//
9//  FastJet is free software; you can redistribute it and/or modify
10//  it under the terms of the GNU General Public License as published by
11//  the Free Software Foundation; either version 2 of the License, or
12//  (at your option) any later version.
13//
14//  The algorithms that underlie FastJet have required considerable
15//  development and are described in hep-ph/0512210. If you use
16//  FastJet as part of work towards a scientific publication, please
17//  include a citation to the FastJet paper.
18//
19//  FastJet is distributed in the hope that it will be useful,
20//  but WITHOUT ANY WARRANTY; without even the implied warranty of
21//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22//  GNU General Public License for more details.
23//
24//  You should have received a copy of the GNU General Public License
25//  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
26//----------------------------------------------------------------------
27//ENDHEADER
28
29#ifndef __FASTJET_INTERNAL_IS_BASE_HH__
30#define __FASTJET_INTERNAL_IS_BASE_HH__
31
32#include "fastjet/internal/numconsts.hh"
33
34FASTJET_BEGIN_NAMESPACE
35
36//---------------------------------------------------
37// define a true and a false 'type'
38// Note:
39//  we could actually template the type and recover
40//  the TR1 integral_constant type. This also
41//  includes adding a typedef for the type and a
42//  typedef for the struct in the struct below
43//
44// This is going to be helpful to "split" a given
45// call into 2 options based on a type constraint
46// at compilation-time (rather than doing an "if"
47// which would only be resolved at runtime and could
48// thus resutl in compilation errors.
49//---------------------------------------------------
50
51/// \if internal_doc
52/// \class integral_type
53/// a generic construct that promotes a generic value of a generic type
54/// as a type
55///
56/// this has 2 template parameters: T, the considered type, and _t, a
57/// value of type T
58/// This object is a basic construct in type traits
59/// \endif
60template<typename T, T _t>
61struct integral_type{
62  static const T value = _t;         ///< the value (only member carrying info)
63  typedef T value_type;              ///< a typedef for the type T
64  typedef integral_type<T,_t> type;  ///< a typedef for the whole structure
65};
66
67// definition of the static member in integral_type
68template<typename T, T _t>
69const T integral_type<T, _t>::value;
70
71// shortcuts
72typedef integral_type<bool, true>  true_type;  ///< the bool 'true'  value promoted to a type
73typedef integral_type<bool, false> false_type; ///< the bool 'false' value promoted to a type
74
75
76//---------------------------------------------------
77// define a yes and a no type (based on their size)
78//---------------------------------------------------
79typedef char (&__yes_type)[1]; //< the yes type
80typedef char (&__no_type) [2]; //< the no type
81
82
83//---------------------------------------------------
84// Now deal with inheritance checks
85//
86// We want to provide a IsBaseAndDerived<B,D> type
87// trait that contains a value that is true if D
88// is derived from B and false otherwise.
89//
90// For an explanation of how the code below works,
91// have a look at
92//   http://groups.google.com/group/comp.lang.c++.moderated/msg/dd6c4e4d5160bd83
93// and the links therein
94//
95// WARNING: according to 'boost', this may have some
96//   issues with MSVC7.1. See their code for a description
97//   of the workaround used below
98//---------------------------------------------------
99
100/// \if internal_doc
101/// \class __inheritance_helper
102/// helper for IsBasedAndDerived<B,D>
103/// \endif
104template<typename B, typename D>
105struct __inheritance_helper{
106#if !((_MSC_VER !=0 ) && (_MSC_VER == 1310))   // MSVC 7.1
107  template <typename T>
108  static __yes_type check_sig(D const volatile *, T);
109#else
110  static __yes_type check_sig(D const volatile *, long);
111#endif
112  static __no_type  check_sig(B const volatile *, int);
113};
114
115/// \if internal_doc
116/// \class IsBaseAndDerived
117/// check if the second template argument is derived from the first one
118///
119/// this class has 2 template dependencies: B and D. It contains a
120/// static boolean value that will be true if D is derived from B and
121/// false otherwise.
122///
123/// Note: This construct may have a problem with MSVC7.1. See the
124/// boost implementation for a description and workaround
125/// \endif
126template<typename B, typename D>
127struct IsBaseAndDerived{
128#if ((_MSC_FULL_VER != 0) && (_MSC_FULL_VER >= 140050000))
129#pragma warning(push)
130#pragma warning(disable:6334)
131#endif
132
133
134  /// \if internal_doc
135  /// a helper structure that will pick between a casting to B*const
136  /// or D.
137  ///
138  /// precisely how this structure works involves advanced C++
139  /// conversion rules
140  /// \endif
141  struct Host{
142#if !((_MSC_VER !=0 ) && (_MSC_VER == 1310))
143    operator B const volatile *() const;
144#else
145    operator B const volatile * const&() const;
146#endif
147    operator D const volatile *();
148  };
149
150  /// the boolean value being true if D is derived from B
151  static const bool value = ((sizeof(B)!=0) && 
152                             (sizeof(D)!=0) && 
153                             (sizeof(__inheritance_helper<B,D>::check_sig(Host(), 0)) == sizeof(__yes_type)));
154
155#if ((_MSC_FULL_VER != 0) && (_MSC_FULL_VER >= 140050000))
156#pragma warning(pop)
157#endif
158};
159
160
161/// a little helper that returns a pointer to d of type B* if D is
162/// derived from B and NULL otherwise
163template<class B, class D>
164B* cast_if_derived(D* d){
165  return IsBaseAndDerived<B,D>::value ? (B*)(d) : NULL;
166}
167
168
169FASTJET_END_NAMESPACE
170
171
172#endif  // __IS_BASE_OF_HH__
Note: See TracBrowser for help on using the repository browser.