C++ ObjectHandle类代码示例

	Variant invoke(const ObjectHandle& object, const IDefinitionManager& definitionManager,
		const ReflectedMethodParameters& parameters) override
	{
		auto pointer = reflectedCast<ClassType>(object.data(), object.type(), definitionManager);
		TF_ASSERT(pointer != nullptr);
		return invokeMember( pointer, method_, definitionManager, parameters, std::index_sequence_for<Args...>{} );
	}

SysStatus
SysVMessagesClient::getCallBackOH(ObjectHandle& oh, void*& blockKey)
{
    ProcessID pid;
    SysStatus rc;

    pid = DREFGOBJ(TheProcessRef)->getPID();
    if (pid != callBackOH.pid()) {
	/* either we've never initialized or
	 * this is a fork child and we need
	 * a new call back oh.
	 */
	ProcessID serverPID;
	ObjectHandle serverOH;
	StubSysVMessages::__Get__metaoh(serverOH);
	passertMsg(!serverOH.invalid(), "No SysVMessages server\n");
	serverPID=serverOH.pid();
	/*
	 * make oh to this object for async callback
	 */
	rc = giveAccessByServer(callBackOH, serverPID);
	passertMsg(_SUCCESS(rc), "giveAccessByServer failed %ld\n", rc);
    }
    oh = callBackOH;
    blockKey = (void*)obj;
    return 0;
}

/*static*/ SysStatus
FileLinuxPacket::CreateInternal(FileLinuxRef& newSocket, ObjectHandle stubOH,
				uval clientType, uval oflags, sval domain,
			        sval type, sval protocol)
{
    SysStatus rc;
    FileLinuxPacket *newp = NULL;

    ObjectHandle dummy;

    switch (type) {
    case SOCK_DGRAM:
    case SOCK_RAW:
	switch (domain) {
	case AF_NETLINK:
	case AF_INET:
	    newp = new FileLinuxPacket(domain, type, protocol);
	    break;
	case AF_UNIX:
	    newp = (FileLinuxPacket*) new FileLinuxPacketUnix(domain, type,
                                                        protocol);
	    break;
	default:
	    tassertMsg(0, "fixme.  Add the domain (%ld) here as well.\n",
	                 domain);
	    break;
	}
	break;
    default:
	tassertMsg(0, "fixme.  Add the type (%ld) here as well.\n", type);
	break;
    }

    // using dummy tells init not to make a stubHolder
    dummy.init();
    newp->init(dummy, NULL);

    newp->local = newp->remote = 0;
    newp->localLen = newp->remoteLen = 0;

    newp->sps.setOH(stubOH);

    switch (clientType) {
    case TransStreamServer::TRANS_VIRT:
	newp->stubHolder = new TransVirtStream(stubOH);
	break;
    case TransStreamServer::TRANS_PPC:
	newp->stubHolder = new TransPPCStream(stubOH);
	break;
    default:
	err_printf("Unknown socket client type: %ld\n", clientType);
    }

    newSocket = (FileLinuxRef)newp->getRef();

    // register object for callback by server
    rc = newp->registerCallback();
    tassert(_SUCCESS(rc), err_printf("do cleanup code\n"));
    return 0;
}

void mexFunction(int nlhs, mxArray *plhs[],
    int nrhs, const mxArray *prhs[]) {
	double *i_oesgp_object;

	i_oesgp_object =  mxGetPr(prhs[0]);
    
    VectorXd prediction;
    VectorXd prediction_variance;
    
    ObjectHandle<OESGP>* handle = 
            ObjectHandle<OESGP>::from_mex_handle(prhs[0]);
	handle->get_object().predict(prediction, prediction_variance);
    
    
    if (nlhs >= 1) {
        plhs[0] = mxCreateDoubleMatrix(prediction.rows(), 1, mxREAL);
        double *output = mxGetPr(plhs[0]);
        for (unsigned int i=0; i<prediction.rows(); i++) {
            output[i] = prediction[i];
        }
    } 
    
    if (nlhs >= 2) {
        plhs[1] = mxCreateDoubleMatrix(prediction_variance.rows(), 1, mxREAL);
        double *output = mxGetPr(plhs[1]);
        for (unsigned int i=0; i<prediction_variance.rows(); i++) {
            output[i] = prediction_variance[i];
        }        
    } 
}

