23

public:

    24

	void inline ResetAll()

    25

	{

    26

		blocks[0] = 0x0000000000000000;

    27

		blocks[1] = 0x0000000000000000;

    28

	};

    30

	void Initialise(const byte *blocklist, int num_bytes)

    31

	{

    32

		ResetAll();

    33

		for (int i = 0; i < num_bytes; i++) {

    34

			blocks[(blocklist[i] < 64) ? 0 : 1] |= GetBlockAsBits(blocklist[i]);

    36

	}

    38

	uint64 inline GetLower() const

    39

	{

    40

		return blocks[0];

    41

	}

    43

	uint64 inline GetUpper() const

    44

	{

    45

		return blocks[1];

    46

	}

    48

	void inline ReserveBlocks(const FSMblockmap *blockmap)

    49

	{

    50

		/* OR with blockmap to reserve blocks */

    51

		blocks[0] |= blockmap->GetLower();

    52

		blocks[1] |= blockmap->GetUpper();

    53

	}

    55

	void inline ReleaseBlocks(const FSMblockmap *blockmap)

    56

	{

    57

		/* AND with ones-complement to clear set bits in blockmap from block_lower and block_upper */

    58

		blocks[0] &= ~blockmap->GetLower();

    59

		blocks[1] &= ~blockmap->GetUpper();

    60

	}

    62

	bool inline BlocksAreFree(const FSMblockmap *blockmap) const

    63

	{

    64

		uint64 test_lower = blockmap->GetLower();

    65

		uint64 test_upper = blockmap->GetUpper();

    66

    67

		if ((~blocks[0] & test_lower) != test_lower)  return false;

    68

		if ((~blocks[1] & test_upper) != test_upper)  return false;

    69

    70

		return true;

    71

	}

    72

    73

	bool inline HasBlocks(const FSMblockmap *blockmap) const

    74

	{

    75

		uint64 test_lower = blockmap->GetLower();

    76

		uint64 test_upper = blockmap->GetUpper();

    77

    78

		if ((blocks[0] & test_lower) != test_lower)  return false;

    79

		if ((blocks[1] & test_upper) != test_upper)  return false;

    80

    81

		return true;

    82

	}

    83

    84

	bool inline HasBlock(byte blocknumber) const

    85

	{

    86

		FSMblockmap test_blockmap;

    87

		test_blockmap.Initialise(&blocknumber, 1);

    88

		return HasBlocks(&test_blockmap);

    89

	}

    90

    91

	//bool inline HasBlock(byte blocknumber)

    92

	//{

    93

	//	uint64 test_block = GetBlockAsBits(blocknumber);

    94

	//	if (blocknumber < 64) return ((block_lower & test_block) == test_block);

    95

	//	return ((block_upper & test_block) == test_block);

    96

	//}

    97

    98

	bool inline IsNotZero(void) const

    99

	{

   100

		return ((blocks[0] != 0) || (blocks[1] != 0));

   101

	}

   102

   103

	void PrintBlock(bool newline = true) const;

   104

   105

	/**

   106

	 * Needed for an ugly hack:

   107

	 *  - vehicles and stations need to store fsmblocks, so they use FSMBlock as container

   108

	 *  - this internals of the container should be protected, e.g. private (or protected) by C++

   109

	 *  - for saving/loading we need to pass pointer to objects

   110

	 *  -> so *if* the pointer to the FSMBlock is the same as the pointer to the blocks array

   111

	 *     encapsulated in the FSMBlock, we can just pass the FSMBlock as "offset".

   112

	 *     Normally we would then just add the offset of the blocks variable within the class

   113

	 *     but that is not possible because the variable is private. Furthermore we are not sure

   114

	 *     that this works on all platforms, we need to check whether the offset is actually 0.

   115

	 *     This cannot be done compile time, because the variable is private. So we need to write

   116

	 *     a function that does actually check the offset runtime and call it somewhere where it

   117

	 *     is always called but it should not be called often.

   118

	 */

   119

	static void AssertOnWrongBlockOffset();

   120

   121

private:

   122

	uint64 blocks[2];