524 lines
16 KiB
C++
524 lines
16 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) Sorbonne Université 2016-2021, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | V L S I B a c k e n d D a t a - B a s e |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./JsonConfiguration.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/configuration/LayoutDescription.h"
|
|
#include "hurricane/Error.h"
|
|
#include "hurricane/viewer/JsonConfiguration.h"
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::Parameter* p )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::Parameter" );
|
|
jsonWrite( w, "_id" , p->getId() );
|
|
jsonWrite( w, "_type" , Cfg::Parameter::typeToString(p->getType()) );
|
|
jsonWrite( w, "_priority", Cfg::Parameter::priorityToString(p->getPriority()) );
|
|
jsonWrite( w, "_value" , p->asString() );
|
|
jsonWrite( w, "_flags" , p->getFlags() );
|
|
|
|
if (p->getType() == Cfg::Parameter::Int) {
|
|
if (p->hasMin()) jsonWrite( w, "_minInt", p->getMinInt() );
|
|
if (p->hasMax()) jsonWrite( w, "_maxInt", p->getMaxInt() );
|
|
}
|
|
if (p->getType() == Cfg::Parameter::Double) {
|
|
if (p->hasMin()) jsonWrite( w, "_minDouble", p->getMinDouble() );
|
|
if (p->hasMax()) jsonWrite( w, "_maxDouble", p->getMaxDouble() );
|
|
}
|
|
|
|
jsonWrite( w, "+values", p->getValues() );
|
|
|
|
w->key( "+slaves" );
|
|
w->startArray();
|
|
for ( std::string slave : p->getSlaves() ) {
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::Parameter::Slave" );
|
|
jsonWrite( w, "_id" , slave );
|
|
w->endObject();
|
|
}
|
|
w->endArray();
|
|
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::Parameter::EnumValue v )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::Parameter::EnumValue" );
|
|
jsonWrite( w, "_label" , v._label );
|
|
jsonWrite( w, "_value" , v._value );
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::Configuration* cfg )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename" , "Cfg::Configuration" );
|
|
jsonWrite( w, "+parameters", cfg->getParameters() );
|
|
jsonWrite( w, "+layout" , &cfg->getLayout () );
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::WidgetDescription* widget )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::WidgetDescription" );
|
|
jsonWrite( w, "_type" , Cfg::WidgetDescription::typeToString(widget->getType()) );
|
|
jsonWrite( w, "_id" , widget->getId () );
|
|
jsonWrite( w, "_label" , widget->getLabel () );
|
|
jsonWrite( w, "_column" , widget->getColumn() );
|
|
jsonWrite( w, "_span" , widget->getSpan () );
|
|
jsonWrite( w, "_flags" , widget->getFlags () );
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::TabDescription* tab )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::TabDescription" );
|
|
jsonWrite( w, "_name" , tab->getName() );
|
|
jsonWrite( w, "_id" , tab->getId() );
|
|
jsonWrite( w, "+widgets" , tab->getWidgets() );
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
void jsonWrite ( JsonWriter* w, const Cfg::LayoutDescription* layout )
|
|
{
|
|
w->startObject();
|
|
jsonWrite( w, "@typename", "Cfg::LayoutDescription" );
|
|
jsonWrite( w, "+tabs" , layout->getTabs() );
|
|
w->endObject();
|
|
}
|
|
|
|
|
|
namespace Hurricane {
|
|
|
|
using Cfg::Parameter;
|
|
using Cfg::Configuration;
|
|
using Cfg::LayoutDescription;
|
|
using Cfg::TabDescription;
|
|
using Cfg::WidgetDescription;
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonConfiguration"
|
|
|
|
Initializer<JsonConfiguration> jsonConfigurationInit ( 0 );
|
|
|
|
|
|
void JsonConfiguration::initialize ()
|
|
{ JsonTypes::registerType( new JsonConfiguration (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonConfiguration::JsonConfiguration( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "+parameters", typeid(JsonArray) );
|
|
}
|
|
|
|
|
|
string JsonConfiguration::getTypeName () const
|
|
{ return "Cfg::Configuration"; }
|
|
|
|
|
|
JsonConfiguration* JsonConfiguration::clone ( unsigned long flags ) const
|
|
{ return new JsonConfiguration ( flags ); }
|
|
|
|
|
|
void JsonConfiguration::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonConfiguration::toData" );
|
|
|
|
Configuration* cfg = Configuration::get();
|
|
|
|
update( stack, cfg );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonParameter"
|
|
|
|
Initializer<JsonParameter> jsonParameterInit ( 0 );
|
|
|
|
|
|
void JsonParameter::initialize ()
|
|
{ JsonTypes::registerType( new JsonParameter (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonParameter::JsonParameter ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "_id" , typeid(string) );
|
|
add( "_type" , typeid(string) );
|
|
add( "_priority", typeid(string) );
|
|
add( "_value" , typeid(string) );
|
|
add( "_flags" , typeid(int64_t) );
|
|
add( "+values" , typeid(JsonArray) );
|
|
add( "+slaves" , typeid(JsonArray) );
|
|
}
|
|
|
|
|
|
string JsonParameter::getTypeName () const
|
|
{ return "Cfg::Parameter"; }
|
|
|
|
|
|
JsonParameter* JsonParameter::clone ( unsigned long flags ) const
|
|
{ return new JsonParameter ( flags ); }
|
|
|
|
|
|
void JsonParameter::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonParameter::toData" );
|
|
|
|
Configuration* cfg = get<Configuration*>( stack, "_configuration" );
|
|
|
|
Parameter* param = NULL;
|
|
string id = get<string> ( stack, "_id" );
|
|
string stype = get<string> ( stack, "_type" );
|
|
string spriority = get<string> ( stack, "_priority" );
|
|
string value = get<string> ( stack, "_value" );
|
|
int flags = get<int64_t>( stack, "_flags" );
|
|
|
|
Parameter::Type type = Parameter::stringToType (stype);
|
|
Parameter::Priority priority = Parameter::stringToPriority(spriority);
|
|
|
|
param = cfg->getParameter( id );
|
|
if (not param) {
|
|
param = cfg->addParameter( id, type, value, priority );
|
|
} else {
|
|
if (param->getType() != type) {
|
|
cerr << Error( "JsonParameter::toData(): Type incoherency on parameter \"%s\", not restored."
|
|
, id.c_str() ) << endl;
|
|
}
|
|
param->setRawString( value, Parameter::Interactive );
|
|
param->setPriority( priority );
|
|
}
|
|
|
|
if (type == Parameter::Int) {
|
|
if (flags & Parameter::HasMin) {
|
|
add( "_minInt", typeid(int64_t) );
|
|
param->setMin( (int)get<int64_t>( stack, "_minInt" ), Parameter::Interactive );
|
|
}
|
|
if (flags & Parameter::HasMax) {
|
|
add( "_maxInt", typeid(int64_t) );
|
|
param->setMax( (int)get<int64_t>( stack, "_maxInt" ), Parameter::Interactive );
|
|
}
|
|
}
|
|
|
|
if (type == Parameter::Double) {
|
|
if (flags & Parameter::HasMin) {
|
|
add( "_minDouble", typeid(int64_t) );
|
|
param->setMin( (double)get<int64_t>( stack, "_minDouble" ), Parameter::Interactive );
|
|
}
|
|
if (flags & Parameter::HasMax) {
|
|
add( "_maxDouble", typeid(int64_t) );
|
|
param->setMax( (double)get<int64_t>( stack, "_maxDouble" ), Parameter::Interactive );
|
|
}
|
|
}
|
|
|
|
if (param) param->valueChanged();
|
|
|
|
update( stack, param );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonParamEnumValue"
|
|
|
|
Initializer<JsonParamEnumValue> jsonParamEnumValueInit ( 0 );
|
|
|
|
|
|
void JsonParamEnumValue::initialize ()
|
|
{ JsonTypes::registerType( new JsonParamEnumValue (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonParamEnumValue::JsonParamEnumValue ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "_label", typeid(string) );
|
|
add( "_value", typeid(int64_t) );
|
|
}
|
|
|
|
|
|
string JsonParamEnumValue::getTypeName () const
|
|
{ return "Cfg::Parameter::EnumValue"; }
|
|
|
|
|
|
JsonParamEnumValue* JsonParamEnumValue::clone ( unsigned long flags ) const
|
|
{ return new JsonParamEnumValue ( flags ); }
|
|
|
|
|
|
void JsonParamEnumValue::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonParamEnumValue::toData" );
|
|
|
|
Parameter* param = get<Parameter*>( stack, ".Cfg::Parameter" );
|
|
string label = get<string> ( stack, "_label" );
|
|
int value = get<int64_t> ( stack, "_value" );
|
|
|
|
if (not param) {
|
|
cerr << Error( "JsonParamEnumValue::toData(): Missing \".Cfg::Parameter\" in stack context.\n"
|
|
" (while reading Cfg::Parameter::EnumValue \"%s\")"
|
|
, label.c_str()
|
|
) << endl;
|
|
} else {
|
|
if (stack.issetFlags(JsonWriter::TechnoMode)) {
|
|
param->addValue( label, value );
|
|
}
|
|
}
|
|
|
|
update( stack, NULL );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonParamSlave"
|
|
|
|
Initializer<JsonParamSlave> jsonParamSlaveInit ( 0 );
|
|
|
|
|
|
void JsonParamSlave::initialize ()
|
|
{ JsonTypes::registerType( new JsonParamSlave (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonParamSlave::JsonParamSlave ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "_id", typeid(string) );
|
|
}
|
|
|
|
|
|
string JsonParamSlave::getTypeName () const
|
|
{ return "Cfg::Parameter::Slave"; }
|
|
|
|
|
|
JsonParamSlave* JsonParamSlave::clone ( unsigned long flags ) const
|
|
{ return new JsonParamSlave ( flags ); }
|
|
|
|
|
|
void JsonParamSlave::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonParamSlave::toData" );
|
|
|
|
Parameter* param = get<Parameter*>( stack, ".Cfg::Parameter" );
|
|
string id = get<string> ( stack, "_id " );
|
|
|
|
if (not param) {
|
|
cerr << Error( "JsonParamSlave::toData(): Missing \".Cfg::Parameter\" in stack context.\n"
|
|
" (while reading Cfg::Parameter::Slave \"%s\")"
|
|
, id.c_str()
|
|
) << endl;
|
|
} else {
|
|
if (stack.issetFlags(JsonWriter::TechnoMode)) {
|
|
param->addSlave( id );
|
|
}
|
|
}
|
|
|
|
update( stack, NULL );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonWidgetDescription"
|
|
|
|
Initializer<JsonWidgetDescription> jsonWidgetDescriptionInit ( 0 );
|
|
|
|
|
|
void JsonWidgetDescription::initialize ()
|
|
{ JsonTypes::registerType( new JsonWidgetDescription (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonWidgetDescription::JsonWidgetDescription ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( ".Cfg::TabDescription", typeid(Cfg::TabDescription*) );
|
|
add( "_type" , typeid(string) );
|
|
add( "_id" , typeid(string) );
|
|
add( "_label" , typeid(string) );
|
|
add( "_column" , typeid(int64_t) );
|
|
add( "_span" , typeid(int64_t) );
|
|
add( "_flags" , typeid(int64_t) );
|
|
}
|
|
|
|
|
|
string JsonWidgetDescription::getTypeName () const
|
|
{ return "Cfg::WidgetDescription"; }
|
|
|
|
|
|
JsonWidgetDescription* JsonWidgetDescription::clone ( unsigned long flags ) const
|
|
{ return new JsonWidgetDescription ( flags ); }
|
|
|
|
|
|
void JsonWidgetDescription::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonWidgetDescription::toData" );
|
|
|
|
LayoutDescription* layout = get<LayoutDescription*>( stack, "+layout" );
|
|
TabDescription* tab = get<TabDescription*> ( stack, ".Cfg::TabDescription" );
|
|
|
|
WidgetDescription* widget = NULL;
|
|
string stype = get<string> ( stack, "_type" );
|
|
string id = get<string> ( stack, "_id" );
|
|
string label = get<string> ( stack, "_label" );
|
|
int column = get<int64_t>( stack, "_column" );
|
|
int span = get<int64_t>( stack, "_span" );
|
|
int flags = get<int64_t>( stack, "_flags" );
|
|
|
|
WidgetDescription::Type type = WidgetDescription::stringToType(stype);
|
|
|
|
if (not layout) {
|
|
cerr << Error( "JsonWidgetDescription::toData(): Missing \"+layout\" in stack context.\n"
|
|
" (while reading \"%s\")"
|
|
, id.c_str()
|
|
) << endl;
|
|
} else if (not tab) {
|
|
cerr << Error( "JsonWidgetDescription::toData(): Missing \".Cfg::TabDescription\" in stack context.\n"
|
|
" (while reading \"%s\")"
|
|
, id.c_str()
|
|
) << endl;
|
|
} else {
|
|
if (stack.issetFlags(JsonWriter::TechnoMode)) {
|
|
switch ( type ) {
|
|
case WidgetDescription::Rule: layout->addRule ( tab->getName() ); break;
|
|
case WidgetDescription::Title: layout->addTitle ( tab->getName(), label ); break;
|
|
case WidgetDescription::Section: layout->addSection( tab->getName(), label, column ); break;
|
|
case WidgetDescription::Parameter:
|
|
layout->addParameter( tab->getName(), id, label, column, span, flags );
|
|
widget = layout->getWidget( id );
|
|
break;
|
|
}
|
|
} else {
|
|
// Coherency checking only.
|
|
if (type == WidgetDescription::Parameter) {
|
|
widget = layout->getWidget( id );
|
|
if (not widget) {
|
|
cerr << Error( "JsonWidgetDescription::toData(): Parameter id=\"%s\" has no layout."
|
|
, id.c_str() ) << endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
update( stack, widget );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonTabDescription"
|
|
|
|
Initializer<JsonTabDescription> jsonTabDescriptionInit ( 0 );
|
|
|
|
|
|
void JsonTabDescription::initialize ()
|
|
{ JsonTypes::registerType( new JsonTabDescription (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonTabDescription::JsonTabDescription ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "_name" , typeid(string) );
|
|
add( "_id" , typeid(string) );
|
|
add( "+widgets", typeid(JsonArray) );
|
|
}
|
|
|
|
|
|
string JsonTabDescription::getTypeName () const
|
|
{ return "Cfg::TabDescription"; }
|
|
|
|
|
|
JsonTabDescription* JsonTabDescription::clone ( unsigned long flags ) const
|
|
{ return new JsonTabDescription ( flags ); }
|
|
|
|
|
|
void JsonTabDescription::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonTabDescription::toData" );
|
|
|
|
LayoutDescription* layout = get<LayoutDescription*>( stack, "+layout" );
|
|
|
|
TabDescription* tab = NULL;
|
|
string id = get<string>( stack, "_id" );
|
|
string name = get<string>( stack, "_name" );
|
|
|
|
if (not layout) {
|
|
cerr << Error( "JsonTabDescription::toData(): Missing \"+layout\" in stack context.\n"
|
|
" (while reading TabDescription \"%s\")"
|
|
, id.c_str()
|
|
) << endl;
|
|
} else {
|
|
if (stack.issetFlags(JsonWriter::TechnoMode)) {
|
|
layout->addTab( name, id );
|
|
tab = layout->getTab( name, id );
|
|
} else {
|
|
// Coherency checking only.
|
|
tab = layout->getTab( name, id );
|
|
if (not tab) {
|
|
cerr << Error( "JsonTabDescription::toData(): Tab name=\"%s\", id=\"%s\" has no layout."
|
|
, name.c_str(), id.c_str() ) << endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
update( stack, tab );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "JsonLayoutDescription"
|
|
|
|
Initializer<JsonLayoutDescription> jsonLayoutDescriptionInit ( 0 );
|
|
|
|
|
|
void JsonLayoutDescription::initialize ()
|
|
{ JsonTypes::registerType( new JsonLayoutDescription (JsonWriter::RegisterMode) ); }
|
|
|
|
|
|
JsonLayoutDescription::JsonLayoutDescription ( unsigned long flags )
|
|
: JsonObject(flags)
|
|
{
|
|
add( "+tabs", typeid(JsonArray) );
|
|
}
|
|
|
|
|
|
JsonLayoutDescription::~JsonLayoutDescription ()
|
|
{
|
|
}
|
|
|
|
|
|
string JsonLayoutDescription::getTypeName () const
|
|
{ return "Cfg::LayoutDescription"; }
|
|
|
|
|
|
JsonLayoutDescription* JsonLayoutDescription::clone ( unsigned long flags ) const
|
|
{ return new JsonLayoutDescription ( flags ); }
|
|
|
|
|
|
void JsonLayoutDescription::toData ( JsonStack& stack )
|
|
{
|
|
check( stack, "JsonLayoutDescription::toData" );
|
|
|
|
LayoutDescription* layout = &Configuration::get()->getLayout();
|
|
|
|
update( stack, layout );
|
|
}
|
|
|
|
|
|
} // Hurricane namespace.
|