C++ CharString::getSize方法代码示例

// if connected, send out a message
// returns false if not connected or error.
// auto-splits large messages larger than buffer.
bool SockClient::sendc(CharString message){
    CharString emsg = (encryptor!=0x0) ? encryptor(message) : message; // Apply encryption
    if(emsg.getSize() <= 2) return false;
    //cout << "Send message(" << emsg.getSize() << ")" << emsg.get() << endl;
    cout << "Send message(" << emsg.getSize() << ")"<< endl;

    int flags=0;
    int looptimes=1;
    int i, msgret, msgsize;
    char* msg;
#ifdef LINUXXX
     if(!testAlive()){
         // uh...
         return false;
     }
    
    if(ctype == SC_TCP){
        //msgret = send(sockd, message.get(), message.getSize(), flags);
        //cout << "Pre-write SC_TCP " << emsg.getSize() << endl;
        if(testAlive())
            msgret = write(sockd, emsg.get(), emsg.getSize());
        //cout << "post-write" << endl;
    }else{
        socklen_t addrlen = sizeof(struct sockaddr_in);
        //msgret = sendto(sockd, emsg.get(), emsg.getSize(), &cli_addr, address);
    }
    // detect error
    if(msgret == -1) return false;
#endif
    return true;
}

/* Returns the name of the end point.
*  Input: String location
*  Output: Very ending of string after last "/"
 */
CharString FileSystem::getNameFromString(CharString location) {
    // gets the name of the last "/dir/dir2/name", even if it ends with "/".
    if(location.get()[location.getSize()-1] == '/') {
        // remove trailing "/".
        location.get()[location.getSize()-1] = '\0';
        location.setSize(location.getSize()-1);
    }

    CharString result = CharString("");
    // split all by "/".
    if(location.contains("/")) {
        // get the very last result of the split.
        LinkedList<CharString>* sresult = location.split('/','`');
        result = *sresult->get(sresult->size()-1);
    } else {
        result = location;
    }

    return result;
}

void Logger::processLog(CharString data){
    if(console){
        cout << data;// << endl;
        cout.flush();
    }
    
    // push data to file
    if(file.is_open()){
        file.write(data.get(), data.getSize());
        file.write((char*)"\n", 1);
    }
}

void _msgClientHandler(CharString dataIn, CharString &dataOut, SockClient* client, void* instance){
    // handle packets. First 2 bytes on the packet are the channel to use.
    MSGServer *serv = (MSGServer*)instance;

    if(dataIn.getSize() > 2){
        
        // loop through and manage clients
        MSGClient* cli = serv->getMSGClient(client);
        
        if(cli != 0x0){
            _msgClientHandler_ANY_recv(serv, cli, dataIn, dataOut);
        
            //PacketChannel* channelx = cli->getChannel(channel);
            //channelx->addRecvPacketData(new CharString(dataIn.get(), dataIn.getSize()));
            //serv->handler (cli, channelx);
        }
    }
}

// LinkedList<LinkedList<CharString>> lines = SimpleParseFile(file, '\n');
void APIMod::loadProperties(){ // , CharString name, CharString language, CharString version
    if(propertiesloaded) return;

    LinkedList<LinkedList<CharString>> lines = SimpleParseString(getModFileData("mod.properties"), '=');

    CharString depvers = "";
    LinkedListIterator<LinkedList<CharString>> lineit = lines.getIterator();
    while(lineit.hasNext()){
        LinkedList<CharString> p = lineit.next();
        CharString pname = p[0];
        if(pname.compare(CharString("name")))
            this->name = p[1];
        else if(pname.compare(CharString("unixname")))
            this->unixname = p[1];
        else if(pname.compare(CharString("language"))) // c++, java, etc.
            this->language = p[1];
        else if(pname.compare(CharString("version"))){
            this->versionstr = p[1];
            this->version = APIModVersion(p[1]);
        }else if(pname.compare(CharString("dependency_versions")))
            depvers = p[1];
    }

    this->modcwdloc = unixname; // relative folder location for mod
    
    // load dependency versioning information
    //      this->dependencyversions.add("mod1:v12938");
    if(depvers.getSize() > 3){
        if(depvers.contains(", ")){
            depvers.replace(" ", "");
            LinkedList<CharString> v = depvers.split(",");
            this->dependencyversions.addAll(v);
        }else{
            this->dependencyversions.add(depvers);
        }
    }


    propertiesloaded=true;
}

