macoy
/
galavant-game
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

Removed Flatbuffers experimentation

master
Macoy Madson 6 years ago
parent
95801e5a2d
commit
2b25358941
11 changed files with 0 additions and 614 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 13
      src/experiments/flatbuffers/Jamfile
  2. BIN
      src/experiments/flatbuffers/SavedHello.bin
  3. BIN
      src/experiments/flatbuffers/SavedHelloForWrite.bin
  4. 8
      src/experiments/flatbuffers/anotherBogusSchema.flb
  5. 85
      src/experiments/flatbuffers/anotherBogusSchema_generated.h
  6. 14
      src/experiments/flatbuffers/bogusSchema.flb
  7. 122
      src/experiments/flatbuffers/bogusSchema_generated.h
  8. 10
      src/experiments/flatbuffers/lastBogusSchema.flb
  9. 98
      src/experiments/flatbuffers/lastBogusSchema_generated.h
  10. 162
      src/experiments/flatbuffers/testFlatbuffers.cpp
  11. 102
      src/experiments/flatbuffers/testFlatbuffers_WriteOut.cpp

13
src/experiments/flatbuffers/Jamfile
View File

@ -1,13 +0,0 @@
SubDir . src experiments flatbuffers ;
SubDirC++Flags $(TESTSC++FLAGS) ;
Main testFlatbuffers : testFlatbuffers.cpp ;
Main testFlatbuffers_write : testFlatbuffers_WriteOut.cpp ;
LinkLibraries testFlatbuffers_write : ./thirdParty/flatbuffers/libflatbuffers.a ;
# Note that we're not moving testFlatbuffers_write to bin because it's
# dependent on SavedHelloForWrite.bin (this is how lazy I am)
MakeLocate testFlatbuffers : bin ;

BIN
src/experiments/flatbuffers/SavedHello.bin
View File

Binary file not shown.

BIN
src/experiments/flatbuffers/SavedHelloForWrite.bin
View File

Binary file not shown.

8
src/experiments/flatbuffers/anotherBogusSchema.flb
View File

@ -1,8 +0,0 @@
namespace Galavant.Test;
table HelloReply
{
message:string;
}
root_type HelloReply;

85
src/experiments/flatbuffers/anotherBogusSchema_generated.h
View File

