C++ (Cpp) outArray Examples

Example #1

File: ReverseArray.cpp Project: yangsenit/c_code

void main()
{
	int arr[5]={1,2,3,4,5};
	cout<<"ok?"<<endl;
	outArray(arr,5);
	reverseArray(arr,5);
	outArray(arr,5);
}

Example #2

File: HookPlayerNameHandling.cpp Project: ghost30812/client

static bool CheckForEmoji(const std::string& name)
{
	// convert to codepoints
	std::codecvt_utf8<char32_t> converter;
	std::mbstate_t mb;

	std::vector<uint32_t> outArray(name.size());

	const char* inMid;
	uint32_t* outMid;
	converter.in(mb, &name[0], &name[name.size()], inMid, &outArray[0], &outArray[outArray.size()], outMid);

	outArray.resize(outMid - &outArray[0]);

	// check codepoint array for emoji
	bool containsEmoji = false;

	for (auto i : outArray)
	{
		if (i >= 0x1F300 && i <= 0x1F6FF) 
		{
			containsEmoji = true;
			break;
		}
	}

	return containsEmoji;
}

Example #3

void VoltageReader::run()
{
    cs::SensorData sensorMessage;

    sensorMessage.set_sensor_id((int) SensorIds::Voltage_sensor);
    sensorMessage.set_sensor_desc(VOLTAGE_SENSOR_NAME);
    auto values = sensorMessage.mutable_sensor_values();
    auto voltageData = values->Add();
    auto currentData = values->Add();

    voltageData->set_associated_name(VOLTAGE_PARAM_VOLTAGE);
    voltageData->set_data_type(cs::REAL);
    currentData->set_associated_name(VOLTAGE_PARAM_CURRENT);
    currentData->set_data_type(cs::REAL);

    float prevVoltageData = 0, prevCurrentData = 0;

    auto delayTime = std::chrono::milliseconds(sensorInfo.measurementRate);
    auto t = std::chrono::high_resolution_clock::now();

    while (!stopVariable)
    {
        pc::ADCReader::ADCValue adcValue;
        adcReader.read(adcValue);

        float voltage = adcValue.adcVoltages[voltageChannel] * 
            sensorInfo.voltageScale;
        voltage = (voltage + prevVoltageData) / 2;
        prevVoltageData = voltage;

        float current = (adcValue.adcVoltages[currentChannel] - 
            sensorInfo.currentOffset) / sensorInfo.currentScale;
        current = (current + prevCurrentData) / 2;
        prevCurrentData = current;

        voltageData->set_real_value(voltage);        
        currentData->set_real_value(current);

        int messageSize = sensorMessage.ByteSize();
        std::vector<int8_t> outArray(messageSize);
        sensorMessage.SerializeToArray(&outArray[0], messageSize);

        sendData(outArray);

        std::this_thread::sleep_until(t + delayTime);
        t += delayTime;
    }
}

Example #4

void IMUReader::run()
{
    initSensors();
    
    cs::SensorData sensorMessage;

    sensorMessage.set_sensor_id((int) SensorIds::IMU_sensor);
    sensorMessage.set_sensor_desc(IMU_SENSOR_NAME);
    auto values = sensorMessage.mutable_sensor_values();

    auto gyroData = values->Add();
        
    gyroData->set_associated_name("gyro_data");
    gyroData->set_data_type(cs::COORD_3D);
    auto gyroCoords = gyroData->mutable_coord_value();

    int64_t loopCount = 0;
    GyroState gyroState = { 0 };
    bool calibration = true;
    
    int64_t calibrationDelay = 500;
    AHRSProcessor ahrsProcessor(100);
    
    auto instance = ConfigManager::getInstance();
    if (!instance)
    {
        COMM_EXCEPTION(NullPointerException, "Can't get instance of "
            "configuration manager");
    }
    
    float pitch, roll, yaw;
    QUATERNION offsetQ;
    
    showCalibration(true);
    
    auto delayTime = std::chrono::milliseconds(10);
    auto t = std::chrono::high_resolution_clock::now();
    
#if WRITE_SENSORS_DATA
    std::ofstream stream("raw_data.txt");
#endif

    while (!stopVariable)
    {
        IMUSensorsData sensorsData = { 0 };
        readSensors(sensorsData, gyroState, calibration);
        
        std::this_thread::sleep_until(t + delayTime);
        t += delayTime;
        
#if WRITE_SENSORS_DATA
        stream << sensorsData.rawAccelX << " " << sensorsData.rawAccelY <<
                " " << sensorsData.rawAccelZ << " " << sensorsData.rawGyroX << 
                " " << sensorsData.rawGyroY << " " << sensorsData.rawGyroZ <<
                std::endl;
#endif
        
        if (!calibration)
        {
            ahrsProcessor.updateState(sensorsData, roll, pitch, yaw);

            putCurrentAngles(roll, pitch, yaw);
        }
        else
        {
            IMUSensorsData tmpData = { 0 };
            
            tmpData.rawAccelX = sensorsData.rawAccelX;
            tmpData.rawAccelY = sensorsData.rawAccelY;
            tmpData.rawAccelZ = sensorsData.rawAccelZ;
            
            ahrsProcessor.updateState(tmpData, offsetQ);            
        }
        
        gyroCoords->set_x(roll);
        gyroCoords->set_y(pitch);
        gyroCoords->set_z(yaw);
        
        int messageSize = sensorMessage.ByteSize();
        std::vector<int8_t> outArray(messageSize);
        sensorMessage.SerializeToArray(&outArray[0], messageSize);

        if (!calibration && loopCount % 10 == 0)
        {
            //std::cout << sensorsData.rawCompassX << " " << sensorsData.rawCompassY << " " <<
            //        sensorsData.rawCompassZ << std::endl;
            sendData(outArray);
        }
        
        loopCount++;
        
        if (loopCount == calibrationDelay)
        {
            calibration = false;
            
            gyroState.offsetX /= calibrationDelay;
            gyroState.offsetY /= calibrationDelay;
            gyroState.offsetZ /= calibrationDelay;
            
            ahrsProcessor.setGyroOffsets(gyroState.offsetX, gyroState.offsetY,
                    gyroState.offsetZ);
            ahrsProcessor.setOffsetQuaternion(offsetQ);
            showCalibration(false);
        }
    }

#if WRITE_SENSORS_DATA    
    stream.close();
#endif
}