C++ createObject函数代码示例

    T* ClsTypeManager<T>::createByLabel(string _strLabel)
    {
	// getTypeName exceptions passed onto caller.
	string strType = label2type(_strLabel);

	T* pNewObject;
	try {
	    pNewObject = createObject(strType);
	}
	catch (iqrcommon::UnknownTypeError &e) {
	    throw UnknownTypeError(_strLabel);
	}

	return pNewObject;
    }

void onSignificantWifiChange(wifi_request_id id,
        unsigned num_results, wifi_significant_change_result **results) {
    JNIEnv *env = NULL;
    mVM->AttachCurrentThread(&env, NULL);

    ALOGD("onSignificantWifiChange called, vm = %p, obj = %p, env = %p", mVM, mCls, env);

    jclass clsScanResult = (env)->FindClass("android/net/wifi/ScanResult");
    if (clsScanResult == NULL) {
        ALOGE("Error in accessing class");
        return;
    }

    jobjectArray scanResults = env->NewObjectArray(num_results, clsScanResult, NULL);
    if (scanResults == NULL) {
        ALOGE("Error in allocating array");
        return;
    }

    for (unsigned i = 0; i < num_results; i++) {

        wifi_significant_change_result result = *(results[i]);

        jobject scanResult = createObject(env, "android/net/wifi/ScanResult");
        if (scanResult == NULL) {
            ALOGE("Error in creating scan result");
            return;
        }

        // setStringField(env, scanResult, "SSID", results[i].ssid);

        char bssid[32];
        sprintf(bssid, "%02x:%02x:%02x:%02x:%02x:%02x", result.bssid[0], result.bssid[1],
            result.bssid[2], result.bssid[3], result.bssid[4], result.bssid[5]);

        setStringField(env, scanResult, "BSSID", bssid);

        setIntField(env, scanResult, "level", result.rssi[0]);
        setIntField(env, scanResult, "frequency", result.channel);
        // setLongField(env, scanResult, "timestamp", result.ts);

        env->SetObjectArrayElement(scanResults, i, scanResult);
    }

    reportEvent(env, mCls, "onSignificantWifiChange", "(I[Landroid/net/wifi/ScanResult;)V",
        id, scanResults);

}

/**creates an quilateral traingle at given position and size**/
RenderObject Renderer::createRectangle(glm::vec3 origin, float length, float height, float size)
{

	float l = size * length / 2;
	float h = size * height / 2;
	return createObject (origin,	{	
									glm::vec3(origin.x - l, origin.y - h, origin.z),
									glm::vec3(origin.x - l, origin.y + h, origin.z),
									glm::vec3(origin.x + l, origin.y + h, origin.z),
									glm::vec3(origin.x + l, origin.y + h, origin.z),
									glm::vec3(origin.x + l, origin.y - h, origin.z),
									glm::vec3(origin.x - l, origin.y - h, origin.z) 
									}
						);
	
}

ossimObject* ossimContribImageSourceFactory::createObject(const ossimKeywordlist& kwl,
                                          const char* prefix)const
{
   const char* type = kwl.find(prefix, ossimKeywordNames::TYPE_KW);
   ossimObject* result = NULL;
   if(type)
   {
      result = createObject(ossimString(type));
      if(result)
      {
         result->loadState(kwl, prefix);
      }
   }

   return result;
}

void hsetCommand(caller_t *c)
{
    robj *o, *result;
    unsigned long update;

    if ((o = hashTypeLookupWriteElseCreate(c,c->argv[1])) == NULL) return;
    hashTypeTryConversion(o,c->argv,2,3);
    hashTypeTryObjectEncoding(o,&c->argv[2], &c->argv[3]);
    update = hashTypeSet(o,c->argv[2],c->argv[3]);
    update = update ? 0 : 1;
    result = createObject(REDIS_STRING, (void*)update);
    result->encoding = REDIS_ENCODING_INT;
    caller_set_err(c, ERR_NONE);
    caller_add_result(c, result);
    server.dirty++;
}

void Memory::resize(MemSize newSize)
{
    ObjectPtr* newMemory = new ObjectPtr[newSize];
    for (MemSize i = 0; i < (this->currentSize < newSize ? this->currentSize : newSize); i++)
    {
        newMemory[i] = this->memory[i];
    }

    for (MemSize i = this->currentSize; i < newSize; i++)
    {
        newMemory[i] = createObject();
    }

    this->currentSize = newSize;
    this->memory = newMemory;
}

static Value createMethod(Context *ctx, const List<Value>& args)
{
    if (args.getCount() != 2)
    {
        ctx->throwException(createException(ExcType::ValueError, "__methodify takes 2 argument."));
    }

    Value result = createObject();

    HashMap<Str, Value>& resultMembers = ((ObjectData *)result.p)->members;

    resultMembers.set("__func__", createCopy(args[0]));
    resultMembers.set("__obj__", createCopy(args[1]));
    resultMembers.set("__call__", createNativeFunction(methodCall));

    return result;
}

// extern (used by Global.cpp)
void
boolean_class_init(as_object& where, const ObjectURI& uri)
{
    VM& vm = getVM(where);
    Global_as& gl = getGlobal(where);

    as_object* proto = createObject(gl);
    as_object* cl = vm.getNative(107, 2);
    cl->init_member(NSV::PROP_PROTOTYPE, proto);
    proto->init_member(NSV::PROP_CONSTRUCTOR, cl);

    attachBooleanInterface(*proto);
    
    // Register _global.Boolean
    where.init_member(uri, cl, as_object::DefaultFlags);

}

