标签: dispatch

这是正确的方法吗？

// convert
const void *buffer = NULL;
size_t size = 0;
dispatch_data_t new_data_file = dispatch_data_create_map(data, &buffer, &size);
if(new_data_file){ /* to avoid warning really - since dispatch_data_create_map demands we care about the return arg */}

NSData *nsdata = [[NSData alloc] initWithBytes:buffer length:size];

// use the nsdata... code removed for general purpose

// clean up
[nsdata release];
free(buffer); // warning: passing const void * to parameter of type void *

它工作正常.我主要担心的是内存泄漏.泄漏数据缓冲区并不好玩.那么NSData,缓冲区和dispatch_data_t new_data_file都可以吗？

从我在http://opensource.apple.com/source/libdispatch/libdispatch-187.7/dispatch/data.c上可以看到,似乎缓冲区是DISPATCH_DATA_DESTRUCTOR_FREE.这是否意味着释放缓冲区是我的责任？

我写了一个简单的例子,它使用基类接口和dynamic_cast以及非虚函数调用来估计调用虚函数的平均时间.就这个:

#include <iostream>
#include <numeric>
#include <list>
#include <time.h>

#define CALL_COUNTER (3000)

__forceinline int someFunction()
{
  return 5;
}

struct Base
{
  virtual int virtualCall() = 0;
  virtual ~Base(){};
};

struct Derived : public Base
{
  Derived(){};
  virtual ~Derived(){};
  virtual int virtualCall(){ return someFunction(); };
  int notVirtualCall(){ return someFunction(); };
};


struct Derived2 : public Base
{
  Derived2(){};
  virtual ~Derived2(){};
  virtual int virtualCall(){ return someFunction(); };
  int notVirtualCall(){ return someFunction(); };
};

typedef std::list<double> Timings;

