storage

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 26, 2021 License: GPL-3.0 Imports: 15 Imported by: 0

Documentation

Overview

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BlockCacheObject 

type BlockCacheObject struct {
	ID        int64
	Height    uint32
	Timestamp int64
	BlockHash []byte
}

BlockCacheObject represent selected field from model.Block want to cache

type BlockStateStorage 

type BlockStateStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

BlockStateStorage represent last state of block

func NewBlockStateStorage 

func NewBlockStateStorage() *BlockStateStorage

NewBlockStateStorage returns BlockStateStorage instance

func (*BlockStateStorage) CacheRegularCleaningListener 

func (bs *BlockStateStorage) CacheRegularCleaningListener() observer.Listener

func (*BlockStateStorage) ClearCache 

func (bs *BlockStateStorage) ClearCache() error

ClearCache cleaner of BlockStateStorage

func (*BlockStateStorage) GetAllItems 

func (bs *BlockStateStorage) GetAllItems(item interface{}) error

func (*BlockStateStorage) GetItem 

func (bs *BlockStateStorage) GetItem(lastUpdate, block interface{}) error

GetItem getter of BlockStateStorage

func (*BlockStateStorage) GetItems 

func (bs *BlockStateStorage) GetItems(keys, items interface{}) error

func (*BlockStateStorage) GetSize 

func (bs *BlockStateStorage) GetSize() int64

GetSize return the size of BlockStateStorage

func (*BlockStateStorage) GetTotalItems 

func (bs *BlockStateStorage) GetTotalItems() int

func (*BlockStateStorage) RemoveItem 

func (bs *BlockStateStorage) RemoveItem(key interface{}) error

func (*BlockStateStorage) RemoveItems 

func (bs *BlockStateStorage) RemoveItems(keys interface{}) error

func (*BlockStateStorage) SetItem 

func (bs *BlockStateStorage) SetItem(lastUpdate, block interface{}) error

SetItem setter of BlockStateStorage

func (*BlockStateStorage) SetItems 

func (bs *BlockStateStorage) SetItems(_ interface{}) error

type BlocksStorage 

type BlocksStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

Blockstorage will cache last 720 blocks

func NewBlocksStorage 

func NewBlocksStorage(metricLabel monitoring.CacheStorageType) *BlocksStorage

func (*BlocksStorage) CacheRegularCleaningListener 

func (b *BlocksStorage) CacheRegularCleaningListener() observer.Listener

func (*BlocksStorage) Clear 

func (b *BlocksStorage) Clear() error

func (*BlocksStorage) ClearCache 

func (b *BlocksStorage) ClearCache() error

ClearCache empty the storage item

func (*BlocksStorage) GetAll 

func (b *BlocksStorage) GetAll(items interface{}) error

func (*BlocksStorage) GetAllItems 

func (b *BlocksStorage) GetAllItems(item interface{}) error

GetAllItems fetch all cached items

func (*BlocksStorage) GetAtIndex 

func (b *BlocksStorage) GetAtIndex(height uint32, item interface{}) error

GetAtIndex get block cache object based on given index

func (*BlocksStorage) GetItem 

func (b *BlocksStorage) GetItem(key, item interface{}) error

GetItem take variable and assign implementation stored item to it

func (*BlocksStorage) GetItems 

func (b *BlocksStorage) GetItems(keys, items interface{}) error

func (*BlocksStorage) GetSize 

func (b *BlocksStorage) GetSize() int64

GetSize return the size of storage in number of `byte`

func (*BlocksStorage) GetTop 

func (b *BlocksStorage) GetTop(item interface{}) error

func (*BlocksStorage) GetTotalItems 

func (b *BlocksStorage) GetTotalItems() int

GetTotalItems fetch the number of total cached items

func (*BlocksStorage) Pop 

func (b *BlocksStorage) Pop() error

func (*BlocksStorage) PopTo 

func (b *BlocksStorage) PopTo(height uint32) error