Actor* ObjectFactory::createActor(const std::string& path)
{
    if(Object* object = createObject(path))
    {
        if(Actor* actor = dynamic_cast<Actor*>(object))
        {
            return actor;
        }
        else
        {
            rLogErr(g_log, "[ObjectFactory] Given path \"" << path << "\" doesn`t describe an actor.");
            destroyObject(object);
        }
    }

    return nullptr;
}

/// This provides the prototype and static methods for TextField.
//
/// For SWF5 there is initially no prototype, for SWF6+ there is a 
/// limited prototype. This is changed later on instantiation of a
/// TextField.
void
textfield_class_init(as_object& where, const ObjectURI& uri)
{

    Global_as& gl = getGlobal(where);
    as_object* proto = createObject(gl);
    as_object* cl = gl.createClass(&textfield_ctor, proto);

    attachTextFieldInterface(*proto);
    attachTextFieldStaticMembers(*cl);
             
    where.init_member(uri, cl, as_object::DefaultFlags);

    // ASSetPropFlags is called on the TextField class.
    as_object* null = nullptr;
    callMethod(&gl, NSV::PROP_AS_SET_PROP_FLAGS, cl, null, 131);
}

int put(HashMap *map,void *key,void *value){
	List *listOfHashObjects;
	Object *objectPrevoiuslyPresent,*object;
	int hash;
	if(map == NULL || key == NULL) return 0;
	objectPrevoiuslyPresent = getMatchingObject(map,key,0);
	if(objectPrevoiuslyPresent){
		objectPrevoiuslyPresent->values = value;
		return 1;
	}
	object = createObject(key,value);
	hash = calculateHash(map,key);
	listOfHashObjects = get(map->buckets,hash);
	insert(listOfHashObjects,object,1);
	rehashIfNeeded(map);
	return 1;
};

void throw_tprotocolexception(char* what, long errorcode) {
    TSRMLS_FETCH();

    zval *zwhat, *zerrorcode;
    MAKE_STD_ZVAL(zwhat);
    MAKE_STD_ZVAL(zerrorcode);

    ZVAL_STRING(zwhat, what, 1);
    ZVAL_LONG(zerrorcode, errorcode);

    zval* ex;
    MAKE_STD_ZVAL(ex);
    createObject("TProtocolException", ex, 2, zwhat, zerrorcode);
    zval_ptr_dtor(&zwhat);
    zval_ptr_dtor(&zerrorcode);
    throw PHPExceptionWrapper(ex);
}

HbXmlLoaderBaseActions::ObjectMapItem HbXmlLoaderBaseActions::lookUp(const QString& type, const QString &name, const QString &plugin)
{   
    const bool nameNotEmpty = name.size() != 0;
    bool doLookUp = true;
    ObjectMapItem current;
    current.mObject = 0;
    current.mType = HbXml::OBJECT;
    
    if (nameNotEmpty) {
        ObjectMap::const_iterator it = mObjectMap.find(name);
        if (it != mObjectMap.end()) {
            current = it.value();
            
            if (!current.mObject) {
                mObjectMap.remove(name);
            }
            // CHECK DISABLED FOR NOW.
            /*
            if (current.mObject && !type.isEmpty()) {
                const QByteArray array = type.toUtf8();
                
                if (!current.mObject->inherits(array.data())) {                    
                    HB_DOCUMENTLOADER_PRINT( QString( "Existing object requested with invalid type" ) );
                    // We have object already in mObjectMap, but it does not fulfill
                    // all needs. So object look up has failed.
                    doLookUp = false;
                    current.mObject = 0;
                }
            }
            */
        }
    }
    
    if (doLookUp && !current.mObject) {
        QObject *obj = createObject(type, name, plugin);        
        if (obj) {
            current.mObject = obj;
            current.mType = qobject_cast<QGraphicsWidget*>(obj) ? HbXml::WIDGET : HbXml::OBJECT;
        }
        if (nameNotEmpty) {
            mObjectMap.insert(name, current);
        }
    }

    return current;
}

ObjectNodeInstance::Pointer ObjectNodeInstance::create(const NodeMetaInfo &nodeMetaInfo, QDeclarativeContext *context, QObject *objectToBeWrapped)
{
    QObject *object = 0;
    if (objectToBeWrapped)
        object = objectToBeWrapped;
    else
        object = createObject(nodeMetaInfo, context);

    Pointer instance(new ObjectNodeInstance(object));

    if (objectToBeWrapped)
        instance->setDeleteHeldInstance(false); // the object isn't owned

    instance->populateResetValueHash();

    return instance;
}

	cocos2d::Node* SceneReader::createNodeWithSceneFile(const char* pszFileName, ISceneReaderListener* listener )
    {
        unsigned long size = 0;
        const char* pData = 0;
		cocos2d::Node *pNode = NULL;
        do {
			  CC_BREAK_IF(pszFileName == NULL);
              pData = (char*)(cocos2d::FileUtils::getInstance()->getFileData(pszFileName, "r", &size));
              CC_BREAK_IF(pData == NULL || strcmp(pData, "") == 0);
              cs::JsonDictionary *jsonDict = new cs::JsonDictionary();
              jsonDict->initWithDescription(pData);
			  pNode = createObject(jsonDict, NULL, listener);
              CC_SAFE_DELETE(jsonDict);
        } while (0);
        
        return pNode;
	}