标签: composition

我有一个 Django 应用程序，它有许多不同的模型，所有模型都有一堆通用数据。最终，我认为这个问题归结为继承和组合之间的决定。我当前的实现是这样的：

class Thing(models.Model):\n    foo = models.FooField()\n    bar = models.BarField()\n    type = models.CharField()\n\nclass A(CommonStuff):\n    aFoo = models.FooField()\n\nclass B(CommonStuff):\n    bFoo = models.FooField()\n

通过这个模型，我可以查询Thing使用事物模型的管理器。使用 上的 type 字段Thing，我可以通过查看type包含 'a' 或 'b' 的字段，然后询问 (ie) 来获取子对象数据thing.a.aFoo。这是我喜欢的一个功能，因为获取所有Thing对象的列表是我的应用程序中相当常见的操作。

我在这里看到几个问题。首先，这个type领域似乎没有必要。有没有办法无需先查找类型即可获取子数据？似乎我可以使用一个实例方法来解决这个问题，该方法根据给定的类型值返回正确的对象，或者如果我真的想摆脱类型字段，我可以迭代 上的每个反向关系字段，寻找Thing一个这不会引发DoesNotExist异常。但这对我来说感觉很脆弱。如果我添加一个新的 'subthing' C，我必须更新Thing以查找新类型。我可以通过制作Thing和抽象模型来解决这个问题。这样，A就B可以获取 的所有字段Thing，并且避免使用该type字段。但问题是我失去了对所有Thing对象执行查询的能力。

我正在考虑的另一种模型通过将数据转换为和Thing上的字段来翻转这个模型。AB

class Thing(models.Model):\n …

我有点困惑Association, Aggregation and Composition。尽管大量的网站和论坛讨论了这个主题，但在阅读其中一些内容后我变得更加困惑。

我想知道以下是否正确：

1.) 聚合——如果整体被破坏，聚合就会存在。例如， anEngine可以有或没有 a 存在Car。

2.) 组合 - 如果对象被破坏，组合将不存在。例如，Room没有 a 就不可能存在House。

3.) 关联 - 我不确定在什么情况下我们应该使用它。有人可以对此发表评论吗？

当涉及到为聚合、组合和关联编写 Java 代码时

4.)聚合

Class Car {

    private Engine engine;

    public void setEngine(Engine engine){
     this.engine=engine;
    }  

    public Engine getEngine(){
     return engine;
    }
}

我认为如果是聚合关联，那么就应该accessors and mutators定义。它是否正确 ？

根据我对聚合的定义，我提到如果Car对象被销毁，则Engine可以访问。但是，我在上面的代码中没有看到这种情况发生。如果 Car 对象被销毁，将无法像car.getEngine(). 那么这是怎么发生的呢？

作品

