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] = 0x0000000000000000;

    27

		blocks[1] = 0x0000000000000000;

    28

	};

    29

    36

	void Initialise(const byte *blocklist, int num_bytes)

    37

	{

    38

		ResetAll();

    39

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

    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 ReserveBlocks(const FSMblockmap *blockmap)

    59

	{

    60

		/* OR with blockmap to reserve blocks */

    61

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

    62

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

    63

	}

    64

    65

	void inline ReleaseBlocks(const FSMblockmap *blockmap)

    66

	{

    67

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

    68

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

    69

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

    70

	}

    71

    72

	bool inline BlocksAreFree(const FSMblockmap *blockmap) const

    73

	{

    74

		uint64 test_lower = blockmap->GetLower();

    75

		uint64 test_upper = blockmap->GetUpper();

    76

    77

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

    78

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

    79

    80

		return true;

    81

	}

    82

    83

	bool inline HasBlocks(const FSMblockmap *blockmap) const

    84

	{

    85

		uint64 test_lower = blockmap->GetLower();

    86

		uint64 test_upper = blockmap->GetUpper();

    87

    88

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

    89

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

    90

    91

		return true;

    92

	}

    93

    94

	bool inline HasBlock(byte blocknumber) const

    95

	{

    96

		FSMblockmap test_blockmap;

    97

		test_blockmap.Initialise(&blocknumber, 1);

    98

		return HasBlocks(&test_blockmap);

    99

	}

   100

   101

	//bool inline HasBlock(byte blocknumber)

   102

	//{

   103

	//	uint64 test_block = GetBlockAsBits(blocknumber);

   104

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

   105

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

   106

	//}

   107

   108

	bool inline IsNotZero(void) const

   109

	{

   110

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

   111

	}

   112

   113

	void PrintBlock(bool newline = true) const;

   114

   115

	/**

   116

	 * Needed for an ugly hack:

   117

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

   118

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

   119

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

   120

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

   121

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

   122

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

   123

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

   124

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

   125

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

   126

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

   127

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

   128

	 */

   129

	static void AssertOnWrongBlockOffset();

   130

   131

private:

   132

	uint64 blocks[2];

   133

};

   134

   135

FSMblockmap* SetFSMSingleBlock(const byte *blocklist);

   136

   137

#endif /* FSMBLOCKMAP_H */