BVB Source Codes

mars Show mapped_file.cpp Source code

Return Download mars: download mapped_file.cpp Source code - Download mars Source code - Type:.cpp
  1. // (C) Copyright Craig Henderson 2002 'boost/memmap.hpp' from sandbox
  2. // (C) Copyright Jonathan Turkanis 2004.
  3. // (C) Copyright Jonathan Graehl 2004.
  4. // (C) Copyright Jorge Lodos 2008.
  5. // Distributed under the Boost Software License, Version 1.0. (See accompanying
  6. // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
  7.  
  8. // Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp>
  9. // knows that we are building the library (possibly exporting code), rather
  10. // than using it (possibly importing code).
  11. #define BOOST_IOSTREAMS_SOURCE
  12.  
  13. #include <cassert>
  14. #include <boost/iostreams/detail/config/rtl.hpp>
  15. #include <boost/iostreams/detail/config/windows_posix.hpp>
  16. #include <boost/iostreams/detail/file_handle.hpp>
  17. #include <boost/iostreams/detail/system_failure.hpp>
  18. #include <boost/iostreams/device/mapped_file.hpp>
  19. #include <boost/throw_exception.hpp>
  20. #include <boost/detail/no_exceptions_support.hpp>
  21.  
  22.  
  23. #ifdef BOOST_IOSTREAMS_WINDOWS
  24. # define WIN32_LEAN_AND_MEAN  // Exclude rarely-used stuff from Windows headers
  25. # include <windows.h>
  26.  
  27. #if UWP
  28.  
  29. DWORD SetFilePointer(
  30.         _In_ HANDLE hFile,
  31.         _In_ LONG lDistanceToMove,
  32.         _Inout_opt_ PLONG lpDistanceToMoveHigh,
  33.         _In_ DWORD dwMoveMethod
  34.         );
  35.  
  36.  
  37. HANDLE
  38. CreateFileW(
  39.         _In_ LPCWSTR lpFileName,
  40.         _In_ DWORD dwDesiredAccess,
  41.         _In_ DWORD dwShareMode,
  42.         _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  43.         _In_ DWORD dwCreationDisposition,
  44.         _In_ DWORD dwFlagsAndAttributes,//
  45.         _In_opt_ HANDLE hTemplateFile
  46.         );
  47.  
  48.  
  49.  
  50.  
  51. DWORD GetFileSize(
  52.         _In_      HANDLE  hFile,
  53.         _Out_opt_ LPDWORD lpFileSizeHigh
  54.         );
  55.  
  56.  
  57. HANDLE
  58. WINAPI
  59. CreateFileA(
  60.         _In_ LPCSTR lpFileName,
  61.         _In_ DWORD dwDesiredAccess,
  62.         _In_ DWORD dwShareMode,
  63.         _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
  64.         _In_ DWORD dwCreationDisposition,
  65.         _In_ DWORD dwFlagsAndAttributes,
  66.         _In_opt_ HANDLE hTemplateFile
  67.         );
  68.  
  69.  
  70. HANDLE
  71. CreateFileMappingA(
  72.         _In_     HANDLE hFile,
  73.         _In_opt_ LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
  74.         _In_     DWORD flProtect,
  75.         _In_     DWORD dwMaximumSizeHigh,
  76.         _In_     DWORD dwMaximumSizeLow,
  77.         _In_opt_ LPCSTR lpName
  78.         );
  79.  
  80. LPVOID
  81. WINAPI
  82. MapViewOfFileEx(
  83.         _In_ HANDLE hFileMappingObject,
  84.         _In_ DWORD dwDesiredAccess,
  85.         _In_ DWORD dwFileOffsetHigh,
  86.         _In_ DWORD dwFileOffsetLow,
  87.         _In_ SIZE_T dwNumberOfBytesToMap,
  88.         _In_opt_ LPVOID lpBaseAddress
  89.         );
  90.  
  91.  
  92. #endif
  93.  
  94.  
  95. #else
  96. # include <errno.h>
  97. # include <fcntl.h>
  98. # include <sys/mman.h>      // mmap, munmap.
  99. # include <sys/stat.h>
  100. # include <sys/types.h>     // struct stat.
  101. # include <unistd.h>        // sysconf.
  102. #endif
  103.  
  104. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace iostreams {
  105.  
  106. namespace detail {
  107.  
  108. // Class containing the platform-sepecific implementation
  109. // Invariant: The members params_, data_, size_, handle_ (and mapped_handle_
  110. // on Windows) either
  111. //    - all have default values (or INVALID_HANDLE_VALUE for
  112. //      Windows handles), or
  113. //    - all have values reflecting a successful mapping.
  114. // In the first case, error_ may be true, reflecting a recent unsuccessful
  115. // open or close attempt; in the second case, error_ is always false.
  116. class mapped_file_impl {
  117. public:
  118.     typedef mapped_file_source::size_type   size_type;
  119.     typedef mapped_file_source::param_type  param_type;
  120.     typedef mapped_file_source::mapmode     mapmode;
  121.     BOOST_STATIC_CONSTANT(
  122.         size_type, max_length =  mapped_file_source::max_length);
  123.     mapped_file_impl();
  124.     ~mapped_file_impl();
  125.     void open(param_type p);
  126.     bool is_open() const { return (data_ != 0 && handle_ >= 0); }
  127.     void close();
  128.     bool error() const { return error_; }
  129.     mapmode flags() const { return params_.flags; }
  130.     std::size_t size() const { return size_; }
  131.     char* data() const { return data_; }
  132.     void resize(stream_offset new_size);
  133.     static int alignment();
  134. private:
  135.     void open_file(param_type p);
  136.     void try_map_file(param_type p);
  137.     void map_file(param_type& p);
  138.     bool unmap_file();
  139.     void clear(bool error);
  140.     void cleanup_and_throw(const char* msg);
  141.     param_type     params_;
  142.     char*          data_;
  143.     stream_offset  size_;
  144.     file_handle    handle_;
  145. #ifdef BOOST_IOSTREAMS_WINDOWS
  146.     file_handle    mapped_handle_;
  147. #endif
  148.     bool           error_;
  149. };
  150.  
  151. mapped_file_impl::mapped_file_impl() { clear(false); }
  152.  
  153. mapped_file_impl::~mapped_file_impl()
  154. { BOOST_TRY { close(); } BOOST_CATCH (...) { } BOOST_CATCH_END }
  155.  
  156. void mapped_file_impl::open(param_type p)
  157. {
  158.     if (is_open()) {
  159.         mars_boost::throw_exception(BOOST_IOSTREAMS_FAILURE("file already open"));
  160.         return;
  161.     }
  162.     p.normalize();
  163.     open_file(p);
  164.     map_file(p);  // May modify p.hint
  165.     params_ = p;
  166. }
  167.  
  168. void mapped_file_impl::close()
  169. {
  170.     if (data_ == 0)
  171.         return;
  172.     bool error = false;
  173.     error = !unmap_file() || error;
  174.     #ifdef BOOST_IOSTREAMS_WINDOWS
  175.     if(handle_ != INVALID_HANDLE_VALUE)
  176.     #else
  177.     if(handle_ >= 0)
  178.     #endif
  179.     {
  180.         error =
  181.             #ifdef BOOST_IOSTREAMS_WINDOWS
  182.                 !::CloseHandle(handle_)
  183.             #else
  184.                 ::close(handle_) != 0
  185.             #endif
  186.                 || error;
  187.     }
  188.     clear(error);
  189.     if (error)
  190.         throw_system_failure("failed closing mapped file");
  191. }
  192.  
  193. void mapped_file_impl::resize(stream_offset new_size)
  194. {
  195.     if (!is_open()) {
  196.         mars_boost::throw_exception(BOOST_IOSTREAMS_FAILURE("file is closed"));
  197.         return;
  198.     }
  199.     if (flags() & mapped_file::priv) {
  200.         mars_boost::throw_exception(
  201.             BOOST_IOSTREAMS_FAILURE("can't resize private mapped file")
  202.         );
  203.         return;
  204.     }
  205.     if (!(flags() & mapped_file::readwrite)) {
  206.         mars_boost::throw_exception(
  207.             BOOST_IOSTREAMS_FAILURE("can't resize readonly mapped file")
  208.         );
  209.         return;
  210.     }
  211.     if (params_.offset >= new_size) {
  212.         mars_boost::throw_exception(
  213.             BOOST_IOSTREAMS_FAILURE("can't resize below mapped offset")
  214.         );
  215.         return;
  216.     }
  217.     if (!unmap_file()) {
  218.         cleanup_and_throw("failed unmapping file");
  219.         return;
  220.     }
  221. #ifdef BOOST_IOSTREAMS_WINDOWS
  222.     stream_offset offset = ::SetFilePointer(handle_, 0, NULL, FILE_CURRENT);
  223.     if (offset == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR) {
  224.          cleanup_and_throw("failed querying file pointer");
  225.         return;
  226.     }
  227.     LONG sizehigh = (new_size >> (sizeof(LONG) * 8));
  228.     LONG sizelow = (new_size & 0xffffffff);
  229.     DWORD result = ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
  230.     if ((result == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
  231.         || !::SetEndOfFile(handle_)) {
  232.         cleanup_and_throw("failed resizing mapped file");
  233.         return;
  234.     }
  235.     sizehigh = (offset >> (sizeof(LONG) * 8));
  236.     sizelow = (offset & 0xffffffff);
  237.     ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
  238. #else
  239.     if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, new_size) == -1) {
  240.         cleanup_and_throw("failed resizing mapped file");
  241.         return;
  242.     }
  243. #endif
  244.     size_ = new_size;
  245.     param_type p(params_);
  246.     map_file(p);  // May modify p.hint
  247.     params_ = p;
  248. }
  249.  
  250. int mapped_file_impl::alignment()
  251. {
  252. #ifdef BOOST_IOSTREAMS_WINDOWS
  253.     SYSTEM_INFO info;
  254.     ::GetSystemInfo(&info);
  255.     return static_cast<int>(info.dwAllocationGranularity);
  256. #else
  257.     return static_cast<int>(sysconf(_SC_PAGESIZE));
  258. #endif
  259. }
  260.  
  261. void mapped_file_impl::open_file(param_type p)
  262. {
  263.     bool readonly = p.flags != mapped_file::readwrite;
  264. #ifdef BOOST_IOSTREAMS_WINDOWS
  265.  
  266.     // Open file
  267.     DWORD dwDesiredAccess =
  268.         readonly ?
  269.             GENERIC_READ :
  270.             (GENERIC_READ | GENERIC_WRITE);
  271.     DWORD dwCreationDisposition = (p.new_file_size != 0 && !readonly) ?
  272.         CREATE_ALWAYS :
  273.         OPEN_EXISTING;
  274.     DWORD dwFlagsandAttributes =
  275.         readonly ?
  276.             FILE_ATTRIBUTE_READONLY :
  277.             FILE_ATTRIBUTE_TEMPORARY;
  278.     handle_ = p.path.is_wide() ?
  279.         ::CreateFileW(
  280.             p.path.c_wstr(),
  281.             dwDesiredAccess,
  282.             FILE_SHARE_READ,
  283.             NULL,
  284.             dwCreationDisposition,
  285.             dwFlagsandAttributes,
  286.             NULL ) :
  287.         ::CreateFileA(
  288.             p.path.c_str(),
  289.             dwDesiredAccess,
  290.             FILE_SHARE_READ,
  291.             NULL,
  292.             dwCreationDisposition,
  293.             dwFlagsandAttributes,
  294.             NULL );
  295.     if (handle_ == INVALID_HANDLE_VALUE) {
  296.         cleanup_and_throw("failed opening file");
  297.         return;
  298.     }
  299.  
  300.     // Set file size
  301.     if (p.new_file_size != 0 && !readonly) {
  302.         LONG sizehigh = (p.new_file_size >> (sizeof(LONG) * 8));
  303.         LONG sizelow = (p.new_file_size & 0xffffffff);
  304.         DWORD result = ::SetFilePointer(handle_, sizelow, &sizehigh, FILE_BEGIN);
  305.         if ((result == INVALID_SET_FILE_POINTER && ::GetLastError() != NO_ERROR)
  306.             || !::SetEndOfFile(handle_)) {
  307.             cleanup_and_throw("failed setting file size");
  308.             return;
  309.         }
  310.     }
  311.  
  312.     // Determine file size. Dynamically locate GetFileSizeEx for compatibility
  313.     // with old Platform SDK (thanks to Pavel Vozenilik).
  314.     typedef BOOL (WINAPI *func)(HANDLE, PLARGE_INTEGER);
  315. #ifdef UWP
  316.         func get_size = &GetFileSizeEx;
  317. #else
  318.     HMODULE hmod = ::GetModuleHandleA("kernel32.dll");
  319.     func get_size =
  320.         reinterpret_cast<func>(::GetProcAddress(hmod, "GetFileSizeEx"));
  321. #endif
  322.     if (get_size) {
  323.         LARGE_INTEGER info;
  324.         if (get_size(handle_, &info)) {
  325.             mars_boost::intmax_t size =
  326.                 ( (static_cast<mars_boost::intmax_t>(info.HighPart) << 32) |
  327.                   info.LowPart );
  328.             size_ =
  329.                 static_cast<std::size_t>(
  330.                     p.length != max_length ?
  331.                         std::min<mars_boost::intmax_t>(p.length, size) :
  332.                         size
  333.                 );
  334.         } else {
  335.             cleanup_and_throw("failed querying file size");
  336.             return;
  337.         }
  338.     } else {
  339.         DWORD hi;
  340.         DWORD low;
  341.         if ( (low = ::GetFileSize(handle_, &hi))
  342.                  !=
  343.              INVALID_FILE_SIZE )
  344.         {
  345.             mars_boost::intmax_t size =
  346.                 (static_cast<mars_boost::intmax_t>(hi) << 32) | low;
  347.             size_ =
  348.                 static_cast<std::size_t>(
  349.                     p.length != max_length ?
  350.                         std::min<mars_boost::intmax_t>(p.length, size) :
  351.                         size
  352.                 );
  353.         } else {
  354.             cleanup_and_throw("failed querying file size");
  355.             return;
  356.         }
  357.     }
  358. #else // #ifdef BOOST_IOSTREAMS_WINDOWS
  359.  
  360.     // Open file
  361.     int flags = (readonly ? O_RDONLY : O_RDWR);
  362.     if (p.new_file_size != 0 && !readonly)
  363.         flags |= (O_CREAT | O_TRUNC);
  364.     #ifdef _LARGEFILE64_SOURCE
  365.         flags |= O_LARGEFILE;
  366.     #endif
  367.     errno = 0;
  368.     handle_ = ::open(p.path.c_str(), flags, S_IRWXU);
  369.     if (errno != 0) {
  370.         cleanup_and_throw("failed opening file");
  371.         return;
  372.     }
  373.  
  374.     //--------------Set file size---------------------------------------------//
  375.  
  376.     if (p.new_file_size != 0 && !readonly)
  377.         if (BOOST_IOSTREAMS_FD_TRUNCATE(handle_, p.new_file_size) == -1) {
  378.             cleanup_and_throw("failed setting file size");
  379.             return;
  380.         }
  381.  
  382.     //--------------Determine file size---------------------------------------//
  383.  
  384.     bool success = true;
  385.     if (p.length != max_length) {
  386.         size_ = p.length;
  387.     } else {
  388.         struct BOOST_IOSTREAMS_FD_STAT info;
  389.         success = ::BOOST_IOSTREAMS_FD_FSTAT(handle_, &info) != -1;
  390.         size_ = info.st_size;
  391.     }
  392.     if (!success) {
  393.         cleanup_and_throw("failed querying file size");
  394.         return;
  395.     }
  396. #endif // #ifdef BOOST_IOSTREAMS_WINDOWS
  397. }
  398.  
  399. void mapped_file_impl::try_map_file(param_type p)
  400. {
  401.     bool priv = p.flags == mapped_file::priv;
  402.     bool readonly = p.flags == mapped_file::readonly;
  403. #ifdef BOOST_IOSTREAMS_WINDOWS
  404.  
  405.     // Create mapping
  406.     DWORD protect = priv ?
  407.         PAGE_WRITECOPY :
  408.         readonly ?
  409.             PAGE_READONLY :
  410.             PAGE_READWRITE;
  411.     mapped_handle_ =
  412.         ::CreateFileMappingA(
  413.             handle_,
  414.             NULL,
  415.             protect,
  416.             0,
  417.             0,
  418.             NULL );
  419.     if (mapped_handle_ == NULL)
  420.         cleanup_and_throw("failed create mapping");
  421.  
  422.     // Access data
  423.     DWORD access = priv ?
  424.         FILE_MAP_COPY :
  425.         readonly ?
  426.             FILE_MAP_READ :
  427.             FILE_MAP_WRITE;
  428.     void* data =
  429.         ::MapViewOfFileEx(
  430.             mapped_handle_,
  431.             access,
  432.             (DWORD) (p.offset >> 32),
  433.             (DWORD) (p.offset & 0xffffffff),
  434.             size_ != max_length ? size_ : 0,
  435.             (LPVOID) p.hint );
  436.     if (!data) {
  437.         cleanup_and_throw("failed mapping view");
  438.         return;
  439.     }
  440. #else
  441.     void* data =
  442.         ::BOOST_IOSTREAMS_FD_MMAP(
  443.             const_cast<char*>(p.hint),
  444.             size_,
  445.             readonly ? PROT_READ : (PROT_READ | PROT_WRITE),
  446.             priv ? MAP_PRIVATE : MAP_SHARED,
  447.             handle_,
  448.             p.offset );
  449.     if (data == MAP_FAILED) {
  450.         cleanup_and_throw("failed mapping file");
  451.         return;
  452.     }
  453. #endif
  454.     data_ = static_cast<char*>(data);
  455. }
  456.  
  457. void mapped_file_impl::map_file(param_type& p)
  458. {
  459.     BOOST_TRY {
  460.         try_map_file(p);
  461.     } BOOST_CATCH (const std::exception&) {
  462.         if (p.hint) {
  463.             p.hint = 0;
  464.             try_map_file(p);
  465.         } else {
  466.             BOOST_RETHROW;
  467.         }
  468.     }
  469.     BOOST_CATCH_END
  470. }
  471.  
  472. bool mapped_file_impl::unmap_file()
  473. {
  474. #ifdef BOOST_IOSTREAMS_WINDOWS
  475.     bool error = false;
  476.     error = !::UnmapViewOfFile(data_) || error;
  477.     error = !::CloseHandle(mapped_handle_) || error;
  478.     mapped_handle_ = NULL;
  479.     return !error;
  480. #else
  481.     return ::munmap(data_, size_) == 0;
  482. #endif
  483. }
  484.  
  485. void mapped_file_impl::clear(bool error)
  486. {
  487.     params_ = param_type();
  488.     data_ = 0;
  489.     size_ = 0;
  490. #ifdef BOOST_IOSTREAMS_WINDOWS
  491.     handle_ = INVALID_HANDLE_VALUE;
  492.     mapped_handle_ = NULL;
  493. #else
  494.     handle_ = -1;
  495. #endif
  496.     error_ = error;
  497. }
  498.  
  499. // Called when an error is encountered during the execution of open_file or
  500. // map_file
  501. void mapped_file_impl::cleanup_and_throw(const char* msg)
  502. {
  503. #ifdef BOOST_IOSTREAMS_WINDOWS
  504.     DWORD error = GetLastError();
  505.     if (mapped_handle_ != NULL)
  506.         ::CloseHandle(mapped_handle_);
  507.     if (handle_ != INVALID_HANDLE_VALUE)
  508.         ::CloseHandle(handle_);
  509.     SetLastError(error);
  510. #else
  511.     int error = errno;
  512.     if (handle_ >= 0)
  513.         ::close(handle_);
  514.     errno = error;
  515. #endif
  516.     clear(true);
  517.     BOOST_TRY {
  518.         mars_boost::iostreams::detail::throw_system_failure(msg);
  519.     } BOOST_CATCH(...) {
  520.     } BOOST_CATCH_END
  521. }
  522.  
  523. //------------------Implementation of mapped_file_params_base-----------------//
  524.  
  525. void mapped_file_params_base::normalize()
  526. {
  527.     if (mode && flags)
  528.         mars_boost::throw_exception(BOOST_IOSTREAMS_FAILURE(
  529.             "at most one of 'mode' and 'flags' may be specified"
  530.         ));
  531.     if (flags) {
  532.         switch (flags) {
  533.         case mapped_file::readonly:
  534.         case mapped_file::readwrite:
  535.         case mapped_file::priv:
  536.             break;
  537.         default:
  538.             mars_boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags"));
  539.         }
  540.     } else {
  541.         flags = (mode & BOOST_IOS::out) ?
  542.             mapped_file::readwrite :
  543.             mapped_file::readonly;
  544.         mode = BOOST_IOS::openmode();
  545.     }
  546.     if (offset < 0)
  547.         mars_boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid offset"));
  548.     if (new_file_size < 0)
  549.         mars_boost::throw_exception(
  550.             BOOST_IOSTREAMS_FAILURE("invalid new file size")
  551.         );
  552. }
  553.  
  554. } // End namespace detail.
  555.  
  556. //------------------Implementation of mapped_file_source----------------------//
  557.  
  558. mapped_file_source::mapped_file_source()
  559.     : pimpl_(new impl_type)
  560.     { }
  561.  
  562. mapped_file_source::mapped_file_source(const mapped_file_source& other)
  563.     : pimpl_(other.pimpl_)
  564.     { }
  565.  
  566. bool mapped_file_source::is_open() const
  567. { return pimpl_->is_open(); }
  568.  
  569. void mapped_file_source::close() { pimpl_->close(); }
  570.  
  571. // safe_bool is explicitly qualified below to please msvc 7.1
  572. mapped_file_source::operator mapped_file_source::safe_bool() const
  573. { return pimpl_->error() ? &safe_bool_helper::x : 0; }
  574.  
  575. bool mapped_file_source::operator!() const
  576. { return pimpl_->error(); }
  577.  
  578. mapped_file_source::mapmode mapped_file_source::flags() const
  579. { return pimpl_->flags(); }
  580.  
  581. mapped_file_source::size_type mapped_file_source::size() const
  582. { return pimpl_->size(); }
  583.  
  584. const char* mapped_file_source::data() const { return pimpl_->data(); }
  585.  
  586. const char* mapped_file_source::begin() const { return data(); }
  587.  
  588. const char* mapped_file_source::end() const { return data() + size(); }
  589. int mapped_file_source::alignment()
  590. { return detail::mapped_file_impl::alignment(); }
  591.  
  592. void mapped_file_source::init() { pimpl_.reset(new impl_type); }
  593.  
  594. void mapped_file_source::open_impl(const param_type& p)
  595. { pimpl_->open(p); }
  596.  
  597. //------------------Implementation of mapped_file-----------------------------//
  598.  
  599. mapped_file::mapped_file(const mapped_file& other)
  600.     : delegate_(other.delegate_)
  601.     { }
  602.  
  603. void mapped_file::resize(stream_offset new_size)
  604. { delegate_.pimpl_->resize(new_size); }
  605.  
  606. //------------------Implementation of mapped_file_sink------------------------//
  607.  
  608. mapped_file_sink::mapped_file_sink(const mapped_file_sink& other)
  609.     : mapped_file(static_cast<const mapped_file&>(other))
  610.     { }
  611.  
  612. //----------------------------------------------------------------------------//
  613.  
  614. } } // End namespaces iostreams, boost.
  615.  
downloadmapped_file.cpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top