int
main()
{
    NativeProcess();

    SysStatus rc;
    ObjectHandle oh;

    UsrTstRef ref = UsrTst::Create();

    rc = DREF(ref)->giveAccessByServer(oh, _KERNEL_PID);
    tassert(_SUCCESS(rc), err_printf("woops\n"));
    printf("testDisabledIPC: calling kernel with oh %lx %lx\n",
	   oh.commID(), oh.xhandle());
    Scheduler::Disable();
    ALLOW_PRIMITIVE_PPC();
    DREFGOBJ(TheProcessRef)->testUserIPC(oh);
    UN_ALLOW_PRIMITIVE_PPC();
    Scheduler::Enable();
    printf("testDisabledIPC: done calling kernel\n");
    for (uval i = 0; i < 20; i++) {
	printf("testDisabledIPC: sleeping (%ld)\n", i);
	Scheduler::DelayMicrosecs(5000);
    }
    printf("testDisabledIPC: terminating\n");
    return 0;
}

RECEIVE(DROP, id, msg, reliable)
{
	ObjectHandle item = Object::construct((string) msg[1]);
	if (!item) return;
	item->unserialize(msg[1]);
	game.world->temporary.push_back(item);
}

	ReflectedMethodParameterWrapper( const Variant& variant, const IDefinitionManager & definitionManager )
	{
		ObjectHandle handle;
		value = variant.tryCast<ObjectHandle>( handle )
			? *reflectedCast< Type >(handle.data(), handle.type(), definitionManager )
			: variant.cast<Type>();
	}

//==============================================================================
ObjectHandle SetReflectedPropertyCommand::execute(
	const ObjectHandle & arguments ) const
{
	ReflectedPropertyCommandArgument * commandArgs =
		arguments.getBase< ReflectedPropertyCommandArgument >();
	auto objManager = definitionManager_.getObjectManager();
	assert( objManager != nullptr );
	ObjectHandle object = objManager->getObject( commandArgs->getContextId() );
	if (!object.isValid())
	{
		return CommandErrorCode::INVALID_ARGUMENTS;
	}
	PropertyAccessor property = object.getDefinition( definitionManager_ )->bindProperty( 
		commandArgs->getPropertyPath(), object );
	if (property.isValid() == false)
	{
		//Can't set
		return CommandErrorCode::INVALID_ARGUMENTS;
	}
	const Variant & data = commandArgs->getPropertyValue();
	bool br = property.setValue( data );
	if (!br)
	{
		return CommandErrorCode::INVALID_VALUE;
	}

	// Do not return the object
	// CommandInstance will hold a reference to the return value
	// and the CommandInstance is stored in the undo/redo history forever
	// This is due to a circular reference in CommandManagerImpl::pushFrame
	return nullptr;
}

    OSPModel MPIDistributedDevice::newModel()
    {
      auto *instance = new DistributedModel;
      ObjectHandle handle;
      handle.assign(instance);

      return (OSPModel)(int64)handle;
    }

// create a server file object to represent this block file
/* virtual */ SysStatus
FileSystemK42RamFS::createServerFileBlock(ServerFileRef &fref, FSFile *fsFile)
{
    ObjectHandle oh;
    SysStatus rc = DREF(tref)->getKptoh(oh);
    tassertMsg(_SUCCESS(rc) && oh.valid(), "?");
    return ServerFileBlockK42RamFS::Create(fref, fsFile, oh);
}

    inline API_TYPE createDistributedObject(const char *type)
    {
      auto *instance = OSPRAY_TYPE::createInstance(type);

      ObjectHandle handle;
      handle.assign(instance);

      return (API_TYPE)(int64)handle;
    }

 OSPFrameBuffer
 MPIDistributedDevice::frameBufferCreate(const vec2i &size,
                                         const OSPFrameBufferFormat mode,
                                         const uint32 channels)
 {
   ObjectHandle handle;
   auto *instance = new DistributedFrameBuffer(size, handle, mode, channels,
                                               true);
   handle.assign(instance);
   return (OSPFrameBuffer)(int64)handle;
 }

