Example #1
0
int main()
{
	int arr[10], carr[10];
	std::vector<int> varr(10), cvarr(10);

	for (int i = 0; i < 10; ++i) {
		arr[i] = i;
		std::cout << "arr[" << i << "] :" << arr[i] << std::endl;
	}
	std::cout << "===================" << std::endl;

	for (int i = 0; i < 10; ++i) {
		carr[i] = arr[i];
		std::cout << "carr[" << i << "] :" << carr[i] << std::endl;
	}
	std::cout << "===================" << std::endl;

	for (int i = 0; i < 10; ++i) {
		varr[i] = i;
		std::cout << "varr[" << i << "] :" << varr[i] << std::endl;
	}
	std::cout << "===================" << std::endl;
	cvarr = varr;
	for (int i = 0; i < 10; ++i) {
		cvarr[i] = i;
		std::cout << "cvarr[" << i << "] :" << cvarr[i] << std::endl;
	}

	return 0;
}
Example #2
0
Variant _jobject_to_variant(JNIEnv * env, jobject obj) {

	jclass c = env->GetObjectClass(obj);
	bool array;
	String name = _get_class_name(env, c, &array);
	//print_line("name is " + name + ", array "+Variant(array));

	print_line("ARGNAME: "+name);
	if (name == "java.lang.String") {

		return String::utf8(env->GetStringUTFChars( (jstring)obj, NULL ));
	};


	if (name == "[Ljava.lang.String;") {

		jobjectArray arr = (jobjectArray)obj;
		int stringCount = env->GetArrayLength(arr);
		//print_line("String array! " + String::num(stringCount));
		DVector<String> sarr;

		for (int i=0; i<stringCount; i++) {
			jstring string = (jstring) env->GetObjectArrayElement(arr, i);
			const char *rawString = env->GetStringUTFChars(string, 0);
			sarr.push_back(String(rawString));
			env->DeleteLocalRef(string);

		}

		return sarr;
	};

	if (name == "java.lang.Boolean") {

		jmethodID boolValue = env->GetMethodID(c, "booleanValue", "()Z");
		bool ret = env->CallBooleanMethod(obj, boolValue);
		return ret;
	};

	if (name == "java.lang.Integer") {

		jclass nclass = env->FindClass("java/lang/Number");
		jmethodID intValue = env->GetMethodID(nclass, "intValue", "()I");
		int ret = env->CallIntMethod(obj, intValue);
		return ret;
	};

	if (name == "[I") {

		jintArray arr = (jintArray)obj;
		int fCount = env->GetArrayLength(arr);
		DVector<int> sarr;
		sarr.resize(fCount);

		DVector<int>::Write w = sarr.write();
		env->GetIntArrayRegion(arr,0,fCount,w.ptr());
		w = DVector<int>::Write();
		return sarr;
	};

	if (name == "[B") {

		jbyteArray arr = (jbyteArray)obj;
		int fCount = env->GetArrayLength(arr);
		DVector<uint8_t> sarr;
		sarr.resize(fCount);

		DVector<uint8_t>::Write w = sarr.write();
		env->GetByteArrayRegion(arr,0,fCount,reinterpret_cast<signed char*>(w.ptr()));
		w = DVector<uint8_t>::Write();
		return sarr;
	};

	if (name == "java.lang.Float" || name == "java.lang.Double") {

		jclass nclass = env->FindClass("java/lang/Number");
		jmethodID doubleValue = env->GetMethodID(nclass, "doubleValue", "()D");
		double ret = env->CallDoubleMethod(obj, doubleValue);
		return ret;
	};

	if (name == "[D") {

		jdoubleArray arr = (jdoubleArray)obj;
		int fCount = env->GetArrayLength(arr);
		RealArray sarr;
		sarr.resize(fCount);

		RealArray::Write w = sarr.write();

		for (int i=0; i<fCount; i++) {

			double n;
			env->GetDoubleArrayRegion(arr, i, 1, &n);
			w.ptr()[i] = n;

		};
		return sarr;
	};

	if (name == "[F") {

		jfloatArray arr = (jfloatArray)obj;
		int fCount = env->GetArrayLength(arr);
		RealArray sarr;
		sarr.resize(fCount);


		RealArray::Write w = sarr.write();

		for (int i=0; i<fCount; i++) {

			float n;
			env->GetFloatArrayRegion(arr, i, 1, &n);
			w.ptr()[i] = n;

		};
		return sarr;
	};


	if (name == "[Ljava.lang.Object;") {

		jobjectArray arr = (jobjectArray)obj;
		int objCount = env->GetArrayLength(arr);
		Array varr(true);

		for (int i=0; i<objCount; i++) {
			jobject jobj = env->GetObjectArrayElement(arr, i);
			Variant v = _jobject_to_variant(env, jobj);
			varr.push_back(v);
			env->DeleteLocalRef(jobj);

		}

		return varr;
	};

    if (name == "java.util.HashMap" || name == "org.godotengine.godot.Dictionary") {

		Dictionary ret(true);
		jclass oclass = c;
		jmethodID get_keys = env->GetMethodID(oclass, "get_keys", "()[Ljava/lang/String;");
		jobjectArray arr = (jobjectArray)env->CallObjectMethod(obj, get_keys);

		StringArray keys = _jobject_to_variant(env, arr);
		env->DeleteLocalRef(arr);

		jmethodID get_values = env->GetMethodID(oclass, "get_values", "()[Ljava/lang/Object;");
		arr = (jobjectArray)env->CallObjectMethod(obj, get_values);

		Array vals = _jobject_to_variant(env, arr);
		env->DeleteLocalRef(arr);

		//print_line("adding " + String::num(keys.size()) + " to Dictionary!");
		for (int i=0; i<keys.size(); i++) {

			ret[keys[i]] = vals[i];
		};


		return ret;
	};

	env->DeleteLocalRef(c);

	return Variant();
};
Example #3
0
bool MemoryCache::pack(const std::string& filename) {
    std::unique_ptr<rocksdb::DB> db;
    rocksdb::Options options;
    options.create_if_missing = true;
    rocksdb::Status status = OpenDB(options, filename, db);

    if (!status.ok()) {
        throw std::invalid_argument("unable to open rocksdb file for packing");
    }

    std::map<key_type, std::deque<value_type>> memoized_prefixes;

    for (auto const& item : this->cache_) {
        std::size_t array_size = item.second.size();
        if (array_size > 0) {
            // make copy of intarray so we can sort without
            // modifying the original array
            intarray varr = item.second;

            // delta-encode values, sorted in descending order.
            std::sort(varr.begin(), varr.end(), std::greater<uint64_t>());
            // remove duplicates
            varr.erase(std::unique(varr.begin(), varr.end()), varr.end());

            packVec(varr, db, item.first);

            std::string prefix_t1;
            std::string prefix_t2;

            // add this to the memoized prefix array too, maybe
            auto phrase_length = item.first.find(LANGFIELD_SEPARATOR);
            // use the full string for things shorter than the limit
            // or the prefix otherwise
            if (phrase_length < MEMO_PREFIX_LENGTH_T1) {
                prefix_t1 = "=1" + item.first;
            } else {
                // get the prefix, then append the langfield back onto it again
                langfield_type langfield = extract_langfield(item.first);

                prefix_t1 = "=1" + item.first.substr(0, MEMO_PREFIX_LENGTH_T1);
                add_langfield(prefix_t1, langfield);

                if (phrase_length < MEMO_PREFIX_LENGTH_T2) {
                    prefix_t2 = "=2" + item.first;
                } else {
                    prefix_t2 = "=2" + item.first.substr(0, MEMO_PREFIX_LENGTH_T2);
                    add_langfield(prefix_t2, langfield);
                }
            }

            if (!prefix_t1.empty()) {
                std::map<key_type, std::deque<value_type>>::const_iterator mitr = memoized_prefixes.find(prefix_t1);
                if (mitr == memoized_prefixes.end()) {
                    memoized_prefixes.emplace(prefix_t1, std::deque<value_type>());
                }
                std::deque<value_type>& buf = memoized_prefixes[prefix_t1];

                buf.insert(buf.end(), varr.begin(), varr.end());
            }
            if (!prefix_t2.empty()) {
                std::map<key_type, std::deque<value_type>>::const_iterator mitr = memoized_prefixes.find(prefix_t2);
                if (mitr == memoized_prefixes.end()) {
                    memoized_prefixes.emplace(prefix_t2, std::deque<value_type>());
                }
                std::deque<value_type>& buf = memoized_prefixes[prefix_t2];

                buf.insert(buf.end(), varr.begin(), varr.end());
            }
        }
    }

    for (auto const& item : memoized_prefixes) {
        // copy the deque into a vector so we can sort without
        // modifying the original array
        intarray varr(item.second.begin(), item.second.end());

        // delta-encode values, sorted in descending order.
        std::sort(varr.begin(), varr.end(), std::greater<uint64_t>());
        // remove duplicates
        varr.erase(std::unique(varr.begin(), varr.end()), varr.end());

        packVec(varr, db, item.first);
    }

    return true;
}