bool setResponse::content_type(const char* str) {
	const char* mime = http::matchMime::getInstance().find_ext_name_mime(str);
	setResponse::str_.format("Content-Type: %s\r\n", mime);
	return true;
}
bool setResponse::content_encode() {
	setResponse::str_.append("Content-Encoding: deflate\r\n");
	return true;
}
bool setResponse::content_length(size_t len) {
	setResponse::str_.format("Content-Length: %ld\r\n", len);
	return true;
}
void setResponse::cache_control() {
	setResponse::str_.append("Cache-Control: no-cache\r\n");
}
bool setResponse::transfer_encoding() {
	setResponse::str_.append("Transfer-Encoding: chunked\r\n");
	return true;
}

/*
 * string_cc.h
 *
 *  Created on: Sep 30, 2013
 *      Author: root
 */

#ifndef STRING_CC_H_
#define STRING_CC_H_

#include "base_config.h"

#define min(a,b) ((a)<(b))?(a):(b)

namespace base {
std::string splitFileName(const std::string& str);
std::string splitFilePath(const std::string& str);
class string_cc {
public:
	string_cc();
	string_cc(const char* in);
	string_cc(const string_cc& in);
	~string_cc();
	string_cc& operator=(const string_cc& rhs);
	string_cc operator+(const string_cc& lhs);
	string_cc& operator+=(const string_cc& lhs);
	char& operator[](size_t n);
	void print() const;
	void append(char* str);
	void append(const char* str);
	void format(const char* format, ...);
	size_t getLength() const;
	const char* getBytes() const;
	void clear();
private:
	char *data;
};
}

#endif /* STRING_CC_H_ */

/*
 * string_cc.cc
 *
 *  Created on: Sep 30, 2013
 *      Author: root
 */

#include "string_cc.h"
#include "leakdbg_malloc-inl.h"
#include "leakdbg_debug_new.h"

namespace base {
std::string splitFileName(const std::string& str) {
	size_t found  = str.find_last_of("/\\");
	return str.substr(found + 1);
}

std::string splitFilePath(const std::string& str) {
	size_t found = str.find_last_of("/\\");
	return str.substr(0, found);
}
string_cc::string_cc() :
	data(0) {
	data = (char*) leakdbg_malloc(1);
	data[0] = '\0';
}

string_cc::string_cc(const char* in) :
	data(0) {
	data = (char*) leakdbg_malloc(std::strlen(in) + 1);
	std::strcpy(data, in);
}

string_cc::string_cc(const string_cc& in) :
	data(0) {
	data = (char*) leakdbg_malloc(in.getLength() + 1);
	std::strcpy(data, in.data);
}

string_cc::~string_cc() {
	leakdbg_delete(data);
}

string_cc& string_cc::operator=(const string_cc& rhs) {
	if (&rhs != this) {
		leakdbg_delete(data);
		data = (char*) leakdbg_malloc(rhs.getLength() + 1);
		std::strcpy(data, rhs.data);
	}
	return *this;
}

string_cc string_cc::operator+(const string_cc& lhs) {
	size_t length = (lhs.getLength() + string_cc::getLength() + 1);
	char* newData = (char*) leakdbg_malloc(length);
	memset(newData,0,length);
	std::strcpy(newData, string_cc::getBytes());
	std::strcpy(newData + string_cc::getLength(), lhs.getBytes());
	string_cc newString(newData);
	leakdbg_delete(newData);
	return newString;
}

string_cc& string_cc::operator+=(const string_cc& lhs) {
	*this = string_cc::operator+(lhs);
	return *this;
}

char& string_cc::operator[](size_t n) {
	size_t length = string_cc::getLength();
	if (n > length)
		return data[length - 1];
	else
		return data[n];
}

void string_cc::print() const {
	std::cout << data << std::endl;
}

void string_cc::append(char* str) {
	string_cc k(str);
	string_cc::operator+=(k);
}

void string_cc::append(const char* str) {
	char* str1 = const_cast<char*> (str);
	string_cc::append(str1);
}

void string_cc::format(const char* format, ...) {
	char buffer[kMaxFmtMessage] = { 0 };
	va_list pArg;
	va_start(pArg, format);
	vsnprintf(buffer, kMaxFmtMessage, format, pArg);
	buffer[kMaxFmtMessage - 1] = '\0';
	va_end(pArg);
	string_cc k(buffer);
	string_cc::operator+=(k);
}

size_t string_cc::getLength() const {
	return std::strlen(data);
}

const char* string_cc::getBytes() const {
	return data;
}

void string_cc::clear() {
	int length = string_cc::getLength();
	if (length) {
		memset(data,0,length);
	}
}
}

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课