void SockClient::readhandler(){
    int n;
    const int buflen = bufferSize;
    char buffer[buflen];
    CharString writeto;
    
    Logger::GLOBAL.log("[SockClient]  reading thread started");
    
    while(alive){
        
        n = read(sockd, buffer, buflen);
        if (n < 0){
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
            continue;
        }else if(n==0){
            Logger::GLOBAL.log("[SockClient] disconnected from server");
            if(disconnected != 0x0) disconnected(server, this);
            alive = false;
            return;
        }
        
        // post-clear extra data in packet... (Prevents extra cpu usage, clearer data stream)
        for(int i=n-1;i<buflen;i++) buffer[i] = 0;

        if(_clientHandler != 0x0 && n > 1) {
            //CharString d = (server->decryptor!=0x0) ? server->decryptor(CharString(buffer,n)) : CharString(buffer,n); // decrypt
            CharString d = CharString(buffer,n); // decrypt
            _clientHandler(d, writeto, this, exVAL);

            if(writeto.getSize() > 0){
                // segment packet if it is too large.
                sendc(writeto); // encryption in-client
            }
        }
    }
    
    Logger::GLOBAL.log("[SockClient] reading thread ended");
    alive = false;
}

// Handle basic client stuff
void ClientHandler_(SockClient* tclient) {
    // Talk with the client, pre-load into a buffer
    int n;
    char buffer[BUFFER_SIZEX];

    while(tclient->alive) {
#if __linux__ || __unix__


        n = read(tclient->sockd, buffer, BUFFER_SIZEX);
        if (n < 0) error("ERROR reading from socket");

        CharString* writeto = new CharString(); // writeto is a string that we write to, used by the

        if(tclient->_clientHandler != 0x0) {
            tclient->_clientHandler(new CharString(buffer,BUFFER_SIZEX), writeto);

            n = write(tclient->sockd, writeto->get(), writeto->getSize());
            if (n < 0) error("ERROR writing to socket");
        }
#endif // __linux__
    }
}

/*
 * Desc: Takes in a single line and expresses the line in a math formula to solve it.
 * Input: CharString* Line.
 * Output: (Console) Output of all expressions.
 * */
CharString Eval(CharString Line) {
    //cout << line << endl;
    // get length of line
    int lsize = 0;
    for(int i=0; i<Line.getSize(); i++) {
        if(Line.get()[i] != 0x0) {
            lsize++;
        }
    }
    Line.setSize(lsize);


    // PARSE each section. Format SHOULD be like this:
    // 1 + 2 [number operator number]
    // 1 + 2 * 3 [n o n o n]
    // 1 + 5 * 10^2 [n o n o non]
    // 110/ 98 [no n] (Automatic parse finding)

    // list of operators:
    // () + - / * ^ % < > = <= >= [NOTE that as of this time, parentheses will not be used]

    // Thus, it can be infered that we can break up each system by placing the most important
    //  System (order of operations) on the top of the stack and placing the least important
    // +/- at the bottom of the stack...

    // Order of operations:
    //  ^  /  *  +  -  (>= = <= < > [END-CLASS operators])

    // Parse method:
    //  1.) loop-through n times to get full stack.

    NumStack = new Stack(); // NumStack is used to store the initial numbers
    OpStack = new Stack(); // OpStack is used to store the initial operators

    // note that both stacks store information through the same MathOperationNode Type.
    //  This will be solved later when we interlace the operators with the variables.
    char* LineD = Line.get();
    char* NumTemp = new char();
    int NumTempLen = 0;
    MOperator OpTemp = none;
    for(int i=0; i<Line.getSize(); i++) {
        char g = LineD[i];
        MOperator tOp = getOperatorFromChar(g);

        if(isCharNumber(g)) { // is this a number?
            // this is a single digit for NumTemp. Add to it.
            NumTemp[NumTempLen] = g;
            NumTempLen++;

            // dump OpTemp if it is available.
            dumpOp(OpTemp);
            OpTemp = none;
        } else if (tOp != none) {
            if(OpTemp != none) {
                MOperator gox = combineOperators(tOp,OpTemp);
                if(gox != none) OpTemp = gox;
            } else {
                OpTemp = tOp;
            }

            // dump NumTemp if it is available.
            dumpNum(NumTemp,NumTempLen);
            NumTempLen=0;
        } else {
            // dump NumTemp if it is available.
            // dump OpTemp if it is available.
            dumpNum(NumTemp,NumTempLen);
            NumTempLen=0;
            dumpOp(OpTemp);
            OpTemp = none;
        }
    }

    // dump NumTemp if it is available.
    // dump OpTemp if it is available.
    dumpNum(NumTemp,NumTempLen);
    NumTempLen=0;
    dumpOp(OpTemp);
    OpTemp = none;

    while(OpStack->size > 0) {
        int res = doOp();
        //cout << "=" << res << endl;
        NumStack->push(res);
    }
    int c = NumStack->pop();
    if(c == -98) cout << "F";
    else if(c == -99) cout << "T";
    else cout << c;

    return CharString::ConvertFromInt(c);
}