Overview   Project   Class   Tree   Index 
CEF3 C++ API Docs - Version 75.1.4+g4210896+chromium-75.0.3770.100
FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD

base
(base globals)

   in cef_atomic_ref_count.h
   in cef_bind.h
   in cef_bind_helpers.h
   in cef_callback_helpers.h
   in cef_template_util.h
   in cef_tuple.h
   in cef_weak_ptr.h

(base globals)


Field Summary
 cef_internal::ConvertHelper::Create< From >() ) )
          
 
Method Summary
 template< typename Derived > WeakPtr< Derived > AsWeakPtr( Derived* t )
          
 inline bool AtomicRefCountDec( volatile AtomicRefCount* ptr )
          
 inline bool AtomicRefCountDecN( volatile AtomicRefCount* ptr, AtomicRefCount decrement )
          
 inline void AtomicRefCountInc( volatile AtomicRefCount* ptr )
          
 inline void AtomicRefCountIncN( volatile AtomicRefCount* ptr, AtomicRefCount increment )
          
 inline bool AtomicRefCountIsOne( volatile AtomicRefCount* ptr )
          
 inline bool AtomicRefCountIsZero( volatile AtomicRefCount* ptr )
          
 template< typename Functor > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void() >::UnboundRunType > Bind( Functor functor )
          
 template< typename Functor, typename P1 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1 )
          
 template< typename Functor, typename P1, typename P2, typename P3 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3 )
          
 template< typename Functor, typename P1, typename P2, typename P3, typename P4 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4 )
          
 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5 )
          
 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType, typename cef_internal::CallbackParamTraits< P6 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6 )
          
 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType, typename cef_internal::CallbackParamTraits< P6 >::StorageType, typename cef_internal::CallbackParamTraits< P7 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7 )
          
 template< typename Functor, typename P1, typename P2 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2 )
          
 template< typename T > static inline cef_internal::ConstRefWrapper< T > ConstRef( const T& o )
          
 template< typename T > void DeletePointer( T* obj )
          
 template< class Function, class A, class B, class C > inline void DispatchToFunction( Function function, const Tuple3< A, B, C >& arg )
          
 template< class Function, class A, class B, class C, class D, class E > inline void DispatchToFunction( Function function, const Tuple5< A, B, C, D, E >& arg )
          
 template< class Function, class A, class B, class C, class D, class E, class F, class G, class H > inline void DispatchToFunction( Function function, const Tuple8< A, B, C, D, E, F, G, H >& arg )
          
 template< class Function, class A, class B, class C, class D, class E, class F, class G > inline void DispatchToFunction( Function function, const Tuple7< A, B, C, D, E, F, G >& arg )
          
 template< class Function, class A, class B, class C, class D, class E, class F > inline void DispatchToFunction( Function function, const Tuple6< A, B, C, D, E, F >& arg )
          
 template< class Function > inline void DispatchToFunction( Function function, const Tuple0& arg )
          
 template< class Function, class A, class B, class C, class D > inline void DispatchToFunction( Function function, const Tuple4< A, B, C, D >& arg )
          
 template< class Function, class A, class B > inline void DispatchToFunction( Function function, const Tuple2< A, B >& arg )
          
 template< class Function, class A > inline void DispatchToFunction( Function function, const Tuple1< A >& arg )
          
 template< class Function, class A > inline void DispatchToFunction( Function function, const A& arg )
          
 template< class ObjT, class Method, class A, class B > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< A, B >& arg, Tuple0* )
          
 template< class ObjT, class Method, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class A, class B, class C, class D > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< A, B, C, D >& arg, Tuple0* )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< A, B, C, D, E >& arg, Tuple0* )
          
 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class A, class B, class C > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< A, B, C >& arg, Tuple0* )
          
 template< class ObjT, class Method, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& arg )
          
 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const A& arg )
          
 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< A >& arg )
          
 template< class ObjT, class Method, class A, class B > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< A, B >& arg )
          
 template< class ObjT, class Method, class A, class B, class C > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< A, B, C >& arg )
          
 template< class ObjT, class Method, class A, class B, class C, class D > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< A, B, C, D >& arg )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< A, B, C, D, E >& arg )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< A, B, C, D, E, F >& arg )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F, class G > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple7< A, B, C, D, E, F, G >& arg )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F, class G, class H > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple8< A, B, C, D, E, F, G, H >& arg )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class InA, class InB, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& arg, Tuple0* )
          
 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const A& arg, Tuple0* )
          
 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< A >& arg, Tuple0* )
          
 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out )
          
 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< A, B, C, D, E, F >& arg, Tuple0* )
          
 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple4< OutA, OutB, OutC, OutD >* out )
          
 template< class ObjT, class Method, class InA, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class InA, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple3< OutA, OutB, OutC >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple1< OutA >* out )
          
 template< class ObjT, class Method, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple2< OutA, OutB >* out )
          
 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple2< OutA, OutB >* out )
          
 void DoNothing()
          
 template< typename T > static inline cef_internal::IgnoreResultHelper< T > IgnoreResult( T data )
          
 template< typename T > static inline cef_internal::IgnoreResultHelper< Callback< T > > IgnoreResult( const Callback< T >& data )
          
 template< class A, class B, class C, class D, class E, class F, class G, class H > inline Tuple8< A&, B&, C&, D&, E&, F&, G&, H& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h )
          
 template< class A, class B, class C, class D, class E > inline Tuple5< A&, B&, C&, D&, E& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e )
          
 template< class A, class B, class C, class D, class E, class F, class G > inline Tuple7< A&, B&, C&, D&, E&, F&, G& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f, G& g )
          
 template< class A, class B, class C, class D, class E, class F > inline Tuple6< A&, B&, C&, D&, E&, F& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f )
          
 template< class A, class B > inline Tuple2< A&, B& > MakeRefTuple( A& a, B& b )
          
 template< class A, class B, class C, class D > inline Tuple4< A&, B&, C&, D& > MakeRefTuple( A& a, B& b, C& c, D& d )
          
 template< class A, class B, class C > inline Tuple3< A&, B&, C& > MakeRefTuple( A& a, B& b, C& c )
          
 template< class A > inline Tuple1< A& > MakeRefTuple( A& a )
          
 inline Tuple0 MakeTuple()
          
 template< class A > inline Tuple1< A > MakeTuple( const A& a )
          
 template< class A, class B > inline Tuple2< A, B > MakeTuple( const A& a, const B& b )
          
 template< class A, class B, class C > inline Tuple3< A, B, C > MakeTuple( const A& a, const B& b, const C& c )
          
 template< class A, class B, class C, class D, class E > inline Tuple5< A, B, C, D, E > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e )
          
 template< class A, class B, class C, class D, class E, class F, class G, class H > inline Tuple8< A, B, C, D, E, F, G, H > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h )
          
 template< class A, class B, class C, class D, class E, class F, class G > inline Tuple7< A, B, C, D, E, F, G > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g )
          
 template< class A, class B, class C, class D, class E, class F > inline Tuple6< A, B, C, D, E, F > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f )
          
 template< class A, class B, class C, class D > inline Tuple4< A, B, C, D > MakeTuple( const A& a, const B& b, const C& c, const D& d )
          
 template< typename T > static inline cef_internal::OwnedWrapper< T > Owned( T* o )
          
 template< typename T > static inline cef_internal::PassedWrapper< T > Passed( T scoper )
          
 template< typename T > static inline cef_internal::PassedWrapper< T > Passed( T* scoper )
          
 template< typename Sig > base::Callback< Sig > ResetAndReturn( base::Callback< Sig >* cb )
          
 template< typename T > static inline cef_internal::UnretainedWrapper< T > Unretained( T* o )
          
 