Public House {
   private Room room;
   Public House (){ …

我想做这样的事情：

@QueryHints(@QueryHint(name = "org.hibernate.fetchSize", value = FetchSize.value()))
@Target({ })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FetchSize {
    String value();
}

不起作用的部分是value = FetchSize.value()。我想将 @FetchSize 中的值属性传递给目标注释@QueryHint，以便我可以像这样注释：

@FetchSize("1000")

类似的事情是否可能以某种方式实现，我将如何使其发挥作用？

我有一堂课MyClass：

class MyClass(object):
    def __init__(self):
        pass

    def my_function(self, x):
        # MyClass.my_function.__doc__ is not writable!
        # Otherwise, I could just set it here.
        Origin.func(self, x)

该类借用Origin：

class Origin(object):    
    def func(obj, x):
        """This is a function
        """
        # do stuff
        pass

如何自动将文档字符串从 Origin.func 复制到 MyClass.my_function 以便 Sphinx Autodoc 识别它？我怎样才能将原始文档字符串扩展几个单词？

编辑：

Afaik，我不能__doc__在函数定义之后进行更改，因为那时 Sphinx 找不到它。或者如果是这样，“docfix”会去哪里？

我很难在 React 中用继承代替组合。我将尝试基于 React 风格指南中不鼓励的继承来解释所提出的问题和我当前的解决方案。

首先，我在超级组件中定义公共状态和方法：

export default class SuperComponent extends Component {
    constructor(props) {
        super(props);
        this.state = commonState;
    }

    foo() {
        this.setState({a: 3});
    }

    render() {
        return (
            <div>
                {this.getContent()}
            </div>
        )
    }
}

然后我制作具有更多状态和方法的子组件。这些也应该可以访问超级组件的状态：

export default class SubComponent1 extends SuperComponent {
    constructor(props) {
        super(props);
        this.state = Object.assign(this.state, subComponent1State);
    }

    bar() {
        this.setState({b: 7});
    }

    getContent() {
        return (
            <div>
                I'm subcomponent 1
            </div>
        )
    }
}

export default class SubComponent2 extends SuperComponent {
    constructor(props) {
        super(props);
        this.state = …

我正在尝试创建一个由函数 f(x) 组成 N 次的函数，类似于：

function CompositionN(f,N)
             for i in 1:N
                f(x) = f(f(x))
             end
return f(x)

我需要函数 CompositionN 返回另一个函数，而不是值。

这个标题似乎受到了很多批评。但是，我发现这个概念很难搜索。它在 C++ 领域也相对较新，学校仍在教授C++11.

避免 XY 问题的动机和背景

现在，我正在检测一个嵌入式设备项目，concepts作为逆向工程（和学习）过程的一部分。设备库和设备 API 的问题在于，有各种各样的编程禁忌来自于文字设备（或设备产品线）功能：

• 硬编码设置
• 扩展
• 宏
• 设备功能的特定捆绑或子集
• 它利用宏和辅助类来构建结构（structs building structs）
• 没有简化的假设：跨平台和设备测试的大量错误处理包袱
• 等等。

代码结束了——无论开发人员如何努力，我知道不可能有更好的结果——非常冗长和复杂。换句话说，它在功能上很简单，但很难理解。

通常，我可能会形成structs包装包并隐藏硬编码内容，但现在我正在使用concepts它们，因为它们允许我构建我（一个单独的开发人员）可以在知识方面更有效地更改或更新的接口命名空间. 我对使用设备的了解越少越好。

通过概念，我还可以保护我编写的代码，这些代码取决于我的概念化内容，以免设备制造商和 api 提供商传播更改。

在利用这些概念时，我试图尽早选择如何构建我的代码。

为了做出决定，我需要知道是否concepts可以原子地编写，然后组合成conceptual structures. 例如：

// real code

// Concepts

template < typename ContextInfo>
concept ExtensibleDeviceContext = requires(ContextInfo & contextInfo, const char * name, 
                                           bool optional, void * devFeatures)
{
    { contextInfo.addDeviceExtension(name, optional, devFeatures)};
};

template< typename ContextInfo>
concept ExtensibleInstanceContext = requires(ContextInfo & …

有没有办法让它在 C++20 上工作？

auto view = std::views::all;\n\nif (condition1) {\n    view = view | std::views::filter([](int i) {\n        return i%5 == 0;\n    });\n}\n\nif (condition2) {\n    view = view | std::views::filter([](int i) {\n        return i%10 == 0;\n    });\n}\n\n/* Do something with the view */\nfor (int i : list | view) {\n   ...\n}\n

我收到这个丑陋的错误：

\n

test.cpp:13:10: 错误：与 \xe2\x80\x98operator=\xe2\x80\x99 不匹配（操作数类型为 \xe2\x80\x98std::ranges::views::__adaptor::_RangeAdaptorClosurestd::范围::视图::<lambda(_Range&&) >\xe2\x80\x99 和\xe2\x80\x98std::ranges::views::__adaptor::_RangeAdaptorClosurestd::ranges::views::__adaptor::operator| <std::ranges::views::<lambda(_Range&&) >::<lambda(_Up&&)> >\xe2\x80\x99)\n13 | });\n| ^\n在 test.cpp 包含的文件中：2:\n/usr/include/c++/10/ranges:1155:14： 注意：候选者：\xe2\x80\x98constexpr std::ranges::views::__adaptor： :_RangeAdaptorClosurestd::ranges::views::<lambda(_Range&&) >& std::ranges::views::__adaptor::_RangeAdaptorClosurestd::ranges::views::<lambda(_Range&&) >::operator=(const std::ranges::views::__adaptor::_RangeAdaptorClosurestd::ranges::views::<lambda(_Range&&) >&)\xe2\x80\x99\n1155 | 结构 _RangeAdaptorClosure …

我一直想知道一个完整的、包罗万象的背景instance Functor (f :.: g)是什么样的。我脑海中立即浮现的想法是：

newtype (f :.: g) a = Comp (f (g a))
instance (Functor f, Functor g) => Functor (f :.: g) where
    fmap f (Comp x) = Comp (fmap (fmap f) x)

但是，两个逆变函子也会组合成协变的，如下所示：

instance (Contravariant f, Contravariant g) => Functor (f :.: g) where
    fmap f (Comp x) = Comp (contramap (contramap f) x)

这已经不是一个有希望的开始。然而，我也注意到，从技术上讲，f甚至g不必有 kind * -> *—— 唯一的要求f :.: g :: * -> * …

我听说每个拉链都是一个共元，而我认为每个与其自身组成的拉链仍然是一个拉链，因此它是一个共元。所以我决定创建一个。

我有以下拉链列表：

{-# LANGUAGE DeriveFunctor #-}\n{-# LANGUAGE InstanceSigs #-}\nmodule ListZipper where\nimport Control.Comonad\nimport Data.List (unfoldr)\nimport Test.QuickCheck (Arbitrary (arbitrary))\n\ndata ListZipper a = ZList {previous :: [a], currentL :: a, next :: [a]} deriving (Functor, Eq)\n\ngoLeft, goRight :: ListZipper a -> Maybe (ListZipper a)\ngoLeft  (ZList (p:ps) cur ns) = Just $ ZList ps p (cur : ns)\ngoLeft _  = Nothing\ngoRight (ZList ps cur (n:ns)) = Just $ ZList (cur : ps) n ns\ngoRight _ = Nothing\n\nfork :: b -> (b, b)\nfork …