标签: self-reference

我试图将这些Readable实例存储在Coordinator结构上，并有一个schedule方法可以选择其中一个实例readables并将其推送到 FuturesUnordered 实例（也在 内部Coordinator）中以便稍后提取。问题是：由于生命周期错误，这无法编译

use bytes::Bytes;
use futures::prelude::stream::FuturesUnordered;
use std::future::Future;
use std::pin::Pin;

struct Readable {}

impl Readable {
    async fn read(&mut self) -> Result<Bytes, ()> {
        Err(())
    }
}

type Futures = FuturesUnordered<Pin<Box<dyn Future<Output = Result<Bytes, ()>> + Send>>>;

struct Coordinator {
    readers: Vec<Readable>,
    futures: Futures,
}

impl Coordinator {
    fn schedule(&mut self) {
        let reader = self.readers.get_mut(0).unwrap();
        let f = Box::pin(reader.read());
        self.futures.push(f);
    }
}

错误

error[E0759]: `self` has an …

需要一些帮助来理解如何做到这一点; 我将在文件系统上运行递归"查找",并且我希望将信息保存在单个数据库表中 - 具有自引用的层次结构:

这是我要填充的数据库表结构.

目录表:

id       int NOT NULL,
name     varchar(255) NOT NULL,
parentid int NOT NULL);

这是我想要映射的Java类(仅显示字段):