Field Detail

)

 cef_internal::ConvertHelper::Create< From >() ) );


Method Detail

AsWeakPtr

 template< typename Derived > WeakPtr< Derived > AsWeakPtr( Derived* t );

AtomicRefCountDec

 inline bool AtomicRefCountDec( volatile AtomicRefCount* ptr );

AtomicRefCountDecN

 inline bool AtomicRefCountDecN( volatile AtomicRefCount* ptr, AtomicRefCount decrement );

AtomicRefCountInc

 inline void AtomicRefCountInc( volatile AtomicRefCount* ptr );

AtomicRefCountIncN

 inline void AtomicRefCountIncN( volatile AtomicRefCount* ptr, AtomicRefCount increment );

AtomicRefCountIsOne

 inline bool AtomicRefCountIsOne( volatile AtomicRefCount* ptr );

AtomicRefCountIsZero

 inline bool AtomicRefCountIsZero( volatile AtomicRefCount* ptr );

Bind

 template< typename Functor > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void() >::UnboundRunType > Bind( Functor functor );

Bind

 template< typename Functor, typename P1 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1 );

Bind

 template< typename Functor, typename P1, typename P2, typename P3 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3 );

Bind

 template< typename Functor, typename P1, typename P2, typename P3, typename P4 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4 );