int MemoryManager::garbageCollect()
{
    register int j;
    int c=1,f=0;

    if(noGC)
        return 0;

    if (debugging) 
        fprintf(stderr,"\ngarbage collecting ... \n");

    for(TObjectTableIterator x = objectTable.begin(), xend = objectTable.end(); x != xend; ++x)
        x->referenceCount = 0;
    objectTable[0].referenceCount = 1;
    /* visit symbols and firstProcess to toggle their referenceCount */

    visit(symbols);

    /* Visit any explicitly held references from the use of ObjectHandle */
    ObjectHandle* explicitRef = ObjectHandle::getListHead();
    while(explicitRef)
    {
        visit(*explicitRef);
        explicitRef = explicitRef->next();
    }

    /* add new garbage to objectFreeList 
    * toggle referenceCount 
    * count the objects
    */

    for (j=objectTable.size()-1; j>0; j--) 
    {
        if (objectTable[j].referenceCount == 0) 
        {
            if(destroyObject(j))
                f++;
        } 
        else
        {
            if (0!=(objectTable[j].referenceCount = -objectTable[j].referenceCount))
                c++;
        }
    }

    if (debugging)
    {
        fprintf(stderr," %d references.\n",ObjectHandle::numTotalHandles());
        fprintf(stderr," %d objects - %d freed.\n",c,f);
    }

    return f;
}

	ReflectedMethodParameterWrapper(const Variant& variant, const IDefinitionManager& definitionManager)
	{
		if (variant.canCast<ObjectHandle>())
		{
			ObjectHandle handle = variant.cast<ObjectHandle>();
			pointer_ = reflectedCast<Type>(handle.data(), handle.type(), definitionManager);
		}
		else
		{
			pointer_ = &const_cast<Variant&>(variant).cast<Type&>();
		}
	}

/* static */ SysStatus
RegionReplicated::_CreateFixedLenExtDyn(uval& regionVaddr, uval regionSize,
					uval alignmentreq, ObjectHandle frOH,
					uval fileOffset, uval accessreq,
					XHandle target, ObjectHandle tsOH,
					RegionType::Type regionType,
					__CALLER_PID callerPID)
{
    RegionRef ref;
    ProcessRef pref=0;
    SysStatus rc;
    FCMRef fcmRef;
    TypeID type;
    ObjRef objRef;
    FRRef frRef;

    rc = RegionDefault::PrefFromTarget(target, callerPID, pref);
    _IF_FAILURE_RET(rc);

    rc = XHandleTrans::XHToInternal(frOH.xhandle(), callerPID,
				    MetaObj::attach, objRef, type);
    tassertWrn(_SUCCESS(rc), "RegionReplicated failed XHToInternal\n");
    _IF_FAILURE_RET(rc);

    // verify that type is of FRComp - we'd really like just FR
// FIXMEXX talk to Orran, the brilliant, charming, ..
    if (!MetaFR::isBaseOf(type)) {
	tassertWrn(0, "object handle <%lx,%lx> not of correct type\n",
		   frOH.commID(), frOH.xhandle());
	return _SERROR(1542, 0, EINVAL);
    }

    //FIXME check xobj to make sure it matches our processID

    frRef = (FRRef)objRef;

    rc = RegionReplicated::CreateFixedLen(
	ref, pref, regionVaddr,
	regionSize, alignmentreq, frRef, fileOffset,
	(AccessMode::mode)accessreq);

    // FIXME: Kludge for enabling dyn-switch
#if 0
    CObjRoot *partitionedFCMRoot = 0;
    rc = FCMPartitionedTrivial::Create(partitionedFCMRoot, fcmRef, regionSize,
				       /* number of cache lines per rep */ 256,
				       /* associativity of each line */    4);
    tassert(_SUCCESS(rc), err_printf("Replicated Trivial fcm create\n"));

    PMRef pmRef;
    rc = DREF(pref)->getPM(pmRef);
    tassert(_SUCCESS(rc), ;);