1

/* $Id$ */

     2

     3

/** @file FSMblockmap.h Definition of FSMblockmap class for use in state machines*/

     4

     5

#ifndef FSMBLOCKMAP_H

     6

#define FSMBLOCKMAP_H

     7

     8

#include "stdafx.h"

     9

    10

uint64 inline GetBlockAsBits(byte blocknumber)

    11

{

    12

	if (blocknumber == 0) return 0ULL;

    13

	if (blocknumber > 63) blocknumber -= 64;

    14

	uint64 result = 1ULL << blocknumber;

    15

	return result;

    16

}

    17

    18

/**

    19

 * This class provides functions and internal storage for blockmaps used in Finite State Machine

    20

 *

    21

*/

    22

struct FSMblockmap {

    23

public:

    24

	void inline ResetAll()

    25

	{

    26

		blocks[0] = 0x0000000000000000ULL;

    27

		blocks[1] = 0x0000000000000000ULL;

    28

	};

    29

    30

	void inline SetAll()

    31

	{

    32

		blocks[0] = 0xFFFFFFFFFFFFFFFFULL;

    33

		blocks[1] = 0xFFFFFFFFFFFFFFFFULL;

    34

	};

    35

    36

	void Initialise(const byte *blocklist, int num_bytes)

    37

	{

    38

		ResetAll();

    39

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

    40

			if (blocklist[i] == 0xFF) {

    41

				SetAll();

    42

				break;

    43

			}

    44

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

    45

		}

    46

	}

    47

    48

	uint64 inline GetLower() const

    49

	{

    50

		return blocks[0];

    51

	}

    52

    53

	uint64 inline GetUpper() const

    54

	{

    55

		return blocks[1];

    56

	}

    57

    58

	void inline BlockCopy(const FSMblockmap *blockmap)

    59

	{

    60

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

    61

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

    62

	}

    63

    64

	void inline ReserveBlocks(const FSMblockmap *blockmap)

    65

	{

    66

		/* OR with blockmap to reserve blocks */

    67

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

    68

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

    69

	}

    70

    71

	void inline ReleaseBlocks(const FSMblockmap *blockmap)

    72

	{

    73

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

    74

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

    75

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

    76

	}

    77

    78

	void inline ReleaseOnlyOwnedBlocks(const FSMblockmap *blockmap, const FSMblockmap *owned_blockmap)

    79

	{

    80

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

    81

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

    82

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

    83

	}

    84

    85

	void inline ReleaseLowerBlocks(const FSMblockmap *blockmap)

    86

	{

    87

		/* used to forget any existing terminal reservations */

    88

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

    89

	}

    90

    91

	void inline ReleaseUpperBlocks(const FSMblockmap *blockmap)

    92

	{

    93

		/* used to forget any normal movemnt reservations */

    94

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

    95

	}

    96

    97

	bool inline BlocksAreFree(const FSMblockmap *blockmap) const

    98

	{

    99

		uint64 test_lower = blockmap->GetLower();

   100

		uint64 test_upper = blockmap->GetUpper();

   101

   102

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

   103

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

   104

   105

		return true;

   106

	}

   107

   108

	bool inline CanReserveBlocks(const FSMblockmap *wantedblockmap, const FSMblockmap *targetblockmap) const

   109

	{

   110

		/* HasBlocks is a strict "have I got all the blocks? Yes/No". While useful in places

   111

		 * sometimes you want to ask "ive got some blocks. can I get the rest?"

   112

		 * This function does that.

   113

		 * The first assignment calculates which bits you need, but dont already have.

   114

		 * Then it tests whether the remaining bits are free in targetblockmap.

   115

		 * If they are, then return true.

   116

		 */

   117

		uint64 test_lower = (blocks[0] ^ wantedblockmap->GetLower()) & wantedblockmap->GetLower();

   118

		uint64 test_upper = (blocks[1] ^ wantedblockmap->GetUpper()) & wantedblockmap->GetUpper();

   119

   120

		if ((~targetblockmap->GetLower() & test_lower) != test_lower)  return false;

   121

		if ((~targetblockmap->GetUpper() & test_upper) != test_upper)  return false;

   122

   123

		return true;

   124

	}

   125

   126

	bool inline HasBlocks(const FSMblockmap *blockmap) const

   127

	{

   128

		uint64 test_lower = blockmap->GetLower();

   129

		uint64 test_upper = blockmap->GetUpper();

   130

   131

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

   132

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

   133

   134

		return true;

   135

	}

   136

   137

	bool inline HasBlock(byte blocknumber) const

   138

	{

   139

		FSMblockmap test_blockmap;

   140

		test_blockmap.Initialise(&blocknumber, 1);

   141

		return HasBlocks(&test_blockmap);

   142

	}

   143

   144

	//bool inline HasBlock(byte blocknumber)

   145

	//{

   146

	//	uint64 test_block = GetBlockAsBits(blocknumber);

   147

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

   148

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

   149

	//}

   150

   151

	bool inline IsNotZero(void) const

   152

	{

   153

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

   154

	}

   155

   156

	void PrintBlock(bool newline = true) const;

   157

   158

	/**

   159

	 * Needed for an ugly hack:

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

	 */

   172

	static void AssertOnWrongBlockOffset();

   173

   174

private:

   175

	uint64 blocks[2];

   176

};

   177

   178

FSMblockmap* SetFSMSingleBlock(const byte *blocklist);

   179

   180

#endif /* FSMBLOCKMAP_H */