PopTo pop the cache blocks from the provided height to the last height

func (*BlocksStorage) Push 

func (b *BlocksStorage) Push(item interface{}) error

Push add new item into list & remove the oldest one if needed

func (*BlocksStorage) RemoveItem 

func (b *BlocksStorage) RemoveItem(key interface{}) error

RemoveItem not implementaed, set intem already implement in Pop CacheStackStorageInterface

func (*BlocksStorage) RemoveItems 

func (b *BlocksStorage) RemoveItems(keys interface{}) error

func (*BlocksStorage) SetItem 

func (b *BlocksStorage) SetItem(key, item interface{}) error

SetItem not implementaed, set intem already implement in push CacheStackStorageInterface

func (*BlocksStorage) SetItems 

func (b *BlocksStorage) SetItems(item interface{}) error

SetItem not implementaed, set intem already implement in push CacheStackStorageInterface

type CacheStackStorageInterface 

type CacheStackStorageInterface interface {
	// Pop delete the latest item on the stack
	Pop() error
	// Push item into the stack, if exceed size first item is deleted and shifted
	Push(interface{}) error
	// PopTo takes index (uint32) and delete item to the given index (start from 0)
	PopTo(uint32) error
	// GetAll return all item in the stack to given `interface` arguments
	GetAll(interface{}) error
	// GetAtIndex return item at given index
	GetAtIndex(uint32, interface{}) error
	// GetTop return top item on the stack
	GetTop(interface{}) error
	// Clear clean up the whole stack and reinitialize with new array
	Clear() error
}

type CacheStorageInterface 

type CacheStorageInterface interface {
	// SetItem take any item and store to its specific storage implementation
	SetItem(key, item interface{}) error
	// SetItems take all items that stored and refill item reference
	SetItems(item interface{}) error
	// GetItem take variable and assign implementation stored item to it
	GetItem(key, item interface{}) error
	// GetItems take variable and assign implementation stored items to it
	GetItems(keys, items interface{}) error
	// GetAllItems fetch all cached items
	GetAllItems(item interface{}) error
	// GetTotalItems fetch the number of total cached items
	GetTotalItems() int
	// RemoveItem remove item by providing the key
	RemoveItem(key interface{}) error
	// RemoveItems remove item by providing the keys
	RemoveItems(keys interface{}) error
	// GetSize return the size of storage in number of `byte`
	GetSize() int64
	// ClearCache empty the storage item
	ClearCache() error
	// CacheRegularCleaningListener returns listener to run cleaning operation for cache items
	CacheRegularCleaningListener() observer.Listener
}

type MempoolBackupStorage 

type MempoolBackupStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

MempoolBackupStorage cache storage for backup transactions that want to rollback

func NewMempoolBackupStorage 

func NewMempoolBackupStorage() *MempoolBackupStorage

NewMempoolBackupStorage create new instance of MempoolBackupStorage

func (*MempoolBackupStorage) CacheRegularCleaningListener 

func (m *MempoolBackupStorage) CacheRegularCleaningListener() observer.Listener

func (*MempoolBackupStorage) ClearCache 

func (m *MempoolBackupStorage) ClearCache() error

ClearCache clear or remove all items from MempoolBackupStorage

func (*MempoolBackupStorage) GetAllItems 

func (m *MempoolBackupStorage) GetAllItems(item interface{}) error

GetAllItems get all from MempoolBackupStorage and refill reference item

func (*MempoolBackupStorage) GetItem 

func (m *MempoolBackupStorage) GetItem(key, item interface{}) error

GetItem get an item from MempoolBackupStorage by key and refill reference item

func (*MempoolBackupStorage) GetItems 

func (m *MempoolBackupStorage) GetItems(keys, items interface{}) error

func (*MempoolBackupStorage) GetSize 

func (m *MempoolBackupStorage) GetSize() int64

GetSize get size of MempoolBackupStorage values

func (*MempoolBackupStorage) GetTotalItems 

func (m *MempoolBackupStorage) GetTotalItems() int

