[ONOS-2563]Optimize RFC 7047's code.

Change-Id: I000f2b802420e4f47ce320f6ed021049bd2fd83e

@@ -16,25 +16,25 @@
 package org.onosproject.ovsdb.rfc.error;
 package org.onosproject.ovsdb.rfc.error;
 
 
 /**
 /**
- * AbnormalSchema exception is thrown when the received schema is invalid.
+ * AbnormalJsonNodeException exception is thrown when the received JsonNode is invalid.
  */
  */
-public class AbnormalSchemaException extends RuntimeException {
+public class AbnormalJsonNodeException extends RuntimeException {
     private static final long serialVersionUID = 8328377718334680368L;
     private static final long serialVersionUID = 8328377718334680368L;
 
 
     /**
     /**
-     * Constructs a AbnormalSchemaException object.
+     * Constructs a AbnormalJsonNodeException object.
      * @param message error message
      * @param message error message
      */
      */
-    public AbnormalSchemaException(String message) {
+    public AbnormalJsonNodeException(String message) {
         super(message);
         super(message);
     }
     }
 
 
     /**
     /**
-     * Constructs a AbnormalSchemaException object.
+     * Constructs a AbnormalJsonNodeException object.
      * @param message error message
      * @param message error message
      * @param cause Throwable
      * @param cause Throwable
      */
      */
-    public AbnormalSchemaException(String message, Throwable cause) {
+    public AbnormalJsonNodeException(String message, Throwable cause) {
         super(message, cause);
         super(message, cause);
     }
     }
 
 

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.error;
-
-/**
- * This exception is thrown when the argument is not supported.
- */
-public class ArgumentException extends RuntimeException {
-    private static final long serialVersionUID = 4950089877540156797L;
-
-    /**
-     * Constructs a ArgumentException object.
-     * @param message error message
-     */
-    public ArgumentException(String message) {
-        super(message);
-    }
-
-    /**
-     * Constructs a ArgumentException object.
-     * @param message error message
-     * @param cause Throwable
-     */
-    public ArgumentException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.error;
-
-/**
- * The JsonParsingException is thrown when JSON could not be successfully
- * parsed.
- */
-public class JsonParsingException extends RuntimeException {
-    private static final long serialVersionUID = 1424752181911923235L;
-
-    /**
-     * Constructs a JsonParsingException object.
-     * @param message error message
-     */
-    public JsonParsingException(String message) {
-        super(message);
-    }
-
-    /**
-     * Constructs a JsonParsingException object.
-     * @param message error message
-     * @param cause Throwable
-     */
-    public JsonParsingException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    /**
-     * Constructs a JsonParsingException object.
-     * @param cause Throwable
-     */
-    public JsonParsingException(Throwable cause) {
-        super(cause);
-    }
-
-    /**
-     * Constructs a JsonParsingException object.
-     * @param message error message
-     * @param cause Throwable
-     * @param enableSuppression enable Suppression
-     * @param writableStackTrace writable StackTrace
-     */
-    public JsonParsingException(String message, Throwable cause,
-                                boolean enableSuppression,
-                                boolean writableStackTrace) {
-        super(message, cause, enableSuppression, writableStackTrace);
-    }
-}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.error;
-
-/**
- * This is a generic exception thrown by the Typed Schema utilities.
- */
-public class TypedSchemaException extends RuntimeException {
-    private static final long serialVersionUID = -1452257990783176715L;
-
-    /**
-     * Constructs a TypedSchemaException object.
-     * @param message error message
-     */
-    public TypedSchemaException(String message) {
-        super(message);
-    }
-
-    /**
-     * Constructs a TypedSchemaException object.
-     * @param message error message
-     * @param cause Throwable
-     */
-    public TypedSchemaException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}

-package org.onosproject.ovsdb.rfc.error;
-
-/**
- * This exception is thrown when the encoding does not meet UTF-8 in RFC7047.
- */
-public class UnsupportedEncodingException extends RuntimeException {
-    private static final long serialVersionUID = -4865311369828520666L;
-
-    /**
-     * Constructs a UnsupportedEncodingException object.
-     * @param message error message
-     */
-    public UnsupportedEncodingException(String message) {
-        super(message);
-    }
-}

@@ -16,26 +16,26 @@
 package org.onosproject.ovsdb.rfc.error;
 package org.onosproject.ovsdb.rfc.error;
 
 
 /**
 /**
- * This exception is thrown when a result does not meet any of the known formats
- * in RFC7047.
+ * This exception is thrown when the caller invoke the unsupported method or
+ * use the encoding is not supported.
  */
  */
-public class UnknownResultException extends RuntimeException {
+public class UnsupportedException extends RuntimeException {
     private static final long serialVersionUID = 1377011546616825375L;
     private static final long serialVersionUID = 1377011546616825375L;
 
 
     /**
     /**
-     * Constructs a UnknownResultException object.
+     * Constructs a UnsupportedException object.
      * @param message error message
      * @param message error message
      */
      */
-    public UnknownResultException(String message) {
+    public UnsupportedException(String message) {
         super(message);
         super(message);
     }
     }
 
 
     /**
     /**
-     * Constructs a UnknownResultException object.
+     * Constructs a UnsupportedException object.
      * @param message error message
      * @param message error message
      * @param cause Throwable
      * @param cause Throwable
      */
      */
-    public UnknownResultException(String message, Throwable cause) {
+    public UnsupportedException(String message, Throwable cause) {
         super(message, cause);
         super(message, cause);
     }
     }
 }
 }

@@ -15,7 +15,6 @@
  */
  */
 package org.onosproject.ovsdb.rfc.error;
 package org.onosproject.ovsdb.rfc.error;
 
 
-import static com.google.common.base.MoreObjects.toStringHelper;
 
 
 /**
 /**
  * This exception is used when the a table or row is accessed though a typed
  * This exception is used when the a table or row is accessed though a typed
@@ -47,15 +46,9 @@ public class VersionMismatchException extends RuntimeException {
      * @param fromVersion the initial version
      * @param fromVersion the initial version
      * @return message
      * @return message
      */
      */
-    public static String createFromMessage(String actualVersion,
-                                           String fromVersion) {
-        String message = toStringHelper("VersionMismatchException")
-                .addValue("The fromVersion should less than the actualVersion.\n"
-                                  + "fromVersion: "
-                                  + fromVersion
-                                  + ".\n"
-                                  + "actualVersion: " + actualVersion)
-                .toString();
+    public static String createFromMessage(String actualVersion, String fromVersion) {
+        String message = "The fromVersion should less than the actualVersion.\n fromVersion: "
+                + fromVersion + ".\n" + "actualVersion: " + actualVersion;
         return message;
         return message;
     }
     }
 
 
@@ -66,13 +59,8 @@ public class VersionMismatchException extends RuntimeException {
      * @return message
      * @return message
      */
      */
     public static String createToMessage(String actualVersion, String toVersion) {
     public static String createToMessage(String actualVersion, String toVersion) {
-        String message = toStringHelper("VersionMismatchException")
-                .addValue("The toVersion should greater than the required version.\n"
-                                  + "toVersion: "
-                                  + toVersion
-                                  + ".\n"
-                                  + "Actual Version: " + actualVersion)
-                .toString();
+        String message = "The toVersion should greater than the actualVersion.\n"
+                + "toVersion: " + toVersion + ".\n" + " actualVersion: " + actualVersion;
         return message;
         return message;
     }
     }
 }
 }

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.message;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Objects;
-
-import org.onosproject.ovsdb.rfc.notation.json.UpdateNotificationConverter;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
-
-/**
- * The "update" notification is sent by the server to the client to report
- * changes in tables that are being monitored following a "monitor" request. The
- * "params" of the result JsonNode.
- */
-@JsonDeserialize(converter = UpdateNotificationConverter.class)
-public final class UpdateNotification {
-    private final Object context;
-    private final JsonNode tbUpdatesJsonNode;
-
-    /**
-     * Constructs a UpdateNotification object.
-     * @param context the "json-value" in "params" of the result JsonNode
-     * @param tbUpdatesJsonNode the "table-updates" in "params" of the result JsonNode
-     */
-    public UpdateNotification(Object context, JsonNode tbUpdatesJsonNode) {
-        checkNotNull(context, "context cannot be null");
-        checkNotNull(tbUpdatesJsonNode, "tablebUpdates JsonNode cannot be null");
-        this.context = context;
-        this.tbUpdatesJsonNode = tbUpdatesJsonNode;
-    }
-
-    /**
-     * Return context.
-     * @return context
-     */
-    public Object context() {
-        return context;
-    }
-
-    /**
-     * Return tbUpdatesJsonNode.
-     * @return tbUpdatesJsonNode
-     */
-    public JsonNode tbUpdatesJsonNode() {
-        return tbUpdatesJsonNode;
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(context, tbUpdatesJsonNode);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj instanceof UpdateNotification) {
-            final UpdateNotification other = (UpdateNotification) obj;
-            return Objects.equals(this.context, other.context)
-                    && Objects.equals(this.tbUpdatesJsonNode,
-                                      other.tbUpdatesJsonNode);
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        return toStringHelper(this).add("context", context)
-                .add("tbUpdatesJsonNode", tbUpdatesJsonNode).toString();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.message;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+
+import org.onosproject.ovsdb.rfc.notation.json.UpdateNotificationConverter;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+
+/**
+ * The "update" notification is sent by the server to the client to report
+ * changes in tables that are being monitored following a "monitor" request. The
+ * "params" of the result JsonNode.
+ */
+@JsonDeserialize(converter = UpdateNotificationConverter.class)
+public final class UpdateNotification {
+    private final Object jsonValue;
+    private final JsonNode tbUpdatesJsonNode;
+
+    /**
+     * Constructs a UpdateNotification object.
+     * @param jsonValue the "json-value" in "params" of the result JsonNode
+     * @param tbUpdatesJsonNode the "table-updates" in "params" of the result JsonNode
+     */
+    public UpdateNotification(Object jsonValue, JsonNode tbUpdatesJsonNode) {
+        checkNotNull(jsonValue, "jsonValue cannot be null");
+        checkNotNull(tbUpdatesJsonNode, "tablebUpdates JsonNode cannot be null");
+        this.jsonValue = jsonValue;
+        this.tbUpdatesJsonNode = tbUpdatesJsonNode;
+    }
+
+    /**
+     * Return context.
+     * @return context
+     */
+    public Object jsonValue() {
+        return jsonValue;
+    }
+
+    /**
+     * Return tbUpdatesJsonNode.
+     * @return tbUpdatesJsonNode
+     */
+    public JsonNode tbUpdatesJsonNode() {
+        return tbUpdatesJsonNode;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(jsonValue, tbUpdatesJsonNode);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof UpdateNotification) {
+            final UpdateNotification other = (UpdateNotification) obj;
+            return Objects.equals(this.jsonValue, other.jsonValue)
+                    && Objects.equals(this.tbUpdatesJsonNode,
+                                      other.tbUpdatesJsonNode);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("jsonValue", jsonValue)
+                .add("tbUpdatesJsonNode", tbUpdatesJsonNode).toString();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.notation;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Objects;
-
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-/**
- * Column is the basic element of the OpenVswitch database.
- */
-public final class Column {
-    @JsonIgnore
-    private final ColumnSchema schema;
-    private final Object data;
-
-    /**
-     * Column constructor.
-     * @param schema the column schema
-     * @param obj the data of the column
-     */
-    public Column(ColumnSchema schema, Object obj) {
-        checkNotNull(schema, "schema cannot be null");
-        checkNotNull(obj, "data cannot be null");
-        this.schema = schema;
-        this.data = obj;
-    }
-
-    /**
-     * Returns column data.
-     * @return column data
-     */
-    public Object data() {
-        return data;
-    }
-
-    /**
-     * Returns ColumnSchema.
-     * @return ColumnSchema
-     */
-    public ColumnSchema schema() {
-        return schema;
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(schema, data);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj instanceof Column) {
-            final Column other = (Column) obj;
-            return Objects.equals(this.schema, other.schema)
-                    && Objects.equals(this.data, other.data);
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        return toStringHelper(this).add("schema", schema).add("data", data)
-                .toString();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.notation;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+
+/**
+ * Column is the basic element of the OpenVswitch database.
+ */
+public final class Column {
+    private final String columnName;
+    private final Object data;
+
+    /**
+     * Column constructor.
+     * @param columnName the column name
+     * @param obj the data of the column
+     */
+    public Column(String columnName, Object obj) {
+        checkNotNull(columnName, "columnName cannot be null");
+        checkNotNull(obj, "data cannot be null");
+        this.columnName = columnName;
+        this.data = obj;
+    }
+
+    /**
+     * Returns column data.
+     * @return column data
+     */
+    public Object data() {
+        return data;
+    }
+
+    /**
+     * Returns columnName.
+     * @return columnName
+     */
+    public String columnName() {
+        return columnName;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(columnName, data);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof Column) {
+            final Column other = (Column) obj;
+            return Objects.equals(this.columnName, other.columnName)
+                    && Objects.equals(this.data, other.data);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("columnName", columnName)
+                .add("data", data).toString();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.notation;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.google.common.collect.Maps;
-
-/**
- * Row is the basic element of the OpenVswitch's table.
- */
-public final class Row {
-    @JsonIgnore
-    private TableSchema tableSchema;
-    private Map<String, Column> columns;
-
-    /**
-     * Row constructor.
-     */
-    public Row() {
-        this.columns = Maps.newHashMap();
-    }
-
-    /**
-     * Row constructor.
-     * @param tableSchema TableSchema entity
-     */
-    public Row(TableSchema tableSchema) {
-        checkNotNull(tableSchema, "tableSchema cannot be null");
-        this.tableSchema = tableSchema;
-        this.columns = Maps.newHashMap();
-    }
-
-    /**
-     * Row constructor.
-     * @param tableSchema TableSchema entity
-     * @param columns List of Column entity
-     */
-    public Row(TableSchema tableSchema, List<Column> columns) {
-        checkNotNull(tableSchema, "tableSchema cannot be null");
-        checkNotNull(columns, "columns cannot be null");
-        this.tableSchema = tableSchema;
-        this.columns = Maps.newHashMap();
-        for (Column column : columns) {
-            this.columns.put(column.schema().name(), column);
-        }
-    }
-
-    /**
-     * Returns tableSchema.
-     * @return tableSchema
-     */
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * Set tableSchema value.
-     * @param tableSchema TableSchema entity
-     */
-    public void setTableSchema(TableSchema tableSchema) {
-        this.tableSchema = tableSchema;
-    }
-
-    /**
-     * Returns Column by ColumnSchema.
-     * @param schema ColumnSchema entity
-     * @return Column
-     */
-    public Column getColumn(ColumnSchema schema) {
-        return (Column) columns.get(schema.name());
-    }
-
-    /**
-     * Returns Collection of Column.
-     * @return Collection of Column
-     */
-    public Collection<Column> getColumns() {
-        return columns.values();
-    }
-
-    /**
-     * add Column.
-     * @param columnName column name
-     * @param data Column entity
-     */
-    public void addColumn(String columnName, Column data) {
-        this.columns.put(columnName, data);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(tableSchema, columns);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj instanceof Row) {
-            final Row other = (Row) obj;
-            return Objects.equals(this.tableSchema, other.tableSchema)
-                    && Objects.equals(this.columns, other.columns);
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        return toStringHelper(this).add("tableSchema", tableSchema).add("columns", columns).toString();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.notation;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+
+import com.google.common.collect.Maps;
+
+/**
+ * Row is the basic element of the OpenVswitch's table.
+ */
+public final class Row {
+    private String tableName;
+    private Map<String, Column> columns;
+
+    /**
+     * Row constructor.
+     */
+    public Row() {
+        this.columns = Maps.newHashMap();
+    }
+
+    /**
+     * Row constructor.
+     * @param tableName table name
+     */
+    public Row(String tableName) {
+        checkNotNull(tableName, "tableName cannot be null");
+        this.tableName = tableName;
+        this.columns = Maps.newHashMap();
+    }
+
+    /**
+     * Row constructor.
+     * @param tableName table name
+     * @param columns Map of Column entity
+     */
+    public Row(String tableName, Map<String, Column> columns) {
+        checkNotNull(tableName, "table name cannot be null");
+        checkNotNull(columns, "columns cannot be null");
+        this.tableName = tableName;
+        this.columns = columns;
+    }
+
+    /**
+     * Returns tableName.
+     * @return tableName
+     */
+    public String tableName() {
+        return tableName;
+    }
+
+    /**
+     * Set tableName value.
+     * @param tableName table name
+     */
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
+    }
+
+    /**
+     * Returns Column by ColumnSchema.
+     * @param columnName column name
+     * @return Column
+     */
+    public Column getColumn(String columnName) {
+        return columns.get(columnName);
+    }
+
+    /**
+     * Returns Collection of Column.
+     * @return Collection of Column
+     */
+    public Collection<Column> getColumns() {
+        return columns.values();
+    }
+
+    /**
+     * add Column.
+     * @param columnName column name
+     * @param data Column entity
+     */
+    public void addColumn(String columnName, Column data) {
+        this.columns.put(columnName, data);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tableName, columns);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof Row) {
+            final Row other = (Row) obj;
+            return Objects.equals(this.tableName, other.tableName)
+                    && Objects.equals(this.columns, other.columns);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toStringHelper(this).add("tableName", tableName)
+                .add("columns", columns).toString();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.operations;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.List;
-
-import org.onosproject.ovsdb.rfc.notation.Condition;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-/**
- * delete operation.Refer to RFC 7047 Section 5.2.
- */
-public final class Delete implements Operation {
-
-    @JsonIgnore
-    private final TableSchema tableSchema;
-    private final String op;
-    private final List<Condition> where;
-
-    /**
-     * Constructs a Delete object.
-     * @param schema TableSchema entity
-     * @param where the List of Condition entity
-     */
-    public Delete(TableSchema schema, List<Condition> where) {
-        checkNotNull(schema, "TableSchema cannot be null");
-        checkNotNull(where, "where is not null");
-        this.tableSchema = schema;
-        this.op = Operations.DELETE.op();
-        this.where = where;
-    }
-
-    /**
-     * Returns the where member of delete operation.
-     * @return the where member of delete operation
-     */
-    public List<Condition> getWhere() {
-        return where;
-    }
-
-    @Override
-    public String getOp() {
-        return op;
-    }
-
-    @Override
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * For the use of serialization.
-     * @return the table member of update operation
-     */
-    @JsonProperty
-    public String getTable() {
-        return (tableSchema == null) ? null : tableSchema.name();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.operations;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.List;
+
+import org.onosproject.ovsdb.rfc.notation.Condition;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+/**
+ * delete operation.Refer to RFC 7047 Section 5.2.
+ */
+public final class Delete implements Operation {
+
+    @JsonIgnore
+    private final TableSchema tableSchema;
+    private final String op;
+    private final List<Condition> where;
+
+    /**
+     * Constructs a Delete object.
+     * @param schema TableSchema entity
+     * @param where the List of Condition entity
+     */
+    public Delete(TableSchema schema, List<Condition> where) {
+        checkNotNull(schema, "TableSchema cannot be null");
+        checkNotNull(where, "where is not null");
+        this.tableSchema = schema;
+        this.op = Operations.DELETE.op();
+        this.where = where;
+    }
+
+    /**
+     * Returns the where member of delete operation.
+     * @return the where member of delete operation
+     */
+    public List<Condition> getWhere() {
+        return where;
+    }
+
+    @Override
+    public String getOp() {
+        return op;
+    }
+
+    @Override
+    public TableSchema getTableSchema() {
+        return tableSchema;
+    }
+
+    /**
+     * For the use of serialization.
+     * @return the table member of update operation
+     */
+    @JsonProperty
+    public String getTable() {
+        return tableSchema.name();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.operations;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.Map;
-
-import org.onosproject.ovsdb.rfc.notation.Column;
-import org.onosproject.ovsdb.rfc.notation.Row;
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.collect.Maps;
-
-/**
- * insert operation.Refer to RFC 7047 Section 5.2.
- */
-public final class Insert implements Operation {
-
-    @JsonIgnore
-    private final TableSchema tableSchema;
-    private final String op;
-    @JsonProperty("uuid-name")
-    private final String uuidName;
-    private final Map<String, Object> row;
-
-    /**
-     * Constructs a Insert object.
-     * @param schema TableSchema entity
-     * @param uuidName uuid-name
-     * @param row Row entity
-     */
-    public Insert(TableSchema schema, String uuidName, Row row) {
-        checkNotNull(schema, "TableSchema cannot be null");
-        checkNotNull(uuidName, "uuid name cannot be null");
-        checkNotNull(row, "row cannot be null");
-        this.tableSchema = schema;
-        this.op = Operations.INSERT.op();
-        this.uuidName = uuidName;
-        this.row = Maps.newHashMap();
-        generateOperationRow(row);
-    }
-
-    /**
-     * Row entity convert into the row format of insert operation. Refer to RFC
-     * 7047 Section 5.2.
-     * @param row Row entity
-     */
-    private void generateOperationRow(Row row) {
-        Collection<Column> columns = row.getColumns();
-        for (Column column : columns) {
-            ColumnSchema columnSchema = column.schema();
-            Object value = column.data();
-            Object untypedValue = TransValueUtil.getFormatData(value);
-            this.row.put(columnSchema.name(), untypedValue);
-        }
-    }
-
-    /**
-     * Returns the uuid-name member of insert operation.
-     * @return the uuid-name member of insert operation
-     */
-    public String getUuidName() {
-        return uuidName;
-    }
-
-    /**
-     * Returns the row member of insert operation.
-     * @return the row member of insert operation
-     */
-    public Map<String, Object> getRow() {
-        return row;
-    }
-
-    @Override
-    public String getOp() {
-        return op;
-    }
-
-    @Override
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * For the use of serialization.
-     * @return the table member of update operation
-     */
-    @JsonProperty
-    public String getTable() {
-        return (tableSchema == null) ? null : tableSchema.name();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.operations;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.onosproject.ovsdb.rfc.notation.Column;
+import org.onosproject.ovsdb.rfc.notation.Row;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.Maps;
+
+/**
+ * insert operation.Refer to RFC 7047 Section 5.2.
+ */
+public final class Insert implements Operation {
+
+    @JsonIgnore
+    private final TableSchema tableSchema;
+    private final String op;
+    @JsonProperty("uuid-name")
+    private final String uuidName;
+    private final Map<String, Object> row;
+
+    /**
+     * Constructs a Insert object.
+     * @param schema TableSchema entity
+     * @param uuidName uuid-name
+     * @param row Row entity
+     */
+    public Insert(TableSchema schema, String uuidName, Row row) {
+        checkNotNull(schema, "TableSchema cannot be null");
+        checkNotNull(uuidName, "uuid name cannot be null");
+        checkNotNull(row, "row cannot be null");
+        this.tableSchema = schema;
+        this.op = Operations.INSERT.op();
+        this.uuidName = uuidName;
+        this.row = Maps.newHashMap();
+        generateOperationRow(row);
+    }
+
+    /**
+     * Row entity convert into the row format of insert operation. Refer to RFC
+     * 7047 Section 5.2.
+     * @param row Row entity
+     */
+    private void generateOperationRow(Row row) {
+        Collection<Column> columns = row.getColumns();
+        for (Column column : columns) {
+            String columnName = column.columnName();
+            Object value = column.data();
+            Object formatValue = TransValueUtil.getFormatData(value);
+            this.row.put(columnName, formatValue);
+        }
+    }
+
+    /**
+     * Returns the uuid-name member of insert operation.
+     * @return the uuid-name member of insert operation
+     */
+    public String getUuidName() {
+        return uuidName;
+    }
+
+    /**
+     * Returns the row member of insert operation.
+     * @return the row member of insert operation
+     */
+    public Map<String, Object> getRow() {
+        return row;
+    }
+
+    @Override
+    public String getOp() {
+        return op;
+    }
+
+    @Override
+    public TableSchema getTableSchema() {
+        return tableSchema;
+    }
+
+    /**
+     * For the use of serialization.
+     * @return the table member of update operation
+     */
+    @JsonProperty
+    public String getTable() {
+        return tableSchema.name();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.operations;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.List;
-
-import org.onosproject.ovsdb.rfc.notation.Condition;
-import org.onosproject.ovsdb.rfc.notation.Mutation;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-/**
- * mutate operation.Refer to RFC 7047 Section 5.2.
- */
-public final class Mutate implements Operation {
-
-    @JsonIgnore
-    private final TableSchema tableSchema;
-    private final String op;
-    private final List<Condition> where;
-    private final List<Mutation> mutations;
-
-    /**
-     * Constructs a Mutate object.
-     * @param schema TableSchema entity
-     * @param where the List of Condition entity
-     * @param mutations the List of Mutation entity
-     */
-    public Mutate(TableSchema schema, List<Condition> where,
-                  List<Mutation> mutations) {
-        checkNotNull(schema, "TableSchema cannot be null");
-        checkNotNull(mutations, "mutations cannot be null");
-        checkNotNull(where, "where cannot be null");
-        this.tableSchema = schema;
-        this.op = Operations.MUTATE.op();
-        this.where = where;
-        this.mutations = mutations;
-    }
-
-    /**
-     * Returns the mutations member of mutate operation.
-     * @return the mutations member of mutate operation
-     */
-    public List<Mutation> getMutations() {
-        return mutations;
-    }
-
-    /**
-     * Returns the where member of mutate operation.
-     * @return the where member of mutate operation
-     */
-    public List<Condition> getWhere() {
-        return where;
-    }
-
-    @Override
-    public String getOp() {
-        return op;
-    }
-
-    @Override
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * For the use of serialization.
-     * @return the table member of update operation
-     */
-    @JsonProperty
-    public String getTable() {
-        return (tableSchema == null) ? null : tableSchema.name();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.operations;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.List;
+
+import org.onosproject.ovsdb.rfc.notation.Condition;
+import org.onosproject.ovsdb.rfc.notation.Mutation;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+/**
+ * mutate operation.Refer to RFC 7047 Section 5.2.
+ */
+public final class Mutate implements Operation {
+
+    @JsonIgnore
+    private final TableSchema tableSchema;
+    private final String op;
+    private final List<Condition> where;
+    private final List<Mutation> mutations;
+
+    /**
+     * Constructs a Mutate object.
+     * @param schema TableSchema entity
+     * @param where the List of Condition entity
+     * @param mutations the List of Mutation entity
+     */
+    public Mutate(TableSchema schema, List<Condition> where,
+                  List<Mutation> mutations) {
+        checkNotNull(schema, "TableSchema cannot be null");
+        checkNotNull(mutations, "mutations cannot be null");
+        checkNotNull(where, "where cannot be null");
+        this.tableSchema = schema;
+        this.op = Operations.MUTATE.op();
+        this.where = where;
+        this.mutations = mutations;
+    }
+
+    /**
+     * Returns the mutations member of mutate operation.
+     * @return the mutations member of mutate operation
+     */
+    public List<Mutation> getMutations() {
+        return mutations;
+    }
+
+    /**
+     * Returns the where member of mutate operation.
+     * @return the where member of mutate operation
+     */
+    public List<Condition> getWhere() {
+        return where;
+    }
+
+    @Override
+    public String getOp() {
+        return op;
+    }
+
+    @Override
+    public TableSchema getTableSchema() {
+        return tableSchema;
+    }
+
+    /**
+     * For the use of serialization.
+     * @return the table member of update operation
+     */
+    @JsonProperty
+    public String getTable() {
+        return tableSchema.name();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.operations;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.List;
-
-import org.onosproject.ovsdb.rfc.notation.Condition;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-
-/**
- * select operation.Refer to RFC 7047 Section 5.2.
- */
-public final class Select implements Operation {
-
-    @JsonIgnore
-    private final TableSchema tableSchema;
-    private final String op;
-    private final List<Condition> where;
-    private final List<String> columns;
-
-    /**
-     * Constructs a Select object.
-     * @param schema TableSchema entity
-     * @param where the List of Condition entity
-     * @param columns the List of column name
-     */
-    public Select(TableSchema schema, List<Condition> where, List<String> columns) {
-        checkNotNull(schema, "TableSchema cannot be null");
-        checkNotNull(where, "where cannot be null");
-        checkNotNull(columns, "columns cannot be null");
-        this.tableSchema = schema;
-        this.op = Operations.SELECT.op();
-        this.where = where;
-        this.columns = columns;
-    }
-
-    /**
-     * Returns the columns member of select operation.
-     * @return the columns member of select operation
-     */
-    public List<String> getColumns() {
-        return columns;
-    }
-
-    /**
-     * Returns the where member of select operation.
-     * @return the where member of select operation
-     */
-    public List<Condition> getWhere() {
-        return where;
-    }
-
-    @Override
-    public String getOp() {
-        return op;
-    }
-
-    @Override
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * For the use of serialization.
-     * @return the table member of update operation
-     */
-    @JsonProperty
-    public String getTable() {
-        return (tableSchema == null) ? null : tableSchema.name();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.operations;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.List;
+
+import org.onosproject.ovsdb.rfc.notation.Condition;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+/**
+ * select operation.Refer to RFC 7047 Section 5.2.
+ */
+public final class Select implements Operation {
+
+    @JsonIgnore
+    private final TableSchema tableSchema;
+    private final String op;
+    private final List<Condition> where;
+    private final List<String> columns;
+
+    /**
+     * Constructs a Select object.
+     * @param schema TableSchema entity
+     * @param where the List of Condition entity
+     * @param columns the List of column name
+     */
+    public Select(TableSchema schema, List<Condition> where, List<String> columns) {
+        checkNotNull(schema, "TableSchema cannot be null");
+        checkNotNull(where, "where cannot be null");
+        checkNotNull(columns, "columns cannot be null");
+        this.tableSchema = schema;
+        this.op = Operations.SELECT.op();
+        this.where = where;
+        this.columns = columns;
+    }
+
+    /**
+     * Returns the columns member of select operation.
+     * @return the columns member of select operation
+     */
+    public List<String> getColumns() {
+        return columns;
+    }
+
+    /**
+     * Returns the where member of select operation.
+     * @return the where member of select operation
+     */
+    public List<Condition> getWhere() {
+        return where;
+    }
+
+    @Override
+    public String getOp() {
+        return op;
+    }
+
+    @Override
+    public TableSchema getTableSchema() {
+        return tableSchema;
+    }
+
+    /**
+     * For the use of serialization.
+     * @return the table member of update operation
+     */
+    @JsonProperty
+    public String getTable() {
+        return tableSchema.name();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.operations;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-import org.onosproject.ovsdb.rfc.notation.Column;
-import org.onosproject.ovsdb.rfc.notation.Condition;
-import org.onosproject.ovsdb.rfc.notation.Row;
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.google.common.collect.Maps;
-
-/**
- * update operation.Refer to RFC 7047 Section 5.2.
- */
-public final class Update implements Operation {
-
-    @JsonIgnore
-    private final TableSchema tableSchema;
-    private final String op;
-    private final Map<String, Object> row;
-    private final List<Condition> where;
-
-    /**
-     * Constructs a Update object.
-     * @param schema TableSchema entity
-     * @param row Row entity
-     * @param where the List of Condition entity
-     */
-    public Update(TableSchema schema, Row row, List<Condition> where) {
-        checkNotNull(schema, "TableSchema cannot be null");
-        checkNotNull(row, "row cannot be null");
-        checkNotNull(where, "where cannot be null");
-        this.tableSchema = schema;
-        this.op = Operations.UPDATE.op();
-        this.row = Maps.newHashMap();
-        this.where = where;
-        generateOperationRow(row);
-    }
-
-    /**
-     * Row entity convert into the row format of update operation. Refer to RFC
-     * 7047 Section 5.2.
-     * @param row Row entity
-     */
-    private void generateOperationRow(Row row) {
-        Collection<Column> columns = row.getColumns();
-        for (Column column : columns) {
-            ColumnSchema columnSchema = column.schema();
-            Object value = column.data();
-            Object untypedValue = TransValueUtil.getFormatData(value);
-            this.row.put(columnSchema.name(), untypedValue);
-        }
-    }
-
-    /**
-     * Returns the row member of update operation.
-     * @return the row member of update operation
-     */
-    public Map<String, Object> getRow() {
-        return row;
-    }
-
-    /**
-     * Returns the where member of update operation.
-     * @return the where member of update operation
-     */
-    public List<Condition> getWhere() {
-        return where;
-    }
-
-    @Override
-    public String getOp() {
-        return op;
-    }
-
-    @Override
-    public TableSchema getTableSchema() {
-        return tableSchema;
-    }
-
-    /**
-     * For the use of serialization.
-     * @return the table member of update operation
-     */
-    @JsonProperty
-    public String getTable() {
-        return (tableSchema == null) ? null : tableSchema.name();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.operations;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.onosproject.ovsdb.rfc.notation.Column;
+import org.onosproject.ovsdb.rfc.notation.Condition;
+import org.onosproject.ovsdb.rfc.notation.Row;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+import org.onosproject.ovsdb.rfc.utils.TransValueUtil;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.collect.Maps;
+
+/**
+ * update operation.Refer to RFC 7047 Section 5.2.
+ */
+public final class Update implements Operation {
+
+    @JsonIgnore
+    private final TableSchema tableSchema;
+    private final String op;
+    private final Map<String, Object> row;
+    private final List<Condition> where;
+
+    /**
+     * Constructs a Update object.
+     * @param schema TableSchema entity
+     * @param row Row entity
+     * @param where the List of Condition entity
+     */
+    public Update(TableSchema schema, Row row, List<Condition> where) {
+        checkNotNull(schema, "TableSchema cannot be null");
+        checkNotNull(row, "row cannot be null");
+        checkNotNull(where, "where cannot be null");
+        this.tableSchema = schema;
+        this.op = Operations.UPDATE.op();
+        this.row = Maps.newHashMap();
+        this.where = where;
+        generateOperationRow(row);
+    }
+
+    /**
+     * Row entity convert into the row format of update operation. Refer to RFC
+     * 7047 Section 5.2.
+     * @param row Row entity
+     */
+    private void generateOperationRow(Row row) {
+        Collection<Column> columns = row.getColumns();
+        for (Column column : columns) {
+            String columnName = column.columnName();
+            Object value = column.data();
+            Object formatValue = TransValueUtil.getFormatData(value);
+            this.row.put(columnName, formatValue);
+        }
+    }
+
+    /**
+     * Returns the row member of update operation.
+     * @return the row member of update operation
+     */
+    public Map<String, Object> getRow() {
+        return row;
+    }
+
+    /**
+     * Returns the where member of update operation.
+     * @return the where member of update operation
+     */
+    public List<Condition> getWhere() {
+        return where;
+    }
+
+    @Override
+    public String getOp() {
+        return op;
+    }
+
+    @Override
+    public TableSchema getTableSchema() {
+        return tableSchema;
+    }
+
+    /**
+     * For the use of serialization.
+     * @return the table member of update operation
+     */
+    @JsonProperty
+    public String getTable() {
+        return tableSchema.name();
+    }
+}

@@ -17,8 +17,9 @@ package org.onosproject.ovsdb.rfc.schema.type;
 
 
 import java.util.Set;
 import java.util.Set;
 
 
-import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
+import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
 import org.onosproject.ovsdb.rfc.schema.type.UuidBaseType.RefType;
 import org.onosproject.ovsdb.rfc.schema.type.UuidBaseType.RefType;
+import org.onosproject.ovsdb.rfc.utils.ObjectMapperUtil;
 
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Sets;
@@ -29,27 +30,29 @@ import com.google.common.collect.Sets;
 public final class BaseTypeFactory {
 public final class BaseTypeFactory {
 
 
     /**
     /**
-     * Constructs a BaseTypeFactory object.
-     * This class should not be instantiated.
+     * Constructs a BaseTypeFactory object. This class should not be
+     * instantiated.
      */
      */
     private BaseTypeFactory() {
     private BaseTypeFactory() {
     }
     }
 
 
     /**
     /**
      * Create a BaseType from the JsonNode.
      * Create a BaseType from the JsonNode.
-     * @param json the BaseType JsonNode
+     * @param baseTypeJson the BaseType JsonNode
      * @param keyorval the key node or value node
      * @param keyorval the key node or value node
      * @return BaseType
      * @return BaseType
      */
      */
-    public static BaseType getBaseTypeFromJson(JsonNode json, String keyorval) {
-        if (json.isValueNode()) {
-            String type = json.asText().trim();
+    public static BaseType getBaseTypeFromJson(JsonNode baseTypeJson, String keyorval) {
+        if (baseTypeJson.isValueNode()) {
+            String type = baseTypeJson.asText().trim();
             return fromTypeStr(type);
             return fromTypeStr(type);
         } else {
         } else {
-            if (!json.has(keyorval)) {
-                throw new TypedSchemaException("not a type");
+            if (!baseTypeJson.has(keyorval)) {
+                String message = "Abnormal BaseType JsonNode, it should contain 'key' or 'value' node but was not found"
+                        + ObjectMapperUtil.convertToString(baseTypeJson);
+                throw new AbnormalJsonNodeException(message);
             }
             }
-            return fromJsonNode(json.get(keyorval));
+            return fromJsonNode(baseTypeJson.get(keyorval));
         }
         }
     }
     }
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.onosproject.ovsdb.rfc.schema.type;
 package org.onosproject.ovsdb.rfc.schema.type;
 
 
-import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
+import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
 import org.onosproject.ovsdb.rfc.utils.ObjectMapperUtil;
 import org.onosproject.ovsdb.rfc.utils.ObjectMapperUtil;
 
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -26,8 +26,8 @@ import com.fasterxml.jackson.databind.JsonNode;
 public final class ColumnTypeFactory {
 public final class ColumnTypeFactory {
 
 
     /**
     /**
-     * Constructs a ColumnTypeFactory object.
-     * This class should not be instantiated.
+     * Constructs a ColumnTypeFactory object. This class should not be
+     * instantiated.
      */
      */
     private ColumnTypeFactory() {
     private ColumnTypeFactory() {
     }
     }
@@ -54,20 +54,22 @@ public final class ColumnTypeFactory {
     }
     }
 
 
     /**
     /**
-     * JsonNode like "flow_tables":{"type":{"key":{"maxInteger":254,"minInteger":0,"type":
+     * JsonNode like
+     * "flow_tables":{"type":{"key":{"maxInteger":254,"minInteger":0,"type":
      * "integer"},"min":0,"value":{"type":"uuid","refTable":"Flow_Table"},"max":
      * "integer"},"min":0,"value":{"type":"uuid","refTable":"Flow_Table"},"max":
      * "unlimited"}}.
      * "unlimited"}}.
-     * @param json the ColumnType JsonNode
+     * @param columnTypeJson the ColumnType JsonNode
      * @return ColumnType
      * @return ColumnType
      */
      */
-    public static ColumnType getColumnTypeFromJson(JsonNode json) {
-        if (!json.isObject() || !json.has(Type.VALUE.type())) {
-            return createAtomicColumnType(json);
-        } else if (!json.isValueNode() && json.has(Type.VALUE.type())) {
-            return createKeyValuedColumnType(json);
+    public static ColumnType getColumnTypeFromJson(JsonNode columnTypeJson) {
+        if (!columnTypeJson.isObject() || !columnTypeJson.has(Type.VALUE.type())) {
+            return createAtomicColumnType(columnTypeJson);
+        } else if (!columnTypeJson.isValueNode() && columnTypeJson.has(Type.VALUE.type())) {
+            return createKeyValuedColumnType(columnTypeJson);
         }
         }
-        throw new TypedSchemaException("could not find the right column type :"
-                + ObjectMapperUtil.convertToString(json));
+        String message = "Abnormal ColumnType JsonNode, it should be AtomicColumnType or KeyValuedColumnType"
+                + ObjectMapperUtil.convertToString(columnTypeJson);
+        throw new AbnormalJsonNodeException(message);
     }
     }
 
 
     /**
     /**
@@ -76,12 +78,11 @@ public final class ColumnTypeFactory {
      * @return AtomicColumnType entity
      * @return AtomicColumnType entity
      */
      */
     private static AtomicColumnType createAtomicColumnType(JsonNode json) {
     private static AtomicColumnType createAtomicColumnType(JsonNode json) {
-        BaseType baseType = BaseTypeFactory
-                .getBaseTypeFromJson(json, Type.KEY.type());
+        BaseType baseType = BaseTypeFactory.getBaseTypeFromJson(json, Type.KEY.type());
         int min = 1;
         int min = 1;
         int max = 1;
         int max = 1;
         JsonNode node = json.get("min");
         JsonNode node = json.get("min");
-        if (node != null) {
+        if (node != null && node.isNumber()) {
             min = node.asInt();
             min = node.asInt();
         }
         }
         node = json.get("max");
         node = json.get("max");
@@ -101,14 +102,12 @@ public final class ColumnTypeFactory {
      * @return KeyValuedColumnType entity
      * @return KeyValuedColumnType entity
      */
      */
     private static KeyValuedColumnType createKeyValuedColumnType(JsonNode json) {
     private static KeyValuedColumnType createKeyValuedColumnType(JsonNode json) {
-        BaseType keyType = BaseTypeFactory.getBaseTypeFromJson(json,
-                                                               Type.KEY.type());
-        BaseType valueType = BaseTypeFactory
-                .getBaseTypeFromJson(json, Type.VALUE.type());
+        BaseType keyType = BaseTypeFactory.getBaseTypeFromJson(json, Type.KEY.type());
+        BaseType valueType = BaseTypeFactory.getBaseTypeFromJson(json, Type.VALUE.type());
         int min = 1;
         int min = 1;
         int max = 1;
         int max = 1;
         JsonNode node = json.get("min");
         JsonNode node = json.get("min");
-        if (node != null) {
+        if (node != null && node.isNumber()) {
             min = node.asInt();
             min = node.asInt();
         }
         }
         node = json.get("max");
         node = json.get("max");

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.tableservice;
-
-import static com.google.common.base.MoreObjects.toStringHelper;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Objects;
-
-import org.onosproject.ovsdb.rfc.error.ColumnSchemaNotFoundException;
-import org.onosproject.ovsdb.rfc.error.TableSchemaNotFoundException;
-import org.onosproject.ovsdb.rfc.error.TypedSchemaException;
-import org.onosproject.ovsdb.rfc.error.VersionMismatchException;
-import org.onosproject.ovsdb.rfc.notation.Column;
-import org.onosproject.ovsdb.rfc.notation.Row;
-import org.onosproject.ovsdb.rfc.notation.UUID;
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-import org.onosproject.ovsdb.rfc.table.OvsdbTable;
-import org.onosproject.ovsdb.rfc.table.VersionNum;
-import org.onosproject.ovsdb.rfc.utils.VersionUtil;
-
-/**
- * Representation of conversion between Ovsdb table and Row.
- */
-public abstract class AbstractOvsdbTableService implements OvsdbTableService {
-
-    private final DatabaseSchema dbSchema;
-    private final Row row;
-    private final TableDescription tableDesc;
-
-    /**
-     * Constructs a AbstractOvsdbTableService object.
-     * @param dbSchema DatabaseSchema entity
-     * @param row Row entity
-     * @param table table name
-     * @param formVersion the initial version
-     */
-    public AbstractOvsdbTableService(DatabaseSchema dbSchema, Row row,
-                                     OvsdbTable table, VersionNum formVersion) {
-        checkNotNull(dbSchema, "database schema cannot be null");
-        checkNotNull(row, "row cannot be null");
-        checkNotNull(table, "table cannot be null");
-        checkNotNull(formVersion, "the initial version cannot be null");
-        this.dbSchema = dbSchema;
-        this.row = row;
-        TableDescription tableDesc = new TableDescription(table, formVersion);
-        this.tableDesc = tableDesc;
-        row.setTableSchema(dbSchema.getTableSchema(table.tableName()));
-    }
-
-    /**
-     * Check whether the parameter of dbSchema is valid and check whether the
-     * table is existent in Database Schema.
-     */
-    private boolean isValid() {
-        if (dbSchema == null) {
-            return false;
-        }
-        if (!dbSchema.name().equalsIgnoreCase(tableDesc.database())) {
-            return false;
-        }
-        checkTableSchemaVersion();
-        return true;
-    }
-
-    /**
-     * Check the table version.
-     */
-    private void checkTableSchemaVersion() {
-        String fromVersion = tableDesc.fromVersion();
-        String untilVersion = tableDesc.untilVersion();
-        String schemaVersion = dbSchema.version();
-        checkVersion(schemaVersion, fromVersion, untilVersion);
-    }
-
-    /**
-     * Check the column version.
-     * @param columnDesc ColumnDescription entity
-     */
-    private void checkColumnSchemaVersion(ColumnDescription columnDesc) {
-        String fromVersion = columnDesc.fromVersion();
-        String untilVersion = columnDesc.untilVersion();
-        String schemaVersion = dbSchema.version();
-        checkVersion(schemaVersion, fromVersion, untilVersion);
-    }
-
-    /**
-     * Check whether the DatabaseSchema version between the initial version and
-     * the end of the version.
-     * @param schemaVersion DatabaseSchema version
-     * @param fromVersion The initial version
-     * @param untilVersion The end of the version
-     * @throws VersionMismatchException this is a version mismatch exception
-     */
-    private void checkVersion(String schemaVersion, String fromVersion,
-                              String untilVersion) {
-        VersionUtil.versionMatch(fromVersion);
-        VersionUtil.versionMatch(untilVersion);
-        if (!fromVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
-            if (VersionUtil.versionCompare(schemaVersion, fromVersion) < 0) {
-                String message = VersionMismatchException
-                        .createFromMessage(schemaVersion, fromVersion);
-                throw new VersionMismatchException(message);
-            }
-        }
-        if (!untilVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
-            if (VersionUtil.versionCompare(untilVersion, schemaVersion) < 0) {
-                String message = VersionMismatchException
-                        .createToMessage(schemaVersion, untilVersion);
-                throw new VersionMismatchException(message);
-            }
-        }
-    }
-
-    /**
-     * Returns TableSchema from dbSchema by table name.
-     * @return TableSchema
-     */
-    private TableSchema getTableSchema() {
-        String tableName = tableDesc.name();
-        return dbSchema.getTableSchema(tableName);
-    }
-
-    /**
-     * Returns ColumnSchema from TableSchema by column name.
-     * @param tableSchema TableSchema entity
-     * @param columnName column name
-     * @return ColumnSchema
-     */
-    private ColumnSchema getColumnSchema(TableSchema tableSchema,
-                                         String columnName) {
-        return tableSchema.getColumnSchema(columnName);
-    }
-
-    @Override
-    public Column getColumnHandler(ColumnDescription columnDesc) {
-        if (!isValid()) {
-            return null;
-        }
-        String columnName = columnDesc.name();
-        checkColumnSchemaVersion(columnDesc);
-        if (columnName == null) {
-            throw new TypedSchemaException("Error processing GetColumn : "
-                    + tableDesc.name() + "." + columnDesc.method());
-        }
-        TableSchema tableSchema = getTableSchema();
-        if (tableSchema == null) {
-            String message = TableSchemaNotFoundException
-                    .createMessage(tableDesc.name(), dbSchema.name());
-            throw new TableSchemaNotFoundException(message);
-        }
-        ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
-        if (columnSchema == null) {
-            String message = ColumnSchemaNotFoundException
-                    .createMessage(columnName, tableSchema.name());
-            throw new ColumnSchemaNotFoundException(message);
-        }
-        if (row == null) {
-            return new Column(columnSchema, null);
-        }
-        return row.getColumn(columnSchema);
-    }
-
-    @Override
-    public Object getDataHandler(ColumnDescription columnDesc) {
-        if (!isValid()) {
-            return null;
-        }
-        String columnName = columnDesc.name();
-        checkColumnSchemaVersion(columnDesc);
-        if (columnName == null) {
-            throw new TypedSchemaException("Error processing GetColumn : "
-                    + tableDesc.name() + "." + columnDesc.method());
-        }
-        TableSchema tableSchema = getTableSchema();
-        if (tableSchema == null) {
-            String message = TableSchemaNotFoundException
-                    .createMessage(tableDesc.name(), dbSchema.name());
-            throw new TableSchemaNotFoundException(message);
-        }
-        ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
-        if (columnSchema == null) {
-            String message = ColumnSchemaNotFoundException
-                    .createMessage(columnName, tableSchema.name());
-            throw new ColumnSchemaNotFoundException(message);
-        }
-        if (row == null || row.getColumn(columnSchema) == null) {
-            return null;
-        }
-        return row.getColumn(columnSchema).data();
-    }
-
-    @Override
-    public void setDataHandler(ColumnDescription columnDesc, Object obj) {
-        if (!isValid()) {
-            return;
-        }
-        String columnName = columnDesc.name();
-        checkColumnSchemaVersion(columnDesc);
-        if (columnName == null) {
-            throw new TypedSchemaException("Unable to locate Column Name for "
-                    + tableDesc.name() + "." + columnDesc.method());
-        }
-        TableSchema tableSchema = getTableSchema();
-        ColumnSchema columnSchema = getColumnSchema(tableSchema, columnName);
-        Column column = new Column(columnSchema, obj);
-        row.addColumn(columnName, column);
-    }
-
-    @Override
-    public Object getTbSchema() {
-        if (!isValid()) {
-            return null;
-        }
-        if (dbSchema == null) {
-            return null;
-        }
-        return getTableSchema();
-    }
-
-    @Override
-    public UUID getUuid() {
-        if (!isValid()) {
-            return null;
-        }
-        ColumnDescription columnDesc = new ColumnDescription("_uuid",
-                                                             "getTbUuid");
-        return (UUID) getDataHandler(columnDesc);
-    }
-
-    @Override
-    public Column getUuidColumn() {
-        if (!isValid()) {
-            return null;
-        }
-        ColumnDescription columnDesc = new ColumnDescription("_uuid",
-                                                             "getTbUuidColumn");
-        return (Column) getColumnHandler(columnDesc);
-    }
-
-    @Override
-    public UUID getVersion() {
-        if (!isValid()) {
-            return null;
-        }
-        ColumnDescription columnDesc = new ColumnDescription("_version",
-                                                             "getTbVersion");
-        return (UUID) getDataHandler(columnDesc);
-    }
-
-    @Override
-    public Column getVersionColumn() {
-        if (!isValid()) {
-            return null;
-        }
-        ColumnDescription columnDesc = new ColumnDescription("_version",
-                                                             "getTbVersionColumn");
-        return (Column) getColumnHandler(columnDesc);
-    }
-
-    /**
-     * Get DatabaseSchema entity.
-     * @return DatabaseSchema entity
-     */
-    public DatabaseSchema dbSchema() {
-        return dbSchema;
-    }
-
-    /**
-     * Get Row entity.
-     * @return Row entity
-     */
-    public Row getRow() {
-        if (!isValid()) {
-            return null;
-        }
-        return this.row;
-    }
-
-    /**
-     * Get TableDescription entity.
-     * @return TableDescription entity
-     */
-    public TableDescription tableDesc() {
-        return tableDesc;
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(row);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) {
-            return true;
-        }
-        if (obj instanceof AbstractOvsdbTableService) {
-            final AbstractOvsdbTableService other = (AbstractOvsdbTableService) obj;
-            return Objects.equals(this.row, other.row);
-        }
-        return false;
-    }
-
-    @Override
-    public String toString() {
-        TableSchema schema = (TableSchema) getTbSchema();
-        String tableName = schema.name();
-        return toStringHelper(this).add("tableName", tableName).add("row", row)
-                .toString();
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.tableservice;
+
+import static com.google.common.base.MoreObjects.toStringHelper;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Objects;
+
+import org.onosproject.ovsdb.rfc.error.ColumnSchemaNotFoundException;
+import org.onosproject.ovsdb.rfc.error.TableSchemaNotFoundException;
+import org.onosproject.ovsdb.rfc.error.VersionMismatchException;
+import org.onosproject.ovsdb.rfc.notation.Column;
+import org.onosproject.ovsdb.rfc.notation.Row;
+import org.onosproject.ovsdb.rfc.notation.UUID;
+import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
+import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+import org.onosproject.ovsdb.rfc.table.OvsdbTable;
+import org.onosproject.ovsdb.rfc.table.VersionNum;
+import org.onosproject.ovsdb.rfc.utils.VersionUtil;
+
+/**
+ * Representation of conversion between Ovsdb table and Row.
+ */
+public abstract class AbstractOvsdbTableService implements OvsdbTableService {
+
+    private final DatabaseSchema dbSchema;
+    private final Row row;
+    private final TableDescription tableDesc;
+
+    /**
+     * Constructs a AbstractOvsdbTableService object.
+     * @param dbSchema DatabaseSchema entity
+     * @param row Row entity
+     * @param table table name
+     * @param formVersion the initial version
+     */
+    public AbstractOvsdbTableService(DatabaseSchema dbSchema, Row row, OvsdbTable table,
+                                     VersionNum formVersion) {
+        checkNotNull(dbSchema, "database schema cannot be null");
+        checkNotNull(row, "row cannot be null");
+        checkNotNull(table, "table cannot be null");
+        checkNotNull(formVersion, "the initial version cannot be null");
+        this.dbSchema = dbSchema;
+        row.setTableName(table.tableName());
+        this.row = row;
+        TableDescription tableDesc = new TableDescription(table, formVersion);
+        this.tableDesc = tableDesc;
+    }
+
+    /**
+     * Check whether the parameter of dbSchema is valid and check whether the
+     * table is existent in Database Schema.
+     */
+    private boolean isValid() {
+        if (dbSchema == null) {
+            return false;
+        }
+        if (!dbSchema.name().equalsIgnoreCase(tableDesc.database())) {
+            return false;
+        }
+        checkTableSchemaVersion();
+        return true;
+    }
+
+    /**
+     * Check the table version.
+     */
+    private void checkTableSchemaVersion() {
+        String fromVersion = tableDesc.fromVersion();
+        String untilVersion = tableDesc.untilVersion();
+        String schemaVersion = dbSchema.version();
+        checkVersion(schemaVersion, fromVersion, untilVersion);
+    }
+
+    /**
+     * Check the column version.
+     * @param columnDesc ColumnDescription entity
+     */
+    private void checkColumnSchemaVersion(ColumnDescription columnDesc) {
+        String fromVersion = columnDesc.fromVersion();
+        String untilVersion = columnDesc.untilVersion();
+        String schemaVersion = dbSchema.version();
+        checkVersion(schemaVersion, fromVersion, untilVersion);
+    }
+
+    /**
+     * Check whether the DatabaseSchema version between the initial version and
+     * the end of the version.
+     * @param schemaVersion DatabaseSchema version
+     * @param fromVersion The initial version
+     * @param untilVersion The end of the version
+     * @throws VersionMismatchException this is a version mismatch exception
+     */
+    private void checkVersion(String schemaVersion, String fromVersion, String untilVersion) {
+        VersionUtil.versionMatch(fromVersion);
+        VersionUtil.versionMatch(untilVersion);
+        if (!fromVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
+            if (VersionUtil.versionCompare(schemaVersion, fromVersion) < 0) {
+                String message = VersionMismatchException.createFromMessage(schemaVersion,
+                                                                            fromVersion);
+                throw new VersionMismatchException(message);
+            }
+        }
+        if (!untilVersion.equals(VersionUtil.DEFAULT_VERSION_STRING)) {
+            if (VersionUtil.versionCompare(untilVersion, schemaVersion) < 0) {
+                String message = VersionMismatchException.createToMessage(schemaVersion,
+                                                                          untilVersion);
+                throw new VersionMismatchException(message);
+            }
+        }
+    }
+
+    /**
+     * Returns TableSchema from dbSchema by table name.
+     * @return TableSchema
+     */
+    private TableSchema getTableSchema() {
+        String tableName = tableDesc.name();
+        return dbSchema.getTableSchema(tableName);
+    }
+
+    /**
+     * Returns ColumnSchema from TableSchema by column name.
+     * @param columnName column name
+     * @return ColumnSchema
+     */
+    private ColumnSchema getColumnSchema(String columnName) {
+        TableSchema tableSchema = getTableSchema();
+        if (tableSchema == null) {
+            String message = TableSchemaNotFoundException.createMessage(tableDesc.name(),
+                                                                        dbSchema.name());
+            throw new TableSchemaNotFoundException(message);
+        }
+        ColumnSchema columnSchema = tableSchema.getColumnSchema(columnName);
+        if (columnSchema == null) {
+            String message = ColumnSchemaNotFoundException.createMessage(columnName,
+                                                                         tableSchema.name());
+            throw new ColumnSchemaNotFoundException(message);
+        }
+        return columnSchema;
+    }
+
+    @Override
+    public Column getColumnHandler(ColumnDescription columnDesc) {
+        if (!isValid()) {
+            return null;
+        }
+        String columnName = columnDesc.name();
+        checkColumnSchemaVersion(columnDesc);
+        ColumnSchema columnSchema = getColumnSchema(columnName);
+        if (row == null) {
+            return null;
+        }
+        return row.getColumn(columnSchema.name());
+    }
+
+    @Override
+    public Object getDataHandler(ColumnDescription columnDesc) {
+        if (!isValid()) {
+            return null;
+        }
+        String columnName = columnDesc.name();
+        checkColumnSchemaVersion(columnDesc);
+        ColumnSchema columnSchema = getColumnSchema(columnName);
+        if (row == null || row.getColumn(columnSchema.name()) == null) {
+            return null;
+        }
+        return row.getColumn(columnSchema.name()).data();
+    }
+
+    @Override
+    public void setDataHandler(ColumnDescription columnDesc, Object obj) {
+        if (!isValid()) {
+            return;
+        }
+        String columnName = columnDesc.name();
+        checkColumnSchemaVersion(columnDesc);
+        ColumnSchema columnSchema = getColumnSchema(columnName);
+        Column column = new Column(columnSchema.name(), obj);
+        row.addColumn(columnName, column);
+    }
+
+    @Override
+    public UUID getTableUuid() {
+        if (!isValid()) {
+            return null;
+        }
+        ColumnDescription columnDesc = new ColumnDescription("_uuid", "getTableUuid");
+        return (UUID) getDataHandler(columnDesc);
+    }
+
+    @Override
+    public Column getTableUuidColumn() {
+        if (!isValid()) {
+            return null;
+        }
+        ColumnDescription columnDesc = new ColumnDescription("_uuid", "getTableUuidColumn");
+        return (Column) getColumnHandler(columnDesc);
+    }
+
+    @Override
+    public UUID getTableVersion() {
+        if (!isValid()) {
+            return null;
+        }
+        ColumnDescription columnDesc = new ColumnDescription("_version", "getTableVersion");
+        return (UUID) getDataHandler(columnDesc);
+    }
+
+    @Override
+    public Column getTableVersionColumn() {
+        if (!isValid()) {
+            return null;
+        }
+        ColumnDescription columnDesc = new ColumnDescription("_version", "getTableVersionColumn");
+        return (Column) getColumnHandler(columnDesc);
+    }
+
+    /**
+     * Get DatabaseSchema entity.
+     * @return DatabaseSchema entity
+     */
+    public DatabaseSchema dbSchema() {
+        return dbSchema;
+    }
+
+    /**
+     * Get Row entity.
+     * @return Row entity
+     */
+    public Row getRow() {
+        if (!isValid()) {
+            return null;
+        }
+        return this.row;
+    }
+
+    /**
+     * Get TableDescription entity.
+     * @return TableDescription entity
+     */
+    public TableDescription tableDesc() {
+        return tableDesc;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(row);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof AbstractOvsdbTableService) {
+            final AbstractOvsdbTableService other = (AbstractOvsdbTableService) obj;
+            return Objects.equals(this.row, other.row);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        TableSchema schema = (TableSchema) getTableSchema();
+        String tableName = schema.name();
+        return toStringHelper(this).add("tableName", tableName).add("row", row).toString();
+    }
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.tableservice;
-
-import org.onosproject.ovsdb.rfc.notation.Column;
-import org.onosproject.ovsdb.rfc.notation.UUID;
-
-/**
- * Representation of conversion between Ovsdb table and Row.
- */
-public interface OvsdbTableService {
-
-    /**
-     * Get Column from row.
-     * @param columndesc Column description
-     * @return Column
-     */
-    public Column getColumnHandler(ColumnDescription columndesc);
-
-    /**
-     * Get Data from row.
-     * @param columndesc Column description
-     * @return Object column data
-     */
-    public Object getDataHandler(ColumnDescription columndesc);
-
-    /**
-     * Set column data of row.
-     * @param columndesc Column description
-     * @param obj column data
-     */
-    public void setDataHandler(ColumnDescription columndesc, Object obj);
-
-    /**
-     * Returns the TableSchema from row.
-     * @return Object TableSchema
-     */
-    public Object getTbSchema();
-
-    /**
-     * Returns UUID which column name is _uuid.
-     * @return UUID
-     */
-    public UUID getUuid();
-
-    /**
-     * Returns UUID Column which column name is _uuid.
-     * @return UUID Column
-     */
-    public Column getUuidColumn();
-
-    /**
-     * Returns UUID which column name is _version.
-     * @return UUID
-     */
-    public UUID getVersion();
-
-    /**
-     * Returns UUID Column which column name is _version.
-     * @return UUID Column
-     */
-    public Column getVersionColumn();
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.tableservice;
+
+import org.onosproject.ovsdb.rfc.notation.Column;
+import org.onosproject.ovsdb.rfc.notation.UUID;
+
+/**
+ * Representation of conversion between Ovsdb table and Row.
+ */
+public interface OvsdbTableService {
+
+    /**
+     * Get Column from row.
+     * @param columndesc Column description
+     * @return Column
+     */
+    public Column getColumnHandler(ColumnDescription columndesc);
+
+    /**
+     * Get Data from row.
+     * @param columndesc Column description
+     * @return Object column data
+     */
+    public Object getDataHandler(ColumnDescription columndesc);
+
+    /**
+     * Set column data of row.
+     * @param columndesc Column description
+     * @param obj column data
+     */
+    public void setDataHandler(ColumnDescription columndesc, Object obj);
+
+    /**
+     * Returns UUID which column name is _uuid.
+     * @return UUID
+     */
+    public UUID getTableUuid();
+
+    /**
+     * Returns UUID Column which column name is _uuid.
+     * @return UUID Column
+     */
+    public Column getTableUuidColumn();
+
+    /**
+     * Returns UUID which column name is _version.
+     * @return UUID
+     */
+    public UUID getTableVersion();
+
+    /**
+     * Returns UUID Column which column name is _version.
+     * @return UUID Column
+     */
+    public Column getTableVersionColumn();
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.utils;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.onosproject.ovsdb.rfc.error.AbnormalSchemaException;
-import org.onosproject.ovsdb.rfc.error.JsonParsingException;
-import org.onosproject.ovsdb.rfc.error.UnknownResultException;
-import org.onosproject.ovsdb.rfc.jsonrpc.Callback;
-import org.onosproject.ovsdb.rfc.jsonrpc.JsonRpcResponse;
-import org.onosproject.ovsdb.rfc.message.OperationResult;
-import org.onosproject.ovsdb.rfc.message.RowUpdate;
-import org.onosproject.ovsdb.rfc.message.TableUpdate;
-import org.onosproject.ovsdb.rfc.message.TableUpdates;
-import org.onosproject.ovsdb.rfc.message.UpdateNotification;
-import org.onosproject.ovsdb.rfc.notation.Column;
-import org.onosproject.ovsdb.rfc.notation.Row;
-import org.onosproject.ovsdb.rfc.notation.UUID;
-import org.onosproject.ovsdb.rfc.operations.Operation;
-import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
-import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-import org.onosproject.ovsdb.rfc.schema.type.ColumnTypeFactory;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-
-/**
- * JsonNode utility class. convert JsonNode into Object.
- */
-public final class FromJsonUtil {
-
-    private static final Logger log = LoggerFactory
-            .getLogger(FromJsonUtil.class);
-
-    /**
-     * Constructs a FromJsonUtil object. Utility classes should not have a
-     * public or default constructor, otherwise IDE will compile unsuccessfully. This
-     * class should not be instantiated.
-     */
-    private FromJsonUtil() {
-    }
-
-    /**
-     * convert JsonNode into DatabaseSchema.
-     * @param dbName database name
-     * @param json the JsonNode of get_schema result
-     * @return DatabaseSchema
-     * @throws JsonParsingException this is a JsonNode parse exception
-     */
-    public static DatabaseSchema jsonNodeToDbSchema(String dbName, JsonNode json) {
-        if (!json.isObject() || !json.has("tables")) {
-            throw new JsonParsingException(
-                                           "bad DatabaseSchema root, expected \"tables\" as child but was not found");
-        }
-        if (!json.isObject() || !json.has("version")) {
-            throw new JsonParsingException(
-                                           "bad DatabaseSchema root, expected \"version\" as child but was not found");
-        }
-
-        String dbVersion = json.get("version").asText();
-
-        Map<String, TableSchema> tables = new HashMap<>();
-        for (Iterator<Map.Entry<String, JsonNode>> iter = json.get("tables")
-                .fields(); iter.hasNext();) {
-            Map.Entry<String, JsonNode> table = iter.next();
-            tables.put(table.getKey(),
-                       jsonNodeToTableSchema(table.getKey(), table.getValue()));
-        }
-
-        return new DatabaseSchema(dbName, dbVersion, tables);
-    }
-
-    /**
-     * convert JsonNode into TableSchema.
-     * @param tableName table name
-     * @param json table JsonNode
-     * @return TableSchema
-     * @throws AbnormalSchemaException this is an abnormal schema exception
-     */
-    private static TableSchema jsonNodeToTableSchema(String tableName,
-                                                     JsonNode json) {
-
-        if (!json.isObject() || !json.has("columns")) {
-            throw new AbnormalSchemaException(
-                                              "bad tableschema root, expected \"columns\" as child");
-        }
-
-        Map<String, ColumnSchema> columns = new HashMap<>();
-        for (Iterator<Map.Entry<String, JsonNode>> iter = json.get("columns")
-                .fields(); iter.hasNext();) {
-            Map.Entry<String, JsonNode> column = iter.next();
-            columns.put(column.getKey(),
-                        jsonNodeToColumnSchema(column.getKey(),
-                                               column.getValue()));
-        }
-
-        return new TableSchema(tableName, columns);
-    }
-
-    /**
-     * convert JsonNode into ColumnSchema.
-     * @param name column name
-     * @param json JsonNode
-     * @return ColumnSchema
-     * @throws AbnormalSchemaException this is an abnormal schema exception
-     */
-    private static ColumnSchema jsonNodeToColumnSchema(String name,
-                                                       JsonNode json) {
-        if (!json.isObject() || !json.has("type")) {
-            throw new AbnormalSchemaException(
-                                              "bad column schema root, expected \"type\" as child");
-        }
-
-        return new ColumnSchema(name,
-                                ColumnTypeFactory.getColumnTypeFromJson(json
-                                        .get("type")));
-    }
-
-    /**
-     * convert JsonNode into the returnType of methods in OvsdbRPC class.
-     * @param resultJsonNode the result JsonNode
-     * @param methodName the method name of methods in OvsdbRPC class
-     * @param objectMapper ObjectMapper entity
-     * @return Object
-     * @throws UnknownResultException this is an unknown result exception
-     */
-    private static Object convertResultType(JsonNode resultJsonNode,
-                                            String methodName,
-                                            ObjectMapper objectMapper) {
-        switch (methodName) {
-        case "getSchema":
-        case "monitor":
-            return resultJsonNode;
-        case "echo":
-        case "listDbs":
-            return objectMapper
-                    .convertValue(resultJsonNode, objectMapper.getTypeFactory()
-                            .constructParametricType(List.class, String.class));
-        case "transact":
-            return objectMapper
-                    .convertValue(resultJsonNode,
-                                  objectMapper
-                                          .getTypeFactory()
-                                          .constructParametricType(List.class,
-                                                                   JsonNode.class));
-        default:
-            throw new UnknownResultException("Don't know how to handle this");
-        }
-    }
-
-    /**
-     * convert JsonNode into the returnType of methods in OvsdbRPC class.
-     * @param jsonNode the result JsonNode
-     * @param methodName the method name of methods in OvsdbRPC class
-     * @return Object
-     */
-    public static Object jsonResultParser(JsonNode jsonNode, String methodName) {
-        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
-        JsonNode error = jsonNode.get("error");
-        if (error != null && !error.isNull()) {
-            log.error("Error : {}", error.toString());
-        }
-        JsonNode resultJsonNode = jsonNode.get("result");
-        Object result = convertResultType(resultJsonNode, methodName,
-                                          objectMapper);
-        return result;
-    }
-
-    /**
-     * When monitor the ovsdb tables, if a table update, ovs send update
-     * notification, then call callback function.
-     * @param jsonNode the result JsonNode
-     * @param callback the callback function
-     * @throws UnknownResultException this is an unknown result exception
-     */
-    public static void jsonCallbackRequestParser(JsonNode jsonNode,
-                                                 Callback callback) {
-        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
-        JsonNode params = jsonNode.get("params");
-        Object param = null;
-        String methodName = jsonNode.get("method").asText();
-        switch (methodName) {
-        case "update":
-            param = objectMapper.convertValue(params, UpdateNotification.class);
-            callback.update((UpdateNotification) param);
-            break;
-        default:
-            throw new UnknownResultException("Cannot handle this method: "
-                    + methodName);
-        }
-    }
-
-    /**
-     * Ovs send echo request to keep the heart, need we return echo result.
-     * @param jsonNode the result JsonNode
-     * @return JsonRpcResponse String
-     */
-    public static String getEchoRequestStr(JsonNode jsonNode) {
-        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
-        String str = null;
-        if (jsonNode.get("method").asText().equals("echo")) {
-            JsonRpcResponse response = new JsonRpcResponse(jsonNode.get("id")
-                    .asText());
-            try {
-                str = objectMapper.writeValueAsString(response);
-            } catch (JsonProcessingException e) {
-                log.error("JsonProcessingException while converting JsonNode into string ", e);
-            }
-        }
-        return str;
-    }
-
-    /**
-     * Convert the List of Operation result into List of OperationResult .
-     * @param input the List of JsonNode
-     * @param operations the List of Operation
-     * @return the List of OperationResult
-     */
-    public static List<OperationResult> jsonNodeToOperationResult(List<JsonNode> input,
-                                                                  List<Operation> operations) {
-        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper(false);
-        List<OperationResult> operationResults = new ArrayList<OperationResult>();
-        for (int i = 0; i < input.size(); i++) {
-            JsonNode jsonNode = input.get(i);
-            Operation operation = operations.get(i);
-            if (jsonNode != null && jsonNode.size() > 0) {
-                if (i >= operations.size() || operation.getOp() != "select") {
-                    OperationResult or = objectMapper.convertValue(jsonNode,
-                                                   OperationResult.class);
-                    operationResults.add(or);
-                } else {
-                    List<Row> rows = createRows(operation.getTableSchema(), jsonNode);
-                    OperationResult or = new OperationResult(rows);
-                    operationResults.add(or);
-                }
-            }
-        }
-        return operationResults;
-    }
-
-    /**
-     * Convert Operation JsonNode into Rows.
-     * @param tableSchema TableSchema entity
-     * @param rowsNode JsonNode
-     * @return ArrayList<Row> the List of Row
-     */
-    private static ArrayList<Row> createRows(TableSchema tableSchema,
-                                             JsonNode rowsNode) {
-        ArrayList<Row> rows = Lists.newArrayList();
-        for (JsonNode rowNode : rowsNode.get("rows")) {
-            rows.add(createRow(tableSchema, rowNode));
-        }
-        return rows;
-    }
-
-    /**
-     * convert the params of Update Notification into TableUpdates.
-     * @param updatesJson the params of Update Notification
-     * @param dbSchema DatabaseSchema entity
-     * @return TableUpdates
-     */
-    public static TableUpdates jsonNodeToTableUpdates(JsonNode updatesJson,
-                                                      DatabaseSchema dbSchema) {
-        Map<String, TableUpdate> tableUpdateMap = Maps.newHashMap();
-        for (Iterator<Map.Entry<String, JsonNode>> itr = updatesJson.fields(); itr
-                .hasNext();) {
-            Map.Entry<String, JsonNode> entry = itr.next();
-            TableSchema tableSchema = dbSchema.getTableSchema(entry.getKey());
-            TableUpdate tableUpdate = jsonNodeToTableUpdate(tableSchema,
-                                                            entry.getValue());
-            tableUpdateMap.put(entry.getKey(), tableUpdate);
-        }
-        return TableUpdates.tableUpdates(tableUpdateMap);
-    }
-
-    /**
-     * convert the params of Update Notification into TableUpdate.
-     * @param tableSchema TableSchema entity
-     * @param value the table-update in params of Update Notification
-     * @return TableUpdate
-     */
-    public static TableUpdate jsonNodeToTableUpdate(TableSchema tableSchema,
-                                                    JsonNode value) {
-        Map<UUID, RowUpdate> rows = Maps.newHashMap();
-        Iterator<Entry<String, JsonNode>> fields = value.fields();
-        while (fields.hasNext()) {
-            Map.Entry<String, JsonNode> idOldNew = fields.next();
-            String uuidStr = idOldNew.getKey();
-            UUID uuid = UUID.uuid(uuidStr);
-            JsonNode newR = idOldNew.getValue().get("new");
-            JsonNode oldR = idOldNew.getValue().get("old");
-            Row newRow = newR != null ? createRow(tableSchema, newR) : null;
-            Row oldRow = oldR != null ? createRow(tableSchema, oldR) : null;
-            RowUpdate rowUpdate = new RowUpdate(uuid, oldRow, newRow);
-            rows.put(uuid, rowUpdate);
-        }
-        return TableUpdate.tableUpdate(rows);
-    }
-
-    /**
-     * Convert Operation JsonNode into Row.
-     * @param tableSchema TableSchema entity
-     * @param rowNode JsonNode
-     * @return Row
-     */
-    private static Row createRow(TableSchema tableSchema, JsonNode rowNode) {
-        List<Column> columns = Lists.newArrayList();
-        for (Iterator<Map.Entry<String, JsonNode>> iter = rowNode.fields(); iter
-                .hasNext();) {
-            Map.Entry<String, JsonNode> next = iter.next();
-            ColumnSchema schema = tableSchema.getColumnSchema(next.getKey());
-            if (schema != null) {
-                Object o = TransValueUtil.getValueFromJson(next.getValue(), schema.type());
-                columns.add(new Column(schema, o));
-            }
-        }
-        return new Row(tableSchema, columns);
-    }
-
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.utils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.onosproject.ovsdb.rfc.error.AbnormalJsonNodeException;
+import org.onosproject.ovsdb.rfc.error.UnsupportedException;
+import org.onosproject.ovsdb.rfc.jsonrpc.Callback;
+import org.onosproject.ovsdb.rfc.jsonrpc.JsonRpcResponse;
+import org.onosproject.ovsdb.rfc.message.OperationResult;
+import org.onosproject.ovsdb.rfc.message.RowUpdate;
+import org.onosproject.ovsdb.rfc.message.TableUpdate;
+import org.onosproject.ovsdb.rfc.message.TableUpdates;
+import org.onosproject.ovsdb.rfc.message.UpdateNotification;
+import org.onosproject.ovsdb.rfc.notation.Column;
+import org.onosproject.ovsdb.rfc.notation.Row;
+import org.onosproject.ovsdb.rfc.notation.UUID;
+import org.onosproject.ovsdb.rfc.operations.Operation;
+import org.onosproject.ovsdb.rfc.schema.ColumnSchema;
+import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+import org.onosproject.ovsdb.rfc.schema.type.ColumnTypeFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+/**
+ * JsonNode utility class. convert JsonNode into Object.
+ */
+public final class FromJsonUtil {
+
+    private static final Logger log = LoggerFactory.getLogger(FromJsonUtil.class);
+
+    /**
+     * Constructs a FromJsonUtil object. Utility classes should not have a
+     * public or default constructor, otherwise IDE will compile unsuccessfully.
+     * This class should not be instantiated.
+     */
+    private FromJsonUtil() {
+    }
+
+    /**
+     * Verify whether the jsonNode is normal.
+     * @param jsonNode JsonNode
+     * @param nodeStr the node name of JsonNode
+     */
+    private static void validateJsonNode(JsonNode jsonNode, String nodeStr) {
+        if (!jsonNode.isObject() || !jsonNode.has(nodeStr)) {
+            String message = "Abnormal DatabaseSchema JsonNode, it should contain " + nodeStr
+                    + " node but was not found";
+            throw new AbnormalJsonNodeException(message);
+        }
+    }
+
+    /**
+     * convert JsonNode into DatabaseSchema.
+     * @param dbName database name
+     * @param dbJson the JsonNode of get_schema result
+     * @return DatabaseSchema
+     * @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
+     */
+    public static DatabaseSchema jsonNodeToDbSchema(String dbName, JsonNode dbJson) {
+        validateJsonNode(dbJson, "tables");
+        validateJsonNode(dbJson, "version");
+        String dbVersion = dbJson.get("version").asText();
+        Map<String, TableSchema> tables = new HashMap<>();
+        Iterator<Map.Entry<String, JsonNode>> tablesIter = dbJson.get("tables").fields();
+        while (tablesIter.hasNext()) {
+            Map.Entry<String, JsonNode> table = tablesIter.next();
+            tables.put(table.getKey(), jsonNodeToTableSchema(table.getKey(), table.getValue()));
+        }
+        return new DatabaseSchema(dbName, dbVersion, tables);
+    }
+
+    /**
+     * convert JsonNode into TableSchema.
+     * @param tableName table name
+     * @param tableJson table JsonNode
+     * @return TableSchema
+     * @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
+     */
+    private static TableSchema jsonNodeToTableSchema(String tableName, JsonNode tableJson) {
+        validateJsonNode(tableJson, "columns");
+        Map<String, ColumnSchema> columns = new HashMap<>();
+        Iterator<Map.Entry<String, JsonNode>> columnsIter = tableJson.get("columns").fields();
+        while (columnsIter.hasNext()) {
+            Map.Entry<String, JsonNode> column = columnsIter.next();
+            columns.put(column.getKey(), jsonNodeToColumnSchema(column.getKey(), column.getValue()));
+        }
+        return new TableSchema(tableName, columns);
+    }
+
+    /**
+     * convert JsonNode into ColumnSchema.
+     * @param name column name
+     * @param columnJson column JsonNode
+     * @return ColumnSchema
+     * @throws AbnormalJsonNodeException this is an abnormal JsonNode exception
+     */
+    private static ColumnSchema jsonNodeToColumnSchema(String name, JsonNode columnJson) {
+        validateJsonNode(columnJson, "type");
+        return new ColumnSchema(name, ColumnTypeFactory.getColumnTypeFromJson(columnJson
+                .get("type")));
+    }
+
+    /**
+     * convert JsonNode into the returnType of methods in OvsdbRPC class.
+     * @param resultJsonNode the result JsonNode
+     * @param methodName the method name of methods in OvsdbRPC class
+     * @param objectMapper ObjectMapper entity
+     * @return Object
+     * @throws UnsupportedException this is an unsupported exception
+     */
+    private static Object convertResultType(JsonNode resultJsonNode, String methodName,
+                                            ObjectMapper objectMapper) {
+        switch (methodName) {
+        case "getSchema":
+        case "monitor":
+            return resultJsonNode;
+        case "echo":
+        case "listDbs":
+            return objectMapper.convertValue(resultJsonNode, objectMapper.getTypeFactory()
+                    .constructParametricType(List.class, String.class));
+        case "transact":
+            return objectMapper.convertValue(resultJsonNode, objectMapper.getTypeFactory()
+                    .constructParametricType(List.class, JsonNode.class));
+        default:
+            throw new UnsupportedException("does not support this rpc method" + methodName);
+        }
+    }
+
+    /**
+     * convert JsonNode into the returnType of methods in OvsdbRPC class.
+     * @param jsonNode the result JsonNode
+     * @param methodName the method name of methods in OvsdbRPC class
+     * @return Object
+     */
+    public static Object jsonResultParser(JsonNode jsonNode, String methodName) {
+        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
+        JsonNode error = jsonNode.get("error");
+        if (error != null && !error.isNull()) {
+            log.error("jsonRpcResponse error : {}", error.toString());
+        }
+        JsonNode resultJsonNode = jsonNode.get("result");
+        Object result = convertResultType(resultJsonNode, methodName, objectMapper);
+        return result;
+    }
+
+    /**
+     * When monitor the ovsdb tables, if a table update, ovs send update
+     * notification, then call callback function.
+     * @param jsonNode the result JsonNode
+     * @param callback the callback function
+     * @throws UnsupportedException this is an unsupported exception
+     */
+    public static void jsonCallbackRequestParser(JsonNode jsonNode, Callback callback) {
+        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
+        JsonNode params = jsonNode.get("params");
+        Object param = null;
+        String methodName = jsonNode.get("method").asText();
+        switch (methodName) {
+        case "update":
+            param = objectMapper.convertValue(params, UpdateNotification.class);
+            callback.update((UpdateNotification) param);
+            break;
+        default:
+            throw new UnsupportedException("does not support this callback method: " + methodName);
+        }
+    }
+
+    /**
+     * Ovs send echo request to keep the heart, need we return echo result.
+     * @param jsonNode the result JsonNode
+     * @return JsonRpcResponse String
+     */
+    public static String getEchoRequestStr(JsonNode jsonNode) {
+        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper();
+        String str = null;
+        if (jsonNode.get("method").asText().equals("echo")) {
+            JsonRpcResponse response = new JsonRpcResponse(jsonNode.get("id").asText());
+            try {
+                str = objectMapper.writeValueAsString(response);
+            } catch (JsonProcessingException e) {
+                log.error("JsonProcessingException while converting JsonNode into string: ", e);
+            }
+        }
+        return str;
+    }
+
+    /**
+     * Convert the List of Operation result into List of OperationResult .
+     * @param input the List of JsonNode
+     * @param operations the List of Operation
+     * @return the List of OperationResult
+     */
+    public static List<OperationResult> jsonNodeToOperationResult(List<JsonNode> input,
+                                                                  List<Operation> operations) {
+        ObjectMapper objectMapper = ObjectMapperUtil.getObjectMapper(false);
+        List<OperationResult> operationResults = new ArrayList<OperationResult>();
+        for (int i = 0; i < input.size(); i++) {
+            JsonNode jsonNode = input.get(i);
+            Operation operation = operations.get(i);
+            if (jsonNode != null && jsonNode.size() > 0) {
+                if (i >= operations.size() || operation.getOp() != "select") {
+                    OperationResult or = objectMapper.convertValue(jsonNode, OperationResult.class);
+                    operationResults.add(or);
+                } else {
+                    List<Row> rows = createRows(operation.getTableSchema(), jsonNode);
+                    OperationResult or = new OperationResult(rows);
+                    operationResults.add(or);
+                }
+            }
+        }
+        return operationResults;
+    }
+
+    /**
+     * Convert Operation JsonNode into Rows.
+     * @param tableSchema TableSchema entity
+     * @param rowsNode JsonNode
+     * @return ArrayList<Row> the List of Row
+     */
+    private static ArrayList<Row> createRows(TableSchema tableSchema, JsonNode rowsNode) {
+        validateJsonNode(rowsNode, "rows");
+        ArrayList<Row> rows = Lists.newArrayList();
+        for (JsonNode rowNode : rowsNode.get("rows")) {
+            rows.add(createRow(tableSchema, rowNode));
+        }
+        return rows;
+    }
+
+    /**
+     * convert the params of Update Notification into TableUpdates.
+     * @param updatesJson the params of Update Notification
+     * @param dbSchema DatabaseSchema entity
+     * @return TableUpdates
+     */
+    public static TableUpdates jsonNodeToTableUpdates(JsonNode updatesJson, DatabaseSchema dbSchema) {
+        Map<String, TableUpdate> tableUpdateMap = Maps.newHashMap();
+        Iterator<Map.Entry<String, JsonNode>> tableUpdatesItr = updatesJson.fields();
+        while (tableUpdatesItr.hasNext()) {
+            Map.Entry<String, JsonNode> entry = tableUpdatesItr.next();
+            TableSchema tableSchema = dbSchema.getTableSchema(entry.getKey());
+            TableUpdate tableUpdate = jsonNodeToTableUpdate(tableSchema, entry.getValue());
+            tableUpdateMap.put(entry.getKey(), tableUpdate);
+        }
+        return TableUpdates.tableUpdates(tableUpdateMap);
+    }
+
+    /**
+     * convert the params of Update Notification into TableUpdate.
+     * @param tableSchema TableSchema entity
+     * @param updateJson the table-update in params of Update Notification
+     * @return TableUpdate
+     */
+    public static TableUpdate jsonNodeToTableUpdate(TableSchema tableSchema, JsonNode updateJson) {
+        Map<UUID, RowUpdate> rows = Maps.newHashMap();
+        Iterator<Map.Entry<String, JsonNode>> tableUpdateItr = updateJson.fields();
+        while (tableUpdateItr.hasNext()) {
+            Map.Entry<String, JsonNode> oldNewRow = tableUpdateItr.next();
+            String uuidStr = oldNewRow.getKey();
+            UUID uuid = UUID.uuid(uuidStr);
+            JsonNode newR = oldNewRow.getValue().get("new");
+            JsonNode oldR = oldNewRow.getValue().get("old");
+            Row newRow = newR != null ? createRow(tableSchema, newR) : null;
+            Row oldRow = oldR != null ? createRow(tableSchema, oldR) : null;
+            RowUpdate rowUpdate = new RowUpdate(uuid, oldRow, newRow);
+            rows.put(uuid, rowUpdate);
+        }
+        return TableUpdate.tableUpdate(rows);
+    }
+
+    /**
+     * Convert Operation JsonNode into Row.
+     * @param tableSchema TableSchema entity
+     * @param rowNode JsonNode
+     * @return Row
+     */
+    private static Row createRow(TableSchema tableSchema, JsonNode rowNode) {
+        if (tableSchema == null) {
+            return null;
+        }
+        Map<String, Column> columns = Maps.newHashMap();
+        Iterator<Map.Entry<String, JsonNode>> rowIter = rowNode.fields();
+        while (rowIter.hasNext()) {
+            Map.Entry<String, JsonNode> next = rowIter.next();
+            ColumnSchema columnSchema = tableSchema.getColumnSchema(next.getKey());
+            if (columnSchema != null) {
+                String columnName = columnSchema.name();
+                Object obj = TransValueUtil.getValueFromJson(next.getValue(), columnSchema.type());
+                columns.put(columnName, new Column(columnName, obj));
+            }
+        }
+        return new Row(tableSchema.name(), columns);
+    }
+
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.utils;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufInputStream;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Stack;
-
-import org.onosproject.ovsdb.rfc.error.UnsupportedEncodingException;
-import org.onosproject.ovsdb.rfc.jsonrpc.JsonReadContext;
-
-import com.fasterxml.jackson.core.JsonEncoding;
-import com.fasterxml.jackson.core.JsonParseException;
-import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.io.IOContext;
-import com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper;
-import com.fasterxml.jackson.core.util.BufferRecycler;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.MappingJsonFactory;
-
-/**
- * Decoder utility class.
- */
-public final class JsonRpcReaderUtil {
-
-    /**
-     * Constructs a JsonRpcReaderUtil object. Utility classes should not have a
-     * public or default constructor, otherwise IDE will compile unsuccessfully.
-     * This class should not be instantiated.
-     */
-    private JsonRpcReaderUtil() {
-    }
-
-    /**
-     * Decode the bytes to Json object.
-     * @param in input of bytes
-     * @param out ouput of Json object list
-     * @param jrContext context for the last decoding process
-     * @throws IOException IOException
-     * @throws JsonParseException JsonParseException
-     */
-    public static void readToJsonNode(ByteBuf in, List<Object> out,
-                                      JsonReadContext jrContext)
-            throws JsonParseException, IOException {
-        int lastReadBytes = jrContext.getLastReadBytes();
-        if (lastReadBytes == 0) {
-            if (in.readableBytes() < 4) {
-                return;
-            }
-            checkEncoding(in);
-        }
-
-        int i = lastReadBytes + in.readerIndex();
-        Stack<Byte> bufStack = jrContext.getBufStack();
-        for (; i < in.writerIndex(); i++) {
-            byte b = in.getByte(i);
-            switch (b) {
-            case '{':
-                if (!isDoubleQuote(bufStack)) {
-                    bufStack.push(b);
-                    jrContext.setStartMatch(true);
-                }
-                break;
-            case '}':
-                if (!isDoubleQuote(bufStack)) {
-                    bufStack.pop();
-                }
-                break;
-            case '"':
-                if (in.getByte(i - 1) != '\\') {
-                    if (!bufStack.isEmpty() && bufStack.peek() != '"') {
-                        bufStack.push(b);
-                    } else {
-                        bufStack.pop();
-                    }
-                }
-                break;
-            default:
-                break;
-            }
-
-            if (jrContext.isStartMatch() && bufStack.isEmpty()) {
-                ByteBuf buf = in.readSlice(i - in.readerIndex() + 1);
-                JsonParser jf = new MappingJsonFactory()
-                        .createParser(new ByteBufInputStream(buf));
-                JsonNode jsonNode = jf.readValueAsTree();
-                out.add(jsonNode);
-                lastReadBytes = 0;
-                jrContext.setLastReadBytes(lastReadBytes);
-                break;
-            }
-        }
-
-        if (i >= in.writerIndex()) {
-            lastReadBytes = in.readableBytes();
-            jrContext.setLastReadBytes(lastReadBytes);
-        }
-    }
-
-    /**
-     * Filter the invalid characters before decoding.
-     * @param in input of bytes
-     * @param lastReadBytes the bytes for last decoding incomplete record
-     */
-    private static void fliterCharaters(ByteBuf in) {
-        while (in.isReadable()) {
-            int ch = in.getByte(in.readerIndex());
-            if ((ch != ' ') && (ch != '\n') && (ch != '\t') && (ch != '\r')) {
-                break;
-            } else {
-                in.readByte();
-            }
-        }
-    }
-
-    /**
-     * Check whether the peek of the stack element is double quote.
-     * @param jrContext context for the last decoding process
-     * @return boolean
-     */
-    private static boolean isDoubleQuote(Stack<Byte> bufStack) {
-        if (!bufStack.isEmpty() && bufStack.peek() == '"') {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Check whether the encoding is valid.
-     * @param in input of bytes
-     * @throws IOException this is an IO exception
-     * @throws UnsupportedEncodingException this is an unsupported encode
-     *             exception
-     */
-    private static void checkEncoding(ByteBuf in) throws IOException {
-        int inputStart = 0;
-        int inputLength = 4;
-        fliterCharaters(in);
-        byte[] buff = new byte[4];
-        in.getBytes(in.readerIndex(), buff);
-        ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(
-                                                                             new IOContext(
-                                                                                           new BufferRecycler(),
-                                                                                           null,
-                                                                                           false),
-                                                                             buff,
-                                                                             inputStart,
-                                                                             inputLength);
-        JsonEncoding jsonEncoding = strapper.detectEncoding();
-        if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
-            throw new UnsupportedEncodingException(
-                                                   "Only UTF-8 encoding is supported.");
-        }
-    }
-
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.utils;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Stack;
+
+import org.onosproject.ovsdb.rfc.error.UnsupportedException;
+import org.onosproject.ovsdb.rfc.jsonrpc.JsonReadContext;
+
+import com.fasterxml.jackson.core.JsonEncoding;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.io.IOContext;
+import com.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper;
+import com.fasterxml.jackson.core.util.BufferRecycler;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.MappingJsonFactory;
+
+/**
+ * Decoder utility class.
+ */
+public final class JsonRpcReaderUtil {
+
+    /**
+     * Constructs a JsonRpcReaderUtil object. Utility classes should not have a
+     * public or default constructor, otherwise IDE will compile unsuccessfully.
+     * This class should not be instantiated.
+     */
+    private JsonRpcReaderUtil() {
+    }
+
+    /**
+     * Decode the bytes to Json object.
+     * @param in input of bytes
+     * @param out ouput of Json object list
+     * @param jrContext context for the last decoding process
+     * @throws IOException IOException
+     * @throws JsonParseException JsonParseException
+     */
+    public static void readToJsonNode(ByteBuf in, List<Object> out, JsonReadContext jrContext)
+            throws JsonParseException, IOException {
+        int lastReadBytes = jrContext.getLastReadBytes();
+        if (lastReadBytes == 0) {
+            if (in.readableBytes() < 4) {
+                return;
+            }
+            checkEncoding(in);
+        }
+
+        int i = lastReadBytes + in.readerIndex();
+        Stack<Byte> bufStack = jrContext.getBufStack();
+        for (; i < in.writerIndex(); i++) {
+            byte b = in.getByte(i);
+            switch (b) {
+            case '{':
+                if (!isDoubleQuote(bufStack)) {
+                    bufStack.push(b);
+                    jrContext.setStartMatch(true);
+                }
+                break;
+            case '}':
+                if (!isDoubleQuote(bufStack)) {
+                    bufStack.pop();
+                }
+                break;
+            case '"':
+                if (in.getByte(i - 1) != '\\') {
+                    if (!bufStack.isEmpty() && bufStack.peek() != '"') {
+                        bufStack.push(b);
+                    } else {
+                        bufStack.pop();
+                    }
+                }
+                break;
+            default:
+                break;
+            }
+
+            if (jrContext.isStartMatch() && bufStack.isEmpty()) {
+                ByteBuf buf = in.readSlice(i - in.readerIndex() + 1);
+                JsonParser jf = new MappingJsonFactory().createParser(new ByteBufInputStream(buf));
+                JsonNode jsonNode = jf.readValueAsTree();
+                out.add(jsonNode);
+                lastReadBytes = 0;
+                jrContext.setLastReadBytes(lastReadBytes);
+                break;
+            }
+        }
+
+        if (i >= in.writerIndex()) {
+            lastReadBytes = in.readableBytes();
+            jrContext.setLastReadBytes(lastReadBytes);
+        }
+    }
+
+    /**
+     * Filter the invalid characters before decoding.
+     * @param in input of bytes
+     * @param lastReadBytes the bytes for last decoding incomplete record
+     */
+    private static void fliterCharaters(ByteBuf in) {
+        while (in.isReadable()) {
+            int ch = in.getByte(in.readerIndex());
+            if ((ch != ' ') && (ch != '\n') && (ch != '\t') && (ch != '\r')) {
+                break;
+            } else {
+                in.readByte();
+            }
+        }
+    }
+
+    /**
+     * Check whether the peek of the stack element is double quote.
+     * @param jrContext context for the last decoding process
+     * @return boolean
+     */
+    private static boolean isDoubleQuote(Stack<Byte> bufStack) {
+        if (!bufStack.isEmpty() && bufStack.peek() == '"') {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check whether the encoding is valid.
+     * @param in input of bytes
+     * @throws IOException this is an IO exception
+     * @throws UnsupportedException this is an unsupported exception
+     */
+    private static void checkEncoding(ByteBuf in) throws IOException {
+        int inputStart = 0;
+        int inputLength = 4;
+        fliterCharaters(in);
+        byte[] buff = new byte[4];
+        in.getBytes(in.readerIndex(), buff);
+        ByteSourceJsonBootstrapper strapper = new ByteSourceJsonBootstrapper(new IOContext(new BufferRecycler(),
+                                                                                           null,
+                                                                                           false),
+                                                                             buff, inputStart,
+                                                                             inputLength);
+        JsonEncoding jsonEncoding = strapper.detectEncoding();
+        if (!JsonEncoding.UTF8.equals(jsonEncoding)) {
+            throw new UnsupportedException("Only UTF-8 encoding is supported.");
+        }
+    }
+
+}

-/*
- * Copyright 2015 Open Networking Laboratory
- *
- * Licensed 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.onosproject.ovsdb.rfc.utils;
-
-import java.util.List;
-import java.util.Set;
-
-import org.onosproject.ovsdb.rfc.message.MonitorRequest;
-import org.onosproject.ovsdb.rfc.message.MonitorSelect;
-import org.onosproject.ovsdb.rfc.operations.Operation;
-import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
-import org.onosproject.ovsdb.rfc.schema.TableSchema;
-
-import com.google.common.base.Function;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-
-/**
- * Params utility class. Params of the request object, refer to RFC7047's Section
- * 4.1.
- */
-public final class ParamUtil {
-
-    /**
-     * Constructs a ParamUtil object. Utility classes should not have a
-     * public or default constructor, otherwise IDE will compile unsuccessfully. This
-     * class should not be instantiated.
-     */
-    private ParamUtil() {
-    }
-
-    /**
-     * Returns MonitorRequest, refer to RFC7047's Section 4.1.5.
-     * @param tableSchema entity
-     * @return MonitorRequest
-     */
-    private static MonitorRequest getAllColumnsMonitorRequest(TableSchema tableSchema) {
-        String tableName = tableSchema.name();
-        Set<String> columns = tableSchema.getColumnNames();
-        MonitorSelect select = new MonitorSelect(true, true, true, true);
-        MonitorRequest monitorRequest = new MonitorRequest(tableName, columns,
-                                                           select);
-        return monitorRequest;
-    }
-
-    /**
-     * Returns params of monitor method, refer to RFC7047's Section 4.1.5.
-     * @param monotorId json-value, refer to RFC7047's Section 4.1.5.
-     * @param dbSchema DatabaseSchema entity
-     * @return List of Object, the params of monitor request
-     */
-    public static List<Object> getMonitorParams(String monotorId,
-                                                DatabaseSchema dbSchema) {
-        Set<String> tables = dbSchema.getTableNames();
-        List<MonitorRequest> monitorRequests = Lists.newArrayList();
-        for (String tableName : tables) {
-            TableSchema tableSchema = dbSchema.getTableSchema(tableName);
-            monitorRequests.add(getAllColumnsMonitorRequest(tableSchema));
-        }
-        ImmutableMap<String, MonitorRequest> reqMap = Maps
-                .uniqueIndex(monitorRequests,
-                             new Function<MonitorRequest, String>() {
-                                 @Override
-                                 public String apply(MonitorRequest input) {
-                                     return input.getTableName();
-                                 }
-                             });
-        return Lists.<Object>newArrayList(dbSchema.name(), monotorId,
-                                           reqMap);
-    }
-
-    /**
-     * Returns params of transact method, refer to RFC7047's Section 4.1.3.
-     * @param dbSchema DatabaseSchema entity
-     * @param operations operation*, refer to RFC7047's Section 4.1.3.
-     * @return List of Object, the params of transact request
-     */
-    public static List<Object> getTransactParams(DatabaseSchema dbSchema,
-                                                 List<Operation> operations) {
-        List<Object> lists = Lists.newArrayList((Object) dbSchema.name());
-        lists.addAll(operations);
-        return lists;
-    }
-}
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed 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.onosproject.ovsdb.rfc.utils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.onosproject.ovsdb.rfc.message.MonitorRequest;
+import org.onosproject.ovsdb.rfc.message.MonitorSelect;
+import org.onosproject.ovsdb.rfc.operations.Operation;
+import org.onosproject.ovsdb.rfc.schema.DatabaseSchema;
+import org.onosproject.ovsdb.rfc.schema.TableSchema;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+
+/**
+ * Params utility class. Params of the request object, refer to RFC7047's
+ * Section 4.1.
+ */
+public final class ParamUtil {
+
+    /**
+     * Constructs a ParamUtil object. Utility classes should not have a public
+     * or default constructor, otherwise IDE will compile unsuccessfully. This
+     * class should not be instantiated.
+     */
+    private ParamUtil() {
+    }
+
+    /**
+     * Returns MonitorRequest, refer to RFC7047's Section 4.1.5.
+     * @param tableSchema entity
+     * @return MonitorRequest
+     */
+    private static MonitorRequest getAllColumnsMonitorRequest(TableSchema tableSchema) {
+        String tableName = tableSchema.name();
+        Set<String> columns = tableSchema.getColumnNames();
+        MonitorSelect select = new MonitorSelect(true, true, true, true);
+        MonitorRequest monitorRequest = new MonitorRequest(tableName, columns, select);
+        return monitorRequest;
+    }
+
+    /**
+     * Returns params of monitor method, refer to RFC7047's Section 4.1.5.
+     * @param monotorId json-value, refer to RFC7047's Section 4.1.5.
+     * @param dbSchema DatabaseSchema entity
+     * @return List of Object, the params of monitor request
+     */
+    public static List<Object> getMonitorParams(String monotorId, DatabaseSchema dbSchema) {
+        Set<String> tables = dbSchema.getTableNames();
+        Map<String, MonitorRequest> mrMap = Maps.newHashMap();
+        for (String tableName : tables) {
+            TableSchema tableSchema = dbSchema.getTableSchema(tableName);
+            MonitorRequest monitorRequest = getAllColumnsMonitorRequest(tableSchema);
+            mrMap.put(tableName, monitorRequest);
+        }
+        return Lists.newArrayList(dbSchema.name(), monotorId, mrMap);
+    }
+
+    /**
+     * Returns params of transact method, refer to RFC7047's Section 4.1.3.
+     * @param dbSchema DatabaseSchema entity
+     * @param operations operation*, refer to RFC7047's Section 4.1.3.
+     * @return List of Object, the params of transact request
+     */
+    public static List<Object> getTransactParams(DatabaseSchema dbSchema, List<Operation> operations) {
+        return Lists.newArrayList(dbSchema.name(), operations);
+    }
+}

@@ -87,33 +87,29 @@ public final class TransValueUtil {
      * @param atoType AtomicColumnType entity
      * @param atoType AtomicColumnType entity
      * @return Object OvsdbSet or the value of JsonNode
      * @return Object OvsdbSet or the value of JsonNode
      */
      */
-    private static Object getValueFromAtoType(JsonNode json,
-                                              AtomicColumnType atoType) {
+    private static Object getValueFromAtoType(JsonNode json, AtomicColumnType atoType) {
         BaseType baseType = atoType.baseType();
         BaseType baseType = atoType.baseType();
         // If "min" or "max" is not specified, If "min" is not 1 or "max" is not
         // If "min" or "max" is not specified, If "min" is not 1 or "max" is not
-        // 1,
-        // or both, and "value" is not specified, the type is a set of scalar
-        // type "key".
-        // Refer to RFC 7047, Section 3.2 <type>.
+        // 1, or both, and "value" is not specified, the type is a set of scalar
+        // type "key". Refer to RFC 7047, Section 3.2 <type>.
         if (atoType.min() != atoType.max()) {
         if (atoType.min() != atoType.max()) {
             Set set = Sets.newHashSet();
             Set set = Sets.newHashSet();
             if (json.isArray()) {
             if (json.isArray()) {
                 if (json.size() == 2) {
                 if (json.size() == 2) {
-                    if (json.get(0).isTextual()
-                            && "set".equals(json.get(0).asText())) {
+                    if (json.get(0).isTextual() && "set".equals(json.get(0).asText())) {
                         for (JsonNode node : json.get(1)) {
                         for (JsonNode node : json.get(1)) {
-                            set.add(TransValueUtil.transToValue(node, baseType));
+                            set.add(transToValue(node, baseType));
                         }
                         }
                     } else {
                     } else {
-                        set.add(TransValueUtil.transToValue(json, baseType));
+                        set.add(transToValue(json, baseType));
                     }
                     }
                 }
                 }
             } else {
             } else {
-                set.add(TransValueUtil.transToValue(json, baseType));
+                set.add(transToValue(json, baseType));
             }
             }
             return OvsdbSet.ovsdbSet(set);
             return OvsdbSet.ovsdbSet(set);
         } else {
         } else {
-            return TransValueUtil.transToValue(json, baseType);
+            return transToValue(json, baseType);
         }
         }
     }
     }
 
 
@@ -123,19 +119,15 @@ public final class TransValueUtil {
      * @param kvType KeyValuedColumnType entity
      * @param kvType KeyValuedColumnType entity
      * @return Object OvsdbMap
      * @return Object OvsdbMap
      */
      */
-    private static Object getValueFromKvType(JsonNode json,
-                                             KeyValuedColumnType kvType) {
+    private static Object getValueFromKvType(JsonNode json, KeyValuedColumnType kvType) {
         if (json.isArray()) {
         if (json.isArray()) {
             if (json.size() == 2) {
             if (json.size() == 2) {
-                if (json.get(0).isTextual()
-                        && "map".equals(json.get(0).asText())) {
+                if (json.get(0).isTextual() && "map".equals(json.get(0).asText())) {
                     Map map = Maps.newHashMap();
                     Map map = Maps.newHashMap();
                     for (JsonNode pairNode : json.get(1)) {
                     for (JsonNode pairNode : json.get(1)) {
                         if (pairNode.isArray() && json.size() == 2) {
                         if (pairNode.isArray() && json.size() == 2) {
-                            Object key = TransValueUtil.transToValue(pairNode
-                                    .get(0), kvType.keyType());
-                            Object value = TransValueUtil.transToValue(pairNode
-                                    .get(1), kvType.valueType());
+                            Object key = transToValue(pairNode.get(0), kvType.keyType());
+                            Object value = transToValue(pairNode.get(1), kvType.valueType());
                             map.put(key, value);
                             map.put(key, value);
                         }
                         }
                     }
                     }
@@ -166,14 +158,13 @@ public final class TransValueUtil {
             if (valueNode.isArray()) {
             if (valueNode.isArray()) {
                 if (valueNode.size() == 2) {
                 if (valueNode.size() == 2) {
                     if (valueNode.get(0).isTextual()
                     if (valueNode.get(0).isTextual()
-                            && "uuid".equals(valueNode.get(0).asText())
-                            || "named-uuid".equals(valueNode.get(0).asText())) {
+                            && ("uuid".equals(valueNode.get(0).asText()) || "named-uuid"
+                                    .equals(valueNode.get(0).asText()))) {
                         return UUID.uuid(valueNode.get(1).asText());
                         return UUID.uuid(valueNode.get(1).asText());
                     }
                     }
                 }
                 }
             } else {
             } else {
-                return new RefTableRow(((UuidBaseType) baseType).getRefTable(),
-                                       valueNode);
+                return new RefTableRow(((UuidBaseType) baseType).getRefTable(), valueNode);
             }
             }
         }
         }
         return null;
         return null;