UPMT-master/java/upmt/src/org/zoolu/sip/message/Message.java
/*
 * Copyright (C) 2005 Luca Veltri - University of Parma - Italy
 * 
 * This file is part of MjSip (http://www.mjsip.org)
 * 
 * MjSip is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * MjSip is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with MjSip; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Author(s):
 * Luca Veltri (luca.veltri@unipr.it)
 */

package org.zoolu.sip.message;


import org.zoolu.net.UdpPacket;
import org.zoolu.sip.header.AllowEventsHeader;
import org.zoolu.sip.header.EventHeader;
import org.zoolu.sip.header.Header;
import org.zoolu.sip.header.ReferToHeader;
import org.zoolu.sip.header.ReferredByHeader;
import org.zoolu.sip.header.ReplacesHeader;
import org.zoolu.sip.header.SipHeaders;
import org.zoolu.sip.header.SubscriptionStateHeader;


/** Class Message extends class sip.message.BaseMessage adding some SIP extensions.
  * <p />
  * Class Message supports all methods and header definened in RFC3261, plus:
  * <ul>
  * <li> method MESSAGE (RFC3428) </>
  * <li> method REFER (RFC3515) </>
  * <li> header Refer-To </>
  * <li> header Referred-By </>
  * <li> header Event </>
  * </ul>
  */
public class Message extends org.zoolu.sip.message.BaseMessage
{
   /** Creates a new empty Message */
   public Message() { super(); }

   /** Creates a new Message */
   public Message(String str)
   {  super(str);
   }

   /** Creates a new Message */
   public Message(byte[] buff, int offset, int len)
   {  super(buff,offset,len);
   }

   /** Creates a new Message */
   public Message(UdpPacket packet)
   {  super(packet);
   }

   /** Creates a new Message */
   public Message(Message msg)
   {  super(msg);
   }
   
   /** Creates and returns a clone of the Message */
   public Object clone()
   {  return new Message(this);
   }


   //****************************** Extensions *******************************/

   /** Returns boolean value to indicate if Message is a MESSAGE request (RFC3428) */
   public boolean isMessage() throws NullPointerException
   {  return isRequest(SipMethods.MESSAGE);
   }

   /** Returns boolean value to indicate if Message is a REFER request (RFC3515) */
   public boolean isRefer() throws NullPointerException
   {  return isRequest(SipMethods.REFER);
   }

   /** Returns boolean value to indicate if Message is a NOTIFY request (RFC3265) */
   public boolean isNotify() throws NullPointerException
   {  return isRequest(SipMethods.NOTIFY);
   }

   /** Returns boolean value to indicate if Message is a SUBSCRIBE request (RFC3265) */
   public boolean isSubscribe() throws NullPointerException
   {  return isRequest(SipMethods.SUBSCRIBE);
   }

   /** Returns boolean value to indicate if Message is a PUBLISH request (RFC3903) */
   public boolean isPublish() throws NullPointerException
   {  return isRequest(SipMethods.PUBLISH);
   }


   /** Whether the message has the Refer-To header */   
   public boolean hasReferToHeader()
   {  return hasHeader(SipHeaders.Refer_To);
   }
   /** Gets ReferToHeader */
   public ReferToHeader getReferToHeader()
   {  Header h=getHeader(SipHeaders.Refer_To);
      if (h==null) return null;
      return new ReferToHeader(h);
   }  
   /** Sets ReferToHeader */
   public void setReferToHeader(ReferToHeader h) 
   {  setHeader(h);
   } 
   /** Removes ReferToHeader from Message (if it exists) */
   public void removeReferToHeader() 
   {  removeHeader(SipHeaders.Refer_To);
   }



   /** Whether the message has the Replaces header */   
   public boolean hasReplacesHeader()
   {  return hasHeader(SipHeaders.Replaces);
   }
   /** Gets ReplacesHeader */
   public ReplacesHeader getReplacesHeader()
   {  Header h=getHeader(SipHeaders.Replaces);
      if (h==null) return null;
      return new ReplacesHeader(h);
   }  
   /** Sets ReplacesHeader */
   public void setReplacesHeader(ReplacesHeader h) 
   {  setHeader(h);
   } 
   /** Removes ReplacesHeader from Message (if it exists) */
   public void removeReplacesHeader() 
   {  removeHeader(SipHeaders.Replaces);
   }



   /** Whether the message has the Referred-By header */   
   public boolean hasReferredByHeader()
   {  return hasHeader(SipHeaders.Refer_To);
   }
   /** Gets ReferredByHeader */
   public ReferredByHeader getReferredByHeader()
   {  Header h=getHeader(SipHeaders.Referred_By);
      if (h==null) return null;
      return new ReferredByHeader(h);
   }  
   /** Sets ReferredByHeader */
   public void setReferredByHeader(ReferredByHeader h) 
   {  setHeader(h);
   } 
   /** Removes ReferredByHeader from Message (if it exists) */
   public void removeReferredByHeader() 
   {  removeHeader(SipHeaders.Referred_By);
   }



   /** Whether the message has the EventHeader */   
   public boolean hasEventHeader()
   {  return hasHeader(SipHeaders.Event);
   }
   /** Gets EventHeader */
   public EventHeader getEventHeader()
   {  Header h=getHeader(SipHeaders.Event);
      if (h==null) return null;
      return new EventHeader(h);
   }  
   /** Sets EventHeader */
   public void setEventHeader(EventHeader h) 
   {  setHeader(h);
   } 
   /** Removes EventHeader from Message (if it exists) */
   public void removeEventHeader() 
   {  removeHeader(SipHeaders.Event);
   }


   /** Whether the message has the AllowEventsHeader */   
   public boolean hasAllowEventsHeader()
   {  return hasHeader(SipHeaders.Allow_Events);
   }
   /** Gets AllowEventsHeader */
   public AllowEventsHeader getAllowEventsHeader()
   {  Header h=getHeader(SipHeaders.Allow_Events);
      if (h==null) return null;
      return new AllowEventsHeader(h);
   }  
   /** Sets AllowEventsHeader */
   public void setAllowEventsHeader(AllowEventsHeader h) 
   {  setHeader(h);
   } 
   /** Removes AllowEventsHeader from Message (if it exists) */
   public void removeAllowEventsHeader() 
   {  removeHeader(SipHeaders.Allow_Events);
   }


   /** Whether the message has the Subscription-State header */   
   public boolean hasSubscriptionStateHeader()
   {  return hasHeader(SipHeaders.Subscription_State);
   }
   /** Gets SubscriptionStateHeader */
   public SubscriptionStateHeader getSubscriptionStateHeader()
   {  Header h=getHeader(SipHeaders.Subscription_State);
      if (h==null) return null;
      return new SubscriptionStateHeader(h);
   }  
   /** Sets SubscriptionStateHeader */
   public void setSubscriptionStateHeader(SubscriptionStateHeader h) 
   {  setHeader(h);
   } 
   /** Removes SubscriptionStateHeader from Message (if it exists) */
   public void removeSubscriptionStateHeader() 
   {  removeHeader(SipHeaders.Subscription_State);
   }

}