func (*MempoolBackupStorage) RemoveItem 

func (m *MempoolBackupStorage) RemoveItem(key interface{}) error

RemoveItem remove specific item by key

func (*MempoolBackupStorage) RemoveItems 

func (m *MempoolBackupStorage) RemoveItems(keys interface{}) error

func (*MempoolBackupStorage) SetItem 

func (m *MempoolBackupStorage) SetItem(key, item interface{}) error

SetItem add new item on mempoolBackup

func (*MempoolBackupStorage) SetItems 

func (m *MempoolBackupStorage) SetItems(items interface{}) error

SetItems replace and set bulk items

type MempoolCacheObject 

type MempoolCacheObject struct {
	Tx                  model.Transaction
	ArrivalTimestamp    int64
	FeePerByte          int64
	TransactionByteSize uint32
	BlockHeight         uint32
}

type MempoolCacheStorage 

type MempoolCacheStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

MempoolCacheStorage cache layer for mempool transaction

func NewMempoolStorage 

func NewMempoolStorage() *MempoolCacheStorage

func (*MempoolCacheStorage) CacheRegularCleaningListener 

func (m *MempoolCacheStorage) CacheRegularCleaningListener() observer.Listener

func (*MempoolCacheStorage) ClearCache 

func (m *MempoolCacheStorage) ClearCache() error

func (*MempoolCacheStorage) GetAllItems 

func (m *MempoolCacheStorage) GetAllItems(item interface{}) error

func (*MempoolCacheStorage) GetItem 

func (m *MempoolCacheStorage) GetItem(key, item interface{}) error

func (*MempoolCacheStorage) GetItems 

func (m *MempoolCacheStorage) GetItems(keys, items interface{}) error

func (*MempoolCacheStorage) GetSize 

func (m *MempoolCacheStorage) GetSize() int64

func (*MempoolCacheStorage) GetTotalItems 

func (m *MempoolCacheStorage) GetTotalItems() int

func (*MempoolCacheStorage) RemoveItem 

func (m *MempoolCacheStorage) RemoveItem(keys interface{}) error

func (*MempoolCacheStorage) RemoveItems 

func (m *MempoolCacheStorage) RemoveItems(keys interface{}) error

func (*MempoolCacheStorage) SetItem 

func (m *MempoolCacheStorage) SetItem(key, item interface{}) error

func (*MempoolCacheStorage) SetItems 

func (m *MempoolCacheStorage) SetItems(_ interface{}) error

type MempoolMap 

type MempoolMap map[int64]MempoolCacheObject

type NodeAddressInfoStorage 

type NodeAddressInfoStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

NodeAddressInfoStorage represent list of node address info

func NewNodeAddressInfoStorage 

func NewNodeAddressInfoStorage() *NodeAddressInfoStorage

func (*NodeAddressInfoStorage) Begin 

func (nas *NodeAddressInfoStorage) Begin() error

Begin prepare data to begin doing transactional change to the cache, this implementation will never return error

func (*NodeAddressInfoStorage) CacheRegularCleaningListener 

func (nas *NodeAddressInfoStorage) CacheRegularCleaningListener() observer.Listener

func (*NodeAddressInfoStorage) ClearCache 

func (nas *NodeAddressInfoStorage) ClearCache() error

func (*NodeAddressInfoStorage) Commit 

func (nas *NodeAddressInfoStorage) Commit() error

func (*NodeAddressInfoStorage) GetAllItems 

func (nas *NodeAddressInfoStorage) GetAllItems(item interface{}) error

func (*NodeAddressInfoStorage) GetItem 

func (nas *NodeAddressInfoStorage) GetItem(key, item interface{}) error

func (*NodeAddressInfoStorage) GetItems 

func (nas *NodeAddressInfoStorage) GetItems(keys, items interface{}) error

func (*NodeAddressInfoStorage) GetSize 

func (nas *NodeAddressInfoStorage) GetSize() int64