@ -1,85 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_
#define FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_
#include "flatbuffers/flatbuffers.h"
namespace Galavant
{
namespace Test
{
struct HelloReply;
struct HelloReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
enum
{
VT_MESSAGE = 4
};
const flatbuffers::String *message() const
{
return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
}
bool Verify(flatbuffers::Verifier &verifier) const
{
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
verifier.Verify(message()) && verifier.EndTable();
}
};
struct HelloReplyBuilder
{
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_message(flatbuffers::Offset<flatbuffers::String> message)
{
fbb_.AddOffset(HelloReply::VT_MESSAGE, message);
}
HelloReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
{
start_ = fbb_.StartTable();
}
HelloReplyBuilder &operator=(const HelloReplyBuilder &);
flatbuffers::Offset<HelloReply> Finish()
{
auto o = flatbuffers::Offset<HelloReply>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<HelloReply> CreateHelloReply(
flatbuffers::FlatBufferBuilder &_fbb, flatbuffers::Offset<flatbuffers::String> message = 0)
{
HelloReplyBuilder builder_(_fbb);
builder_.add_message(message);
return builder_.Finish();
}
inline flatbuffers::Offset<HelloReply> CreateHelloReplyDirect(flatbuffers::FlatBufferBuilder &_fbb,
const char *message = nullptr)
{
return CreateHelloReply(_fbb, message ? _fbb.CreateString(message) : 0);
}
inline const Galavant::Test::HelloReply *GetHelloReply(const void *buf)
{
return flatbuffers::GetRoot<Galavant::Test::HelloReply>(buf);
}
inline bool VerifyHelloReplyBuffer(flatbuffers::Verifier &verifier)
{
return verifier.VerifyBuffer<Galavant::Test::HelloReply>(nullptr);
}
inline void FinishHelloReplyBuffer(flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Galavant::Test::HelloReply> root)
{
fbb.Finish(root);
}
} // namespace Test
} // namespace Galavant
#endif // FLATBUFFERS_GENERATED_ANOTHERBOGUSSCHEMA_GALAVANT_TEST_H_

14
src/experiments/flatbuffers/bogusSchema.flb
View File

@ -1,14 +0,0 @@
include "anotherBogusSchema.flb";
namespace Galavant.Test;
enum FuckYou:byte { FuckYou = 0, FuckYouToo }
table Hello
{
status:FuckYou = FuckYou;
value:int = 1232;
message:HelloReply;
}
root_type Hello;

122
src/experiments/flatbuffers/bogusSchema_generated.h
View File

@ -1,122 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_
#define FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_
#include "flatbuffers/flatbuffers.h"
#include "anotherBogusSchema_generated.h"
namespace Galavant
{
namespace Test
{
struct Hello;
enum FuckYou
{
FuckYou_FuckYou = 0,
FuckYou_FuckYouToo = 1,
FuckYou_MIN = FuckYou_FuckYou,
FuckYou_MAX = FuckYou_FuckYouToo
};
inline const char **EnumNamesFuckYou()
{
static const char *names[] = {"FuckYou", "FuckYouToo", nullptr};
return names;
}
inline const char *EnumNameFuckYou(FuckYou e)
{
return EnumNamesFuckYou()[static_cast<int>(e)];
}
struct Hello FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
enum
{
VT_STATUS = 4,
VT_VALUE = 6,
VT_MESSAGE = 8
};
FuckYou status() const
{
return static_cast<FuckYou>(GetField<int8_t>(VT_STATUS, 0));
}
int32_t value() const
{
return GetField<int32_t>(VT_VALUE, 1232);
}
const Galavant::Test::HelloReply *message() const
{
return GetPointer<const Galavant::Test::HelloReply *>(VT_MESSAGE);
}
bool Verify(flatbuffers::Verifier &verifier) const
{
return VerifyTableStart(verifier) && VerifyField<int8_t>(verifier, VT_STATUS) &&
VerifyField<int32_t>(verifier, VT_VALUE) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
verifier.VerifyTable(message()) && verifier.EndTable();
}
};
struct HelloBuilder
{
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_status(FuckYou status)
{
fbb_.AddElement<int8_t>(Hello::VT_STATUS, static_cast<int8_t>(status), 0);
}
void add_value(int32_t value)
{
fbb_.AddElement<int32_t>(Hello::VT_VALUE, value, 1232);
}
void add_message(flatbuffers::Offset<Galavant::Test::HelloReply> message)
{
fbb_.AddOffset(Hello::VT_MESSAGE, message);
}
HelloBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
{
start_ = fbb_.StartTable();
}
HelloBuilder &operator=(const HelloBuilder &);
flatbuffers::Offset<Hello> Finish()
{
auto o = flatbuffers::Offset<Hello>(fbb_.EndTable(start_, 3));
return o;
}
};
inline flatbuffers::Offset<Hello> CreateHello(
flatbuffers::FlatBufferBuilder &_fbb, FuckYou status = FuckYou_FuckYou, int32_t value = 1232,
flatbuffers::Offset<Galavant::Test::HelloReply> message = 0)
{
HelloBuilder builder_(_fbb);
builder_.add_message(message);
builder_.add_value(value);
builder_.add_status(status);
return builder_.Finish();
}
inline const Galavant::Test::Hello *GetHello(const void *buf)
{
return flatbuffers::GetRoot<Galavant::Test::Hello>(buf);
}
inline bool VerifyHelloBuffer(flatbuffers::Verifier &verifier)
{
return verifier.VerifyBuffer<Galavant::Test::Hello>(nullptr);
}
inline void FinishHelloBuffer(flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Galavant::Test::Hello> root)
{
fbb.Finish(root);
}
} // namespace Test
} // namespace Galavant
#endif // FLATBUFFERS_GENERATED_BOGUSSCHEMA_GALAVANT_TEST_H_

10
src/experiments/flatbuffers/lastBogusSchema.flb
View File

@ -1,10 +0,0 @@
include "bogusSchema.flb";
namespace Galavant.Test;
table HelloDict
{
helloArray:[Hello];
}
root_type HelloDict;

98
src/experiments/flatbuffers/lastBogusSchema_generated.h
View File