Bind

 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5 );

Bind

 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType, typename cef_internal::CallbackParamTraits< P6 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6 );

Bind

 template< typename Functor, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType, typename cef_internal::CallbackParamTraits< P3 >::StorageType, typename cef_internal::CallbackParamTraits< P4 >::StorageType, typename cef_internal::CallbackParamTraits< P5 >::StorageType, typename cef_internal::CallbackParamTraits< P6 >::StorageType, typename cef_internal::CallbackParamTraits< P7 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4, const P5& p5, const P6& p6, const P7& p7 );

Bind

 template< typename Functor, typename P1, typename P2 > base::Callback< typename cef_internal::BindState< typename cef_internal::FunctorTraits< Functor >::RunnableType, typename cef_internal::FunctorTraits< Functor >::RunType, void( typename cef_internal::CallbackParamTraits< P1 >::StorageType, typename cef_internal::CallbackParamTraits< P2 >::StorageType ) >::UnboundRunType > Bind( Functor functor, const P1& p1, const P2& p2 );

ConstRef

 template< typename T > static inline cef_internal::ConstRefWrapper< T > ConstRef( const T& o );

DeletePointer

 template< typename T > void DeletePointer( T* obj );

DispatchToFunction

 template< class Function, class A, class B, class C > inline void DispatchToFunction( Function function, const Tuple3< A, B, C >& arg );

DispatchToFunction

 template< class Function, class A, class B, class C, class D, class E > inline void DispatchToFunction( Function function, const Tuple5< A, B, C, D, E >& arg );

DispatchToFunction

 template< class Function, class A, class B, class C, class D, class E, class F, class G, class H > inline void DispatchToFunction( Function function, const Tuple8< A, B, C, D, E, F, G, H >& arg );

DispatchToFunction

 template< class Function, class A, class B, class C, class D, class E, class F, class G > inline void DispatchToFunction( Function function, const Tuple7< A, B, C, D, E, F, G >& arg );

DispatchToFunction

 template< class Function, class A, class B, class C, class D, class E, class F > inline void DispatchToFunction( Function function, const Tuple6< A, B, C, D, E, F >& arg );

DispatchToFunction

 template< class Function > inline void DispatchToFunction( Function function, const Tuple0& arg );

DispatchToFunction

 template< class Function, class A, class B, class C, class D > inline void DispatchToFunction( Function function, const Tuple4< A, B, C, D >& arg );

DispatchToFunction

 template< class Function, class A, class B > inline void DispatchToFunction( Function function, const Tuple2< A, B >& arg );

DispatchToFunction

 template< class Function, class A > inline void DispatchToFunction( Function function, const Tuple1< A >& arg );

DispatchToFunction

 template< class Function, class A > inline void DispatchToFunction( Function function, const A& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< A, B >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< A, B, C, D >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< A, B, C, D, E >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< A, B, C >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& arg );

DispatchToMethod

 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const A& arg );

DispatchToMethod

 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< A >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< A, B >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< A, B, C >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< A, B, C, D >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< A, B, C, D, E >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< A, B, C, D, E, F >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F, class G > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple7< A, B, C, D, E, F, G >& arg );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F, class G, class H > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple8< A, B, C, D, E, F, G, H >& arg );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const A& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class A > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< A >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class OutA, class OutB, class OutC, class OutD, class OutE > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple5< OutA, OutB, OutC, OutD, OutE >* out );

DispatchToMethod

 template< class ObjT, class Method, class A, class B, class C, class D, class E, class F > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< A, B, C, D, E, F >& arg, Tuple0* );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB, class OutC, class OutD > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple4< OutA, OutB, OutC, OutD >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB, class OutC > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple3< OutA, OutB, OutC >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple1< OutA >* out );

