001 package org.tynamo.descriptor;
002
003 import org.apache.commons.beanutils.BeanUtils;
004 import org.apache.commons.logging.Log;
005 import org.apache.commons.logging.LogFactory;
006
007 import java.io.Serializable;
008 import java.lang.reflect.InvocationTargetException;
009 import java.util.Hashtable;
010 import java.util.Map;
011
012 public class TynamoDescriptor implements Descriptor, Serializable
013 {
014 protected static final Log LOG = LogFactory.getLog(TynamoDescriptor.class);
015
016 protected Class type;
017
018 private boolean hidden;
019
020 Map<String, DescriptorExtension> extensions = new Hashtable<String, DescriptorExtension>();
021
022 /**
023 * @param dto
024 */
025 public TynamoDescriptor(TynamoDescriptor dto)
026 {
027 try
028 {
029 BeanUtils.copyProperties(this, dto);
030 } catch (IllegalAccessException e)
031 {
032 LOG.error(e.getMessage());
033 e.printStackTrace();
034 } catch (InvocationTargetException e)
035 {
036 LOG.error(e.getMessage());
037 e.printStackTrace();
038 } catch (Exception e)
039 {
040 LOG.error(e.toString());
041 e.printStackTrace();
042 }
043 }
044
045 public TynamoDescriptor(Descriptor descriptor)
046 {
047 try
048 {
049 BeanUtils.copyProperties(this, descriptor);
050 copyExtensionsFrom(descriptor);
051 } catch (IllegalAccessException e)
052 {
053 LOG.error(e.getMessage());
054 e.printStackTrace();
055 } catch (InvocationTargetException e)
056 {
057 LOG.error(e.getMessage());
058 e.printStackTrace();
059 } catch (Exception e)
060 {
061 LOG.error(e.toString());
062 e.printStackTrace();
063 }
064 }
065
066 public TynamoDescriptor(Class type)
067 {
068 this.type = type;
069 }
070
071 @Override
072 public Object clone()
073 {
074 return new TynamoDescriptor(this);
075 }
076
077 public void copyFrom(Descriptor descriptor)
078 {
079 try
080 {
081 BeanUtils.copyProperties(this, descriptor);
082 copyExtensionsFrom(descriptor);
083 } catch (IllegalAccessException e)
084 {
085 LOG.error(e.getMessage());
086 e.printStackTrace();
087 } catch (InvocationTargetException e)
088 {
089 LOG.error(e.getMessage());
090 e.printStackTrace();
091 } catch (Exception e)
092 {
093 LOG.error(e.toString());
094 e.printStackTrace();
095 }
096 }
097
098 public void copyExtensionsFrom(Descriptor descriptor)
099 {
100 Map<String, DescriptorExtension> exts = descriptor.getExtensions();
101
102 for (Map.Entry<String, DescriptorExtension> entry : exts.entrySet())
103 {
104 String keye = entry.getKey();
105 DescriptorExtension value = entry.getValue();
106 try
107 {
108 this.addExtension(keye, (DescriptorExtension) BeanUtils.cloneBean(value));
109 } catch (Exception e)
110 {
111 //@todo fix clone methods.
112 }
113 }
114 }
115
116 public boolean isHidden()
117 {
118 return hidden;
119 }
120
121 public void setHidden(boolean hidden)
122 {
123 this.hidden = hidden;
124 }
125
126 public Class getType()
127 {
128 return type;
129 }
130
131 public void setType(Class type)
132 {
133 this.type = type;
134 }
135
136 /**
137 * Keye is property name preceded by package name
138 */
139 public boolean supportsExtension(String keye)
140 {
141 return getExtension(keye) != null;
142 }
143
144 public boolean supportsExtension(Class extensionType)
145 {
146 return supportsExtension(extensionType.getName());
147 }
148
149 /**
150 * Keye is property name preceded by package name
151 */
152 public DescriptorExtension getExtension(String keye)
153 {
154 return extensions.get(keye);
155 }
156
157 /**
158 * Keye is property name preceded by package name
159 */
160 public void addExtension(String keye, DescriptorExtension extension)
161 {
162 extensions.put(keye, extension);
163 }
164
165 public void addExtension(Class extensionType, DescriptorExtension extension)
166 {
167 addExtension(extensionType.getName(), extension);
168 }
169
170 /**
171 * Keye is property name preceded by package name
172 */
173 public void removeExtension(String keye)
174 {
175 extensions.remove(keye);
176 }
177
178 public void removeExtension(Class extensionType)
179 {
180 removeExtension(extensionType.getName());
181 }
182
183 public <E extends DescriptorExtension> E getExtension(Class<E> extensionType)
184 {
185 return (E) extensions.get(extensionType.getName());
186 }
187
188 /**
189 * This getter method is here just to allow clone(), copyFrom() and
190 * BeanUtils.copyProperties(this, descriptor); to work correctly
191 */
192 public Map<String, DescriptorExtension> getExtensions()
193 {
194 return extensions;
195 }
196
197 /**
198 * This setter method is here just to allow clone(), copyFrom() and
199 * BeanUtils.copyProperties(this, descriptor); to work correctly
200 */
201 public void setExtensions(Map<String, DescriptorExtension> extensions)
202 {
203 this.extensions = extensions;
204 }
205 }