Session of low-level optimization of memory usage in C++ programs with total exposure

#ifndef resultS_H
#define resultS_H


// USAGE SAMPLE:
//typedef std::map<void*,
//                 void*,
//                 std::less<void*>,
//                 utils::factory<
//                                 utils::paged_allocator,    // allocator type
//                                 utils::without_params      // this type cannot use params
//                               >
//                               ::result
//                               <
//                                  std::pair<
//                                              const void*,
//                                              void*
//                                           >
//                               >
//> VoidPtrSet;

namespace utils
{

struct without_params
{
};

template<class ObjectType, class ParamType>
struct standard_allocator
{
    ObjectType * NewChars(size_t count)
    {
       return (ObjectType * )operator new(count);
    }

    ObjectType * New(size_t count)
    {
       return (ObjectType * )operator new(count * sizeof (ObjectType));
    }

    void Delete(void * ptr, size_t)
    {
       operator delete (ptr);
    }
};

template<template<class,class> class AllocatorStrategy, class AllocatorParams>
struct factory
{
    template<class ObjectType>
    class result
    {
        AllocatorStrategy<ObjectType, AllocatorParams> m_core;

    public:
        typedef ObjectType  value_type;

        typedef value_type  * pointer;
        typedef value_type  & reference;
        typedef const value_type * const_pointer;
        typedef const value_type & const_reference;

        typedef size_t    size_type;
        typedef ptrdiff_t difference_type;

        template<class OtherType>
        struct rebind
        {
            typedef result<OtherType> other;
        };

        pointer address(reference value) 
        {
            return (&value);
        }

        const_pointer address(const_reference value) const
        {
            return (&value);
        }

        // the same type
        result()
        {
        }
        
        result(const result<ObjectType>& same)
            : m_core(same.m_core)
        {
        }
        
        result<ObjectType>& operator=(const result<ObjectType>& same)
        {
            m_core = same.m_core;
            return (*this);
        }

        // other type
        template<class OtherType>
        result(const result<OtherType>& other)
            : m_core(*other.GetCore())
        {
        }

        template<class OtherType>
        result<ObjectType>& operator=(const result<OtherType> & other)
        {
            m_core = *other.GetCore();
            return (*this);
        }


        //----------------------------------------------------------
        // for fucking prematurely born childs from stl port team:
        void * _Charalloc(size_type size)
        {
            return m_core.NewChars( size );
        }

        // instead of standard [void deallocate(C * ptr, size_type size)] form
        void deallocate(void * ptr, size_type size)
        {
            m_core.Delete( ptr, size );
        }
        //----------------------------------------------------------

        pointer allocate(size_type count)
        {
            return m_core.New( count );
        }

        pointer allocate(size_type count, const void *)
        {
            return m_core.New( count );
        }

        void construct(pointer ptr, const ObjectType& val)
        {
            new ((void *)ptr) ObjectType(val);
        }

        void destroy(pointer ptr)
        {
            &ptr;
            ptr->~ObjectType();
        }

        size_t max_size() const
        {
            size_t count = (size_t)(-1) / sizeof (ObjectType);
            return (0 < count ? count : 1);
        }

        template<class OtherType>
        inline bool operator==(const result<OtherType>&)
        {
            return true;
        }

        template<class OtherType>
        inline bool operator!=(const result<OtherType>&)
        {
            return false;
        }

        // non standard extension
        typedef AllocatorStrategy<ObjectType, AllocatorParams> core_type;

        AllocatorStrategy<ObjectType, AllocatorParams> * GetCore()
        {
            return &m_core;
        }
        const AllocatorStrategy<ObjectType, AllocatorParams> * GetCore() const
        {
            return &m_core;
        }

    };
};


#define DEFINE_TEMPLATE_CONSTRUCTORS(X)\
    X()\
    {\
    }\
    template<class __otherType>\
    X(const __otherType & )\
    {\
    }\
    template<class __otherType>\
    X & operator = (const __otherType & )\
    {\
        return *this; \
    }
} // utils
#endif