Changeset 54723


Ignore:
Timestamp:
Jul 6, 2009, 7:51:24 PM (9 years ago)
Author:
cschladetsch
Message:

added monotonic::stack<>

Location:
sandbox/monotonic
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • sandbox/monotonic/boost/monotonic/fixed_storage.hpp

    r54318 r54723  
    143143                        }
    144144#endif
     145                        //-----------------------------------------------------------------
     146
     147
     148                        template <class Ty>
     149                        Ty *uninitialised_create()
     150                        {
     151                                return reinterpret_cast<Ty *>(allocate_bytes<sizeof(Ty)>());
     152                        }
     153
     154                        template <class Ty>
     155                        void construct(Ty *ptr, const boost::true_type& /*is_pod*/)
     156                        {
     157                                // do nothing
     158                        }
     159
     160                        template <class Ty>
     161                        void construct(Ty *ptr, const boost::false_type&)
     162                        {
     163                                new (ptr) Ty();
     164                        }
     165
     166                        template <class Ty>
     167                        Ty &create()
     168                        {
     169                                Ty *ptr = uninitialised_create<Ty>();
     170                                construct(ptr, boost::is_pod<Ty>());
     171                                return *ptr;
     172                        }
     173
     174                        template <class Ty, class A0>
     175                        Ty &create(A0 a0)
     176                        {
     177                                Ty *ptr = uninitialised_create<Ty>();
     178                                new (ptr) Ty(a0);
     179                                return *ptr;
     180                        }
     181
     182                        template <class Ty, class A0, class A1>
     183                        Ty &create(A0 a0, A1 a1)
     184                        {
     185                                Ty *ptr = uninitialised_create<Ty>();
     186                                new (ptr) Ty(a0, a1);
     187                                return *ptr;
     188                        }
     189
     190                        template <class Ty>
     191                        void destroy(Ty &object)
     192                        {
     193                                object.~Ty();
     194                        }
     195
     196                        template <class Ty>
     197                        void destroy(Ty const &object)
     198                        {
     199                                destroy(const_cast<Ty &>(object));
     200                        }
     201
     202                        template <size_t N>
     203                        char *allocate_bytes()
     204                        {
     205                                return allocate_bytes(N, boost::aligned_storage<N>::alignment);
     206                        }
     207
     208                        char *allocate_bytes(size_t num_bytes, size_t alignment = 1)
     209                        {
     210                                return reinterpret_cast<char *>(allocate(num_bytes, alignment));
     211                        }
     212
    145213                };
    146214       
  • sandbox/monotonic/boost/monotonic/storage.hpp

    r54318 r54723  
    187187
    188188                        template <class Ty>
     189                        void construct(Ty *ptr, const boost::true_type& /*is_pod*/)
     190                        {
     191                                // do nothing
     192                        }
     193
     194                        template <class Ty>
     195                        void construct(Ty *ptr, const boost::false_type&)
     196                        {
     197                                new (ptr) Ty();
     198                        }
     199
     200                        template <class Ty>
    189201                        Ty &create()
    190202                        {
     
    194206                        }
    195207
    196                         template <class Ty>
    197                         void construct(Ty *ptr, const boost::true_type& /*is_pod*/)
    198                         {
    199                                 // do nothing
    200                         }
    201 
    202                         template <class Ty>
    203                         void construct(Ty *ptr, const boost::false_type&)
    204                         {
    205                                 new (ptr) Ty();
    206                         }
    207 
    208                         template <class Ty>
    209                         Ty &create(Ty const &X)
     208                        template <class Ty, class A0>
     209                        Ty &create(A0 a0)
    210210                        {
    211211                                Ty *ptr = uninitialised_create<Ty>();
    212                                 new (ptr) Ty(X);
     212                                new (ptr) Ty(a0);
     213                                return *ptr;
     214                        }
     215
     216                        template <class Ty, class A0, class A1>
     217                        Ty &create(A0 a0, A1 a1)
     218                        {
     219                                Ty *ptr = uninitialised_create<Ty>();
     220                                new (ptr) Ty(a0, a1);
    213221                                return *ptr;
    214222                        }
     
    237245                        }
    238246
     247                        size_t get_cursor() const
     248                        {
     249                                return fixed.get_cursor();
     250                        }
     251                        void set_cursor(size_t n)
     252                        {
     253                                fixed.set_cursor(n);
     254                        }
     255
    239256                private:
    240257                        void AddLink(size_t size)
  • sandbox/monotonic/libs/monotonic/test/Tests/Tests.vcproj

    r54546 r54723  
    175175                        />
    176176                </Configuration>
     177                <Configuration
     178                        Name="ReleaseSym|Win32"
     179                        OutputDirectory="$(SolutionDir)$(ConfigurationName)"
     180                        IntermediateDirectory="$(ConfigurationName)"
     181                        ConfigurationType="1"
     182                        CharacterSet="1"
     183                        >
     184                        <Tool
     185                                Name="VCPreBuildEventTool"
     186                        />
     187                        <Tool
     188                                Name="VCCustomBuildTool"
     189                        />
     190                        <Tool
     191                                Name="VCXMLDataGeneratorTool"
     192                        />
     193                        <Tool
     194                                Name="VCWebServiceProxyGeneratorTool"
     195                        />
     196                        <Tool
     197                                Name="VCMIDLTool"
     198                        />
     199                        <Tool
     200                                Name="VCCLCompilerTool"
     201                                Optimization="3"
     202                                AdditionalIncludeDirectories="$(ProjectDir)/../../../..;C:\Lib\tbb21_20080605oss\include;c:/source/boost/sandbox/cloneable;"
     203                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
     204                                MinimalRebuild="true"
     205                                BasicRuntimeChecks="0"
     206                                RuntimeLibrary="3"
     207                                UsePrecompiledHeader="0"
     208                                WarningLevel="3"
     209                                DebugInformationFormat="3"
     210                        />
     211                        <Tool
     212                                Name="VCManagedResourceCompilerTool"
     213                        />
     214                        <Tool
     215                                Name="VCResourceCompilerTool"
     216                        />
     217                        <Tool
     218                                Name="VCPreLinkEventTool"
     219                        />
     220                        <Tool
     221                                Name="VCLinkerTool"
     222                                LinkIncremental="2"
     223                                AdditionalLibraryDirectories="C:\Program Files\boost\boost_1_38\lib"
     224                                GenerateDebugInformation="true"
     225                                SubSystem="1"
     226                                TargetMachine="1"
     227                        />
     228                        <Tool
     229                                Name="VCALinkTool"
     230                        />
     231                        <Tool
     232                                Name="VCManifestTool"
     233                        />
     234                        <Tool
     235                                Name="VCXDCMakeTool"
     236                        />
     237                        <Tool
     238                                Name="VCBscMakeTool"
     239                        />
     240                        <Tool
     241                                Name="VCFxCopTool"
     242                        />
     243                        <Tool
     244                                Name="VCAppVerifierTool"
     245                        />
     246                        <Tool
     247                                Name="VCPostBuildEventTool"
     248                                Description="Running tests"
     249                                CommandLine="$(OutDir)\$(ProjectName).exe"
     250                                ExcludedFromBuild="true"
     251                        />
     252                </Configuration>
    177253        </Configurations>
    178254        <References>
  • sandbox/monotonic/libs/monotonic/test/Tests/tests.cpp

    r54427 r54723  
    2121#include <boost/interprocess/containers/list.hpp>
    2222#include <boost/monotonic/reclaimable_storage.hpp>
     23#include <boost/monotonic/stack.hpp>
    2324#include <boost/iterator.hpp>
    2425
     
    6263{
    6364        static int count;
     65        Tracked()
     66        {
     67                ++count;
     68                std::cout << "T::T(): " << count << endl;
     69        }
    6470        Tracked(Tracked const &)
    6571        {
    6672                ++count;
    67         }
    68         Tracked()
    69         {
     73                std::cout << "T::T(T const &): " << count << endl;
     74        }
     75        Tracked &operator=(Tracked const &)
     76        {
    7077                ++count;
    71         }
    72         Tracked &operator=(Tracked const &)
    73         {
    74                 ++count;
     78                std::cout << "T &operator=(T const &): " << count << endl;
    7579                return *this;
    7680        }
     
    7882        {
    7983                --count;
     84                std::cout << "T::~T(): " << count << endl;
    8085        }
    8186};
    8287
    8388int Tracked::count = 0;
     89
     90BOOST_AUTO_TEST_CASE(test_stack)
     91{
     92        monotonic::stack<> stack;
     93        {
     94                size_t top = stack.top();
     95                int &n = stack.push<int>();
     96                stack.pop();
     97                size_t top2 = stack.top();
     98                BOOST_ASSERT(top2 == top);
     99
     100                int &n2 = stack.push<int>();
     101                int &n3 = stack.push<int>();
     102                Tracked &tracked = stack.push<Tracked>();
     103                boost::array<int, 42> &a = stack.push<boost::array<int, 42> >();
     104                size_t peak = stack.top();
     105                stack.pop();
     106                stack.pop();
     107                stack.pop();
     108                stack.pop();
     109                top2 = stack.top();
     110                BOOST_ASSERT(top2 == top);
     111                BOOST_ASSERT(Tracked::count == 0);
     112        }
     113}
    84114
    85115template <class Number>
  • sandbox/monotonic/libs/monotonic/test/monotonic.sln

    r54606 r54723  
    2222                {5688980A-015B-4C7D-8D8D-F5894205FACE}.Release|Win32.Build.0 = Release|Win32
    2323                {5688980A-015B-4C7D-8D8D-F5894205FACE}.ReleaseSym|Win32.ActiveCfg = ReleaseSym|Win32
    24                 {5688980A-015B-4C7D-8D8D-F5894205FACE}.ReleaseSym|Win32.Build.0 = ReleaseSym|Win32
    2524                {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.Debug|Win32.ActiveCfg = Debug|Win32
    2625                {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.Debug|Win32.Build.0 = Debug|Win32
    2726                {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.Release|Win32.ActiveCfg = Release|Win32
    28                 {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.ReleaseSym|Win32.ActiveCfg = Release|Win32
    29                 {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.ReleaseSym|Win32.Build.0 = Release|Win32
     27                {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.ReleaseSym|Win32.ActiveCfg = ReleaseSym|Win32
     28                {D4779B0F-266B-46D3-8BCF-0E14EF8B817B}.ReleaseSym|Win32.Build.0 = ReleaseSym|Win32
    3029                {E557E90C-C695-4A7B-B5A6-2F133AF88563}.Debug|Win32.ActiveCfg = Debug|Win32
    3130                {E557E90C-C695-4A7B-B5A6-2F133AF88563}.Debug|Win32.Build.0 = Debug|Win32
     
    3332                {E557E90C-C695-4A7B-B5A6-2F133AF88563}.Release|Win32.Build.0 = Release|Win32
    3433                {E557E90C-C695-4A7B-B5A6-2F133AF88563}.ReleaseSym|Win32.ActiveCfg = ReleaseSym|Win32
    35                 {E557E90C-C695-4A7B-B5A6-2F133AF88563}.ReleaseSym|Win32.Build.0 = ReleaseSym|Win32
    3634                {5FF650E3-53E2-447F-8D2D-A85B76B214D3}.Debug|Win32.ActiveCfg = Debug|Win32
    3735                {5FF650E3-53E2-447F-8D2D-A85B76B214D3}.Debug|Win32.Build.0 = Debug|Win32
  • sandbox/monotonic/libs/monotonic/test/monotonic.vcproj

    r54597 r54723  
    308308                                </File>
    309309                                <File
     310                                        RelativePath="..\..\..\boost\monotonic\stack.hpp"
     311                                        >
     312                                </File>
     313                                <File
    310314                                        RelativePath="..\..\..\boost\monotonic\static_storage.hpp"
    311315                                        >
Note: See TracChangeset for help on using the changeset viewer.