func (*NodeAddressInfoStorage) GetTotalItems 

func (nas *NodeAddressInfoStorage) GetTotalItems() int

func (*NodeAddressInfoStorage) RemoveItem 

func (nas *NodeAddressInfoStorage) RemoveItem(key interface{}) error

func (*NodeAddressInfoStorage) RemoveItems 

func (nas *NodeAddressInfoStorage) RemoveItems(keys interface{}) error

func (*NodeAddressInfoStorage) Rollback 

func (nas *NodeAddressInfoStorage) Rollback() error

func (*NodeAddressInfoStorage) SetItem 

func (nas *NodeAddressInfoStorage) SetItem(key, item interface{}) error

func (*NodeAddressInfoStorage) SetItems 

func (nas *NodeAddressInfoStorage) SetItems(item interface{}) error

func (*NodeAddressInfoStorage) TxRemoveItem 

func (nas *NodeAddressInfoStorage) TxRemoveItem(key interface{}) error

TxRemoveItem will add node address info ID into transactional remove list

func (*NodeAddressInfoStorage) TxSetItem 

func (nas *NodeAddressInfoStorage) TxSetItem(id, item interface{}) error

TxSetItem currently doesn’t need to set in transactional

func (*NodeAddressInfoStorage) TxSetItems 

func (nas *NodeAddressInfoStorage) TxSetItems(items interface{}) error

TxSetItems currently doesn’t need to set in transactional

type NodeAddressInfoStorageKey 

type NodeAddressInfoStorageKey struct {
	NodeID      int64
	AddressPort string
	Statuses    []model.NodeAddressStatus
}

NodeAddressInfoStorageKey represent a key for NodeAddressInfoStorage

type NodeAdmissionTimestampStorage 

type NodeAdmissionTimestampStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

NodeAdmissionTimestampStorage store next node admission timestamp

func NewNodeAdmissionTimestampStorage 

func NewNodeAdmissionTimestampStorage() *NodeAdmissionTimestampStorage

NewNodeAdmissionTimestampStorage returns new NodeAdmissionTimesatmpStorage instance

func (*NodeAdmissionTimestampStorage) CacheRegularCleaningListener 

func (ns *NodeAdmissionTimestampStorage) CacheRegularCleaningListener() observer.Listener

func (*NodeAdmissionTimestampStorage) ClearCache 

func (ns *NodeAdmissionTimestampStorage) ClearCache() error

ClearCache cleaner of NodeAdmissionTimestampStorage

func (*NodeAdmissionTimestampStorage) GetAllItems 

func (ns *NodeAdmissionTimestampStorage) GetAllItems(item interface{}) error

func (*NodeAdmissionTimestampStorage) GetItem 

func (ns *NodeAdmissionTimestampStorage) GetItem(lastChange, item interface{}) error

GetItem getter of NodeAdmissionTimestampStorage

func (*NodeAdmissionTimestampStorage) GetItems 

func (ns *NodeAdmissionTimestampStorage) GetItems(keys, items interface{}) error

func (*NodeAdmissionTimestampStorage) GetSize 

func (ns *NodeAdmissionTimestampStorage) GetSize() int64

GetSize return the size of NodeAdmissionTimestampStorage

func (*NodeAdmissionTimestampStorage) GetTotalItems 

func (ns *NodeAdmissionTimestampStorage) GetTotalItems() int

func (*NodeAdmissionTimestampStorage) RemoveItem 

func (ns *NodeAdmissionTimestampStorage) RemoveItem(key interface{}) error

func (*NodeAdmissionTimestampStorage) RemoveItems 

func (ns *NodeAdmissionTimestampStorage) RemoveItems(keys interface{}) error

func (*NodeAdmissionTimestampStorage) SetItem 

func (ns *NodeAdmissionTimestampStorage) SetItem(lastChange, item interface{}) error

SetItem setter of NodeAdmissionTimestampStorage Note: lastChange curretly unused

func (*NodeAdmissionTimestampStorage) SetItems 

