_impl.h

// Working on it on 2023-11-27 03:34 <3ThomasBorregaardSorensen!!
#pragma once
 
/*
#if !defined(WINDOWS) \
 && !defined(LINUX) \
 && !defined(__APPLE__) \
 && !defined(__ANDROID__) \
 && !defined(FREEBSD) \
 && !defined(OPENBSD)
 
namespace std { enum class align_val_t : std::size_t {}; }
 
#endif
*/
 
 
 
//inline fork_block::fork_block(const memory_base & memory) :
//   fork_block(memory.get_data(), memory.get_size())
//{
//
//}
 
 
#ifndef __cplusplus_winrt
 
 
 
 
#endif // __cplusplus_winrt
 
 
//struct lparam_debug :
//   virtual matter
//{
//
//};
//
//CLASS_DECL_ACME lparam_debug & lparam_debug();
//
 
//template<class TYPE>
//inline void dump_elements(dump_context & dumpcontext, const TYPE* pElements, ::collection::count nCount)
//{
//
//   ENSURE((nCount == 0) || (pElements != nullptr));
//   ASSERT((nCount == 0) ||
//          is_memory_segment_ok(pElements, (size_t)nCount * sizeof(TYPE), false));
//#ifdef WINDOWS
//   &dumpcontext; // not used
//   pElements;  // not used
//   nCount; // not used
//#endif
//   // default does nothing
//
//}
 
 
 
 
//namespace acme
//{
//
//
//   template < class APP >
//   ::pointer<::platform::application>single_application_library < APP > ::get_new_application(::particle * pparticle, const ::scoped_string & scopedstrAppId)
//   {
//
//      if(!contains_app(scopedstrAppId))
//      {
//
//         return error_not_found;
//
//      }
//
//      auto pappNew = allocateø APP();
//
//      if(pappNew == nullptr)
//      {
//
//         return error_no_memory;
//
//      }
//
//      ::pointer<::platform::application>papp;
//
//      papp = pappNew;
//
//      if (!papp)
//      {
//
//         return error_wrong_type;
//
//      }
//
//      auto estatus = papp->initialize(pparticle);
//
//      if (!estatus)
//      {
//
//         return estatus;
//
//      }
//
//      return papp;
//
//   }
//
//
//   template < class APP >
//   void single_application_library < APP > ::get_extension_list(string_array_base & stra)
//   {
//
//      if (m_strFileExt.has_character())
//      {
//
//         stra.add(m_strFileExt);
//
//      }
//
//   }
//
//
//} // namespace acme
 
 
 
 
 
 
 
template < typename T >
const_char_pointer memory_counter_id(T * pthis)
{
 
   return typeid(*pthis).name();
 
}
 
 
//template < typename T >
//void memory_counter_increment(T * pthis)
//{
//
//   if (memory_counter_on())
//   {
//
//      auto psz = memory_counter_id(pthis);
//
//      _memory_counter_increment(scopedstr);
//
//      //synchronous_lock synchronouslock(g_pmutexMemoryCounters, DEFAULT_SYNCHRONOUS_LOCK_SUFFIX);
//
//      //::i32 i = atoi(file_system()->as_string(path));
//
//      //file_system()->put_contents(path, as_string(i + 1));
//   }
//
//}
//
//
//template < typename T >
//void memory_counter_decrement(T * pthis)
//{
//
//   if (memory_counter_on())
//   {
//
//      auto psz = memory_counter_id(pthis);
//
//      _memory_counter_decrement(scopedstr);
//
//      //::i32 i = atoi(file_system()->as_string(path));
//
//      //file_system()->put_contents(path, as_string(i - 1));
//
//   }
//
//}
 
//
//namespace acme
//{
//
//
//   template < typename T >
//   inline void delobj(T * & p)
//   {
//
//      try
//      {
//
//         if (::is_set(p))
//         {
//
//            T * pdel = p;
//
//            p = nullptr;
//
//            delete pdel;
//
//         }
//
//      }
//      catch (...)
//      {
//
//      }
//
//   }
//
//
//} // namespace acme
//
//
//
//
//template < typename BASE >
//inline ::pointer<BASE>alloc_object(::particle * pparticle)
//{
//
//   return BASE::g_pallocfactory->alloc_object(pparticle);
//
//}
//
//
//template < typename BASE >
//inline ::pointer<BASE>& alloc_object(::pointer<BASE> p, ::particle * pparticle)
//{
//
//   return p = ::alloc_object < BASE > (pparticle);
//
//}
//
//
//
//template < typename TDST, typename TSRC >
//inline ::pointer<TDST>& clone(::pointer<TDST> dst, const ::pointer<TSRC>src)
//{
//
//   if (src.is_null())
//   {
//
//      dst.release();
//
//      return dst;
//
//   }
//
//   return dst = ::pointer_transfer(src->clone());
//
//}
//
//
//template < typename T >
//template < typename T2 >
//inline pointer < T > & pointer < T >::clone(T2 * p)
//{
//
//   if (::is_null(p))
//   {
//
//      release();
//
//      return *this;
//
//   }
//
//   return operator = (p->clone());
//
//}
//
//
//
//
//
//namespace acme
//{
//
//
//   namespace chill
//   {
//
//
//      template < typename TYPE >
//      inline TYPE default_payload()
//      {
//
//         throw ::interface_only("template only exception");
//
//      }
//
//
//   } // namespace chill
//
//
//} // namespace acme
//
//
//
//#ifndef WINDOWS
//
//
//inline ::i64 MulDiv(::i64 nNumber, ::i32 iNum, ::i32 iDen)
//{
//
//   return nNumber * iNum / iDen;
//
//}
//
//#endif
//
//
//#ifndef __cplusplus_winrt
//
//
//template < prototype_integral MULTIPLICATOR, prototype_integral NUMERATOR, prototype_integral DENOMINATOR, prototype_integral RESULT >
//inline RESULT muldiv(MULTIPLICATOR iMultiplicator, NUMERATOR iNumerator, DENOMINATOR iDenominator)
//{
//
//   return iMultiplicator * iNumerator / iDenominator;
//
//}
//
//#endif // __cplusplus_winrt
//
//
 
 
#include "allocator.h"
 
 
//template < typename T, typename ...Args >
//inline T * __call_allocate(Args &&... args)
//{
//
//   auto p = ::platform::allocator::__callnew T (::std::forward < Args >(args)...);
//
//   return p;
//
//}
 
//
//template < typename T >
//inline void __call__delete(T * p)
//{
//
//   ::platform::allocator::__call__delete < T >(p);
//
//}
 
//
//template < typename T >
//inline T * øallocate_array(::collection::count c)
//{
//
//   auto p = ::platform::allocator::new  T[c];
//
//   return p;
//
//}
 
 
//template < typename T >
//inline void __delete(T * p)
//{
//
//   ::platform::allocator::__delete < T >(p);
//
//}
 
//template < typename T >
//inline void __delete(T* p, void * pAllocation)
//{
//
//   ::platform::allocator::__delete < T >(p, pAllocation);
//
//}