amxmodx/public/auto-string.h

/* vim: set ts=2 sw=2 tw=99 et:
 *
 * Copyright (C) 2012 David Anderson
 *
 * This file is part of SourcePawn.
 *
 * SourcePawn is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 * 
 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * SourcePawn. If not, see http://www.gnu.org/licenses/.
 */
#ifndef _include_auto_string_h_
#define _include_auto_string_h_

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <am-string.h>

using namespace ke;

class AutoString
{
  public:
    AutoString() : ptr_(NULL), length_(0)
    {
    }
    AutoString(AutoString &&other)
     : ptr_(other.ptr_),
       length_(other.length_)
    {
      other.ptr_ = nullptr;
      other.length_ = 0;
    }
    AutoString(const char *ptr)
    {
      assign(ptr);
    }
    AutoString(const AString &str)
    {
      assign(str.chars(), str.length());
    }
    AutoString(const char *ptr, size_t len)
    {
      assign(ptr, len);
    }
    AutoString(const AutoString &other)
    {
      assign(other.ptr(), other.length());
    }
    ~AutoString()
    {
      free(ptr_);
    }

    AutoString &operator =(const char *ptr) {
      free(ptr_);
      assign(ptr);
      return *this;
    }
    AutoString &operator =(const AutoString &other) {
      free(ptr_);
      assign(other.ptr(), other.length());
      return *this;
    }
    AutoString &operator =(AutoString &&other) {
      Swap(other.ptr_, ptr_);
      Swap(other.length_, length_);
      return *this;
    }

    AutoString operator +(const AutoString &other) const {
      size_t len = length() + other.length();
      char *buf = (char *)malloc(len + 1);
      memcpy(buf, ptr(), length());
      memcpy(buf + length(), other.ptr(), other.length());
      buf[len] = '\0';

      AutoString r;
      r.ptr_ = buf;
      r.length_ = len;
      return r;
    }

    AutoString operator +(const char *other) const {
      size_t other_length = strlen(other);
      size_t len = length() + other_length;
      char *buf = (char *)malloc(len + 1);
      memcpy(buf, ptr(), length());
      memcpy(buf + length(), other, other_length);
      buf[len] = '\0';

      AutoString r;
      r.ptr_ = buf;
      r.length_ = len;
      return r;
    }

    AutoString operator +(unsigned val) const {
      char buffer[24];
      _snprintf(buffer, sizeof(buffer), "%d", val);
      return *this + buffer;
    }

    size_t length() const {
      return length_;
    }

    bool operator !() const {
      return !length_;
    }

    const char *ptr() const {
      return ptr_ ? ptr_ : "";
    }
    operator const char *() const {
      return ptr();
    }

  private:
    void assign(const char *ptr) {
      if (!ptr) {
        ptr_ = NULL;
        length_ = 0;
        return;
      }
      assign(ptr, strlen(ptr));
    }
    void assign(const char *ptr, size_t length) {
      if (!ptr) {
        ptr_ = NULL;
        length_ = 0;
        return;
      }
      length_ = length;
      ptr_ = (char *)malloc(length_ + 1);
      memcpy(ptr_, ptr, length_);
      ptr_[length_] = '\0';
    }

  private:
    char *ptr_;
    size_t length_;
};

#endif // _include_spcomp_auto_string_h_