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