require
5.6.0;
use
JSON
qw(decode_json)
;
use
base (
"Class::Accessor"
,
"Class::Data::Inheritable"
);
__PACKAGE__->mk_classdata(
'attribute_map'
=> {});
__PACKAGE__->mk_classdata(
'openapi_types'
=> {});
__PACKAGE__->mk_classdata(
'method_documentation'
=> {});
__PACKAGE__->mk_classdata(
'class_documentation'
=> {});
sub
new {
my
(
$class
,
%args
) =
@_
;
my
$self
=
bless
{},
$class
;
$self
->init(
%args
);
return
$self
;
}
sub
init
{
my
(
$self
,
%args
) =
@_
;
foreach
my
$attribute
(
keys
%{
$self
->attribute_map}) {
my
$args_key
=
$self
->attribute_map->{
$attribute
};
$self
->
$attribute
(
$args
{
$args_key
} );
}
}
sub
to_hash {
my
$self
=
shift
;
my
$_hash
= decode_json(JSON->new->convert_blessed->encode(
$self
));
return
$_hash
;
}
sub
TO_JSON {
my
$self
=
shift
;
my
$_data
= {};
foreach
my
$_key
(
keys
%{
$self
->attribute_map}) {
if
(
defined
$self
->{
$_key
}) {
my
$_json_attribute
=
$self
->attribute_map->{
$_key
};
my
$_type
=
$self
->openapi_types->{
$_key
};
my
$_value
=
$self
->{
$_key
};
if
(
$_type
=~ /^array\[(.+)\]$/i) {
my
$_subclass
= $1;
$_data
->{
$_json_attribute
} = [
map
{
$self
->_to_json_primitives(
$_subclass
,
$_
) }
@$_value
];
}
elsif
(
$_type
=~ /^hash\[string,(.+)\]$/i) {
my
$_subclass
= $1;
my
%_hash
= ();
while
(
my
(
$_key
,
$_element
) =
each
%{
$_value
}) {
$_hash
{
$_key
} =
$self
->_to_json_primitives(
$_subclass
,
$_element
);
}
$_data
->{
$_json_attribute
} = \
%_hash
;
}
elsif
(
grep
( /^
$_type
$/, (
'int'
,
'double'
,
'string'
,
'boolean'
,
'DATE'
,
'DATE_TIME'
))) {
$_data
->{
$_json_attribute
} =
$self
->_to_json_primitives(
$_type
,
$_value
);
}
else
{
$_data
->{
$_json_attribute
} =
$_value
;
}
}
}
return
$_data
;
}
sub
_to_json_primitives {
my
(
$self
,
$type
,
$data
) =
@_
;
if
(
grep
( /^
$type
$/, (
'int'
,
'double'
))) {
return
undef
unless
defined
$data
;
return
$data
+ 0;
}
elsif
(
$type
eq
'string'
) {
return
undef
unless
defined
$data
;
return
$data
.
q()
;
}
elsif
(
$type
eq
'boolean'
) {
return
$data
? \1 : \0;
}
elsif
(
$type
eq
'DATE'
) {
return
undef
unless
defined
$data
;
if
(
ref
(
$data
) eq
'DateTime'
) {
return
$data
->ymd;
}
return
$data
.
q()
;
}
elsif
(
$type
eq
'DATE_TIME'
) {
return
undef
unless
defined
$data
;
if
(
ref
(
$data
) eq
'DateTime'
) {
return
$data
->rfc3339;
}
return
$data
.
q()
;
}
else
{
return
$data
;
}
}
sub
from_hash {
my
(
$self
,
$hash
) =
@_
;
while
(
my
(
$_key
,
$_type
) =
each
%{
$self
->openapi_types} ) {
my
$_json_attribute
=
$self
->attribute_map->{
$_key
};
if
(
$_type
=~ /^array\[(.+)\]$/i) {
my
$_subclass
= $1;
my
@_array
= ();
foreach
my
$_element
(@{
$hash
->{
$_json_attribute
}}) {
push
@_array
,
$self
->_deserialize(
$_subclass
,
$_element
);
}
$self
->{
$_key
} = \
@_array
;
}
elsif
(
$_type
=~ /^hash\[string,(.+)\]$/i) {
my
$_subclass
= $1;
my
%_hash
= ();
while
(
my
(
$_key
,
$_element
) =
each
%{
$hash
->{
$_json_attribute
}}) {
$_hash
{
$_key
} =
$self
->_deserialize(
$_subclass
,
$_element
);
}
$self
->{
$_key
} = \
%_hash
;
}
elsif
(
exists
$hash
->{
$_json_attribute
}) {
$self
->{
$_key
} =
$self
->_deserialize(
$_type
,
$hash
->{
$_json_attribute
});
}
else
{
$log
->debugf(
"Warning: %s (%s) does not exist in input hash\n"
,
$_key
,
$_json_attribute
);
}
}
return
$self
;
}
sub
_deserialize {
my
(
$self
,
$type
,
$data
) =
@_
;
$log
->debugf(
"deserializing %s with %s"
,Dumper(
$data
),
$type
);
if
(
grep
( /^
$type
$/ , (
'DATE_TIME'
,
'DATE'
))) {
return
DateTime->from_epoch(
epoch
=> str2time(
$data
));
}
elsif
(
grep
( /^
$type
$/, (
'int'
,
'double'
))) {
return
undef
unless
defined
$data
;
return
$data
+ 0;
}
elsif
(
$type
eq
'string'
) {
return
undef
unless
defined
$data
;
return
$data
.
q()
;
}
elsif
(
$type
eq
'boolean'
) {
return
!!
$data
;
}
else
{
my
$_instance
=
eval
"PeakForest::REST_Client::Object::$type->new()"
;
return
$_instance
->from_hash(
$data
);
}
}
__PACKAGE__->class_documentation({
description
=>
''
,
class
=>
'NewChromatographyMetadata'
,
required
=> [],
} );
__PACKAGE__->method_documentation({
'method'
=> {
datatype
=>
'string'
,
base_name
=>
'method'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'column_constructor'
=> {
datatype
=>
'string'
,
base_name
=>
'column_constructor'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'column_constructor_other'
=> {
datatype
=>
'string'
,
base_name
=>
'column_constructor_other'
,
description
=>
'the column constructor, if not available in \"column_constructor\" field list (free value)'
,
format
=>
''
,
read_only
=>
''
,
},
'column_name'
=> {
datatype
=>
'string'
,
base_name
=>
'column_name'
,
description
=>
'the column name'
,
format
=>
''
,
read_only
=>
''
,
},
'column_length'
=> {
datatype
=>
'double'
,
base_name
=>
'column_length'
,
description
=>
'mm'
,
format
=>
''
,
read_only
=>
''
,
},
'column_diameter'
=> {
datatype
=>
'double'
,
base_name
=>
'column_diameter'
,
description
=>
'mm'
,
format
=>
''
,
read_only
=>
''
,
},
'particule_size'
=> {
datatype
=>
'double'
,
base_name
=>
'particule_size'
,
description
=>
'the column's particule size, in µm'
,
format
=>
''
,
read_only
=>
''
,
},
'column_temperature'
=> {
datatype
=>
'double'
,
base_name
=>
'column_temperature'
,
description
=>
'the column's temparature, in °C'
,
format
=>
''
,
read_only
=>
''
,
},
'mode'
=> {
datatype
=>
'string'
,
base_name
=>
'mode'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'separation_flow_rate'
=> {
datatype
=>
'double'
,
base_name
=>
'separation_flow_rate'
,
description
=>
'µL/min'
,
format
=>
''
,
read_only
=>
''
,
},
'solvent_a'
=> {
datatype
=>
'string'
,
base_name
=>
'solvent_a'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'solvent_a_ph'
=> {
datatype
=>
'double'
,
base_name
=>
'solvent_a_ph'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'solvent_b'
=> {
datatype
=>
'string'
,
base_name
=>
'solvent_b'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'solvent_b_ph'
=> {
datatype
=>
'double'
,
base_name
=>
'solvent_b_ph'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
'separation_flow_gradient'
=> {
datatype
=>
'NewChromatographyMetadataSeparationFlowGradient'
,
base_name
=>
'separation_flow_gradient'
,
description
=>
''
,
format
=>
''
,
read_only
=>
''
,
},
});
__PACKAGE__->openapi_types( {
'method'
=>
'string'
,
'column_constructor'
=>
'string'
,
'column_constructor_other'
=>
'string'
,
'column_name'
=>
'string'
,
'column_length'
=>
'double'
,
'column_diameter'
=>
'double'
,
'particule_size'
=>
'double'
,
'column_temperature'
=>
'double'
,
'mode'
=>
'string'
,
'separation_flow_rate'
=>
'double'
,
'solvent_a'
=>
'string'
,
'solvent_a_ph'
=>
'double'
,
'solvent_b'
=>
'string'
,
'solvent_b_ph'
=>
'double'
,
'separation_flow_gradient'
=>
'NewChromatographyMetadataSeparationFlowGradient'
} );
__PACKAGE__->attribute_map( {
'method'
=>
'method'
,
'column_constructor'
=>
'column_constructor'
,
'column_constructor_other'
=>
'column_constructor_other'
,
'column_name'
=>
'column_name'
,
'column_length'
=>
'column_length'
,
'column_diameter'
=>
'column_diameter'
,
'particule_size'
=>
'particule_size'
,
'column_temperature'
=>
'column_temperature'
,
'mode'
=>
'mode'
,
'separation_flow_rate'
=>
'separation_flow_rate'
,
'solvent_a'
=>
'solvent_a'
,
'solvent_a_ph'
=>
'solvent_a_ph'
,
'solvent_b'
=>
'solvent_b'
,
'solvent_b_ph'
=>
'solvent_b_ph'
,
'separation_flow_gradient'
=>
'separation_flow_gradient'
} );
__PACKAGE__->mk_accessors(
keys
%{__PACKAGE__->attribute_map});
1;