void get_URL(const string &host, const string &path) {
    // Your code here.
    TCPSocket sock{};
    sock.connect(Address(host,"http"));
    string message = "GET " + path + " HTTP/1.1\r\nHOST: " + host + "\r\n\r\n";
    sock.write(message);
    sock.shutdown(SHUT_WR);
    while( !sock.closed() && !sock.eof()){
        //通过 eof 判断是否已经读到了最末尾，若没有则读取继续
        cout << sock.read();
    }
    sock.close();
    return ;

    cerr << "Function called: get_URL(" << host << ", " << path << ").\n";
    cerr << "Warning: get_URL() has not been implemented yet.\n";
}

#ifndef SPONGE_LIBSPONGE_BYTE_STREAM_HH
#define SPONGE_LIBSPONGE_BYTE_STREAM_HH

#include <string>
#include <deque>

//! Bytes are written on the "input" side and read from the "output"
//! side.  The byte stream is finite: the writer can end the input,
//! and then no more bytes can be written.
class ByteStream {
  private:
    // Your code here -- add private members as necessary.
    std::deque <char> Stream = {};
    size_t Capacity = 0;
    size_t written_byte = 0;
    size_t read_byte = 0;
    bool is_end_input = false;
    // Hint: This doesn't need to be a sophisticated data structure at
    // all, but if any of your tests are taking longer than a second,
    // that's a sign that you probably want to keep exploring
    // different approaches.

    bool _error{};  //!< Flag indicating that the stream suffered an error.

  public:
    //这部分不需要编辑，略去

#endif  // SPONGE_LIBSPONGE_BYTE_STREAM_HH

#include "byte_stream.hh"

// Dummy implementation of a flow-controlled in-memory byte stream.

// For Lab 0, please replace with a real implementation that passes the
// automated checks run by `make check_lab0`.

// You will need to add private members to the class declaration in `byte_stream.hh`
using namespace std;

ByteStream::ByteStream(const size_t capacity) : Capacity(capacity) {}

// 向队列中写入data
size_t ByteStream::write(const string &data) {
    size_t write_length = data.length();
    if(write_length > Capacity - Stream.size()){
        //compared with left room
        write_length = Capacity - Stream.size();
    }
    for(size_t i = 0;i < write_length;i++){
        Stream.emplace_back(data[i]);
    }
    written_byte += write_length;
    return write_length;
}

//! \param[in] len bytes will be copied from the output side of the buffer
// 从头部读取 len 长度的字节
string ByteStream::peek_output(const size_t len) const {
    string output_string;
    for(size_t i = 0;i < len && i < Stream.size();i++){
        output_string.push_back(Stream.at(i));
    }
    return output_string;
}

//! \param[in] len bytes will be removed from the output side of the buffer
// 将头部 len 长度字节移除字节流
void ByteStream::pop_output(const size_t len) {
    size_t pop_length = len > Stream.size() ? Stream.size(): len;
    read_byte += pop_length;
    while(pop_length --){
        Stream.pop_front();
    }
}

//! Read (i.e., copy and then pop) the next "len" bytes of the stream
//! \param[in] len bytes will be popped and returned
//! \returns a string
// 读取（相当于peek和pop操作的结合）
std::string ByteStream::read(const size_t len) {
    size_t read_length = len > Stream.size() ? Stream.size() : len;
    string read_string = peek_output(read_length);
    pop_output(read_length);
    return read_string;
}

void ByteStream::end_input() {  is_end_input = true;}

bool ByteStream::input_ended() const { return is_end_input; }

size_t ByteStream::buffer_size() const { return Stream.size(); }

bool ByteStream::buffer_empty() const { return Stream.empty(); }

bool ByteStream::eof() const { return Stream.empty() && is_end_input; }

size_t ByteStream::bytes_written() const { return written_byte ; }

size_t ByteStream::bytes_read() const { return read_byte; }

size_t ByteStream::remaining_capacity() const { return Capacity - Stream.size(); }