public DirObject {
    int id;
    String name;
    DirObject parent;
...

对于'root'目录,将使用parentid = 0; real id将从1开始,理想情况下我希望hibernate自动生成id.

有人可以为此提供建议的映射文件; 作为第二个问题,我考虑过像这样做Java类:

public DirObject {
    int id;
    String name;
    List<DirObject> subdirs;

我可以对这两种方法中的任何一种使用相同的数据模型吗？(当然使用不同的映射文件).

---更新:所以我尝试了下面建议的映射文件(谢谢!),在此重复以供参考:

<hibernate-mapping>
    <class name="my.proj.DirObject" table="category">
        ...   

        <set name="subDirs" lazy="true" inverse="true">
            <key column="parentId"/>
            <one-to-many class="my.proj.DirObject"/>
        </set>

        <many-to-one name="parent"
                     class="my.proj.DirObject"
                     column="parentId" cascade="all" />
    </class>

...并且改变了我的Java类以使'parentid'和'getSubDirs'[返回'HashSet'].

这似乎有用 - 谢谢,但这是我用来驱动它的测试代码 - 我想我在这里没做什么,因为我认为Hibernate将负责保存Set中的从属对象而不必我做这明确吗？

DirObject dirobject=new DirObject();
   dirobject.setName("/files");
   dirobject.setParent(dirobject);

   DirObject …

以Ryan Bates的asciicast为例:http://asciicasts.com/episodes/163-self-referential-association

他以两个User用户结束

• :朋友
• :inverse_friends

鉴于用户不关心是谁煽动友谊,你会想要一个简单的用户关联

• :朋友

这包括两种关系.即,由用户发起的关系和由用户的朋友发起的关系.

那么如何实现这种双向自引用关联呢？

更新 - Josh Susser在此发表了一篇文章:http: //blog.hasmanythrough.com/2006/4/21/self-referential-through

但是,它仍然讨论has_many:sources和has_many:当真的应该有一个has_many:包含源和接收器的节点时接收.

我有一个多对多模型,遵循这个伟大的railscast中的示例

我的模型将作者彼此联系起来.我想验证作者不能自己交朋友.我知道我可以在UI级别处理这个问题,但是我希望能够进行验证以防止UI中的错误允许它.我已经尝试过validates_exclusion_of,但它不起作用.这是我的关系模型:

class Friendship < ActiveRecord::Base
  # prevent duplicates
  validates_uniqueness_of :friend_id, :scope => :author_id
  # prevent someone from following themselves (doesn't work)
  validates_exclusion_of :friend_id, :in => [:author_id]

  attr_accessible :author_id, :friend_id
  belongs_to :author
  belongs_to :friend, :class_name => "Author"
end

经过一个小时的尝试了解Y-Combinator ......我终于明白了,但大部分时间我意识到没有它可以实现同样的事情......虽然我不确定我是否完全理解它的目的.

例如.使用Y-Combinator的因子

print (lambda h: (lambda f:f(f))(lambda f: h(lambda n: f(f)(n))))(lambda g: lambda n: n and n * g(n-1) or 1)(input())

因子在另一个lambda中引用了该函数

print (lambda f,m:f(f,m))((lambda g,n: n and n * g(g,n-1) or 1),input())

任何人都可以告诉我,如果在python中有Y-Combinator的目的吗？

在我的"主题"实体中,我有一对多,自我引用的关系$parent:$children.

class Topic
{
    /** @ORM\Id 
    * @Column(type="integer")
    * @ORM\GeneratedValue(strategy="IDENTITY")
    */
    private $id;

    /** @Column(length=40, unique=true) */
    private $name;

    /**
     * @ORM\ManyToOne(targetEntity="Topic", inversedBy="children")
     */
    private $parent;

    /**
     * @ORM\OneToMany(targetEntity="Topic", mappedBy="parent")
     */
    private $children;
}

我可以加入表来获得这样的父子层次结构:

return $this->getEntityManager()->createQuery('
    SELECT t, c FROM My\xxxBundle\Entity\Topic t 
    LEFT JOIN t.children c
    WHERE t.parent IS NULL
')
->getArrayResult();

这是正确的输出:

array
  0 => 
    array
      'id' => int 1
      'name' => string 'Parent 1'
      'slug' => string 'p-1'
      'description' => null
      'children' => 
        array
          0 …

我想在实体Stuff上实现版本控制。每个实体都有对下一个版本的可选引用（最新版本为null）和对先前版本的可选引用（第一个版本为null）。我先使用实体​​框架6，然后编写代码。我尝试使用以下模型和modelbuilder语句（以及许多变体）。

public class Stuff
{
    public int StuffId { get; set; }

    [ForeignKey("NextVersion")]
    public int? NextVersionId { get; set; }
    [InverseProperty("PreviousVersion")]
    public virtual Stuff NextVersion { get; set; }

    public virtual Stuff PreviousVersion { get; set; }
}

modelBuilder.Entity<Stuff>().HasOptional(t => t.NextVersion).WithOptionalDependent(t => t.PreviousVersion);

但是，在这种情况下，[ForeignKey（“ NextVersion”）]将被忽略，并生成一个外键NextVersion_StuffId。如何指示EF使用属性NextVersionId作为外键？

假设我们有一个像这样的自引用表

CREATE TABLE Month
(
  Id int IDENTITY(1,1)  PRIMARY KEY,
  Title char(128)
)
CREATE TABLE Entity
(
 Id int IDENTITY(1,1)  PRIMARY KEY,
 MonthId int FOREIGN KEY REFERENCES Month(Id),
 Name char(128),
 ParentId int FOREIGN KEY REFERENCES Entity(Id),
)

我想将某个MonthId的所有行复制到另一个MonthId.重复的parentId也应该更新,实体及其父母应该在同一个月.

作为一个例子假设我们有

Id        MonthId    Name     ParentId
------------------------------------
1         1          name1     null
2         1          name11    1
3         1          name3     null 
4         1          name31    3
5         1          name311   4

将monthId = 1行复制到monthId = 2后,结果应如下所示:

Id        MonthId    Name     ParentId
------------------------------------
1         1          name1     null
2         1 …

我想将当前脚本作为Python中变量的字符串.

我找到了两种次优方法,但我希望有更好的解决方案.我发现:

1. 该inspect进口有一个getsource方法,但只返回一个函数(或类或其他),而不是整个脚本的代码.我找不到将整个脚本的对象传递给的方法getsource.

2. 我可以用找到脚本文件的文件位置,__file__或者sys.argv[0]和open它来阅读.但这对我来说似乎太间接了.

那么:是否有(更好的)方法以字符串形式访问整个脚本？

如果相关:我更喜欢3.0以上的Python 2.7解决方案.

有没有办法声明std::map其值类型是自身的迭代器？

map<string, map<string, (#)>::iterator> myMap;

上面的代码片段不起作用,因为迭代器类型需要知道第二个模板参数,标记为(#).(这本身就是).

目的是避免执行不必要的find操作来访问另一个元素指向的元素 - 而不是使用map<string, string>.