ConscienceEncoder.h

Go to the documentation of this file.

#ifndef ConscienceEncoder_h
#define ConscienceEncoder_h
 
#include <string>
 
#include "CoreObjects/CscEntityModel.h"
#include "CoreObjects/CscMemberInputStatus.h"
#include "CoreObjects/CscSequence.h"
#include "CoreObjects/CscSequencePositions.h"
#include "CoreObjects/CscState.h"
#include "CoreObjects/sequenceMovements/CscSequenceMovements.h"
 
using std::vector, std::string, std::stoull;
 
namespace conscience_core::bridging {
 
enum CscStateEncodingOption : uint32_t {
    NONE = 0,
    WITH_INPUTS = 1 << 0,
 
    WITH_EXTRAS = 1 << 1
};
typedef uint32_t CscStateEncodingOptions;
 
struct CscStateExtras {
    double delay = 0;
    double duration = 0;
    double objectiveValue = 0;
 
    operator string() const {
        return "delay=" + to_string(delay) + ",duration=" + to_string(duration) + ",objectiveValue=" + to_string(objectiveValue);
    }
};
 
struct CscStateWithExtras {
    CscState *state;
    optional<CscStateExtras> extras = {};
};
 
class ConscienceEncoder {
public:
    static ConscienceEncoder *getInstance();
 
    static constexpr double ENCODER_VERSION = 4.2;
 
    virtual DoubleSizedArray encodeSequence(CscSequence *sequence) const;
 
    virtual string encodeSequenceToString(CscSequence *sequence) const;
 
    virtual CscStateWithExtras decodeState(const double *const values) const;
 
    CscSequence *decodeSequenceStates(const double *const values) const;
 
    CscSequence *decodeSequence(const double *const values) const;
 
    CscSequence *decodeSequenceFromString(const string &sequenceString) const;
 
    virtual CscStateWithExtras decodeStateFromString(const string &valuesString, const string &delimiter = ",") const;
 
    virtual DoubleSizedArray encodeState(const CscState &state,
                                         CscStateEncodingOptions options = CscStateEncodingOption::NONE,
                                         optional<CscStateExtras> stateExtras = {}) const;
 
    string encodeStateToString(const CscState &state,
                               CscStateEncodingOptions options = CscStateEncodingOption::NONE,
                               optional<CscStateExtras> stateExtras = {}) const;
 
    unsigned getEncodedStateLength(const CscState &state, CscStateEncodingOptions options) const;
 
    CscMovement *decodeMovement(const double *const values, int &arrayIndex) const;
 
private:
    inline static ConscienceEncoder *instance = nullptr;
    unique_ptr<CscLogger> logger;
    ConscienceEncoder();
 
    virtual DoubleSizedArray encodeSequencePositions(CscSequencePositions *sequence) const;
    virtual DoubleSizedArray encodeSequencePositionsWithOutputs(CscSequencePositions *sequence) const;
    unsigned getEncodedSequenceLength(CscSequence *sequence, CscStateEncodingOptions stateEncodingOptions) const;
    unsigned getEncodedSequenceOfPositionsLength(CscSequencePositions *sequence, CscStateEncodingOptions stateEncodingOptions) const;
    CscSequenceMovements *decodeSequenceMovements(const double *const values) const;
 
    DoubleSizedArray encodeMovement(const CscMovement *movement) const;
    DoubleSizedArray encodeSequenceMovements(const CscSequenceMovements *sequence) const;
 
    int getEncodedMovementLength(const CscMovement *sequence) const;
    int getEncodedSequenceMovementsLength(const CscSequenceMovements *movement) const;
 
    string encodeStateValuesToString(DoubleSizedArray values) const;
};
}
#endif