001: /*
002: * <copyright>
003: *
004: * Copyright 1997-2004 BBNT Solutions, LLC
005: * under sponsorship of the Defense Advanced Research Projects
006: * Agency (DARPA).
007: *
008: * You can redistribute this software and/or modify it under the
009: * terms of the Cougaar Open Source License as published on the
010: * Cougaar Open Source Website (www.cougaar.org).
011: *
012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
023: *
024: * </copyright>
025: */
026:
027: package org.cougaar.planning.ldm;
028:
029: import org.cougaar.core.domain.Factory;
030: import org.cougaar.core.mts.MessageAddress;
031: import org.cougaar.core.service.UIDServer;
032: import org.cougaar.planning.ldm.asset.Asset;
033: import org.cougaar.planning.ldm.asset.PropertyGroup;
034: import org.cougaar.planning.service.PrototypeRegistryService;
035: import java.util.HashMap;
036: import java.util.Map;
037:
038: /**
039: * Plugins primary interface to the LDM.
040: *
041: * @see org.cougaar.planning.ldm.LDMPluginServesLDM
042: **/
043: public interface LDMServesPlugin extends PrototypeRegistryService {
044:
045: /**
046: * Equivalent to <code>((PlanningFactory) getFactory("planning"))</code>.
047: */
048: PlanningFactory getFactory();
049:
050: /** @return the Requested Domain's LDM Factory.
051: **/
052: Factory getFactory(String domainName);
053:
054: /** @return the Requested Domain's LDM Factory.
055: **/
056: Factory getFactory(Class domainClass);
057:
058: /** @return the classloader to be used for loading classes for the LDM.
059: * Domain Plugins should not use this, as they will have been themselves
060: * loaded by this ClassLoader. Some infrastructure components which are
061: * not loaded in the same way will require this for correct operation.
062: **/
063: ClassLoader getLDMClassLoader();
064:
065: /** The current agent's Address */
066: MessageAddress getMessageAddress();
067:
068: UIDServer getUIDServer();
069:
070: /**
071: * If the Delegator is used, this gets the real thing
072: **/
073: LDMServesPlugin getLDM();
074:
075: class Delegator implements LDMServesPlugin {
076: private LDMServesPlugin ldm;
077:
078: Delegator() {
079: }
080:
081: synchronized void setLDM(LDMServesPlugin ldm) {
082: this .ldm = ldm;
083: }
084:
085: public LDMServesPlugin getLDM() {
086: return ldm != null ? ldm : this ;
087: }
088:
089: public void addPrototypeProvider(PrototypeProvider prov) {
090: ldm.addPrototypeProvider(prov);
091: }
092:
093: public void addPropertyProvider(PropertyProvider prov) {
094: ldm.addPropertyProvider(prov);
095: }
096:
097: public void addLatePropertyProvider(LatePropertyProvider lpp) {
098: ldm.addLatePropertyProvider(lpp);
099: }
100:
101: public void fillProperties(Asset anAsset) {
102: ldm.fillProperties(anAsset);
103: }
104:
105: public PropertyGroup lateFillPropertyGroup(Asset anAsset,
106: Class pg, long time) {
107: return ldm.lateFillPropertyGroup(anAsset, pg, time);
108: }
109:
110: public int getPrototypeProviderCount() {
111: return ldm.getPrototypeProviderCount();
112: }
113:
114: public int getPropertyProviderCount() {
115: return ldm.getPropertyProviderCount();
116: }
117:
118: public PlanningFactory getFactory() {
119: return ldm.getFactory();
120: }
121:
122: public Factory getFactory(String domainName) {
123: return ldm.getFactory(domainName);
124: }
125:
126: public Factory getFactory(Class domainClass) {
127: return ldm.getFactory(domainClass);
128: }
129:
130: public ClassLoader getLDMClassLoader() {
131: return ldm.getLDMClassLoader();
132: }
133:
134: public MessageAddress getMessageAddress() {
135: return ldm.getMessageAddress();
136: }
137:
138: public UIDServer getUIDServer() {
139: return ldm.getUIDServer();
140: }
141:
142: //
143: // set up a temporary prototype cache while bootstrapping
144: //
145:
146: private HashMap _pcache;
147:
148: private HashMap pc() { /* must be called within synchronized */
149: if (_pcache == null) {
150: _pcache = new HashMap(13);
151: }
152: return _pcache;
153: }
154:
155: // called by LDMContextTable to read out any cached prototypes into the real one
156: synchronized HashMap flushTemporaryPrototypeCache() {
157: HashMap c = _pcache;
158: _pcache = null;
159: return c;
160: }
161:
162: public synchronized void cachePrototype(String aTypeName,
163: Asset aPrototype) {
164: if (ldm != null) {
165: ldm.cachePrototype(aTypeName, aPrototype);
166: } else {
167: pc().put(aTypeName, aPrototype);
168: }
169: }
170:
171: public synchronized boolean isPrototypeCached(String aTypeName) {
172: if (ldm != null) {
173: return ldm.isPrototypeCached(aTypeName);
174: } else {
175: return (_pcache == null ? false : _pcache
176: .get(aTypeName) != null);
177: }
178: }
179:
180: public synchronized Asset getPrototype(String aTypeName,
181: Class anAssetClass) {
182: if (ldm != null) {
183: return ldm.getPrototype(aTypeName, anAssetClass);
184: } else {
185: return (Asset) (_pcache == null ? null : _pcache
186: .get(aTypeName)); /*no hint passed, since we've got no actual providers*/
187: }
188: }
189:
190: public synchronized Asset getPrototype(String aTypeName) {
191: if (ldm != null) {
192: return ldm.getPrototype(aTypeName);
193: } else {
194: return (Asset) (_pcache == null ? null : _pcache
195: .get(aTypeName));
196: }
197: }
198:
199: public synchronized int getCachedPrototypeCount() {
200: if (ldm != null) {
201: return ldm.getCachedPrototypeCount();
202: } else {
203: return (_pcache == null) ? 0 : pc().size();
204: }
205: }
206: }
207: }
|