ulAssetManager::ulAssetManager(std::string artFilePath)
{
    // Should probably find a better way of doing this bit
    int len = 256;
    char pBuf[len];
    char szTmp[32];
    sprintf(szTmp, "/proc/%d/exe", getpid());
    int bytes = std::min((int)readlink(szTmp, pBuf, len), len - 1);
    if(bytes >= 0)
    {
        pBuf[bytes] = '\0';
    }

    progDir = std::string(pBuf);
    progDir = progDir.substr(0, progDir.length() - 10);

    std::ifstream artFile(progDir + artFilePath);
    if (!artFile.is_open())
    {
        std::cerr<<"Could not open art definition file ("<<progDir + artFilePath<<")"<<std::endl;
    }
    else
    {
        std::string jsonString((std::istreambuf_iterator<char>(artFile)),
                         std::istreambuf_iterator<char>());
        doc.Parse(jsonString.c_str());
        assert(!doc.HasParseError());
    }
}
            void MyPinsFileIO::SaveAllRepositoryPinsToDisk(const std::vector<MyPinModel*>& pinModels)
            {
                if (m_fileIO.Exists(MyPinsDataFilename))
                {
                    m_fileIO.DeleteFile(MyPinsDataFilename);
                }

                rapidjson::Document jsonDoc;
                jsonDoc.SetObject();

                rapidjson::Value pinsArray(rapidjson::kArrayType);
                pinsArray.SetArray();
                rapidjson::Document::AllocatorType& allocator = jsonDoc.GetAllocator();

                jsonDoc.AddMember(MyPinsJsonArrayName.c_str(), pinsArray, allocator);
                rapidjson::Value& myPinsArray = jsonDoc[MyPinsJsonArrayName.c_str()];

                for (std::vector<MyPinModel*>::const_iterator it = pinModels.begin(); it != pinModels.end(); ++it)
                {
                    const MyPinModel* pinModel = *it;
                    const Eegeo::Space::LatLong& latLong = pinModel->GetLatLong();

                    rapidjson::Value pinModelJson;
                    MyPinModelToJson(*pinModel, allocator, m_myPinBoundObjectRepository, pinModelJson);

                    myPinsArray.PushBack(pinModelJson, allocator);
                }

                rapidjson::StringBuffer strbuf;
                rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
                jsonDoc.Accept(writer);

                std::string jsonString(strbuf.GetString());
                m_fileIO.WriteFile((Byte*)jsonString.c_str(), jsonString.size(), MyPinsDataFilename);
            }
Exemple #3
0
void SimpleJsonDB::flush()
{
    qDebug() << "flush for db:" << path << "thread:" << QThread::currentThread();

    // skip flush if delay is -1
    if (maxFlushDelay == -1 || path == ":memory:")
    {
        qDebug() << "skipping flush for:" << jsonString();
        return;
    }

    // stop pending timers
    flushTimer.stop();

    QString dbString = jsonString();

    if (dbString == "{}")
    {
        // db is empty, remove old db file (if it exists)
        QFile file(path);
        file.remove();
    }
    else
    {
        dbString += '\n';

        // save json file with atomic QSaveFile
        QSaveFile file(path);
        if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
        {
            qWarning() << "unable to write to db:" << path;
        }
        else
        {
            QTextStream outStream(&file);
            outStream << dbString;
            file.commit();
        }
#if QT_VERSION >= 0x050500
        qInfo() << "flushed db:" << path;
#endif
    }

    emit flushed();
}
QMap<QString, QVariant> JsonReader::decodeFile(QString filePath)
{
    QFile file;
    file.setFileName(filePath);
    file.open(QIODevice::ReadOnly);
    QByteArray byteArray = file.readAll();
    file.close();
    QString jsonString(byteArray);
    Json json;
    return json.decode(jsonString);    
}
// Reads a file containing json text and stores that in our json variable to go through
// in our forge method
void SceneBuilder::jsonFromFile(std::string fileName)
{
    std::ifstream t(fileName);
    std::string jsonString((std::istreambuf_iterator<char>(t)),std::istreambuf_iterator<char>());
    std::string errorString;
    
    // Deferencing the pointer so we can use the overloaded operator method provided
    // by our json11::Json method
    this->setJson(new json11::Json(json11::Json::parse(jsonString, errorString)));
    std::cout << "Error string: '" << errorString << "'" << std::endl;
};
            void CreateEmptyJsonFile(Eegeo::Helpers::IFileIO& fileIO)
            {
                rapidjson::Document jsonDoc;
                jsonDoc.SetObject();

                rapidjson::Value myArray(rapidjson::kArrayType);

                jsonDoc.AddMember(MyPinsJsonArrayName.c_str(), myArray, jsonDoc.GetAllocator());
                rapidjson::StringBuffer strbuf;
                rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
                jsonDoc.Accept(writer);

                std::string jsonString(strbuf.GetString());
                fileIO.WriteFile((Byte*)jsonString.c_str(), jsonString.size(), MyPinsDataFilename);
            }
