The Windows Access Control Model: Part 2

oshah

Rate me:

4.80/5 (28 votes)

27 Jun 2005CPOL43 min read

244.5K

7.2K

113

This second part of the Access Control series will program with the basic Access Control structures.

userfun.zip
- 2000
  - 2000.vcproj
  - boosthelper.h
  - Privateobject.h
  - release
    - 2000.exe
  - Safer.h
  - sized_array.h
  - UserFun2000.cpp
  - UserFun2000.h
- ATL
  - PrivateObject.cpp
  - PrivateObject.h
  - release
    - UserFun.exe
  - stdafx.cpp
  - stdafx.h
  - UserFun.vcproj
  - UserFunATL.cpp
- Boostlib.txt
- LowLevel
  - LowLevel.vcproj
  - release
    - LowLevel.exe
  - UserFunLowLevel.c
- ReadMe.txt
whoami.zip
- Whoami
  - release
    - Whoami.exe
  - sized_array.h
  - Whoami.cpp
  - Whoami.vcproj
boost.zip
- boost
  - assert.hpp
  - checked_delete.hpp
  - config.hpp
  - config
    - compiler
    - platform
      - aix.hpp
      - amigaos.hpp
      - beos.hpp
      - bsd.hpp
      - cygwin.hpp
      - hpux.hpp
      - irix.hpp
      - linux.hpp
      - macos.hpp
      - solaris.hpp
      - win32.hpp
    - posix_features.hpp
    - select_compiler_config.hpp
    - select_platform_config.hpp
    - select_stdlib_config.hpp
    - stdlib
    - suffix.hpp
    - user.hpp
  - cregex.hpp
  - cstdint.hpp
  - cstdlib.hpp
  - current_function.hpp
  - detail
    - allocator.hpp
    - catch_exceptions.hpp
    - limits.hpp
    - workaround.hpp
  - limits.hpp
  - mpl
    - aux_
  - preprocessor
    - arithmetic.hpp
    - arithmetic
      - add.hpp
      - dec.hpp
      - detail
        
        div_base.hpp
      - div.hpp
      - inc.hpp
      - mod.hpp
      - mul.hpp
      - sub.hpp
    - array.hpp
    - array
      - data.hpp
      - elem.hpp
      - insert.hpp
      - pop_back.hpp
      - pop_front.hpp
      - push_back.hpp
      - push_front.hpp
      - remove.hpp
      - replace.hpp
      - reverse.hpp
      - size.hpp
    - assert_msg.hpp
    - cat.hpp
    - comma.hpp
    - comma_if.hpp
    - comparison.hpp
    - comparison
      - equal.hpp
      - greater.hpp
      - greater_equal.hpp
      - less.hpp
      - less_equal.hpp
      - not_equal.hpp
    - config
      - config.hpp
      - limits.hpp
    - control.hpp
    - control
      - deduce_d.hpp
      - detail
        
        edg
        
        while.hpp
        
        msvc
        
        while.hpp
        
        while.hpp
      - expr_if.hpp
      - expr_iif.hpp
      - if.hpp
      - iif.hpp
      - while.hpp
    - debug.hpp
    - dec.hpp
    - detail
      - auto_rec.hpp
      - check.hpp
      - is_binary.hpp
      - is_nullary.hpp
      - is_unary.hpp
      - null.hpp
      - split.hpp
    - empty.hpp
    - enum.hpp
    - enum_params.hpp
    - enum_params_with_a_default.hpp
    - enum_params_with_defaults.hpp
    - enum_shifted.hpp
    - enum_shifted_params.hpp
    - expand.hpp
    - expr_if.hpp
    - facilities.hpp
    - facilities
      - apply.hpp
      - empty.hpp
      - expand.hpp
      - identity.hpp
      - intercept.hpp
      - is_1.hpp
      - is_empty.hpp
      - is_empty_or_1.hpp
    - for.hpp
    - identity.hpp
    - if.hpp
    - inc.hpp
    - iterate.hpp
    - iteration.hpp
    - iteration
      - detail
        
        bounds
        
        lower1.hpp
        
        lower2.hpp
        
        lower3.hpp
        
        lower4.hpp
        
        lower5.hpp
        
        upper1.hpp
        
        upper2.hpp
        
        upper3.hpp
        
        upper4.hpp
        
        upper5.hpp
        
        finish.hpp
        
        iter
        
        forward1.hpp
        
        forward2.hpp
        
        forward3.hpp
        
        forward4.hpp
        
        forward5.hpp
        
        reverse1.hpp
        
        reverse2.hpp
        
        reverse3.hpp
        
        reverse4.hpp
        
        reverse5.hpp
        
        local.hpp
        
        rlocal.hpp
        
        self.hpp
        
        start.hpp
      - iterate.hpp
      - local.hpp
      - self.hpp
    - library.hpp
    - limits.hpp
    - list.hpp
    - list
      - adt.hpp
      - append.hpp
      - at.hpp
      - cat.hpp
      - detail
        
        edg
        
        fold_left.hpp
        
        fold_right.hpp
        
        fold_left.hpp
        
        fold_right.hpp
      - enum.hpp
      - filter.hpp
      - first_n.hpp
      - fold_left.hpp
      - fold_right.hpp
      - for_each.hpp
      - for_each_i.hpp
      - for_each_product.hpp
      - rest_n.hpp
      - reverse.hpp
      - size.hpp
      - to_tuple.hpp
      - transform.hpp
    - logical.hpp
    - logical
      - and.hpp
      - bitand.hpp
      - bitnor.hpp
      - bitor.hpp
      - bitxor.hpp
      - bool.hpp
      - compl.hpp
      - nor.hpp
      - not.hpp
      - or.hpp
      - xor.hpp
    - max.hpp
    - min.hpp
    - punctuation.hpp
    - punctuation
      - comma.hpp
      - comma_if.hpp
      - paren.hpp
      - paren_if.hpp
    - repeat.hpp
    - repeat_2nd.hpp
    - repeat_3rd.hpp
    - repeat_from_to.hpp
    - repeat_from_to_2nd.hpp
    - repeat_from_to_3rd.hpp
    - repetition.hpp
    - repetition
      - deduce_r.hpp
      - deduce_z.hpp
      - detail
        
        edg
        
        for.hpp
        
        for.hpp
        
        msvc
        
        for.hpp
      - enum.hpp
      - enum_binary_params.hpp
      - enum_params.hpp
      - enum_params_with_a_default.hpp
      - enum_params_with_defaults.hpp
      - enum_shifted.hpp
      - enum_shifted_params.hpp
      - enum_trailing.hpp
      - enum_trailing_binary_params.hpp
      - enum_trailing_params.hpp
      - for.hpp
      - repeat.hpp
      - repeat_from_to.hpp
    - selection.hpp
    - selection
      - max.hpp
      - min.hpp
    - seq.hpp
    - seq
      - cat.hpp
      - detail
        
        split.hpp
      - elem.hpp
      - enum.hpp
      - filter.hpp
      - first_n.hpp
      - fold_left.hpp
      - fold_right.hpp
      - for_each.hpp
      - for_each_i.hpp
      - for_each_product.hpp
      - insert.hpp
      - pop_back.hpp
      - pop_front.hpp
      - push_back.hpp
      - push_front.hpp
      - remove.hpp
      - replace.hpp
      - rest_n.hpp
      - reverse.hpp
      - seq.hpp
      - size.hpp
      - subseq.hpp
      - to_array.hpp
      - to_tuple.hpp
      - transform.hpp
    - slot.hpp
    - slot
      - detail
        
        def.hpp
        
        shared.hpp
        
        slot1.hpp
        
        slot2.hpp
        
        slot3.hpp
        
        slot4.hpp
        
        slot5.hpp
      - slot.hpp
    - stringize.hpp
    - tuple.hpp
    - tuple
      - eat.hpp
      - elem.hpp
      - rem.hpp
      - reverse.hpp
      - to_list.hpp
      - to_seq.hpp
    - while.hpp
    - wstringize.hpp
  - regex.h
  - regex.hpp
  - regex
    - config.hpp
    - pattern_except.hpp
    - regex_traits.hpp
    - src.cpp
    - user.hpp
    - v3
  - regex_fwd.hpp
  - scoped_array.hpp
  - scoped_ptr.hpp
  - static_assert.hpp
  - test
    - auto_unit_test.hpp
    - detail
    - execution_monitor.hpp
    - floating_point_comparison.hpp
    - included
    - minimal.hpp
    - test_tools.hpp
    - unit_test.hpp
    - unit_test_log.hpp
    - unit_test_result.hpp
    - unit_test_suite.hpp
    - unit_test_suite_ex.hpp
  - timer.hpp
  - type_traits.hpp
  - type_traits
    - add_const.hpp
    - add_cv.hpp
    - add_pointer.hpp
    - add_reference.hpp
    - add_volatile.hpp
    - alignment_of.hpp
    - alignment_traits.hpp
    - arithmetic_traits.hpp
    - array_traits.hpp
    - broken_compiler_spec.hpp
    - composite_traits.hpp
    - config.hpp
    - conversion_traits.hpp
    - cv_traits.hpp
    - detail
      - bool_trait_def.hpp
      - bool_trait_undef.hpp
      - cv_traits_impl.hpp
      - false_result.hpp
      - ice_and.hpp
      - ice_eq.hpp
      - ice_not.hpp
      - ice_or.hpp
      - is_function_ptr_helper.hpp
      - is_function_ptr_tester.hpp
      - is_function_type_tester.hpp
      - is_mem_fun_pointer_impl.hpp
      - is_mem_fun_pointer_tester.hpp
      - size_t_trait_def.hpp
      - size_t_trait_undef.hpp
      - template_arity_spec.hpp
      - type_trait_def.hpp
      - type_trait_undef.hpp
      - wrap.hpp
      - yes_no_type.hpp
    - function_traits.hpp
    - has_nothrow_assign.hpp
    - has_nothrow_constructor.hpp
    - has_nothrow_copy.hpp
    - has_nothrow_destructor.hpp
    - has_trivial_assign.hpp
    - has_trivial_constructor.hpp
    - has_trivial_copy.hpp
    - has_trivial_destructor.hpp
    - ice.hpp
    - intrinsics.hpp
    - is_arithmetic.hpp
    - is_array.hpp
    - is_base_and_derived.hpp
    - is_class.hpp
    - is_compound.hpp
    - is_const.hpp
    - is_convertible.hpp
    - is_empty.hpp
    - is_enum.hpp
    - is_float.hpp
    - is_function.hpp
    - is_fundamental.hpp
    - is_integral.hpp
    - is_member_function_pointer.hpp
    - is_member_pointer.hpp
    - is_object.hpp
    - is_pod.hpp
    - is_pointer.hpp
    - is_polymorphic.hpp
    - is_reference.hpp
    - is_same.hpp
    - is_scalar.hpp
    - is_stateless.hpp
    - is_union.hpp
    - is_void.hpp
    - is_volatile.hpp
    - object_traits.hpp
    - reference_traits.hpp
    - remove_bounds.hpp
    - remove_const.hpp
    - remove_cv.hpp
    - remove_pointer.hpp
    - remove_reference.hpp
    - remove_volatile.hpp
    - same_traits.hpp
    - transform_traits.hpp
    - transform_traits_spec.hpp
    - type_traits_test.hpp
    - type_with_alignment.hpp
  - utility.hpp
  - utility
    - addressof.hpp
    - base_from_member.hpp
    - value_init.hpp
  - utility_fwd.hpp