func (ns *NodeAdmissionTimestampStorage) SetItems(_ interface{}) error

type NodeRegistry 

type NodeRegistry struct {
	Node               model.NodeRegistration
	ParticipationScore int64
}

NodeRegistry store in-memory representation of node registry, excluding its NodeAddressInfo which is cache on different storage struct

type NodeRegistryCacheStorage 

type NodeRegistryCacheStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewNodeRegistryCacheStorage 

func NewNodeRegistryCacheStorage(
	metricLabel monitoring.CacheStorageType,
	sortFunc func([]NodeRegistry),
) *NodeRegistryCacheStorage

NewNodeRegistryCacheStorage returns NodeRegistryCacheStorage instance

func (*NodeRegistryCacheStorage) Begin 

func (n *NodeRegistryCacheStorage) Begin() error

Begin prepare data to begin doing transactional change to the cache, this implementation will never return error

func (*NodeRegistryCacheStorage) CacheRegularCleaningListener 

func (n *NodeRegistryCacheStorage) CacheRegularCleaningListener() observer.Listener

func (*NodeRegistryCacheStorage) ClearCache 

func (n *NodeRegistryCacheStorage) ClearCache() error

func (*NodeRegistryCacheStorage) Commit 

func (n *NodeRegistryCacheStorage) Commit() error

Commit of node registry cache replace all value in n.nodeRegistries this implementation will never return error

func (*NodeRegistryCacheStorage) GetAllItems 

func (n *NodeRegistryCacheStorage) GetAllItems(item interface{}) error

func (*NodeRegistryCacheStorage) GetItem 

func (n *NodeRegistryCacheStorage) GetItem(idx, item interface{}) error

func (*NodeRegistryCacheStorage) GetItems 

func (n *NodeRegistryCacheStorage) GetItems(keys, items interface{}) error

func (*NodeRegistryCacheStorage) GetSize 

func (n *NodeRegistryCacheStorage) GetSize() int64

func (*NodeRegistryCacheStorage) GetTotalItems 

func (n *NodeRegistryCacheStorage) GetTotalItems() int

func (*NodeRegistryCacheStorage) RemoveItem 

func (n *NodeRegistryCacheStorage) RemoveItem(idx interface{}) error

func (*NodeRegistryCacheStorage) RemoveItems 

func (n *NodeRegistryCacheStorage) RemoveItems(keys interface{}) error

func (*NodeRegistryCacheStorage) Rollback 

func (n *NodeRegistryCacheStorage) Rollback() error

Rollback return the state of cache to before any changes made, either to transactional data or actual committed data. This implementation will never return error.

func (*NodeRegistryCacheStorage) SetItem 

func (n *NodeRegistryCacheStorage) SetItem(idx, item interface{}) error

SetItem don't require index in node registry cache implementation, since it's a sorted array

func (*NodeRegistryCacheStorage) SetItems 

func (n *NodeRegistryCacheStorage) SetItems(items interface{}) error

func (*NodeRegistryCacheStorage) TxRemoveItem 

func (n *NodeRegistryCacheStorage) TxRemoveItem(idx interface{}) error

TxRemoveItem remove an item from transactional state given the index

func (*NodeRegistryCacheStorage) TxSetItem 

func (n *NodeRegistryCacheStorage) TxSetItem(idx, item interface{}) error

func (*NodeRegistryCacheStorage) TxSetItems 

func (n *NodeRegistryCacheStorage) TxSetItems(items interface{}) error

type NodeShardCacheStorage 

type NodeShardCacheStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewNodeShardCacheStorage 

func NewNodeShardCacheStorage() *NodeShardCacheStorage

func (*NodeShardCacheStorage) CacheRegularCleaningListener 

func (n *NodeShardCacheStorage) CacheRegularCleaningListener() observer.Listener

func (*NodeShardCacheStorage) ClearCache 

func (n *NodeShardCacheStorage) ClearCache() error

func (*NodeShardCacheStorage) GetAllItems 

