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;
	}

static jobject android_net_wifi_getLinkLayerStats (JNIEnv *env, jclass cls, jint iface)  {

    wifi_stats_result_handler handler;
    memset(&handler, 0, sizeof(handler));
    handler.on_link_stats_results = &onLinkStatsResults;
    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
    int result = wifi_get_link_stats(0, handle, handler);
    if (result < 0) {
        ALOGE("android_net_wifi_getLinkLayerStats: failed to get link statistics\n");
        return NULL;
    }

    jobject wifiLinkLayerStats = createObject(env, "android/net/wifi/WifiLinkLayerStats");
    if (wifiLinkLayerStats == NULL) {
       ALOGE("Error in allocating wifiLinkLayerStats");
       return NULL;
    }

    setIntField(env, wifiLinkLayerStats, "beacon_rx", link_stat.beacon_rx);
    setIntField(env, wifiLinkLayerStats, "rssi_mgmt", link_stat.rssi_mgmt);
    setLongField(env, wifiLinkLayerStats, "rxmpdu_be", link_stat.ac[WIFI_AC_BE].rx_mpdu);
    setLongField(env, wifiLinkLayerStats, "rxmpdu_bk", link_stat.ac[WIFI_AC_BK].rx_mpdu);
    setLongField(env, wifiLinkLayerStats, "rxmpdu_vi", link_stat.ac[WIFI_AC_VI].rx_mpdu);
    setLongField(env, wifiLinkLayerStats, "rxmpdu_vo", link_stat.ac[WIFI_AC_VO].rx_mpdu);
    setLongField(env, wifiLinkLayerStats, "txmpdu_be", link_stat.ac[WIFI_AC_BE].tx_mpdu);
    setLongField(env, wifiLinkLayerStats, "txmpdu_bk", link_stat.ac[WIFI_AC_BK].tx_mpdu);
    setLongField(env, wifiLinkLayerStats, "txmpdu_vi", link_stat.ac[WIFI_AC_VI].tx_mpdu);
    setLongField(env, wifiLinkLayerStats, "txmpdu_vo", link_stat.ac[WIFI_AC_VO].tx_mpdu);
    setLongField(env, wifiLinkLayerStats, "lostmpdu_be", link_stat.ac[WIFI_AC_BE].mpdu_lost);
    setLongField(env, wifiLinkLayerStats, "lostmpdu_bk", link_stat.ac[WIFI_AC_BK].mpdu_lost);
    setLongField(env, wifiLinkLayerStats, "lostmpdu_vi",  link_stat.ac[WIFI_AC_VI].mpdu_lost);
    setLongField(env, wifiLinkLayerStats, "lostmpdu_vo", link_stat.ac[WIFI_AC_VO].mpdu_lost);
    setLongField(env, wifiLinkLayerStats, "retries_be", link_stat.ac[WIFI_AC_BE].retries);
    setLongField(env, wifiLinkLayerStats, "retries_bk", link_stat.ac[WIFI_AC_BK].retries);
    setLongField(env, wifiLinkLayerStats, "retries_vi", link_stat.ac[WIFI_AC_VI].retries);
    setLongField(env, wifiLinkLayerStats, "retries_vo", link_stat.ac[WIFI_AC_VO].retries);


    setIntField(env, wifiLinkLayerStats, "on_time", radio_stat.on_time);
    setIntField(env, wifiLinkLayerStats, "tx_time", radio_stat.tx_time);
    setIntField(env, wifiLinkLayerStats, "rx_time", radio_stat.rx_time);
    setIntField(env, wifiLinkLayerStats, "on_time_scan", radio_stat.on_time_scan);

    return wifiLinkLayerStats;
}

int main( int argc, char** argv )
{
  btDynamicsWorld* bw = initPhysics();
  osg::Group* root = new osg::Group;

  osg::ref_ptr< osgbInteraction::SaveRestoreHandler > srh = new osgbInteraction::SaveRestoreHandler;

  osg::Matrix m;

  m = osg::Matrix::rotate( .4, 0., 0., 1. ) * osg::Matrix::translate( 16., 0., 10. );
  btRigidBody *rb = createObject(root, m, srh.get());
  bw->addRigidBody(rb);
  
  m = osg::Matrix::rotate( osg::PI_2, 0, 1, 0 ) * osg::Matrix::translate( 0., 0., 10. );
  bw->addRigidBody(createWheel(root, m, srh.get()));

  m = osg::Matrix::rotate( 0, 0., 0., 1. ) * osg::Matrix::translate( -20., 0., 0. );
  bw->addRigidBody(createCow(root, m, srh.get()));

  root->addChild( osgbDynamics::generateGroundPlane( osg::Vec4( 0.f, 0.f, 1.f, 0.f ), bw ) );

  osgViewer::Viewer viewer;
  viewer.setUpViewInWindow( 30, 30, 768, 480, 1 );
  viewer.setSceneData( root );
  osgGA::TrackballManipulator* tb = new osgGA::TrackballManipulator;
  viewer.setCameraManipulator( tb );

  viewer.realize();
  srh->capture();

  viewer.addEventHandler(new myEventHandler(rb));
  viewer.addEventHandler( srh.get() );
  viewer.addEventHandler( new osgbInteraction::DragHandler(bw, viewer.getCamera() ) );

  double prevSimTime = 0.;
  while( !viewer.done() )
  {
    const double currSimTime = viewer.getFrameStamp()->getSimulationTime();
    bw->stepSimulation( currSimTime - prevSimTime );
    prevSimTime = currSimTime;
    viewer.frame();
  }

  return( 0 );
}

void PPPDlg::OnBnClickedOk()
{
    if( !UpdateData( TRUE ) ) return;

    if( m_objId.isNull() )
    {
        m_objId = createObject();
        if( m_objId.isNull() )
        {
            MessageBox( _T( "添加失败" ) );
            OnOK();
            return;
        }
    }

    writePropertyData();
    OnOK();
}

object *createObjects(int num)
{
	object *ptr = (object*) malloc(sizeof(object)*num);

	srand(time(NULL));
	int i =0 ; 
	while(i<num)
	{

		float p = (rand()%10)+1;
		float weight = (float)(rand()%7)+1 ;

		ptr[i]=createObject(p,weight,i);
		i++;

	}
return ptr;
}

void Editor::giveCursorPos(glm::vec2 pos)
{
	if (mode == 1 && clickTimer < FLT_EPSILON)
	{
		createObject(pos, currentColor);
		clickTimer = 0.3f;
	}
	if (mode == 2 && clickTimer < FLT_EPSILON)
	{
		createPlayer(pos);
		clickTimer = 0.3f;
	}
	if (mode == 3 && clickTimer < FLT_EPSILON)
	{
		createGoal(pos);
		clickTimer = 0.3f;
	}
}