void CheckpointService::PIdLsnInfo::writeFile() {
	util::LockGuard<util::Mutex> guard(mutex_);
	std::string lsnInfoFileName;
	util::NamedFile file;
	try {
		picojson::object jsonNodeInfo;
		NodeAddress &address =
			checkpointService_->partitionTable_->getNodeInfo(0)
				.getNodeAddress();
		jsonNodeInfo["address"] = picojson::value(address.toString(false));
		jsonNodeInfo["port"] =
			picojson::value(static_cast<double>(address.port_));

		picojson::object jsonLsnInfo;

		picojson::array lsnList;
		for (PartitionId pId = 0; pId < partitionNum_; ++pId) {
			lsnList.push_back(
				picojson::value(static_cast<double>(lsnList_[pId])));
		}

		picojson::object jsonObject;
		jsonObject["nodeInfo"] = picojson::value(jsonNodeInfo);
		jsonObject["partitionNum"] =
			picojson::value(static_cast<double>(partitionNum_));
		jsonObject["groupNum"] =
			picojson::value(static_cast<double>(partitionGroupNum_));
		jsonObject["lsnInfo"] = picojson::value(lsnList);

		std::string jsonString(picojson::value(jsonObject).serialize());

		util::FileSystem::createPath(
			path_.c_str(), PID_LSN_INFO_FILE_NAME.c_str(), lsnInfoFileName);
		file.open(lsnInfoFileName.c_str(), util::FileFlag::TYPE_READ_WRITE |
											   util::FileFlag::TYPE_CREATE |
											   util::FileFlag::TYPE_TRUNCATE);
		file.lock();
		file.write(jsonString.c_str(), jsonString.length());
		file.close();
	}
	catch (std::exception &e) {
		GS_RETHROW_USER_ERROR(e, "Write lsn info file failed. (fileName="
									 << lsnInfoFileName.c_str() << ", reason="
									 << GS_EXCEPTION_MESSAGE(e) << ")");
	}
}
Exemple #8
0
QVariantMap APIHelper::jsonToVariantMap(const QByteArray &json)
{
#ifdef QT_DEBUG
        qDebug() << "Start to parse JSON into QVariantMap.";
#endif
        QString jsonString(json);

#ifdef QT_DEBUG
        qDebug() << json;
#endif
        QJsonParseError err;

        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonString.toUtf8(), &err);

#ifdef QT_DEBUG
        qDebug() << err.errorString();
#endif

    return jsonDoc.object().toVariantMap();
}
Exemple #9
0
        std::string jsonString(BSONObj &obj, JsonStringFormat format, int pretty, UUIDEncoding uuidEncoding)
        {
            if ( obj.isEmpty() ) return "{}";

            StringBuilder s;
            s << "{";
            BSONObjIterator i(obj);
            BSONElement e = i.next();
            if ( !e.eoo() )
                while ( 1 ) {
                    if ( pretty ) {
                        s << '\n';
                        for( int x = 0; x < pretty; x++ )
                            s << "    ";
                    }
                    else {
                        s << " ";
                    }
                    s << jsonString(e, format, true, pretty?pretty+1:0, uuidEncoding);
                    e = i.next();

                    if (e.eoo()) {
                        s << '\n';
                        for( int x = 0; x < pretty - 1; x++ )
                            s << "    ";
                        s << "}";
                        break;
                    }

                    s << ",";

        /*            if ( e.eoo() )
                        break;
                    s << ","; */
                }
            //s << "\n}";
            return s.str();
        }