Base* createObject(int i)
{
  if(i …

我正在尝试执行以下操作:

public abstract BaseClass {

  public virtual void ReceiveEvent(Event evt)
    {
        ProcessEvent(evt as dynamic);
    }

    private void ProcessEvent(object evt)
    { 
        LogManager.Log(@"Received an event that is not being processed! 
                        Dispatch fallback");
    }
}

public DerivedClass: BaseClass {

    private void ProcessEvent(SpecificEvent evt)
    { 
        LogManager.Log("Processing Event");
    }
}

SpecificEvents命中了回退方法而不是派生类中的方法.我一直在同一个类中使用动态调度,并发现它非常有用/干净.它是否不适用于上面示例中所示的派生类？

编辑: 答案似乎有些混乱.基本上我一直使用以下设计:

public class SomeClass{

    public void DoSomethingDispatcher(SomeObject obj)
    {
        ProcessObject(obj as dynamic);
    }

    private void DoSomething(SomeObjectType1 obj)
    { 

    }

    private void DoSomething(SomeObjectType2 obj)
    { 

    }

    private void DoSomething(SomeObjectType3 obj)
    { 

    }

    private void …

我想知道Java7的新invokedynamic字节码指令是否可用于实现Java语言的多个调度.java.lang.invoke下的新API是否有助于执行此类操作？

我正在思考的场景如下所示.(这看起来像访问者设计模式的应用案例,但可能有理由认为这不是一个可行的选择.)

class A {} 
class A1 extends A {}
class A2 extends A {}

class SomeHandler {
    private void doHandle(A1 a1) { ... }
    private void doHandle(A2 a2) { ... }
    private void doHandle(A a) { ... }

    public void handle(A a) {
        MultipleDispatch.call(this, "doHandle", a);
    }
}

然后库类MultipleDispatch会做类似的事情:

class MultipleDispatch {

    public static Object call(Object receiver, String method, Object...arg) {
        // something like that in byte code
        #invokeDynamic "doHandle" "someBootstrap"
    }

    static …

我有一个对象子类,它__ iter __使用缓存生成器实现动态调度(我还有一个使iter缓存无效的方法),如下所示:

def __iter__(self):
    print("iter called")
    if self.__iter_cache is None:
        iter_seen = {}
        iter_cache = []
        for name in self.__slots:
            value = self.__slots[name]
            iter_seen[name] = True
            item = (name, value)
            iter_cache.append(item)
            yield item           
        for d in self.__dc_list:
            for name, value in iter(d):
                if name not in iter_seen:
                    iter_seen[name] = True
                    item = (name, value)
                    iter_cache.append(item)
                    yield item
        self.__iter_cache = iter_cache
    else:
        print("iter cache hit")
        for item in self.__iter_cache:
            yield item

它似乎工作......有没有我可能不知道的陷阱？我做的事情有多荒谬吗？

R的S3 OO系统以泛型函数为中心,这些函数根据调用泛型函数的对象类调用方法.关键是泛型函数调用适当的方法,而不是在类中定义方法的其他OO编程语言.

例如,该mean函数是通用函数.

isGeneric("mean")
methods(mean)

这将打印

TRUE
[1] mean,ANY-method          mean.Date                mean.default             mean.difftime           
[5] mean.IDate*              mean,Matrix-method       mean.POSIXct             mean.POSIXlt            
[9] mean,sparseMatrix-method mean,sparseVector-method
see '?methods' for accessing help and source code

我正在探索R并发现了这个as功能.我很困惑R这个函数不是通用的,但它仍然有方法.

isGeneric("as")
methods(as)

TRUE
  [1] as.AAbin                                  as.AAbin.character                       
  [3] as.alignment                              as.allPerms                              
  [5] as.array                                  as.array.default                         
  [7] as.binary                                 as.bitsplits                             
  [9] as.bitsplits.prop.part                    as.call
  ...                                  

最后有一个警告说这as不是通用的.

 Warning message:
 In .S3methods(generic.function, class, parent.frame()) :
 function 'as' appears not to be S3 generic; found functions that look like S3 methods

有人能解释我是什么as功能,以及如何连接 …

在参考这个问题/答案时,perl6 multi默认为sub.

对于<class>类型的调用者,没有这样的方法<name>

我原以为它默认为方法.有人可以解释一下这个理由吗？

我有一个对象，我想动态调用它的方法。

进行类型检查会很好，但这可能是不可能的。但目前我什至无法编译它：

  const key: string = 'someMethod'
  const func = this[key]
  func(msgIn)

给我这个错误...

Element implicitly has an 'any' type 
because expression of type 'any' can't be used 
to index type 'TixBot'.

我尝试了一些其他类型的选项但没有成功。

  const key: any = cmd.func
  const func: any = this[key]

除了@ts-ignore我怎么能解决这个问题？我想知道我是否可以使用.call()或bind以某种方式解决它？

我在 Julia (1.2) REPL 中尝试了一些东西，但我一直在想一些我不了解调度的东西。

我首先尝试了这件事，它按我预期的方式工作：

f(a::T) where {T <: Int} = "Test"

• 调用 f(3) 有效 Int <: Int == true

• 调用 f("Hello") 会导致“MethodError: no method matching”错误，因为 String <: Int == false

然后，我尝试了这个方法，我不明白为什么在某些情况下调用它有效：

f(a::T, b::U) where {T, U <: T} = "Another Test"

• 调用 f(3, 3) 有效（如我所料）

• 但是 f(3, "Hello") 也可以工作并且不会抛出“MethodError: no method matching”？？？

我认为（因为 T 变成了一个 Int 而 U 变成了一个字符串）String <: Int == false？？？

我想我在这里遗漏了一些非常简单的东西，但我找不到它......所以这是我的问题，为什么 f(3, "Hello") 正在工作？？？

此外，我尝试了这段代码（我尝试重新创建第二个方法签名），但正如我所料，它正确地失败了：

Test = Tuple{T, U} where {T, U <: …

希望有人能指出我正确的方向。基本上我已经创建了一个使用钩子的反应应用程序，特别是 useContext、useEffect 和 useReducer。我的问题是我似乎无法通过测试来检测相关组件的点击或调度事件。

可以在以下位置找到我的应用程序的精简版本：https : //github.com/atlantisstorm/hooks-testing 测试与 layout.test.js 脚本相关。

我尝试了各种方法，模拟分派、useContext 等的不同方法，但对此并不满意。最新版本。

布局.test.js

import React from 'react';
import { render, fireEvent } from "@testing-library/react";
import Layout from './layout';
import App from './app';
import { Provider, initialState } from './context';

const dispatch = jest.fn();

const spy = jest
  .spyOn(React, 'useContext')
  .mockImplementation(() => ({
    state: initialState,
    dispatch: dispatch
}));

describe('Layout component', () => {
  it('starts with a count of 0', () => {
    const { getByTestId } = render(
      <App>
        <Provider> …