@ -1,98 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_
#define FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_
#include "flatbuffers/flatbuffers.h"
#include "anotherBogusSchema_generated.h"
#include "bogusSchema_generated.h"
namespace Galavant
{
namespace Test
{
struct HelloDict;
struct HelloDict FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
{
enum
{
VT_HELLOARRAY = 4
};
const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > *helloArray() const
{
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > *>(
VT_HELLOARRAY);
}
bool Verify(flatbuffers::Verifier &verifier) const
{
return VerifyTableStart(verifier) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_HELLOARRAY) &&
verifier.Verify(helloArray()) && verifier.VerifyVectorOfTables(helloArray()) &&
verifier.EndTable();
}
};
struct HelloDictBuilder
{
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_helloArray(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > >
helloArray)
{
fbb_.AddOffset(HelloDict::VT_HELLOARRAY, helloArray);
}
HelloDictBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
{
start_ = fbb_.StartTable();
}
HelloDictBuilder &operator=(const HelloDictBuilder &);
flatbuffers::Offset<HelloDict> Finish()
{
auto o = flatbuffers::Offset<HelloDict>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<HelloDict> CreateHelloDict(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello> > >
helloArray = 0)
{
HelloDictBuilder builder_(_fbb);
builder_.add_helloArray(helloArray);
return builder_.Finish();
}
inline flatbuffers::Offset<HelloDict> CreateHelloDictDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<flatbuffers::Offset<Galavant::Test::Hello> > *helloArray = nullptr)
{
return CreateHelloDict(
_fbb, helloArray ?
_fbb.CreateVector<flatbuffers::Offset<Galavant::Test::Hello> >(*helloArray) :
0);
}
inline const Galavant::Test::HelloDict *GetHelloDict(const void *buf)
{
return flatbuffers::GetRoot<Galavant::Test::HelloDict>(buf);
}
inline bool VerifyHelloDictBuffer(flatbuffers::Verifier &verifier)
{
return verifier.VerifyBuffer<Galavant::Test::HelloDict>(nullptr);
}
inline void FinishHelloDictBuffer(flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Galavant::Test::HelloDict> root)
{
fbb.Finish(root);
}
} // namespace Test
} // namespace Galavant
#endif // FLATBUFFERS_GENERATED_LASTBOGUSSCHEMA_GALAVANT_TEST_H_

162
src/experiments/flatbuffers/testFlatbuffers.cpp
View File

@ -1,162 +0,0 @@
#include <vector>
#include <iostream>
#include <fstream>
#include "bogusSchema_generated.h"
#include "lastBogusSchema_generated.h"
// This is awful code written only to test flatbuffers. It should be burned in hell.
void printHello(const Galavant::Test::Hello *hello)
{
if (hello)
{
std::string message = hello->message() ? hello->message()->message()->str() : "";
std::cout << "From buffer:\n\tstatus: " << Galavant::Test::EnumNameFuckYou(hello->status())
<< " value: " << hello->value() << " message: \"" << message << "\"\n";
}
}
void writeBuffer(flatbuffers::FlatBufferBuilder &builder)
{
std::ofstream outputFile;
std::cout << "Writing out SavedHello.bin...\n";
outputFile.open("SavedHello.bin", std::ios::binary);
if (outputFile.is_open())
{
// outputFile.seekg(0, std::ios::beg);
outputFile.write((char *)builder.GetBufferPointer(), builder.GetSize());
outputFile.close();
std::cout << "Done writing to SavedHello.bin\n\t(" << builder.GetSize() << " bytes)\n";
}
else
std::cout << "Failed to write out to SavedHello.bin\n";
}
char *readBuffer()
{
std::ifstream inputFile;
std::cout << "Reading in SavedHello.bin...\n";
// open with std::ios::ate so buffer pointer starts at end. tellg() tells us the size,
// then we move the pointer back to the start and read in the entire file
// This sucks and I should be ashamed to have written it
inputFile.open("SavedHello.bin", std::ios::binary | std::ios::ate);
if (inputFile.is_open())
{
std::streampos size = inputFile.tellg();
char *memblock = new char[size];
inputFile.seekg(0, std::ios::beg);
inputFile.read(memblock, size);
inputFile.close();
std::cout << "Successfully read in SavedHello.bin\n\t(" << size << " bytes)\n";
return memblock;
}
else
std::cout << "Failed to read in SavedHello.bin\n";
return nullptr;
}
void createPlaceholderHelloArray(std::vector<flatbuffers::Offset<Galavant::Test::Hello>> &array,
flatbuffers::FlatBufferBuilder &builder, int count)
{
for (int i = 0; i < count; i++)
{
flatbuffers::Offset<flatbuffers::String> messageString =
builder.CreateString("This is the message!!!1 hello codegomad, mckenna and 123ran");
flatbuffers::Offset<Galavant::Test::HelloReply> message =
Galavant::Test::CreateHelloReply(builder, messageString);
flatbuffers::Offset<Galavant::Test::Hello> testHello = Galavant::Test::CreateHello(
builder, Galavant::Test::FuckYou::FuckYou_FuckYouToo, i, message);
array.push_back(testHello);
}
}
void testHellos()
{
flatbuffers::FlatBufferBuilder builder;
flatbuffers::Offset<flatbuffers::String> messageString =
builder.CreateString("This is the message!!!1 hello codegomad and 123ran");
flatbuffers::Offset<Galavant::Test::HelloReply> message =
Galavant::Test::CreateHelloReply(builder, messageString);
flatbuffers::Offset<Galavant::Test::Hello> testHello = Galavant::Test::CreateHello(
builder, Galavant::Test::FuckYou::FuckYou_FuckYouToo, 58008, message);
builder.Finish(testHello);
const Galavant::Test::Hello *actualHello = Galavant::Test::GetHello(builder.GetBufferPointer());
printHello(actualHello);
writeBuffer(builder);
char *memblock = readBuffer();
if (memblock)
{
const Galavant::Test::Hello *readInHello = Galavant::Test::GetHello(memblock);
printHello(readInHello);
delete memblock;
}
}
void testHelloDict()
{
flatbuffers::FlatBufferBuilder builder;
std::vector<flatbuffers::Offset<Galavant::Test::Hello>> helloArray;
createPlaceholderHelloArray(helloArray, builder, 10000);
flatbuffers::Offset<Galavant::Test::HelloDict> helloDict =
Galavant::Test::CreateHelloDictDirect(builder, &helloArray);
builder.Finish(helloDict);
writeBuffer(builder);
char *memblock = readBuffer();
if (memblock)
{
const Galavant::Test::HelloDict *readInHelloDict = Galavant::Test::GetHelloDict(memblock);
if (readInHelloDict)
{
const flatbuffers::Vector<flatbuffers::Offset<Galavant::Test::Hello>> *helloArray =
readInHelloDict->helloArray();
if (helloArray)
{
for (unsigned int i = 0; i < helloArray->Length(); i++)
{
const Galavant::Test::Hello *readInHello = helloArray->Get(i);
if (readInHello)
printHello(readInHello);
}
}
}
delete memblock;
}
}
int main()
{
std::cout << "Test Flatbuffers\n";
testHellos();
testHelloDict();
return 1;
}

