z3-z3-4.12.6.src.util.string_buffer.h Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of z3-turnkey Show documentation
TurnKey artifact for Z3
There is a newer version: 4.13.0.1
/*++
  Copyright (c) 2006 Microsoft Corporation

  Module Name:

  string_buffer.h

  Abstract:

  Simple string buffer

  Author:

  Leonardo de Moura (leonardo) 2006-10-14.

  Revision History:

  --*/
#pragma once

#include
#include
#include
#include "util/util.h"
#include "util/memory_manager.h"

// This string buffer will not use the heap if the data consumes less than INITIAL_SIZE bytes. 
template
class string_buffer {
    char   m_initial_buffer[INITIAL_SIZE];
    char * m_buffer;
    size_t m_pos;
    size_t m_capacity;

    void expand() {
        size_t new_capacity = m_capacity << 1;
        char * new_buffer   = alloc_svect(char, new_capacity);
        memcpy(new_buffer, m_buffer, m_pos);
        if (m_capacity > INITIAL_SIZE) {
            dealloc_svect(m_buffer);
        }
        m_capacity = new_capacity;
        m_buffer   = new_buffer;
    }

public:  
    string_buffer():
        m_buffer(m_initial_buffer),
        m_pos(0),
        m_capacity(INITIAL_SIZE) {
    }

    ~string_buffer() {
        if (m_capacity > INITIAL_SIZE) {
            dealloc_svect(m_buffer);
        }
    }

    void reset() {
        m_pos = 0;
    }

    void append(char c) {
        if (m_pos >= m_capacity) {
            expand();
        }
        m_buffer[m_pos] = c;
        m_pos++;
    }

    void append(const char * str) {
        size_t len       = strlen(str);
        size_t new_pos = m_pos + len;
        while (new_pos > m_capacity) {
            expand();
        }
        memcpy(m_buffer + m_pos, str, len);
        m_pos += len;
    }

    void append(const std::string &str) {
        size_t len     = str.size();
        size_t new_pos = m_pos + len;
        while (new_pos > m_capacity) {
            expand();
        }
        memcpy(m_buffer + m_pos, str.c_str(), len);
        m_pos += len;
    }

    void append(int n) {
        auto str = std::to_string(n);
        append(str.c_str());
    }

    void append(unsigned n) {
        auto str = std::to_string(n);
        append(str.c_str());
    }

    void append(long n) {
        auto str = std::to_string(n);
        append(str.c_str());
    }

    void append(bool b) {
        append(b ? "true" : "false");
    }

    unsigned size() const {
        return m_pos;
    }

    bool empty() const { 
        return m_pos == 0;
    }
    
    const char * c_str() const {
        if (m_pos >= m_capacity) {
            const_cast(this)->expand();
        }
        const_cast(this)->m_buffer[m_pos] = 0;
        return m_buffer;
    }
};


template
inline string_buffer & operator<<(string_buffer & buffer, const char * str) {
    buffer.append(str);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, const std::string &str) {
    buffer.append(str);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, char c) {
    buffer.append(c);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, int i) {
    buffer.append(i);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, unsigned i) {
    buffer.append(i);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, bool b) {
    buffer.append(b);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer, long l) {
    buffer.append(l);
    return buffer;
}

template
inline string_buffer & operator<<(string_buffer & buffer1, const string_buffer & buffer2) {
    buffer1.append(buffer2.c_str());
    return buffer1;
}