void processAndLogNewSpawnException(SpawnException &e, const Options &options,
	const SpawningKit::ConfigPtr &config)
{
	TRACE_POINT();
	UnionStation::TransactionPtr transaction;
	ErrorRenderer renderer(*config->resourceLocator);
	string appMessage = e.getErrorPage();
	string errorId;
	char filename[PATH_MAX];
	stringstream stream;

	if (options.analytics && config->unionStationCore != NULL) {
		try {
			UPDATE_TRACE_POINT();
			transaction = config->unionStationCore->newTransaction(
				options.getAppGroupName(),
				"exceptions",
				options.unionStationKey);
			errorId = transaction->getTxnId();
		} catch (const tracable_exception &e2) {
			transaction.reset();
			P_WARN("Cannot log to Union Station: " << e2.what() <<
				"\n  Backtrace:\n" << e2.backtrace());
		}
	}

	UPDATE_TRACE_POINT();
	if (appMessage.empty()) {
		appMessage = "none";
	}
	if (errorId.empty()) {
		errorId = config->randomGenerator->generateHexString(4);
	}
	e.set("error_id", errorId);

	try {
		int fd = -1;
		string errorPage;

		UPDATE_TRACE_POINT();
		errorPage = renderer.renderWithDetails(appMessage, options, &e);

		#if (defined(__linux__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 11))) || defined(__APPLE__) || defined(__FreeBSD__)
			snprintf(filename, PATH_MAX, "%s/passenger-error-XXXXXX.html",
				getSystemTempDir());
			fd = mkstemps(filename, sizeof(".html") - 1);
		#else
			snprintf(filename, PATH_MAX, "%s/passenger-error.XXXXXX",
				getSystemTempDir());
			fd = mkstemp(filename);
		#endif
		FdGuard guard(fd, NULL, 0, true);
		if (fd == -1) {
			int e = errno;
			throw SystemException("Cannot generate a temporary filename",
				e);
		}

		UPDATE_TRACE_POINT();
		writeExact(fd, errorPage);
	} catch (const SystemException &e2) {
		filename[0] = '\0';
		P_ERROR("Cannot render an error page: " << e2.what() << "\n" <<
			e2.backtrace());
	}

	if (transaction != NULL) {
		try {
			UPDATE_TRACE_POINT();
			transaction->message("Context: spawning");
			transaction->message("Message: " +
				jsonString(e.what()));
			transaction->message("App message: " +
				jsonString(appMessage));

			const char *kind;
			switch (e.getErrorKind()) {
			case SpawnException::PRELOADER_STARTUP_ERROR:
				kind = "PRELOADER_STARTUP_ERROR";
				break;
			case SpawnException::PRELOADER_STARTUP_PROTOCOL_ERROR:
				kind = "PRELOADER_STARTUP_PROTOCOL_ERROR";
				break;
			case SpawnException::PRELOADER_STARTUP_TIMEOUT:
				kind = "PRELOADER_STARTUP_TIMEOUT";
				break;
			case SpawnException::PRELOADER_STARTUP_EXPLAINABLE_ERROR:
				kind = "PRELOADER_STARTUP_EXPLAINABLE_ERROR";
				break;
			case SpawnException::APP_STARTUP_ERROR:
				kind = "APP_STARTUP_ERROR";
				break;
			case SpawnException::APP_STARTUP_PROTOCOL_ERROR:
				kind = "APP_STARTUP_PROTOCOL_ERROR";
				break;
			case SpawnException::APP_STARTUP_TIMEOUT:
				kind = "APP_STARTUP_TIMEOUT";
				break;
			case SpawnException::APP_STARTUP_EXPLAINABLE_ERROR:
				kind = "APP_STARTUP_EXPLAINABLE_ERROR";
				break;
			default:
				kind = "UNDEFINED_ERROR";
				break;
			}
			transaction->message(string("Kind: ") + kind);

			Json::Value details;
			const map<string, string> &annotations = e.getAnnotations();
			map<string, string>::const_iterator it, end = annotations.end();

			for (it = annotations.begin(); it != end; it++) {
				details[it->first] = it->second;
			}

			// This information is not very useful. Union Station
			// already collects system metrics.
			details.removeMember("system_metrics");
			// Don't include environment variables because they may
			// contain sensitive information.
			details.removeMember("envvars");

			transaction->message("Details: " + stringifyJson(details));
		} catch (const tracable_exception &e2) {
			P_WARN("Cannot log to Union Station: " << e2.what() <<
				"\n  Backtrace:\n" << e2.backtrace());
		}
	}

	UPDATE_TRACE_POINT();
	stream << "Could not spawn process for application " << options.appRoot <<
		": " << e.what() << "\n" <<
		"  Error ID: " << errorId << "\n";
	if (filename[0] != '\0') {
		stream << "  Error details saved to: " << filename << "\n";
	}
	stream << "  Message from application: " << appMessage << "\n";
	P_ERROR(stream.str());

	if (config->agentsOptions != NULL) {
		HookScriptOptions hOptions;
		hOptions.name = "spawn_failed";
		hOptions.spec = config->agentsOptions->get("hook_spawn_failed", false);
		hOptions.agentsOptions = config->agentsOptions;
		hOptions.environment.push_back(make_pair("PASSENGER_APP_ROOT", options.appRoot));
		hOptions.environment.push_back(make_pair("PASSENGER_APP_GROUP_NAME", options.getAppGroupName()));
		hOptions.environment.push_back(make_pair("PASSENGER_ERROR_MESSAGE", e.what()));
		hOptions.environment.push_back(make_pair("PASSENGER_ERROR_ID", errorId));
		hOptions.environment.push_back(make_pair("PASSENGER_APP_ERROR_MESSAGE", appMessage));
		oxt::thread(boost::bind(runHookScripts, hOptions),
			"Hook: spawn_failed", 256 * 1024);
	}
}
Exemple #11
0
int main(int argC,char **argV)
{
	ros::init(argC,argV,"startBody");
	ros::NodeHandle n;
	std::string serverAddress;
	n.getParam("/serverNameOrIP",serverAddress);
	Socket mySocket(serverAddress.c_str(),"9003",streamSize);
	iconv_t charConverter = iconv_open("UTF-8","UTF-16");
	ros::Publisher bodyPub = n.advertise<k2_client::BodyArray>(topicName,1);
	char jsonCharArray[readSkipSize];
	while(ros::ok())
	{
		mySocket.readData();
		char *jsonCharArrayPtr;
		char *socketCharArrayPtr;
		jsonCharArrayPtr = jsonCharArray;
		socketCharArrayPtr = mySocket.mBuffer;
		iconv(charConverter,&socketCharArrayPtr,&readSkipSize,&jsonCharArrayPtr,&stringSize);
		double utcTime;
		memcpy(&utcTime,&mySocket.mBuffer[readSkipSize],sizeof(double));
		std::string jsonString(jsonCharArray);
		//std::cout<<jsonCharArray<<std::endl<<"***"<<std::endl;
		Json::Value jsonObject;
		Json::Reader jsonReader;
		bool parsingSuccessful = jsonReader.parse(jsonString,jsonObject,false);
		if(!parsingSuccessful)
		{
			std::cout<<"Failure to parse: "<<parsingSuccessful<<std::endl;
			continue;
		}
		k2_client::BodyArray bodyArray;
		try
		{
			for(int i=0;i<6;i++)
			{
				k2_client::Body body;
				body.header.stamp = ros::Time(utcTime);
				body.header.frame_id =  ros::this_node::getNamespace().substr(1,std::string::npos) + "/depthFrame";
				body.leanTrackingState = jsonObject[i]["LeanTrackingState"].asInt();
				body.lean.leanX = jsonObject[i]["Lean"]["X"].asDouble();
				body.lean.leanY = jsonObject[i]["Lean"]["Y"].asDouble();
				body.isTracked = jsonObject[i]["IsTracked"].asBool();
				body.trackingId = jsonObject[i]["TrackingId"].asUInt64();
				body.clippedEdges = jsonObject[i]["ClippedEdges"].asInt();
				body.engaged = jsonObject[i]["Engaged"].asBool();
				body.handRightConfidence = jsonObject[i]["HandRightConfidence"].asInt();
				body.handRightState = jsonObject[i]["HandRightState"].asInt();
				body.handLeftConfidence = jsonObject[i]["HandLeftConfidence"].asInt();
				body.handLeftState = jsonObject[i]["HandLeftState"].asInt();
				body.appearance.wearingGlasses = jsonObject[i]["Appearance"]["WearingGlasses"].asBool();
				body.activities.eyeLeftClosed = jsonObject[i]["Activities"]["EyeLeftClosed"].asBool();
				body.activities.eyeRightClosed = jsonObject[i]["Activities"]["EyeRightClosed"].asBool();
				body.activities.mouthOpen = jsonObject[i]["Activities"]["MouthOpen"].asBool();
				body.activities.mouthMoved = jsonObject[i]["Activities"]["MouthMoved"].asBool();
				body.activities.lookingAway = jsonObject[i]["Activities"]["LookingAway"].asBool();
				body.expressions.neutral = jsonObject[i]["Expressions"]["Neutral"].asBool();
				body.expressions.neutral = jsonObject[i]["Expressions"]["Happy"].asBool();
				for(int j=0;j<25;j++)
				{
					k2_client::JointOrientationAndType JOAT;
					k2_client::JointPositionAndState JPAS;
					std::string fieldName;
					switch (j)
					{
						case 0: fieldName = "SpineBase";break;
						case 1: fieldName = "SpineMid";break;
						case 2: fieldName = "Neck";break;
						case 3: fieldName = "Head";break;
						case 4: fieldName = "ShoulderLeft";break;
						case 5: fieldName = "ElbowLeft";break;
						case 6: fieldName = "WristLeft";break;
						case 7: fieldName = "HandLeft";break;
						case 8: fieldName = "ShoulderRight";break;
						case 9: fieldName = "ElbowRight";break;
						case 10: fieldName = "WristRight";break;
						case 11: fieldName = "HandRight";break;
						case 12: fieldName = "HipLeft";break;
						case 13: fieldName = "KneeLeft";break;
						case 14: fieldName = "AnkleLeft";break;
						case 15: fieldName = "SpineBase";break;
						case 16: fieldName = "HipRight";break;
						case 17: fieldName = "KneeRight";break;
						case 18: fieldName = "AnkleRight";break;
						case 19: fieldName = "FootRight";break;
						case 20: fieldName = "SpineShoulder";break;
						case 21: fieldName = "HandTipLeft";break;
						case 22: fieldName = "ThumbLeft";break;
						case 23: fieldName = "HandTipRight";break;
						case 24: fieldName = "ThumbRight";break;
					}
					
					JOAT.orientation.x = jsonObject[i][fieldName]["Orientation"]["X"].asDouble();
					JOAT.orientation.y = jsonObject[i][fieldName]["Orientation"]["Y"].asDouble();
					JOAT.orientation.z = jsonObject[i][fieldName]["Orientation"]["Z"].asDouble();
					JOAT.orientation.w = jsonObject[i][fieldName]["Orientation"]["W"].asDouble();
					JOAT.jointType = jsonObject[i][fieldName]["JointType"].asInt();

					JPAS.trackingState = jsonObject[i][fieldName]["TrackingState"].asBool();
					JPAS.position.x = jsonObject[i][fieldName]["Position"]["X"].asDouble();
					JPAS.position.y = jsonObject[i][fieldName]["Position"]["Y"].asDouble();
					JPAS.position.z = jsonObject[i][fieldName]["Position"]["Z"].asDouble();
					JPAS.jointType = jsonObject[i][fieldName]["JointType"].asInt();
					
					body.jointOrientations.push_back(JOAT);
					body.jointPositions.push_back(JPAS);
				}
				bodyArray.bodies.push_back(body);
			}
		}
		catch (...)
		{
			std::cout<<"An exception occured"<<std::endl;
			continue;
		}
		bodyPub.publish(bodyArray);
	}
	return 0;
}
Exemple #12
0
        std::string jsonString(BSONElement &elem, JsonStringFormat format, bool includeFieldNames, int pretty, UUIDEncoding uuidEncoding)
        {
            BSONType t = elem.type();
            int sign;
            if ( t == Undefined )
                return "undefined";

            stringstream s;
            if ( includeFieldNames )
                s << '"' << escape( elem.fieldName() ) << "\" : ";
            switch ( elem.type() ) {
            case mongo::String:
            case Symbol:
                s << '"' << escape( string(elem.valuestr(), elem.valuestrsize()-1) ) << '"';
                break;
            case NumberLong:
                s << "NumberLong(" << elem._numberLong() << ")";
                break;
            case NumberInt:
            case NumberDouble:
                if ( elem.number() >= -numeric_limits< double >::max() &&
                        elem.number() <= numeric_limits< double >::max() ) {
                    s.precision( 16 );
                    s << elem.number();
                }
                else if ( mongo::isNaN(elem.number()) ) {
                    s << "NaN";
                }
                else if ( mongo::isInf(elem.number(), &sign) ) {
                    s << ( sign == 1 ? "Infinity" : "-Infinity");
                }
                else {
                    StringBuilder ss;
                    ss << "Number " << elem.number() << " cannot be represented in JSON";
                    string message = ss.str();
                    //massert( 10311 ,  message.c_str(), false );
                }
                break;
            case mongo::Bool:
                s << ( elem.boolean() ? "true" : "false" );
                break;
            case jstNULL:
                s << "null";
                break;
            case Object: {
                BSONObj obj = elem.embeddedObject();
                s << jsonString(obj, format, pretty, uuidEncoding);
                }
                break;
            case mongo::Array: {
                if ( elem.embeddedObject().isEmpty() ) {
                    s << "[]";
                    break;
                }
                s << "[ ";
                BSONObjIterator i( elem.embeddedObject() );
                BSONElement e = i.next();
                if ( !e.eoo() ) {
                    int count = 0;
                    while ( 1 ) {
                        if( pretty ) {
                            s << '\n';
                            for( int x = 0; x < pretty; x++ )
                                s << "    ";
                        }

                        if (strtol(e.fieldName(), 0, 10) > count) {
                            s << "undefined";
                        }
                        else {
                            s << jsonString(e, format, false, pretty?pretty+1:0, uuidEncoding);
                            e = i.next();
                        }
                        count++;
                        if ( e.eoo() ) {
                            s << '\n';
                            for( int x = 0; x < pretty - 1; x++ )
                                s << "    ";
                            s << "]";
                            break;
                        }
                        s << ", ";
                    }
                }
                //s << " ]";
                break;
            }
            case DBRef: {
                mongo::OID *x = (mongo::OID *) (elem.valuestr() + elem.valuestrsize());
                if ( format == TenGen )
                    s << "Dbref( ";
                else
                    s << "{ \"$ref\" : ";
                s << '"' << elem.valuestr() << "\", ";
                if ( format != TenGen )
                    s << "\"$id\" : ";
                s << '"' << *x << "\" ";
                if ( format == TenGen )
                    s << ')';
                else
                    s << '}';
                break;
            }
            case jstOID:
                if ( format == TenGen ) {
                    s << "ObjectId(";
                }
                else {
                    s << "{ \"$oid\" : ";
                }
                s << '"' << elem.__oid() << '"';
                if ( format == TenGen ) {
                    s << ")";
                }
                else {
                    s << " }";
                }
                break;
            case BinData: {
                int len = *(int *)( elem.value() );
                BinDataType type = BinDataType( *(char *)( (int *)( elem.value() ) + 1 ) );

                if (type == mongo::bdtUUID || type == mongo::newUUID) {
                    s << HexUtils::formatUuid(elem, uuidEncoding);
                    break;
                }

                s << "{ \"$binary\" : \"";
                char *start = ( char * )( elem.value() ) + sizeof( int ) + 1;
                base64::encode( s , start , len );
                s << "\", \"$type\" : \"" << hex;
                s.width( 2 );
                s.fill( '0' );
                s << type << dec;
                s << "\" }";
                break;
            }
            case mongo::Date:
                if ( format == Strict )
                    s << "{ \"$date\" : ";
                else
                    s << "ISODate(";
                if( pretty ) {
                    Date_t d = elem.date();

                    long long ms = (long long) d.millis;
                    boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
                    boost::posix_time::time_duration diff = boost::posix_time::millisec(ms);
                    boost::posix_time::ptime time = epoch + diff;
                    std::string timestr = miutil::isotimeString(time, true, true);
                    s << '"' << timestr << '"';

        /*            if( d == 0 ) s << '0';
                    else
                        //P s << '"' << elem.date().toString() << '"';
                        s << '"' << elem.date().millis << '"';*/

                }
                else
                    s << elem.date();
                if ( format == Strict )
                    s << " }";
                else
                    s << ")";
                break;
            case RegEx:
                if ( format == Strict ) {
                    s << "{ \"$regex\" : \"" << escape( elem.regex() );
                    s << "\", \"$options\" : \"" << elem.regexFlags() << "\" }";
                }
                else {
                    s << "/" << escape( elem.regex() , true ) << "/";
                    // FIXME Worry about alpha order?
                    for ( const char *f = elem.regexFlags(); *f; ++f ) {
                        switch ( *f ) {
                        case 'g':
                        case 'i':
                        case 'm':
                            s << *f;
                        default:
                            break;
                        }
                    }
                }
                break;

            case CodeWScope: {
                BSONObj scope = elem.codeWScopeObject();
                if ( ! scope.isEmpty() ) {
                    s << "{ \"$code\" : " << elem._asCode() << " , "
                      << " \"$scope\" : " << scope.jsonString() << " }";
                    break;
                }
            }

            case Code:
                s << elem._asCode();
                break;

            case Timestamp:
                if ( format == TenGen ) {
                    s << "Timestamp(" << ( elem.timestampTime() / 1000 ) << ", " << elem.timestampInc() << ")";
                }
                else {
                    s << "{ \"$timestamp\" : { \"t\" : " << ( elem.timestampTime() / 1000 ) << ", \"i\" : " << elem.timestampInc() << " } }";
                }
                break;

            case MinKey:
                s << "{ \"$minKey\" : 1 }";
                break;

            case MaxKey:
                s << "{ \"$maxKey\" : 1 }";
                break;

            default:
                StringBuilder ss;
                ss << "Cannot create a properly formatted JSON string with "
                   << "element: " << elem.toString() << " of type: " << elem.type();
                string message = ss.str();
                //massert( 10312 ,  message.c_str(), false );
            }
            return s.str();
        }