DispatchToMethod

 template< class ObjT, class Method, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple0& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const InA& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple1< InA >& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple2< InA, InB >& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple3< InA, InB, InC >& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple4< InA, InB, InC, InD >& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple5< InA, InB, InC, InD, InE >& in, Tuple2< OutA, OutB >* out );

DispatchToMethod

 template< class ObjT, class Method, class InA, class InB, class InC, class InD, class InE, class InF, class OutA, class OutB > inline void DispatchToMethod( ObjT* obj, Method method, const Tuple6< InA, InB, InC, InD, InE, InF >& in, Tuple2< OutA, OutB >* out );

DoNothing

 void DoNothing();

IgnoreResult

 template< typename T > static inline cef_internal::IgnoreResultHelper< T > IgnoreResult( T data );

IgnoreResult

 template< typename T > static inline cef_internal::IgnoreResultHelper< Callback< T > > IgnoreResult( const Callback< T >& data );

MakeRefTuple

 template< class A, class B, class C, class D, class E, class F, class G, class H > inline Tuple8< A&, B&, C&, D&, E&, F&, G&, H& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h );

MakeRefTuple

 template< class A, class B, class C, class D, class E > inline Tuple5< A&, B&, C&, D&, E& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e );

MakeRefTuple

 template< class A, class B, class C, class D, class E, class F, class G > inline Tuple7< A&, B&, C&, D&, E&, F&, G& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f, G& g );

MakeRefTuple

 template< class A, class B, class C, class D, class E, class F > inline Tuple6< A&, B&, C&, D&, E&, F& > MakeRefTuple( A& a, B& b, C& c, D& d, E& e, F& f );

MakeRefTuple

 template< class A, class B > inline Tuple2< A&, B& > MakeRefTuple( A& a, B& b );

MakeRefTuple

 template< class A, class B, class C, class D > inline Tuple4< A&, B&, C&, D& > MakeRefTuple( A& a, B& b, C& c, D& d );

MakeRefTuple

 template< class A, class B, class C > inline Tuple3< A&, B&, C& > MakeRefTuple( A& a, B& b, C& c );

MakeRefTuple

 template< class A > inline Tuple1< A& > MakeRefTuple( A& a );

MakeTuple

 inline Tuple0 MakeTuple();

MakeTuple

 template< class A > inline Tuple1< A > MakeTuple( const A& a );

MakeTuple

 template< class A, class B > inline Tuple2< A, B > MakeTuple( const A& a, const B& b );

MakeTuple

 template< class A, class B, class C > inline Tuple3< A, B, C > MakeTuple( const A& a, const B& b, const C& c );

MakeTuple

 template< class A, class B, class C, class D, class E > inline Tuple5< A, B, C, D, E > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e );

MakeTuple

 template< class A, class B, class C, class D, class E, class F, class G, class H > inline Tuple8< A, B, C, D, E, F, G, H > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h );

MakeTuple

 template< class A, class B, class C, class D, class E, class F, class G > inline Tuple7< A, B, C, D, E, F, G > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g );

MakeTuple

 template< class A, class B, class C, class D, class E, class F > inline Tuple6< A, B, C, D, E, F > MakeTuple( const A& a, const B& b, const C& c, const D& d, const E& e, const F& f );

MakeTuple

 template< class A, class B, class C, class D > inline Tuple4< A, B, C, D > MakeTuple( const A& a, const B& b, const C& c, const D& d );

Owned

 template< typename T > static inline cef_internal::OwnedWrapper< T > Owned( T* o );

Passed

 template< typename T > static inline cef_internal::PassedWrapper< T > Passed( T scoper );

Passed

 template< typename T > static inline cef_internal::PassedWrapper< T > Passed( T* scoper );

ResetAndReturn

 template< typename Sig > base::Callback< Sig > ResetAndReturn( base::Callback< Sig >* cb );

Unretained

 template< typename T > static inline cef_internal::UnretainedWrapper< T > Unretained( T* o );

 Overview   Project   Class   Tree   Index 
CEF3 C++ API Docs - Version 75.1.4+g4210896+chromium-75.0.3770.100
FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD

Chromium Embedded Framework (CEF) Copyright © 2016 Marshall A. Greenblatt