include/rive/runtime_header.hpp

#ifndef _RIVE_RUNTIME_HEADER_HPP_
#define _RIVE_RUNTIME_HEADER_HPP_

#include "rive/core/binary_reader.hpp"
#include <unordered_map>

namespace rive
{
	/// Rive file runtime header. The header is fonud at the beginning of every
	/// Rive runtime file, and begins with a specific 4-byte format: "RIVE".
	/// This is followed by the major and minor version of Rive used to create
	/// the file. Finally the owner and file ids are at the end of header; these
	/// unsigned integers may be zero.
	class RuntimeHeader
	{
	private:
		static constexpr char fingerprint[] = "RIVE";

		int m_MajorVersion;
		int m_MinorVersion;
		int m_FileId;
		std::unordered_map<int, int> m_PropertyToFieldIndex;

	public:
		/// @returns the file's major version
		int majorVersion() const { return m_MajorVersion; }
		/// @returns the file's minor version
		int minorVersion() const { return m_MinorVersion; }
		/// @returns the file's id; may be zero
		int fileId() const { return m_FileId; }

		int propertyFieldId(int propertyKey) const
		{
			auto itr = m_PropertyToFieldIndex.find(propertyKey);
			if (itr == m_PropertyToFieldIndex.end())
			{
				return -1;
			}

			return itr->second;
		}

		/// Reads the header from a binary buffer/
		/// @param reader the binary reader attached to the buffer
		/// @param header a pointer to the header where the data will be stored.
		/// @returns true if the header is successfully read
		static bool read(BinaryReader& reader, RuntimeHeader& header)
		{
			for (int i = 0; i < 4; i++)
			{
				auto b = reader.readByte();
				if (fingerprint[i] != b)
				{
					return false;
				}
			}

			header.m_MajorVersion = (int)reader.readVarUint64();
			if (reader.didOverflow())
			{
				return false;
			}
			header.m_MinorVersion = (int)reader.readVarUint64();
			if (reader.didOverflow())
			{
				return false;
			}

			header.m_FileId = (int)reader.readVarUint64();

			if (reader.didOverflow())
			{
				return false;
			}

			std::vector<int> propertyKeys;
			for (int propertyKey = (int)reader.readVarUint64(); propertyKey != 0;
			     propertyKey = (int)reader.readVarUint64())
			{
				propertyKeys.push_back(propertyKey);
				if (reader.didOverflow())
				{
					return false;
				}
			}

			int currentInt = 0;
			int currentBit = 8;
			for (auto propertyKey : propertyKeys)
			{
				if (currentBit == 8)
				{
					currentInt = reader.readUint32();
					currentBit = 0;
				}
				int fieldIndex = (currentInt >> currentBit) & 3;
				header.m_PropertyToFieldIndex[propertyKey] = fieldIndex;
				currentBit += 2;
				if (reader.didOverflow())
				{
					return false;
				}
			}

			return true;
		}
	};
} // namespace rive
#endif