102
src/experiments/flatbuffers/testFlatbuffers_WriteOut.cpp
View File

@ -1,102 +0,0 @@
#include <vector>
#include <iostream>
#include <fstream>
#include "flatbuffers/idl.h"
#include "bogusSchema_generated.h"
char *readSchema(const char *filename)
{
std::ifstream inputFile;
std::cout << "Reading in " << filename << "...\n";
// open with std::ios::ate so buffer pointer starts at end. tellg() tells us the size,
// then we move the pointer back to the start and read in the entire file
// This sucks and I should be ashamed to have written it
inputFile.open(filename, std::ios::ate);
if (inputFile.is_open())
{
std::streampos size = inputFile.tellg();
char *memblock = new char[size];
inputFile.seekg(0, std::ios::beg);
inputFile.read(memblock, size);
inputFile.close();
std::cout << "Successfully read in " << filename << "\n\t(" << size << " bytes)\n";
return memblock;
}
else
std::cout << "Failed to read in " << filename << "\n";
return nullptr;
}
char *readBinary(const char *filename)
{
std::ifstream inputFile;
std::cout << "Reading in " << filename << "...\n";
// open with std::ios::ate so buffer pointer starts at end. tellg() tells us the size,
// then we move the pointer back to the start and read in the entire file
// This sucks and I should be ashamed to have written it
inputFile.open(filename, std::ios::binary | std::ios::ate);
if (inputFile.is_open())
{
std::streampos size = inputFile.tellg();
char *memblock = new char[size];
inputFile.seekg(0, std::ios::beg);
inputFile.read(memblock, size);
inputFile.close();
std::cout << "Successfully read in " << filename << "\n\t(" << size << " bytes)\n";
return memblock;
}
else
std::cout << "Failed to read in " << filename << "\n";
return nullptr;
}
void testFlatbufferToJSON()
{
//const char *outputFilename = "Output.json";
const char *flatbufferFilename = "SavedHelloForWrite.bin";
const char *schemaFilename = "bogusSchema.flb";
const char *includePaths = {
"/home/macoy/Development/code/repositories/galavant/src/experiments/flatbuffers"};
char *schemaBlock = readSchema(schemaFilename);
char *memblock = readBinary(flatbufferFilename);
if (memblock && schemaBlock)
{
// const Galavant::Test::Hello *readInHello = Galavant::Test::GetHello(memblock);
// printHello(readInHello);
flatbuffers::Parser parser;
parser.Parse(schemaBlock, &includePaths, schemaFilename);
std::string outputString = "";
flatbuffers::GenerateText(parser, memblock, &outputString);
std::cout << outputString << "\n";
// std::cout << "Generating text file...\n";
// flatbuffers::GenerateTextFile(parser, memblock, outputFilename);
delete memblock;
delete schemaBlock;
}
}
int main()
{
std::cout << "Test Flatbuffers\n";
testFlatbufferToJSON();
return 1;
}
Write Preview
Loading…
Cancel
Save