C++ Bind类代码示例

	bool Program::dispatchExecution(const Bind<void (const Callback&)>& dispatcher, uint timeout)
	{
		auto envptr = pEnv;
		if (!envptr)
		{
			envptr = std::make_shared<ProcessSharedInfo>();
			pEnv = envptr;
		}

		Thread::Signal signal;
		if (not signal.valid())
		{
			std::cerr << "impossible to initialize signal\n";
			return false;
		}

		// Dispatch the message
		// The code is within a block to let the variable
		// `runner` destroyed, thus to notify the end of the execution
		// (via signal->notify())
		ExecutionHelper runner(*this, signal);

		// scope to destroy our callback as soon as possible
		{
			Bind<bool ()>  callback;
			callback.bind(&runner, &ExecutionHelper::perform, timeout);
			dispatcher(callback);
		}

		// waiting for the process startup from the main loop
		signal.wait();

		// ok ready
		return runner.result;
	}

int main(int argc,char* argv[])
{
  if (argc == 3)
  {
    Bind bd;
    return bd.BindProc(argv[1], argv[2]);
  }
  else
  {
    printf("usage:%s lm_dict bind_dict.\n", argv[0]);
    return -1;
  }
}

void ScopeBuilder::initializeScopeChain()
{
    ScopeChain &scopeChain = _context->scopeChain();
    if (scopeChain.qmlComponentScope
            && scopeChain.qmlComponentScope->document == _doc) {
        return;
    }

    scopeChain = ScopeChain(); // reset

    Interpreter::Engine *engine = _context->engine();

    // ### TODO: This object ought to contain the global namespace additions by QML.
    scopeChain.globalScope = engine->globalObject();

    if (! _doc) {
        scopeChain.update();
        return;
    }

    Bind *bind = _doc->bind();
    QHash<Document *, ScopeChain::QmlComponentChain *> componentScopes;

    ScopeChain::QmlComponentChain *chain = new ScopeChain::QmlComponentChain;
    scopeChain.qmlComponentScope = QSharedPointer<const ScopeChain::QmlComponentChain>(chain);
    if (_doc->qmlProgram()) {
        componentScopes.insert(_doc.data(), chain);
        makeComponentChain(_doc, chain, &componentScopes);

        if (const TypeEnvironment *typeEnvironment = _context->typeEnvironment(_doc.data())) {
            scopeChain.qmlTypes = typeEnvironment;
        }
    } else {
        // add scope chains for all components that import this file
        foreach (Document::Ptr otherDoc, _snapshot) {
            foreach (const ImportInfo &import, otherDoc->bind()->imports()) {
                if (import.type() == ImportInfo::FileImport && _doc->fileName() == import.name()) {
                    ScopeChain::QmlComponentChain *component = new ScopeChain::QmlComponentChain;
                    componentScopes.insert(otherDoc.data(), component);
                    chain->instantiatingComponents += component;
                    makeComponentChain(otherDoc, component, &componentScopes);
                }
            }
        }

        // ### TODO: Which type environment do scripts see?

        if (bind->rootObjectValue())
            scopeChain.jsScopes += bind->rootObjectValue();
    }

 bool hasStatePrototype(Node *ast)
 {
     Bind *bind = m_scopeChain.document()->bind();
     const ObjectValue *v = bind->findQmlObject(ast);
     if (!v)
         return false;
     PrototypeIterator it(v, m_scopeChain.context());
     while (it.hasNext()) {
         const ObjectValue *proto = it.next();
         const CppComponentValue *qmlProto = value_cast<CppComponentValue>(proto);
         if (!qmlProto)
             continue;
         if (qmlProto->metaObject() == m_statePrototype->metaObject())
             return true;
     }
     return false;
 }

void Link::initializeScopeChain()
{
    ScopeChain &scopeChain = _context->scopeChain();

    // ### TODO: This object ought to contain the global namespace additions by QML.
    scopeChain.globalScope = engine()->globalObject();

    if (! _doc) {
        scopeChain.update();
        return;
    }

    Bind *bind = _doc->bind();
    QHash<Document *, ScopeChain::QmlComponentChain *> componentScopes;

    if (_doc->qmlProgram()) {
        scopeChain.qmlComponentScope.clear();
        componentScopes.insert(_doc.data(), &scopeChain.qmlComponentScope);
        makeComponentChain(_doc, &scopeChain.qmlComponentScope, &componentScopes);

        if (const ObjectValue *typeEnvironment = _context->typeEnvironment(_doc.data()))
            scopeChain.qmlTypes = typeEnvironment;
    } else {
        // add scope chains for all components that import this file
        foreach (Document::Ptr otherDoc, _snapshot) {
            foreach (const QString &fileImport, otherDoc->bind()->fileImports()) {
                if (_doc->fileName() == fileImport) {
                    ScopeChain::QmlComponentChain *component = new ScopeChain::QmlComponentChain;
                    componentScopes.insert(otherDoc.data(), component);
                    scopeChain.qmlComponentScope.instantiatingComponents += component;
                    makeComponentChain(otherDoc, component, &componentScopes);
                }
            }
        }

        // ### TODO: Which type environment do scripts see?

        if (bind->rootObjectValue())
            scopeChain.jsScopes += bind->rootObjectValue();
    }

 void audioSample(int16_t lsample, int16_t rsample) { return bind->audioSample(lsample, rsample); }

 string server() { return bind->server(); }

template<typename... Args> void notify(Args&&... args) { return bind->notify({std::forward<Args>(args)...}); }

 unsigned dipSettings(const Markup::Node& node) { return bind->dipSettings(node); }

 string path(unsigned group) { return bind->path(group); }

 int16_t inputPoll(unsigned port, unsigned device, unsigned input) { return bind->inputPoll(port, device, input); }

 void inputRumble(unsigned port, unsigned device, unsigned input, bool enable) { return bind->inputRumble(port, device, input, enable); }

 //callback bindings (provided by user interface)
 void loadRequest(unsigned id, string name, string type) { return bind->loadRequest(id, name, type); }

 void videoRefresh(const uint32_t* palette, const uint32_t* data, unsigned pitch, unsigned width, unsigned height) { return bind->videoRefresh(palette, data, pitch, width, height); }

 uint32_t videoColor(unsigned source, uint16_t alpha, uint16_t red, uint16_t green, uint16_t blue) { return bind->videoColor(source, alpha, red, green, blue); }