wiselib.testing/util/pstl/string_dynamic.h

Go to the documentation of this file.

#ifndef STRING_DYNAMIC_H
#define STRING_DYNAMIC_H

namespace wiselib {
   
   template<
      typename OsModel_P,
      typename Allocator_P
   >
   class string_dynamic {
      public:
         typedef OsModel_P OsModel;
         typedef typename OsModel_P::size_t size_t;
         typedef Allocator_P Allocator;
         
         typedef string_dynamic<OsModel_P, Allocator_P> self_type;
         typedef self_type* self_pointer_t;
         typedef typename Allocator::template Ref<char>::pointer_t char_pointer_t;
         
         string_dynamic() : buffer_(0), size_(0), allocator_(0) {
         }
         
         string_dynamic(Allocator& alloc) : buffer_(0), size_(0), allocator_(&alloc) {
         }
         
         string_dynamic(const char* c, Allocator& alloc) : buffer_(0), size_(0), allocator_(&alloc) {
            resize(strlen(c));
            to_buffer_(c, strlen(c));
         }
         
         string_dynamic(const string_dynamic& other) : buffer_(0), size_(0), allocator_(other.allocator_) {
            resize(other.size_);
            to_buffer_(other.buffer_, size_);
         }
         
         string_dynamic& operator=(const string_dynamic& other) {
            if(!allocator_) {
               allocator_ = other.allocator_;
            }
            resize(other.size_);
            to_buffer_(other.buffer_, size_);
            return *this;
         }
         
         string_dynamic& operator=(const char* other) {
            resize(strlen(other));
            to_buffer_(other, size_);
            return *this;
         }
         
         ~string_dynamic() {
            if(buffer_) {
               allocator_->template free_array<char>(buffer_);
               buffer_ = 0;
               size_ = 0;
            }
         }
         
         
         size_t size() const {
            return size_;
         }
         
         void resize(size_t n, char c = '\0') {
            if(n == size_) { return; }
            size_ = n;
            
            if(buffer_) { allocator_->template free_array<char>(buffer_); }
            buffer_ = allocator_->template allocate_array<char>(size_ + 1);
         }
         
         const char* c_str() {
            buffer_[size_] = '\0';
            return buffer_.raw();
         }
         
         bool operator==(const string_dynamic& other) {
            if(size_ != other.size_) { return false; }
            for(size_t i=0; i<size_; i++) {
               if(buffer_[i] != other.buffer_[i]) {
                  return false;
               }
            }
            return true;
         }
         bool operator!=(const string_dynamic& other) { return !(*this == other); }
         
         string_dynamic& append(const char* other) {
            return append(string_dynamic(other, *allocator_));
         }
         
         string_dynamic& append(const string_dynamic& other) {
            char_pointer_t old_buffer = buffer_;
            buffer_ = allocator_->template allocate_array<char>(size_ + other.size_ + 1);
            
            if(old_buffer) {
               to_buffer_(old_buffer, size_);
            }
            to_buffer_(other.buffer_, other.size_, size_);
            
            size_ = size_ + other.size_;
            if(old_buffer) {
               allocator_->template free_array<char>(old_buffer);
            }
            
            return *this;
         }
         
      private:
         template<typename T>
         void to_buffer_(T src, size_t n, size_t offset = 0) {
            char* ptr = buffer_.raw() + offset;
            for(size_t i=0; i<n; i++) {
               *ptr = *src;
               ++ptr; ++src;
            }
         }
         
         char_pointer_t buffer_;
         size_t size_;
         typename Allocator::self_pointer_t allocator_;
   };
   
   template<
      typename String_P,
      typename Allocator_P
   >
   class string_creator {
      public:
         typedef String_P String;
         typedef Allocator_P Allocator;
         
         string_creator(Allocator& alloc) : allocator_(alloc) {
         }
         
         String operator()(const char* s) {
            return String(s, allocator_);
         }
         
      private:
         Allocator& allocator_;
   };
   
} // ns

#endif // STRING_DYNAMIC_H