protected static FactMemento CreateRoom(long domainId)
 {
     FactMemento room = new FactMemento(TypeRoom);
     room.Data = new byte[] { 1, 2, 3, 4 };
     room.AddPredecessor(RoleRoomDomain, new FactID { key = domainId }, true);
     return room;
 }

 public FactID? FindExistingFact(string domain, FactMemento fact)
 {
     using (var procedures = new Procedures(new Session(_connectionString)))
     {
         FactID id;
         if (FindExistingFact(fact, out id, procedures, readCommitted: true))
             return id;
         return null;
     }
 }

 public FactID? FindExistingFact(string domain, FactMemento memento)
 {
     lock (this)
     {
         // See if the fact already exists.
         FactRecord fact = _factTable.FirstOrDefault(o =>
             o.IdentifiedFactMemento.Memento.Equals(memento));
         if (fact == null)
             return null;
         else
             return fact.IdentifiedFactMemento.Id;
     }
 }

			public CorrespondenceFact CreateFact(FactMemento memento)
			{
				Identity newFact = new Identity(memento);

				// Create a memory stream from the memento data.
				using (MemoryStream data = new MemoryStream(memento.Data))
				{
					using (BinaryReader output = new BinaryReader(data))
					{
						newFact._anonymousId = (string)_fieldSerializerByType[typeof(string)].ReadData(output);
					}
				}

				return newFact;
			}

 // Hydration constructor
 private ContactInformation(FactMemento memento)
 {
     InitializeResults();
     _order = new PredecessorObj<Order>(this, RoleOrder, memento);
     _prior = new PredecessorList<ContactInformation>(this, RolePrior, memento);
 }

 // Hydration constructor
 private Company(FactMemento memento)
 {
     InitializeResults();
 }

 // Hydration constructor
 private Closed(FactMemento memento)
 {
     InitializeResults();
     _delivered = new PredecessorObj<Delivered>(this, RoleDelivered, memento);
 }

 // Hydration constructor
 private Pull(FactMemento memento)
 {
     InitializeResults();
     _order = new PredecessorObj<Order>(this, RoleOrder, memento);
     _kitchen = new PredecessorObj<Kitchen>(this, RoleKitchen, memento);
 }

 // Hydration constructor
 private ProvisionFrontOffice(FactMemento memento)
 {
     InitializeResults();
     _machine = new PredecessorObj<Machine>(this, RoleMachine, memento);
     _company = new PredecessorObj<Company>(this, RoleCompany, memento);
 }

 // Hydration constructor
 private CakeDetail(FactMemento memento)
 {
     InitializeResults();
     _order = new PredecessorObj<Order>(this, RoleOrder, memento);
     _size = new PredecessorObj<CakeSize>(this, RoleSize, memento);
     _cakeFlavor = new PredecessorObj<CakeFlavor>(this, RoleCakeFlavor, memento);
     _frostingFlavor = new PredecessorObj<FrostingFlavor>(this, RoleFrostingFlavor, memento);
     _mainColor = new PredecessorObj<FrostingColor>(this, RoleMainColor, memento);
     _decorationColor = new PredecessorObj<FrostingColor>(this, RoleDecorationColor, memento);
     _prior = new PredecessorList<CakeDetail>(this, RolePrior, memento);
 }

 // Hydration constructor
 private EnableToastNotification(FactMemento memento)
 {
     InitializeResults();
     _individual = new PredecessorObj<Individual>(this, RoleIndividual, memento);
 }

            public CorrespondenceFact CreateFact(FactMemento memento)
            {
                Domain newFact = new Domain(memento);

                // Create a memory stream from the memento data.
                using (MemoryStream data = new MemoryStream(memento.Data))
                {
                    using (BinaryReader output = new BinaryReader(data))
                    {
                    }
                }

                return newFact;
            }

 // Hydration constructor
 private Domain(FactMemento memento)
 {
     InitializeResults();
 }

 // Hydration constructor
 private DisableToastNotification(FactMemento memento)
 {
     InitializeResults();
     _enable = new PredecessorList<EnableToastNotification>(this, RoleEnable, memento);
 }

        public FactID Save(string domain, FactMemento fact, Guid clientGuid)
        {
            FactID factId;
            List<FactID> affectedPivots;

            lock (this)
            {
                // See if the fact already exists.
                FactRecord existingFact = _factTable.FirstOrDefault(o =>
                    o.IdentifiedFactMemento.Memento.Equals(fact));
                if (existingFact == null)
                {
                    // It doesn't, so create it.
                    FactID newFactID = new FactID() { key = _factTable.Count + 1 };
                    factId = newFactID;
                    existingFact = new FactRecord()
                    {
                        IdentifiedFactMemento = new IdentifiedFactMemento(factId, fact)
                    };

                    _factTable.Add(existingFact);

                    // Store a message for each pivot.
                    var pivots = fact.Predecessors
                        .Where(predecessor => predecessor.IsPivot);
                    _messageTable.AddRange(pivots
                        .Select(predecessor => new MessageRecord(
                            new MessageMemento(predecessor.ID, newFactID),
                            newFactID,
                            predecessor.Role,
                            clientGuid)));

                    // Store messages for each non-pivot. This fact belongs to all predecessors' pivots.
                    List<FactID> nonPivots = fact.Predecessors
                        .Where(predecessor => !predecessor.IsPivot)
                        .Select(predecessor => predecessor.ID)
                        .ToList();
                    List<MessageRecord> predecessorsPivots = _messageTable
                        .Where(message => nonPivots.Contains(message.Message.FactId))
                        .Distinct()
                        .ToList();
                    _messageTable.AddRange(predecessorsPivots
                        .Select(predecessorPivot => new MessageRecord(
                            new MessageMemento(predecessorPivot.Message.PivotId, newFactID),
                            predecessorPivot.AncestorFact,
                            predecessorPivot.AncestorRole,
                            clientGuid)));

                    affectedPivots =
                        pivots
                            .Select(pivot => pivot.ID)
                        .Union(predecessorsPivots
                            .Select(predecessorPivot => predecessorPivot.Message.PivotId))
                        .ToList();
                }
                else
                {
                    factId = existingFact.IdentifiedFactMemento.Id;
                    affectedPivots = null;
                }
            }

            if (affectedPivots != null && affectedPivots.Any() && PivotAffected != null)
                foreach (var pivotId in affectedPivots)
                    PivotAffected(domain, pivotId, factId, clientGuid);

            return factId;
        }

 // Hydration constructor
 private DeprovisionFrontOffice(FactMemento memento)
 {
     InitializeResults();
     _provision = new PredecessorObj<ProvisionFrontOffice>(this, RoleProvision, memento);
 }

 // Hydration constructor
 private DeprovisionKitchen(FactMemento memento)
 {
     InitializeResults();
     _provision = new PredecessorObj<ProvisionKitchen>(this, RoleProvision, memento);
 }

 // Hydration constructor
 private Machine(FactMemento memento)
 {
     InitializeResults();
 }

 // Hydration constructor
 private Individual(FactMemento memento)
 {
     InitializeResults();
 }

 // Hydration constructor
 private ProvisionKitchen(FactMemento memento)
 {
     InitializeResults();
     _machine = new PredecessorObj<Machine>(this, RoleMachine, memento);
     _kitchen = new PredecessorObj<Kitchen>(this, RoleKitchen, memento);
 }