Fix split between codec and Message

diff --git a/src/codec/mod.rs b/src/codec/mod.rs
index cb6244a95c4dcb7eb1d498116aeb96e511222cf2..39dfd890b87fba1960700cdb3ec60ef10025eb30 100644 (file)
--- a/src/codec/mod.rs
+++ b/src/codec/mod.rs
@@ -8,8 +8,8 @@ mod chartype;
 
 use self::chartype::{chartype, CharType, CR, LF};
 use message::Message;
-use parser::header;
-use types::Header;
+use parser::{header, top_line};
+use types::{Header, TopLine};
 
 impl Header {
     fn parse(line: UnparsedLine) -> Option<(Header, UnparsedLine)> {
@@ -163,7 +163,7 @@ impl SipCodec {
                         let length = new_message.body_length();
 
                         if length == 0 {
-                            if let Some(message) = Message::new(new_message) {
+                            if let Some(message) = new_message.into_message(None) {
                                 debug!("Got message without body: {:?}", message);
 
                                 return Ok(Some(message));
@@ -175,7 +175,7 @@ impl SipCodec {
                             return Ok(None);
                         } else {
                             let body = buf.split_to(length);
-                            if let Some(message) = Message::new_with_body(new_message, body) {
+                            if let Some(message) = new_message.into_message(Some(body)) {
                                 debug!("Got message with body: {:?}", message);
 
                                 return Ok(Some(message));
@@ -221,6 +221,21 @@ impl PartialMessage {
 
         body_length
     }
+
+    pub fn into_message(self, body: Option<BytesMut>) -> Option<Message> {
+        match top_line(self.top_line.clone().as_bytes()) {
+            nom::IResult::Done(_, TopLine::RequestLine(r)) => {
+                Some(Message::request(r, self.top_line, self.headers, body))
+            }
+            nom::IResult::Done(_, TopLine::StatusLine(s)) => {
+                Some(Message::response(s, self.top_line, self.headers, body))
+            }
+            result => {
+                warn!("Failed to parse top line: {:?}", result);
+                None
+            }
+        }
+    }
 }
 
 impl Decoder for SipCodec {
@@ -235,8 +250,11 @@ impl Decoder for SipCodec {
 
             if length > buf.len() {
                 return Ok(None);
-            } else if let Some(message) =
-                Message::new_with_body(self.message.take().unwrap(), buf.split_to(length))
+            } else if let Some(message) = self
+                .message
+                .take()
+                .unwrap()
+                .into_message(Some(buf.split_to(length)))
             {
                 return Ok(Some(message));
             } else {

diff --git a/src/message.rs b/src/message.rs
index e3e01e225c9819b4f9b4a6f6a6e40f18e9fbfefd..39edba6789bab3671f34e330d7db0e18a16bf008 100644 (file)
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,9 +1,7 @@
 use bytes::BytesMut;
-use nom;
 
-use codec::{PartialMessage, UnparsedLine};
-use parser::top_line;
-use types::{Header, Method, RequestLine, StatusLine, TopLine};
+use codec::UnparsedLine;
+use types::{Header, Method, RequestLine, StatusLine};
 
 #[derive(Debug)]
 pub enum Message {
@@ -12,31 +10,30 @@ pub enum Message {
 }
 
 impl Message {
-    pub fn new(message: PartialMessage) -> Option<Message> {
-        Message::parse(message, None)
+    pub fn request(
+        request: RequestLine,
+        up_request: UnparsedLine,
+        headers: Vec<(Header, UnparsedLine)>,
+        body: Option<BytesMut>,
+    ) -> Message {
+        Message::Request(Request {
+            headers: headers,
+            request_line: (request, up_request.clone()),
+            body: body,
+        })
     }
 
-    pub fn new_with_body(message: PartialMessage, body: BytesMut) -> Option<Message> {
-        Message::parse(message, Some(body))
-    }
-
-    pub fn parse(message: PartialMessage, body: Option<BytesMut>) -> Option<Message> {
-        match top_line(message.top_line.as_bytes()) {
-            nom::IResult::Done(_, TopLine::RequestLine(r)) => Some(Message::Request(Request {
-                headers: message.headers,
-                request_line: (r, message.top_line.clone()),
-                body: body,
-            })),
-            nom::IResult::Done(_, TopLine::StatusLine(s)) => Some(Message::Response(Response {
-                headers: message.headers,
-                status_line: (s, message.top_line.clone()),
-                body: body,
-            })),
-            result => {
-                warn!("Failed to parse top line: {:?}", result);
-                None
-            }
-        }
+    pub fn response(
+        status: StatusLine,
+        up_status: UnparsedLine,
+        headers: Vec<(Header, UnparsedLine)>,
+        body: Option<BytesMut>,
+    ) -> Message {
+        Message::Response(Response {
+            headers: headers,
+            status_line: (status, up_status.clone()),
+            body: body,
+        })
     }
 
     pub fn as_bytes<'a>(&'a self) -> &'a [u8] {