1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
package org.openecomp.sdc.toscaparser;
import org.openecomp.sdc.toscaparser.elements.CapabilityTypeDef;
import org.openecomp.sdc.toscaparser.elements.PropertyDef;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
public class Capability {
private String name;
private LinkedHashMap<String,Object> _properties;
private CapabilityTypeDef _definition;
public Capability(String cname,
LinkedHashMap<String,Object> cproperties,
CapabilityTypeDef cdefinition) {
name = cname;
_properties = cproperties;
_definition = cdefinition;
}
public ArrayList<Property> getPropertiesObjects() {
// Return a list of property objects
ArrayList<Property> properties = new ArrayList<Property>();
LinkedHashMap<String,Object> props = _properties;
if(props != null) {
for(Map.Entry<String,Object> me: props.entrySet()) {
String pname = me.getKey();
Object pvalue = me.getValue();
LinkedHashMap<String,PropertyDef> propsDef = _definition.getPropertiesDef();
if(propsDef != null) {
PropertyDef pd = (PropertyDef)propsDef.get(pname);
if(pd != null) {
properties.add(new Property(pname,pvalue,pd.getSchema(),null));
}
}
}
}
return properties;
}
public LinkedHashMap<String,Property> getProperties() {
// Return a dictionary of property name-object pairs
LinkedHashMap<String,Property> npps = new LinkedHashMap<>();
for(Property p: getPropertiesObjects()) {
npps.put(p.getName(),p);
}
return npps;
}
public Object getPropertyValue(String pname) {
// Return the value of a given property name
LinkedHashMap<String,Property> props = getProperties();
if(props != null && props.get(pname) != null) {
return props.get(name).getValue();
}
return null;
}
public String getName() {
return name;
}
public CapabilityTypeDef getDefinition() {
return _definition;
}
// setter
public void setProperty(String pname,Object pvalue) {
_properties.put(pname,pvalue);
}
@Override
public String toString() {
return "Capability{" +
"name='" + name + '\'' +
", _properties=" + _properties +
", _definition=" + _definition +
'}';
}
}
/*python
from toscaparser.properties import Property
class Capability(object):
'''TOSCA built-in capabilities type.'''
def __init__(self, name, properties, definition):
self.name = name
self._properties = properties
self.definition = definition
def get_properties_objects(self):
'''Return a list of property objects.'''
properties = []
props = self._properties
if props:
for name, value in props.items():
props_def = self.definition.get_properties_def()
if props_def and name in props_def:
properties.append(Property(name, value,
props_def[name].schema))
return properties
def get_properties(self):
'''Return a dictionary of property name-object pairs.'''
return {prop.name: prop
for prop in self.get_properties_objects()}
def get_property_value(self, name):
'''Return the value of a given property name.'''
props = self.get_properties()
if props and name in props:
return props[name].value
*/
|
