| … | … | @@ -39,7 +39,8 @@ template class ObjectCRTP<StorageNode>; |
| 39 | 39 | // ==================================================================== |
| 40 | 40 | |
| 41 | 41 | StorageNode::StorageNode(Type t, std::string uri) : |
| 42 | | ObjectCRTP<StorageNode>(t, std::move(uri)) |
| 42 | ObjectCRTP<StorageNode>(t, std::move(uri)), |
| 43 | _target_as(nullptr) |
| 43 | 44 | { |
| 44 | 45 | if (not nameserver().isA(t, STORAGE_NODE)) |
| 45 | 46 | throw RuntimeException(TRACE_INFO, "Bad inheritance!"); |
| … | … | @@ -124,21 +125,46 @@ void StorageNode::setValue(const Handle& key, const ValuePtr& value) |
| 124 | 125 | const std::string& pred = key->get_name(); |
| 125 | 126 | switch (dispatch_hash(pred.c_str())) |
| 126 | 127 | { |
| 127 | | case p_open: |
| 128 | case p_open: { |
| 128 | 129 | COLL("*-open-*"); |
| 130 | ValuePtr vp(value); |
| 131 | if (vp->is_type(ATOM)) |
| 132 | { |
| 133 | Handle h(HandleCast(value)); |
| 134 | if (h->is_executable()) |
| 135 | vp = h->execute(); |
| 136 | } |
| 137 | |
| 138 | if (vp->is_type(ATOM_SPACE)) |
| 139 | _target_as = AtomSpaceCast(value); |
| 140 | else if (nullptr == vp or 0 == vp->size()) |
| 141 | _target_as = AtomSpaceCast(getAtomSpace()->shared_from_this()); |
| 142 | else |
| 143 | throw RuntimeException(TRACE_INFO, |
| 144 | "Expected *-open-* message expects AtomSpace; got %s", |
| 145 | value->to_string().c_str()); |
| 146 | |
| 129 | 147 | open(); |
| 130 | 148 | return; |
| 149 | } |
| 131 | 150 | case p_close: |
| 132 | 151 | COLL("*-close-*"); |
| 133 | 152 | close(); |
| 153 | _target_as = nullptr; |
| 134 | 154 | return; |
| 135 | 155 | case p_load_atomspace: |
| 136 | 156 | COLL("*-load-atomspace-*"); |
| 137 | | load_atomspace(AtomSpaceCast(value).get()); |
| 157 | if (nullptr == value or 0 == value->size()) |
| 158 | load_atomspace(_target_as.get()); |
| 159 | else |
| 160 | load_atomspace(AtomSpaceCast(value).get()); |
| 138 | 161 | return; |
| 139 | 162 | case p_store_atomspace: |
| 140 | 163 | COLL("*-store-atomspace-*"); |
| 141 | | store_atomspace(AtomSpaceCast(value).get()); |
| 164 | if (nullptr == value or 0 == value->size()) |
| 165 | store_atomspace(_target_as.get()); |
| 166 | else |
| 167 | store_atomspace(AtomSpaceCast(value).get()); |
| 142 | 168 | return; |
| 143 | 169 | case p_load_atoms_of_type: { |
| 144 | 170 | COLL("*-load-atoms-of-type-*"); |
| … | … | @@ -186,7 +212,7 @@ void StorageNode::setValue(const Handle& key, const ValuePtr& value) |
| 186 | 212 | } |
| 187 | 213 | if (not value->is_type(LINK_VALUE)) return; |
| 188 | 214 | const ValueSeq& vsq(LinkValueCast(value)->value()); |
| 189 | | AtomSpace* as = getAtomSpace(); |
| 215 | AtomSpace* as = _target_as.get(); |
| 190 | 216 | for (const ValuePtr& vp : vsq) |
| 191 | 217 | { |
| 192 | 218 | if (vp->is_type (ATOM_SPACE)) |
| … | … | @@ -225,7 +251,7 @@ void StorageNode::setValue(const Handle& key, const ValuePtr& value) |
| 225 | 251 | } |
| 226 | 252 | if (not value->is_type(LINK_VALUE)) return; |
| 227 | 253 | const ValueSeq& vsq(LinkValueCast(value)->value()); |
| 228 | | AtomSpace* as = getAtomSpace(); |
| 254 | AtomSpace* as = _target_as.get(); |
| 229 | 255 | for (const ValuePtr& vp : vsq) |
| 230 | 256 | { |
| 231 | 257 | if (vp->is_type (ATOM_SPACE)) |
| … | … | @@ -275,7 +301,10 @@ void StorageNode::setValue(const Handle& key, const ValuePtr& value) |
| 275 | 301 | return; |
| 276 | 302 | case p_barrier: |
| 277 | 303 | COLL("*-barrier-*"); |
| 278 | | barrier(AtomSpaceCast(value).get()); |
| 304 | if (nullptr == value or 0 == value->size()) |
| 305 | barrier(_target_as.get()); |
| 306 | else |
| 307 | barrier(AtomSpaceCast(value).get()); |
| 279 | 308 | return; |
| 280 | 309 | case p_store_frames: |
| 281 | 310 | COLL("*-store-frames-*"); |
| … | … | @@ -335,7 +364,7 @@ ValuePtr StorageNode::getValue(const Handle& key) const |
| 335 | 364 | |
| 336 | 365 | void StorageNode::barrier(AtomSpace* as) |
| 337 | 366 | { |
| 338 | | if (nullptr == as) as = getAtomSpace(); |
| 367 | if (nullptr == as) as = _target_as.get(); |
| 339 | 368 | as->barrier(); |
| 340 | 369 | } |
| 341 | 370 | |
| … | … | @@ -372,7 +401,7 @@ void StorageNode::remove_atom(AtomSpace* as, Handle h, bool recursive) |
| 372 | 401 | Handle StorageNode::fetch_atom(const Handle& h, AtomSpace* as) |
| 373 | 402 | { |
| 374 | 403 | if (nullptr == h) return Handle::UNDEFINED; |
| 375 | | if (nullptr == as) as = getAtomSpace(); |
| 404 | if (nullptr == as) as = _target_as.get(); |
| 376 | 405 | |
| 377 | 406 | // Now, get the latest values from the backing store. |
| 378 | 407 | // The operation here is to CLOBBER the values, NOT to merge them! |
| … | … | @@ -389,7 +418,7 @@ Handle StorageNode::fetch_atom(const Handle& h, AtomSpace* as) |
| 389 | 418 | Handle StorageNode::fetch_value(const Handle& h, const Handle& key, |
| 390 | 419 | AtomSpace* as) |
| 391 | 420 | { |
| 392 | | if (nullptr == as) as = getAtomSpace(); |
| 421 | if (nullptr == as) as = _target_as.get(); |
| 393 | 422 | Handle lkey = as->add_atom(key); |
| 394 | 423 | Handle lh = as->add_atom(h); |
| 395 | 424 | loadValue(lh, lkey); |
| … | … | @@ -399,7 +428,7 @@ Handle StorageNode::fetch_value(const Handle& h, const Handle& key, |
| 399 | 428 | Handle StorageNode::fetch_incoming_set(const Handle& h, bool recursive, |
| 400 | 429 | AtomSpace* as) |
| 401 | 430 | { |
| 402 | | if (nullptr == as) as = getAtomSpace(); |
| 431 | if (nullptr == as) as = _target_as.get(); |
| 403 | 432 | Handle lh = as->get_atom(h); |
| 404 | 433 | if (nullptr == lh) return lh; |
| 405 | 434 | |
| … | … | @@ -418,7 +447,7 @@ Handle StorageNode::fetch_incoming_set(const Handle& h, bool recursive, |
| 418 | 447 | Handle StorageNode::fetch_incoming_by_type(const Handle& h, Type t, |
| 419 | 448 | AtomSpace* as) |
| 420 | 449 | { |
| 421 | | if (nullptr == as) as = getAtomSpace(); |
| 450 | if (nullptr == as) as = _target_as.get(); |
| 422 | 451 | Handle lh = as->get_atom(h); |
| 423 | 452 | if (nullptr == lh) return lh; |
| 424 | 453 | |
| … | … | @@ -436,7 +465,7 @@ Handle StorageNode::fetch_query(const Handle& query, const Handle& key, |
| 436 | 465 | if (not query->is_executable() and not query->is_evaluatable()) |
| 437 | 466 | throw RuntimeException(TRACE_INFO, "Not executable!"); |
| 438 | 467 | |
| 439 | | if (nullptr == as) as = getAtomSpace(); |
| 468 | if (nullptr == as) as = _target_as.get(); |
| 440 | 469 | Handle lkey = as->add_atom(key); |
| 441 | 470 | Handle lq = as->add_atom(query); |
| 442 | 471 | Handle lmeta = metadata; |
| … | … | @@ -448,7 +477,7 @@ Handle StorageNode::fetch_query(const Handle& query, const Handle& key, |
| 448 | 477 | |
| 449 | 478 | void StorageNode::load_atomspace(AtomSpace* as) |
| 450 | 479 | { |
| 451 | | if (nullptr == as) as = getAtomSpace(); |
| 480 | if (nullptr == as) as = _target_as.get(); |
| 452 | 481 | loadAtomSpace(as); |
| 453 | 482 | } |
| 454 | 483 | |
| … | … | @@ -457,13 +486,13 @@ void StorageNode::load_atomspace(AtomSpace* as) |
| 457 | 486 | */ |
| 458 | 487 | void StorageNode::store_atomspace(AtomSpace* as) |
| 459 | 488 | { |
| 460 | | if (nullptr == as) as = getAtomSpace(); |
| 489 | if (nullptr == as) as = _target_as.get(); |
| 461 | 490 | storeAtomSpace(as); |
| 462 | 491 | } |
| 463 | 492 | |
| 464 | 493 | void StorageNode::fetch_all_atoms_of_type(Type t, AtomSpace* as) |
| 465 | 494 | { |
| 466 | | if (nullptr == as) as = getAtomSpace(); |
| 495 | if (nullptr == as) as = _target_as.get(); |
| 467 | 496 | loadType(as, t); |
| 468 | 497 | } |
| 469 | 498 | |