+
+custom_error! { pub IncorrectPointer{pointer: String} = "Incorrect pointer is specified: {pointer}" }
+
+/// This is a enum that used internally to refer to values inside of

+    Invalid,
+}
+
+/// Implements database's file by wrapping JSON value (`serde_json::Value`)

+}
+
+impl File {
+    /// Creates an empty file that will contain an empty JSON object.

+        }
+    }
+
+    /// Loads JSON value from the specified file.

+        })
+    }
+
+    /// Returns file's "root", - JSON value contained inside it.

+        &self.contents
+    }
+
+    /// Attempts to return JSON value, corresponding to the given JSON pointer.

+    /// 1. If it already exists, - it will be overwritten.
+    /// 2. If it does not exist, but it's parent object/array does -
+    ///     it will be added.
+    /// 3.  Otherwise an error will be raise.

+    ///     it will be added.
+    /// 3.  Otherwise an error will be raise.
+    ///
+    /// If array needs to be expanded, - missing values will be filled

+    /// 3.  Otherwise an error will be raise.
+    ///
+    /// If array needs to be expanded, - missing values will be filled
+    /// with `json!(null)`, i.e. inserting `7` at index `5` in array `[1, 2, 3]`

+        Ok(())
+    }
+
+    /// Removes (and returns) value specified by theJSON pointer.

+    }
+
+    /// Removes (and returns) value specified by theJSON pointer.
+    /// If it did not exist - returns `None`.

+        }
+    }
+
+    /// Helper method to create a value if missing (as `json!(null)`).

+            ValueReference::Array(vec, variable_index) => {
+                //  We've checked at the beginning of this method that value
+                //  at `variable_index` does not exist, which guarantees
+                //  that array is to short and we won't shrink it

+        Ok(())
+    }
+
+    /// Helper method, - converts JSON pointer into auxiliary `ValueReference` enum.

+        if pointer.is_empty() {
+            return ValueReference::Invalid;
+        }
+        //  Extract variable name (that `pointer` points to)

+            Some(v) => v,
+            _ => return ValueReference::Invalid,
+        };
+        //  For arrays we also need to confirm validity of the variable name

+    }
+}
+
+//  Helper function to disassemble JSON path.

+    Ok(())
+}
+
+/// helper function to read a group from a given subdirectory:

+fn get_file_name(path: &path::Path) -> String {
+    path.file_stem()
+        .and_then(|x| x.to_str())
+        .unwrap_or_default()

+/// This database is only supposed to hold a relatively small amount of data
+/// that:
+///
+/// 1. can be freely and full loaded into memory;

+    /// Directory must contain valid database and be readable.
+    ///
+    /// This method will also remove all data from the current database's path
+    /// and fail if it can't.

+    }
+
+    /// Creates a new empty group.
+    /// Will produce error if group already exists.

+        Ok(())
+    }
+
+    /// Checks if specified file (in a specified group) is contained in the database.

+            .expect("Missing value that was just inserted."))
+    }
+
+    /// Removes specified file (in a specified group).

+    }
+
+    /// Removes specified file (in a specified group).
+    /// Will produce error if file does not exist.

+        Ok(())
+    }
+
+    /// Returns immutable reference to the specified file (in a specified group) as `file::File`.

+        }
+    }
+
+    //  Helper methods that return (im)mutable reference to `HashMap`

+
+impl Drop for TestCleanup {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.path);

-        _ => (),
-    }
+    let db = database::Database::load(Path::new(filename));
+    /*match db {

+/// Implements database's file by wrapping JSON value (`serde_json::Value`)
+/// and providing several convenient accessor methods.
+#[derive(Debug)]
+pub struct File {

+        let group_index = self.group_index(group_name)?;
+        Ok(&mut (&mut self.groups[group_index]).files)
+    }
+