Subversion Repositories Kolibri OS

//

// Copyright 2012 Francisco Jerez

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the "Software"),

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

// OTHER DEALINGS IN THE SOFTWARE.

//

#ifndef __CORE_COMPAT_HPP__

#define __CORE_COMPAT_HPP__

#include 

#include 

#include 

#include 

#include 

namespace clover {

   namespace compat {

      // XXX - For cases where we can't rely on STL...  I.e. the

      //       interface between code compiled as C++98 and C++11

      //       source.  Get rid of this as soon as everything can be

      //       compiled as C++11.

      template

      class vector {

      protected:

         static T *

         alloc(int n, const T *q, int m) {

            T *p = reinterpret_cast(std::malloc(n * sizeof(T)));

            for (int i = 0; i < m; ++i)

               new(&p[i]) T(q[i]);

            return p;

         }

         static void

         free(int n, T *p) {

            for (int i = 0; i < n; ++i)

               p[i].~T();

            std::free(p);

         }

      public:

         vector() : p(NULL), n(0) {

         }

         vector(const vector &v) : p(alloc(v.n, v.p, v.n)), n(v.n) {

         }

         vector(T *p, size_t n) : p(alloc(n, p, n)), n(n) {

         }

         template

         vector(const C &v) :

            p(alloc(v.size(), &*v.begin(), v.size())), n(v.size()) {

         }

         ~vector() {

            free(n, p);

         }

         vector &

         operator=(const vector &v) {

            free(n, p);

            p = alloc(v.n, v.p, v.n);

            n = v.n;

            return *this;

         }

         void

         reserve(size_t m) {

            if (n < m) {

               T *q = alloc(m, p, n);

               free(n, p);

               p = q;

               n = m;

            }

         }

         void

         resize(size_t m, T x = T()) {

            size_t n = size();

            reserve(m);

            for (size_t i = n; i < m; ++i)

               new(&p[i]) T(x);

         }

         void

         push_back(const T &x) {

            size_t n = size();

            reserve(n + 1);

            new(&p[n]) T(x);

         }

         size_t

         size() const {

            return n;

         }

         T *

         begin() {

            return p;

         }

         const T *

         begin() const {

            return p;

         }

         T *

         end() {

            return p + n;

         }

         const T *

         end() const {

            return p + n;

         }

         T &

         operator[](int i) {

            return p[i];

         }

         const T &

         operator[](int i) const {

            return p[i];

         }

      private:

         T *p;

         size_t n;

      };

      template

      class vector_ref {

      public:

         vector_ref(T *p, size_t n) : p(p), n(n) {

         }

         template

         vector_ref(C &v) : p(&*v.begin()), n(v.size()) {

         }

         size_t

         size() const {

            return n;

         }

         T *

         begin() {

            return p;

         }

         const T *

         begin() const {

            return p;

         }

         T *

         end() {

            return p + n;

         }

         const T *

         end() const {

            return p + n;

         }

         T &

         operator[](int i) {

            return p[i];

         }

         const T &

         operator[](int i) const {

            return p[i];

         }

      private:

         T *p;

         size_t n;

      };

      class istream {

      public:

         typedef vector_ref buffer_t;

         class error {

         public:

            virtual ~error() {}

         };

         istream(const buffer_t &buf) : buf(buf), offset(0) {}

         void

         read(char *p, size_t n) {

            if (offset + n > buf.size())

               throw error();

            std::memcpy(p, buf.begin() + offset, n);

            offset += n;

         }

      private:

         const buffer_t &buf;

         size_t offset;

      };

      class ostream {

      public:

         typedef vector buffer_t;

         ostream(buffer_t &buf) : buf(buf), offset(buf.size()) {}

         void

         write(const char *p, size_t n) {

            buf.resize(offset + n);

            std::memcpy(buf.begin() + offset, p, n);

            offset += n;

         }

      private:

         buffer_t &buf;

         size_t offset;

      };

      class string : public vector_ref {

      public:

         string(const char *p) : vector_ref(p, std::strlen(p)) {

         }

         template

         string(const C &v) : vector_ref(v) {

         }

         operator std::string() const {

            return std::string(begin(), end());

         }

         const char *

         find(const string &s) const {

            for (size_t i = 0; i + s.size() < size(); ++i) {

               if (!std::memcmp(begin() + i, s.begin(), s.size()))

                  return begin() + i;

            }

            return end();

         }

      };

      template

      bool

      operator==(const vector_ref &a, const vector_ref &b) {

         if (a.size() != b.size())

            return false;

         for (size_t i = 0; i < a.size(); ++i)

            if (a[i] != b[i])

               return false;

         return true;

      }

   }

}

#endif