func (n *NodeShardCacheStorage) GetAllItems(item interface{}) error

func (*NodeShardCacheStorage) GetItem 

func (n *NodeShardCacheStorage) GetItem(lastChange, item interface{}) error

GetItem getter of NodShardCacheStorage

func (*NodeShardCacheStorage) GetItems 

func (n *NodeShardCacheStorage) GetItems(keys, items interface{}) error

func (*NodeShardCacheStorage) GetSize 

func (n *NodeShardCacheStorage) GetSize() int64

func (*NodeShardCacheStorage) GetTotalItems 

func (n *NodeShardCacheStorage) GetTotalItems() int

func (*NodeShardCacheStorage) RemoveItem 

func (n *NodeShardCacheStorage) RemoveItem(key interface{}) error

func (*NodeShardCacheStorage) RemoveItems 

func (n *NodeShardCacheStorage) RemoveItems(keys interface{}) error

func (*NodeShardCacheStorage) SetItem 

func (n *NodeShardCacheStorage) SetItem(lastChange, item interface{}) error

SetItem setter of NodeShardCacheStorage

func (*NodeShardCacheStorage) SetItems 

func (n *NodeShardCacheStorage) SetItems(_ interface{}) error

type ReceiptPoolCacheStorage 

type ReceiptPoolCacheStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewReceiptPoolCacheStorage 

func NewReceiptPoolCacheStorage() *ReceiptPoolCacheStorage

func (*ReceiptPoolCacheStorage) CacheRegularCleaningListener 

func (brs *ReceiptPoolCacheStorage) CacheRegularCleaningListener() observer.Listener

func (*ReceiptPoolCacheStorage) CleanExpiredReceipts 

func (brs *ReceiptPoolCacheStorage) CleanExpiredReceipts(blockHeight uint32)

func (*ReceiptPoolCacheStorage) ClearCache 

func (brs *ReceiptPoolCacheStorage) ClearCache() error

func (*ReceiptPoolCacheStorage) GetAllItems 

func (brs *ReceiptPoolCacheStorage) GetAllItems(items interface{}) error

GetAllItems get all items of ReceiptPoolCacheStorage

  • items: *map[string]BatchReceipt

func (*ReceiptPoolCacheStorage) GetItem 

func (brs *ReceiptPoolCacheStorage) GetItem(_, _ interface{}) error

GetItem getting single item of ReceiptPoolCacheStorage refill the reference item

  • key: receiptKey which is a string
  • item: BatchReceiptCache

func (*ReceiptPoolCacheStorage) GetItems 

func (brs *ReceiptPoolCacheStorage) GetItems(keys, items interface{}) error

GetItems getting multiple items of ReceiptPoolCacheStorage refill the reference item

  • keys: receiptKey which is an array of string
  • items: BatchReceiptCache (map of array of receipts) map is by default passed as reference

func (*ReceiptPoolCacheStorage) GetSize 

func (brs *ReceiptPoolCacheStorage) GetSize() int64

func (*ReceiptPoolCacheStorage) GetTotalItems 

func (brs *ReceiptPoolCacheStorage) GetTotalItems() int

func (*ReceiptPoolCacheStorage) RemoveItem 

func (brs *ReceiptPoolCacheStorage) RemoveItem(_ interface{}) error

func (*ReceiptPoolCacheStorage) RemoveItems 

func (brs *ReceiptPoolCacheStorage) RemoveItems(keys interface{}) error

func (*ReceiptPoolCacheStorage) SetItem 

func (brs *ReceiptPoolCacheStorage) SetItem(key, item interface{}) error

SetItem set new value to ReceiptPoolCacheStorage

  • key: nil
  • item: BatchReceiptCache

func (*ReceiptPoolCacheStorage) SetItems 

func (brs *ReceiptPoolCacheStorage) SetItems(items interface{}) error

SetItems store and replace the old items. (not implemented)

type ReceiptReminderStorage 

type ReceiptReminderStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewReceiptReminderStorage 

func NewReceiptReminderStorage() *ReceiptReminderStorage

func (*ReceiptReminderStorage) CacheRegularCleaningListener 

func (rs *ReceiptReminderStorage) CacheRegularCleaningListener() observer.Listener

func (*ReceiptReminderStorage) ClearCache 

func (rs *ReceiptReminderStorage) ClearCache() error

func (*ReceiptReminderStorage) GetAllItems 

func (rs *ReceiptReminderStorage) GetAllItems(key interface{}) error

func (*ReceiptReminderStorage) GetItem 

func (rs *ReceiptReminderStorage) GetItem(key, item interface{}) error

func (*ReceiptReminderStorage) GetItems 

func (rs *ReceiptReminderStorage) GetItems(keys, items interface{}) error

func (*ReceiptReminderStorage) GetSize 

func (rs *ReceiptReminderStorage) GetSize() int64

func (*ReceiptReminderStorage) GetTotalItems 

func (rs *ReceiptReminderStorage) GetTotalItems() int

func (*ReceiptReminderStorage) RemoveItem 

func (rs *ReceiptReminderStorage) RemoveItem(key interface{}) error

func (*ReceiptReminderStorage) RemoveItems 

func (rs *ReceiptReminderStorage) RemoveItems(keys interface{}) error

func (*ReceiptReminderStorage) SetItem 

func (rs *ReceiptReminderStorage) SetItem(key, item interface{}) error

SetItem add new item into storage

func (*ReceiptReminderStorage) SetItems 

func (rs *ReceiptReminderStorage) SetItems(_ interface{}) error

type ScrambleCacheStackStorage 

type ScrambleCacheStackStorage struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewScrambleCacheStackStorage 

func NewScrambleCacheStackStorage() *ScrambleCacheStackStorage

func (*ScrambleCacheStackStorage) CacheRegularCleaningListener 

func (s *ScrambleCacheStackStorage) CacheRegularCleaningListener() observer.Listener

func (*ScrambleCacheStackStorage) Clear 

func (s *ScrambleCacheStackStorage) Clear() error

func (*ScrambleCacheStackStorage) GetAll 

func (s *ScrambleCacheStackStorage) GetAll(items interface{}) error

func (*ScrambleCacheStackStorage) GetAtIndex 

func (s *ScrambleCacheStackStorage) GetAtIndex(index uint32, item interface{}) error

func (*ScrambleCacheStackStorage) GetItems 

func (s *ScrambleCacheStackStorage) GetItems(keys, items interface{}) error

func (*ScrambleCacheStackStorage) GetTop 

func (s *ScrambleCacheStackStorage) GetTop(item interface{}) error

func (*ScrambleCacheStackStorage) Pop 

func (s *ScrambleCacheStackStorage) Pop() error

func (*ScrambleCacheStackStorage) PopTo 

func (s *ScrambleCacheStackStorage) PopTo(index uint32) error

PopTo pop the scramble stack to index-th element (last element = index-th element)

func (*ScrambleCacheStackStorage) Push 

func (s *ScrambleCacheStackStorage) Push(item interface{}) error

func (*ScrambleCacheStackStorage) RemoveItems 

func (s *ScrambleCacheStackStorage) RemoveItems(keys interface{}) error

type ShardMap 

type ShardMap struct {
	NodeShards  map[int64][]uint64
	ShardChunks map[uint64][][]byte
}

type TransactionalCache 

type TransactionalCache interface {
	// Begin prepare state of cache for transactional writes, must called at start of tx writes
	Begin() error
	// Commit finalize transactional writes to the struct
	Commit() error
	// Rollback release locks and return state of struct to original before tx modifications are made
	Rollback() error
	// TxSetItem set individual item
	TxSetItem(id, item interface{}) error
	// TxSetItems replace items in bulk
	TxSetItems(items interface{}) error
	// TxRemoveItem remove item with given ID
	TxRemoveItem(id interface{}) error
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.