// preprocessed version of 'boost/mpl/aux_/full_lambda.hpp' header
// see the original for copyright information

namespace boost {
namespace mpl {

template<
      typename T
    , typename Protect = false_
    
    >
struct lambda_impl
{
    typedef false_ is_le;
    typedef T type;
};

template<
      typename T
    
    >
struct lambda
    : lambda_impl< T,false_ >
{
};

namespace aux {

template<
      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
    , bool C5 = false
    >
struct lambda_or
    : true_
{
};

template<>
struct lambda_or< false,false,false,false,false >
    : false_
{
};

} // namespace aux

template< int N, typename Protect >
struct lambda_impl< arg<N>,Protect >
{
    typedef true_ is_le;
    typedef arg<N> type;
};

template<
      typename F
    , typename Protect
    >
struct lambda_impl<
      bind0<F>
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind0<
          F
        > type;
};

template<
      template< typename P1 > class F
    , typename T1
    >
struct lambda< F<T1> >
    : lambda_impl< F<T1>,true_ >
{
};

namespace aux {

template<
      typename IsLE, typename Protect
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1
{
    typedef F<
          typename L1::type
        > type;
};

template<
      template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,false_,F,L1 >
{
    typedef bind1<
          quote1<F>
        , typename L1::type
        > type;
};

template<
      template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,true_,F,L1 >
{
    typedef protect< bind1<
          quote1<F>
        , typename L1::type
        > > type;
};

} // namespace aux

template<
      template< typename P1 > class F
    , typename T1
    , typename Protect
    >
struct lambda_impl< 
      F<T1>, Protect 
    >
{
    typedef lambda_impl<T1> l1;
    typedef aux::lambda_or<
          l1::is_le::value
        > is_le;

    typedef typename aux::le_result1<
          typename is_le::type
        , Protect
        , F
        , l1
        >::type type;
};

template<
      typename F, typename T1
    , typename Protect
    >
struct lambda_impl<
      bind1< F,T1 >
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind1<
          F
        , T1
        > type;
};

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
struct lambda< F<T1,T2> >
    : lambda_impl< F<T1,T2>,true_ >
{
};

