meta.h File Reference

Meta data read/write. More...

#include "../declspec.h"
#include "../exception.h"
#include "file.h"
#include "enum.h"
#include "lookuptable.h"
#include <cstdint>
#include <memory>
#include <ostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <cstring>

Go to the source code of this file.

Classes
class	InternalZGY::ZgyInternalWriterArgs
	Internal counterpart to OpenZGY::ZgyWriterArgs. More...
class	InternalZGY::IHeaderAccess
class	InternalZGY::IFileHeaderAccess
class	InternalZGY::IOffsetHeaderAccess
class	InternalZGY::IInfoHeaderAccess
class	InternalZGY::IHistHeaderAccess
class	InternalZGY::ILookupTableAccess
class	InternalZGY::HeaderAccessFactory
class	InternalZGY::ZgyInternalMeta

Namespaces
	InternalZGY
	Implementation not visible to clients.

Detailed Description

Meta data read/write.

The meta data in an OpenZGY file is broken down into multiple headers. In this file, a set of classes for each header type is responsble for reading and decoding that header. A lot of the code is inlined to make it easier to maintain. Keeping everything that needs to be updated close together.

class FooHeaderV1POD
class FooHeaderV1POD etc.

• POD class corresponding exactly to what is stored on the file. A new class needs to be created each time the version changes. The compiler gets to decide the actual layout, but is instructed to not use any padding. Hopefully this makes the layout platform independant.

class IFooHeaderAccess : public IHeaderAccess

• Pure interface, more or less matching the layout of the most recent version of the POD. The purpose is to hide differences between versions when reading. Writing and updating need not be handled the same way. Those are simpler. Creating a new file only needs to worry about the latest version, and updating meta data is only allowed on very few (currently none at all) attributes.

class FooHeaderAccess : public IHeaderAccess

• Adds a concrete dump() method for debugging.

class FooHeaderV1Access : public FooHeaderAccess
class FooHeaderV2Access : public FooHeaderAccess
etc.

• Aggregates (i.e. does not inherit from) the corresponding POD. Implements the interface that allows version independant access of the information on file. Where there is a mismatch the code should compute the result on the fly if possible. The last resort is to cache data in the virtual compute() method and storing the result in this instance instead if the pod. Note that this gets messy if the cached data can become stale.

• TODO-WARNING, the current implementation assumes that the computer architecture and the C++ compiler allows unaligned access. According to the C++ standard this gives UNDEFINED BEHAVIOR even on architectures such as x86_684 that do allow unaligned loads. On newer x86_64 processors this is actually fairly efficient too. BUT the compiler is free to use SSE instructions for load/store and those do NOT allow unaligned pointers. https://pzemtsov.github.io/2016/11/06/bug-story-alignment-on-x86.html

HeaderAccessFactory::createFoo(std::uint32_t version)

• Construct and return the appropriate FooHeaderV?Access instance.

This file was initially generated with some help from openzgy.tools.cppmeta. But that was only a starting point. If major changes are needed to the format (will hopefully never happen) then the code generator might still be useful. otherwise this file is expected to be maintained by hand.