| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.cxf.service.model; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.logging.Logger; |
| |
| import javax.xml.namespace.QName; |
| |
| import org.apache.cxf.common.i18n.Message; |
| import org.apache.cxf.common.logging.LogUtils; |
| |
| public class OperationInfo extends AbstractPropertiesHolder implements NamedItem { |
| private static final Logger LOG = LogUtils.getL7dLogger(OperationInfo.class); |
| InterfaceInfo intf; |
| QName opName; |
| String inName; |
| MessageInfo inputMessage; |
| String outName; |
| MessageInfo outputMessage; |
| Map<QName, FaultInfo> faults; |
| OperationInfo unwrappedOperation; |
| List<String> parameterOrdering; |
| |
| public OperationInfo() { |
| } |
| |
| OperationInfo(InterfaceInfo it, QName n) { |
| intf = it; |
| setName(n); |
| } |
| OperationInfo(OperationInfo op) { |
| intf = op.getInterface(); |
| setName(op.getName()); |
| } |
| |
| /** |
| * Returns the name of the Operation. |
| * @return the name of the Operation |
| */ |
| public QName getName() { |
| return opName; |
| } |
| /** |
| * Sets the name of the operation. |
| * @param name the new name of the operation |
| */ |
| public final void setName(QName name) { |
| if (name == null) { |
| throw new NullPointerException("Operation Name cannot be null."); |
| } |
| opName = name; |
| } |
| public InterfaceInfo getInterface() { |
| return intf; |
| } |
| |
| |
| public MessageInfo createMessage(QName nm, MessageInfo.Type type) { |
| return new MessageInfo(this, type, nm); |
| } |
| |
| public MessageInfo getOutput() { |
| return outputMessage; |
| } |
| public String getOutputName() { |
| return outName; |
| } |
| public void setOutput(String nm, MessageInfo out) { |
| outName = nm; |
| outputMessage = out; |
| if (unwrappedOperation != null && unwrappedOperation.getOutput() != null) { |
| unwrappedOperation.getOutput().setDelegate(out, false); |
| } |
| } |
| public boolean hasOutput() { |
| return outputMessage != null; |
| } |
| |
| public MessageInfo getInput() { |
| return inputMessage; |
| } |
| public String getInputName() { |
| return inName; |
| } |
| public void setInput(String nm, MessageInfo in) { |
| inName = nm; |
| inputMessage = in; |
| if (unwrappedOperation != null && unwrappedOperation.getInput() != null) { |
| unwrappedOperation.getInput().setDelegate(in, false); |
| } |
| } |
| public boolean hasInput() { |
| return inputMessage != null; |
| } |
| |
| public boolean isOneWay() { |
| return inputMessage != null && outputMessage == null; |
| } |
| |
| public boolean isUnwrappedCapable() { |
| return unwrappedOperation != null; |
| } |
| |
| public OperationInfo getUnwrappedOperation() { |
| return unwrappedOperation; |
| } |
| public void setUnwrappedOperation(OperationInfo op) { |
| unwrappedOperation = op; |
| } |
| public boolean isUnwrapped() { |
| return false; |
| } |
| |
| |
| /** |
| * Adds an fault to this operation. |
| * |
| * @param name the fault name. |
| */ |
| public FaultInfo addFault(QName name, QName message) { |
| if (name == null) { |
| throw new NullPointerException(new Message("FAULT.NAME.NOT.NULL", LOG).toString()); |
| } |
| if (faults != null && faults.containsKey(name)) { |
| throw new IllegalArgumentException( |
| new Message("DUPLICATED.FAULT.NAME", LOG, name).toString()); |
| } |
| FaultInfo fault = new FaultInfo(name, message, this); |
| addFault(fault); |
| return fault; |
| } |
| |
| /** |
| * Adds a fault to this operation. |
| * |
| * @param fault the fault. |
| */ |
| public synchronized void addFault(FaultInfo fault) { |
| if (faults == null) { |
| faults = new ConcurrentHashMap<>(4, 0.75f, 2); |
| } |
| faults.put(fault.getFaultName(), fault); |
| } |
| |
| /** |
| * Removes a fault from this operation. |
| * |
| * @param name the qualified fault name. |
| */ |
| public void removeFault(QName name) { |
| if (faults != null) { |
| faults.remove(name); |
| } |
| } |
| |
| /** |
| * Returns the fault with the given name, if found. |
| * |
| * @param name the name. |
| * @return the fault; or <code>null</code> if not found. |
| */ |
| public FaultInfo getFault(QName name) { |
| if (faults != null) { |
| return faults.get(name); |
| } |
| return null; |
| } |
| |
| public boolean hasFaults() { |
| return faults != null && !faults.isEmpty(); |
| } |
| |
| /** |
| * Returns all faults for this operation. |
| * |
| * @return all faults. |
| */ |
| public Collection<FaultInfo> getFaults() { |
| if (faults == null) { |
| return Collections.emptyList(); |
| } |
| return Collections.unmodifiableCollection(faults.values()); |
| } |
| |
| public void setParameterOrdering(List<String> o) { |
| this.parameterOrdering = o; |
| } |
| |
| public List<String> getParameterOrdering() { |
| return parameterOrdering; |
| } |
| |
| @Override |
| public String toString() { |
| return new StringBuilder("[OperationInfo: ") |
| .append(opName) |
| .append(']').toString(); |
| } |
| |
| public int hashCode() { |
| return opName == null ? -1 : opName.hashCode(); |
| } |
| |
| public boolean equals(Object o) { |
| if (o == this) { |
| return true; |
| } |
| |
| if (!(o instanceof OperationInfo)) { |
| return false; |
| } |
| OperationInfo oi = (OperationInfo)o; |
| return equals(opName, oi.opName) |
| && equals(inputMessage, oi.inputMessage) |
| && equals(outputMessage, oi.outputMessage) |
| && equals(faults, oi.faults) |
| && equals(intf.getName(), oi.intf.getName()); |
| } |
| |
| } |