namespace aux {

template<
      typename IsLE, typename Protect
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2
{
    typedef F<
          typename L1::type, typename L2::type
        > type;
};

template<
      template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,false_,F,L1,L2 >
{
    typedef bind2<
          quote2<F>
        , typename L1::type, typename L2::type
        > type;
};

template<
      template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,true_,F,L1,L2 >
{
    typedef protect< bind2<
          quote2<F>
        , typename L1::type, typename L2::type
        > > type;
};

} // namespace aux

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    , typename Protect
    >
struct lambda_impl< 
      F< T1,T2 >, Protect 
    >
{
    typedef lambda_impl<T1> l1;
    typedef lambda_impl<T2> l2;
    
    typedef aux::lambda_or<
          l1::is_le::value, l2::is_le::value
        > is_le;

    typedef typename aux::le_result2<
          typename is_le::type
        , Protect
        , F
        , l1, l2
        >::type type;
};

template<
      typename F, typename T1, typename T2
    , typename Protect
    >
struct lambda_impl<
      bind2< F,T1,T2 >
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind2<
          F
        , T1, T2
        > type;
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
struct lambda< F<T1,T2,T3> >
    : lambda_impl< F<T1,T2,T3>,true_ >
{
};

namespace aux {

template<
      typename IsLE, typename Protect
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        > type;
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,false_,F,L1,L2,L3 >
{
    typedef bind3<
          quote3<F>
        , typename L1::type, typename L2::type, typename L3::type
        > type;
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,true_,F,L1,L2,L3 >
{
    typedef protect< bind3<
          quote3<F>
        , typename L1::type, typename L2::type, typename L3::type
        > > type;
};

} // namespace aux

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    , typename Protect
    >
struct lambda_impl< 
      F< T1,T2,T3 >, Protect 
    >
{
    typedef lambda_impl<T1> l1;
    typedef lambda_impl<T2> l2;
    typedef lambda_impl<T3> l3;
    
    typedef aux::lambda_or<
          l1::is_le::value, l2::is_le::value, l3::is_le::value
        > is_le;

    typedef typename aux::le_result3<
          typename is_le::type
        , Protect
        , F
        , l1, l2, l3
        >::type type;
};

template<
      typename F, typename T1, typename T2, typename T3
    , typename Protect
    >
struct lambda_impl<
      bind3< F,T1,T2,T3 >
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind3<
          F
        , T1, T2, T3
        > type;
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
struct lambda< F<T1,T2,T3,T4> >
    : lambda_impl< F<T1,T2,T3,T4>,true_ >
{
};

namespace aux {

template<
      typename IsLE, typename Protect
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > type;
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,false_,F,L1,L2,L3,L4 >
{
    typedef bind4<
          quote4<F>
        , typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > type;
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,true_,F,L1,L2,L3,L4 >
{
    typedef protect< bind4<
          quote4<F>
        , typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > > type;
};

} // namespace aux

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    , typename Protect
    >
struct lambda_impl< 
      F< T1,T2,T3,T4 >, Protect 
    >
{
    typedef lambda_impl<T1> l1;
    typedef lambda_impl<T2> l2;
    typedef lambda_impl<T3> l3;
    typedef lambda_impl<T4> l4;
    
    typedef aux::lambda_or<
          l1::is_le::value, l2::is_le::value, l3::is_le::value
        , l4::is_le::value
        > is_le;

    typedef typename aux::le_result4<
          typename is_le::type
        , Protect
        , F
        , l1, l2, l3, l4
        >::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename Protect
    >
struct lambda_impl<
      bind4< F,T1,T2,T3,T4 >
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind4<
          F
        , T1, T2, T3, T4
        > type;
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
struct lambda< F<T1,T2,T3,T4,T5> >
    : lambda_impl< F<T1,T2,T3,T4,T5>,true_ >
{
};

namespace aux {

template<
      typename IsLE, typename Protect
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > type;
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,false_,F,L1,L2,L3,L4,L5 >
{
    typedef bind5<
          quote5<F>
        , typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > type;
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,true_,F,L1,L2,L3,L4,L5 >
{
    typedef protect< bind5<
          quote5<F>
        , typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > > type;
};

} // namespace aux

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename Protect
    >
struct lambda_impl< 
      F< T1,T2,T3,T4,T5 >, Protect 
    >
{
    typedef lambda_impl<T1> l1;
    typedef lambda_impl<T2> l2;
    typedef lambda_impl<T3> l3;
    typedef lambda_impl<T4> l4;
    typedef lambda_impl<T5> l5;
    
    typedef aux::lambda_or<
          l1::is_le::value, l2::is_le::value, l3::is_le::value
        , l4::is_le::value, l5::is_le::value
        > is_le;

    typedef typename aux::le_result5<
          typename is_le::type
        , Protect
        , F
        , l1, l2, l3, l4, l5
        >::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Protect
    >
struct lambda_impl<
      bind5< F,T1,T2,T3,T4,T5 >
    , Protect 
    >
{
    typedef false_ is_le;
    typedef bind5<
          F
        , T1, T2, T3, T4, T5
        > type;
};

// special case for 'protect'
template< typename T, typename Protect >
struct lambda_impl< protect<T>,Protect >
{
    typedef false_ is_le;
    typedef protect<T> type;
};

// specializations for main 'bind', 'bind1st' and 'bind2nd' forms
template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Protect
    >
struct lambda_impl<
      bind< F,T1,T2,T3,T4,T5 >
    , Protect 
    
    >
{
    typedef false_ is_le;
    typedef bind< F,T1,T2,T3,T4,T5 > type;
};

template<
      typename F, typename T
    , typename Protect
    >
struct lambda_impl< bind1st<F,T>,Protect >
{
    typedef false_ is_le;
    typedef bind1st< F,T > type;
};

template<
      typename F, typename T
    , typename Protect
    >
struct lambda_impl< bind2nd<F,T>,Protect >
{
    typedef false_ is_le;
    typedef bind2nd< F,T > type;
};

} // namespace mpl
} // namespace boost

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Written By

oshah

Web Developer

United States

Mr. Shah is a reclusive C++/C# developer lurking somewhere in the depths of the city of London. He learnt physics at Kings' College London and obtained a Master in Science there. Having earned an MCAD, he teeters on the brink of transitioning from C++ to C#, unsure of which language to jump to. Fortunately, he also knows how to use .NET interop to merge code between the two languages (which means he won't have to make the choice anytime soon).

His interests (apart from programming) are walking, football (the real one!), philosophy, history, retro-gaming, strategy gaming, and any good game in general.

He maintains a website / blog / FAQ / junk at shexec32.serveftp.net, where he places the best answers he's written to the questions you've asked. If you can find him, maybe you can hire Mr. Shah to help you with anything C++[/CLI]/C#/.NET related Smile | :)

The Windows Access Control Model: Part 2

License

Comments and Discussions