Exemple #13
0
int main(int argC,char **argV)
{
	ros::init(argC,argV,"startBody");
	ros::NodeHandle n;
	std::string serverAddress;
	n.getParam("/serverNameOrIP",serverAddress);
    Socket mySocket(serverAddress.c_str(),const_cast<char*>("9003"), streamSize);
	ros::Publisher bodyPub = n.advertise<k2_client::BodyArray>(topicName,1);
    char utf16Array[readSkipSize];
    char jsonCharArray[stringSize];
    char *jsonCharArrayPtr;
    char *utf16ArrayPtr;
    ros::Rate r(30);
	while(ros::ok())
	{
		mySocket.readData();
        jsonCharArrayPtr = jsonCharArray;
        utf16ArrayPtr = utf16Array;
        memset(utf16Array, 0, sizeof(utf16Array));
        memcpy(utf16Array, mySocket.mBuffer, sizeof(utf16Array));
        size_t iconv_in = static_cast<size_t>(readSkipSize);
        size_t iconv_out = static_cast<size_t>(stringSize);
        iconv_t charConverter = iconv_open("UTF-8","UTF-16");
        size_t nconv = iconv(charConverter, &utf16ArrayPtr, &iconv_in, &jsonCharArrayPtr, &iconv_out);
        iconv_close(charConverter);
        if (nconv == (size_t) - 1)
        {
            if (errno == EINVAL)
                ROS_ERROR("An incomplete multibyte sequence has been encountered in the input.");
            else if (errno == EILSEQ)
                ROS_ERROR("An invalid multibyte sequence has been encountered in the input.");
            else
                ROS_ERROR("There is not sufficient room at jsonCharArray");
        }
        double utcTime = 0.0;
        memcpy(&utcTime,&mySocket.mBuffer[readSkipSize], sizeof(double));
		std::string jsonString(jsonCharArray);
		Json::Value jsonObject;
		Json::Reader jsonReader;
        bool parsingSuccessful = jsonReader.parse(jsonString,jsonObject,false);
        if(!parsingSuccessful)
        {
            ROS_ERROR("Failure to parse");
            continue;
        }
        k2_client::BodyArray bodyArray;
        try
        {
            for(int i=0;i<6;i++)
            {
                k2_client::Body body;
                body.header.stamp = ros::Time(utcTime);
                body.header.frame_id =  ros::this_node::getNamespace().substr(1,std::string::npos) + "/depthFrame";
                body.leanTrackingState = jsonObject[i]["LeanTrackingState"].asInt();
                body.lean.leanX = jsonObject[i]["Lean"]["X"].asDouble();
                body.lean.leanY = jsonObject[i]["Lean"]["Y"].asDouble();
                body.isTracked = jsonObject[i]["IsTracked"].asBool();
                body.trackingId = jsonObject[i]["TrackingId"].asUInt64();
                body.clippedEdges = jsonObject[i]["ClippedEdges"].asInt();
                body.engaged = jsonObject[i]["Engaged"].asBool();
                body.handRightConfidence = jsonObject[i]["HandRightConfidence"].asInt();
                body.handRightState = jsonObject[i]["HandRightState"].asInt();
                body.handLeftConfidence = jsonObject[i]["HandLeftConfidence"].asInt();
                body.handLeftState = jsonObject[i]["HandLeftState"].asInt();
                body.appearance.wearingGlasses = jsonObject[i]["Appearance"]["WearingGlasses"].asBool();
                body.activities.eyeLeftClosed = jsonObject[i]["Activities"]["EyeLeftClosed"].asBool();
                body.activities.eyeRightClosed = jsonObject[i]["Activities"]["EyeRightClosed"].asBool();
                body.activities.mouthOpen = jsonObject[i]["Activities"]["MouthOpen"].asBool();
                body.activities.mouthMoved = jsonObject[i]["Activities"]["MouthMoved"].asBool();
                body.activities.lookingAway = jsonObject[i]["Activities"]["LookingAway"].asBool();
                body.expressions.neutral = jsonObject[i]["Expressions"]["Neutral"].asBool();
                body.expressions.neutral = jsonObject[i]["Expressions"]["Happy"].asBool();
                for(int j=0;j<25;j++)
                {
                    k2_client::JointOrientationAndType JOAT;
                    k2_client::JointPositionAndState JPAS;
                    std::string fieldName;
                    switch (j)
                    {
                        case 0: fieldName = "SpineBase";break;
                        case 1: fieldName = "SpineMid";break;
                        case 2: fieldName = "Neck";break;
                        case 3: fieldName = "Head";break;
                        case 4: fieldName = "ShoulderLeft";break;
                        case 5: fieldName = "ElbowLeft";break;
                        case 6: fieldName = "WristLeft";break;
                        case 7: fieldName = "HandLeft";break;
                        case 8: fieldName = "ShoulderRight";break;
                        case 9: fieldName = "ElbowRight";break;
                        case 10: fieldName = "WristRight";break;
                        case 11: fieldName = "HandRight";break;
                        case 12: fieldName = "HipLeft";break;
                        case 13: fieldName = "KneeLeft";break;
                        case 14: fieldName = "AnkleLeft";break;
                        case 15: fieldName = "SpineBase";break;
                        case 16: fieldName = "HipRight";break;
                        case 17: fieldName = "KneeRight";break;
                        case 18: fieldName = "AnkleRight";break;
                        case 19: fieldName = "FootRight";break;
                        case 20: fieldName = "SpineShoulder";break;
                        case 21: fieldName = "HandTipLeft";break;
                        case 22: fieldName = "ThumbLeft";break;
                        case 23: fieldName = "HandTipRight";break;
                        case 24: fieldName = "ThumbRight";break;
                    }
					
                    JOAT.orientation.x = jsonObject[i]["JointOrientations"][fieldName]["Orientation"]["X"].asDouble();
                    JOAT.orientation.y = jsonObject[i]["JointOrientations"][fieldName]["Orientation"]["Y"].asDouble();
                    JOAT.orientation.z = jsonObject[i]["JointOrientations"][fieldName]["Orientation"]["Z"].asDouble();
                    JOAT.orientation.w = jsonObject[i]["JointOrientations"][fieldName]["Orientation"]["W"].asDouble();
                    JOAT.jointType = jsonObject[i]["JointOrientations"][fieldName]["JointType"].asInt();

                    JPAS.trackingState = jsonObject[i]["Joints"][fieldName]["TrackingState"].asBool();
                    JPAS.position.x = jsonObject[i]["Joints"][fieldName]["Position"]["X"].asDouble();
                    JPAS.position.y = jsonObject[i]["Joints"][fieldName]["Position"]["Y"].asDouble();
                    JPAS.position.z = jsonObject[i]["Joints"][fieldName]["Position"]["Z"].asDouble();
                    JPAS.jointType = jsonObject[i]["Joints"][fieldName]["JointType"].asInt();
					
                    body.jointOrientations.push_back(JOAT);
                    body.jointPositions.push_back(JPAS);
                }
                bodyArray.bodies.push_back(body);
            }
        }
        catch (...)
        {
            ROS_ERROR("An exception occured");
            continue;
        }
        bodyPub.publish(bodyArray);
        ros::spinOnce();
        r.sleep();
	}
	return 0;
}
//================= private ==================
void FigureItem::initFromConfigFile(const FigureKey& figureKey)
{
	assert(figureKey.isValid());

	std::string fileName = 
		FigureResourceManager::getInstance()->constructPath((figureKey.isMale ? "boy/" : "girl/")
		+ figureKey.type + "/" + figureKey.id + "/boneConfig.json");
	cocos2d::Data fileData = cocos2d::FileUtils::getInstance()->getDataFromFile(fileName);
	if (fileData.getSize() <= 0)
	{
		cocos2d::log("Fail opening file:%s\n", fileName.c_str());
		return;
	}
	assert(fileData.getBytes() != nullptr);

	std::string jsonString((char*)fileData.getBytes(), fileData.getSize());
	rapidjson::Document document;
	document.Parse<0>(jsonString.c_str());
	if (document.HasParseError() || document.IsObject() == false)
	{
		cocos2d::log("json ParseError %s\n", document.GetParseError());
		return;
	}

	if (document.HasMember("COMPONENTS"))
	{
		const rapidjson::Value& components = document["COMPONENTS"];
		assert(components.IsArray());
		for (rapidjson::SizeType i = 0; i < components.Size(); ++i)
		{
			const rapidjson::Value& item = components[i];
			assert(item.HasMember("TYPE"));
			assert(item.HasMember("ID"));
			std::string type = item["TYPE"].GetString();
			std::string id = item["ID"].GetString();

			assert(mSonTypeSet.find(type) == mSonTypeSet.end());
			mSonTypeSet.insert(type);
			mSonFigureKeys.push_back(FigureKey(figureKey.isMale, type, id));

			FigureKey sonFigureKey = FigureKey(figureKey.isMale, type, id);
			initFromConfigFile(sonFigureKey);
		}
		return;
	}

	assert(document.HasMember("BONE_CONFIGS"));
	const rapidjson::Value& boneConfigs = document["BONE_CONFIGS"];
	assert(boneConfigs.IsArray());
	for (rapidjson::SizeType i = 0; i < boneConfigs.Size(); ++i)
	{
		const rapidjson::Value& boneConfigJson = boneConfigs[i];
		std::string boneName = boneConfigJson["BONE_NAME"].GetString();
		const rapidjson::Value& bonePicture = boneConfigJson["BONE_PICTURE"];

		BoneConfig boneConfig;
		boneConfig.boneName = boneName;

		if (bonePicture.IsArray())
		{
			for (rapidjson::SizeType i = 0; i < bonePicture.Size(); ++i)
			{
				const rapidjson::Value& item = bonePicture[i];
				assert(item.HasMember("PATH"));
				std::string picturePath = 
					FigureResourceManager::getInstance()->constructPath(item["PATH"].GetString());

				assert(cocos2d::FileUtils::getInstance()->isFileExist(picturePath));
				boneConfig.pictures.push_back(picturePath);
			}
		}
		else
		{
			//bonePicture.GetString() == boy-or-girl/type/id/bone.png
			std::string picturePath = 
				FigureResourceManager::getInstance()->constructPath(bonePicture.GetString());

			assert(cocos2d::FileUtils::getInstance()->isFileExist(picturePath));
			boneConfig.pictures.push_back(picturePath);
		}

		mBoneConfigArray.push_back(boneConfig);
	}
}
void BoneManager::initDefaultBoneConfigMap(bool isMale)
{
	std::map<std::string, std::vector<std::string>>* boneConfigMap = &mBoyDefaultBoneConfigMap;
	std::string fileName = 
		FigureResourceManager::getInstance()->constructPath("boy/defaultBoneConfig.json");
	if (isMale == false)
	{
		fileName = FigureResourceManager::getInstance()->constructPath("girl/defaultBoneConfig.json");
		boneConfigMap = &mGirlDefaultBoneConfigMap;
	}

	cocos2d::Data fileData = cocos2d::FileUtils::getInstance()->getDataFromFile(fileName);
	if (fileData.getSize() <= 0)
	{
		cocos2d::log("Fail opening file:%s\n", fileName.c_str());
		return;
	}
	assert(fileData.getBytes() != nullptr);

	std::string jsonString((char*)fileData.getBytes(), fileData.getSize());
	rapidjson::Document document;
	document.Parse<0>(jsonString.c_str());
	if (document.HasParseError() || document.IsObject() == false)
	{
		cocos2d::log("json ParseError %s\n", document.GetParseError());
		return;
	}

	assert(document.HasMember("COMPONENTS") == false);
	assert(document.HasMember("BONE_CONFIGS"));
	const rapidjson::Value& boneConfigs = document["BONE_CONFIGS"];
	assert(boneConfigs.IsArray());
	for (rapidjson::SizeType i = 0; i < boneConfigs.Size(); ++i)
	{
		const rapidjson::Value& boneConfigJson = boneConfigs[i];
		std::string boneName = boneConfigJson["BONE_NAME"].GetString();
		const rapidjson::Value& bonePicture = boneConfigJson["BONE_PICTURE"];

		std::vector<std::string> pictures;

		if (bonePicture.IsArray())
		{
			for (rapidjson::SizeType i = 0; i < bonePicture.Size(); ++i)
			{
				const rapidjson::Value& item = bonePicture[i];
				assert(item.HasMember("PATH"));
				std::string picturePath = 
					FigureResourceManager::getInstance()->constructPath(item["PATH"].GetString());

				assert(cocos2d::FileUtils::getInstance()->isFileExist(picturePath));
				pictures.push_back(picturePath);
			}
		}
		else
		{
			//bonePicture.GetString() == boy-or-girl/type/id/bone.png
			std::string picturePath = 
				FigureResourceManager::getInstance()->constructPath(bonePicture.GetString());

			assert(cocos2d::FileUtils::getInstance()->isFileExist(picturePath));
			pictures.push_back(picturePath);
		}

		boneConfigMap->insert(
			std::map<std::string, std::vector<std::string>>::value_type(boneName, pictures));
	}
}