use std::marker;
use std::mem;
use std::ptr;
use {raw, Oid, ObjectType, Error, Buf, Commit, Tag, Blob, Tree, Repository};
use {Describe, DescribeOptions};
use util::Binding;
pub struct Object<'repo> {
raw: *mut raw::git_object,
_marker: marker::PhantomData<&'repo Repository>,
}
impl<'repo> Object<'repo> {
pub fn id(&self) -> Oid {
unsafe {
Binding::from_raw(raw::git_object_id(&*self.raw))
}
}
pub fn kind(&self) -> Option<ObjectType> {
ObjectType::from_raw(unsafe { raw::git_object_type(&*self.raw) })
}
pub fn peel(&self, kind: ObjectType) -> Result<Object<'repo>, Error> {
let mut raw = ptr::null_mut();
unsafe {
try_call!(raw::git_object_peel(&mut raw, &*self.raw(), kind));
Ok(Binding::from_raw(raw))
}
}
pub fn peel_to_blob(&self) -> Result<Blob<'repo>, Error> {
self.peel(ObjectType::Blob).map(|o| o.cast_or_panic(ObjectType::Blob))
}
pub fn peel_to_commit(&self) -> Result<Commit<'repo>, Error> {
self.peel(ObjectType::Commit).map(|o| o.cast_or_panic(ObjectType::Commit))
}
pub fn peel_to_tag(&self) -> Result<Tag<'repo>, Error> {
self.peel(ObjectType::Tag).map(|o| o.cast_or_panic(ObjectType::Tag))
}
pub fn peel_to_tree(&self) -> Result<Tree<'repo>, Error> {
self.peel(ObjectType::Tree).map(|o| o.cast_or_panic(ObjectType::Tree))
}
pub fn short_id(&self) -> Result<Buf, Error> {
unsafe {
let buf = Buf::new();
try_call!(raw::git_object_short_id(buf.raw(), &*self.raw()));
Ok(buf)
}
}
pub fn as_commit(&self) -> Option<&Commit<'repo>> {
self.cast(ObjectType::Commit)
}
pub fn into_commit(self) -> Result<Commit<'repo>, Object<'repo>> {
self.cast_into(ObjectType::Commit)
}
pub fn as_tag(&self) -> Option<&Tag<'repo>> {
self.cast(ObjectType::Tag)
}
pub fn into_tag(self) -> Result<Tag<'repo>, Object<'repo>> {
self.cast_into(ObjectType::Tag)
}
pub fn as_tree(&self) -> Option<&Tree<'repo>> {
self.cast(ObjectType::Tree)
}
pub fn into_tree(self) -> Result<Tree<'repo>, Object<'repo>> {
self.cast_into(ObjectType::Tree)
}
pub fn as_blob(&self) -> Option<&Blob<'repo>> {
self.cast(ObjectType::Blob)
}
pub fn into_blob(self) -> Result<Blob<'repo>, Object<'repo>> {
self.cast_into(ObjectType::Blob)
}
pub fn describe(&self, opts: &DescribeOptions)
-> Result<Describe, Error> {
let mut ret = ptr::null_mut();
unsafe {
try_call!(raw::git_describe_commit(&mut ret, self.raw, opts.raw()));
Ok(Binding::from_raw(ret))
}
}
fn cast<T>(&self, kind: ObjectType) -> Option<&T> {
assert_eq!(mem::size_of::<Object>(), mem::size_of::<T>());
if self.kind() == Some(kind) {
unsafe { Some(&*(self as *const _ as *const T)) }
} else {
None
}
}
fn cast_into<T>(self, kind: ObjectType) -> Result<T, Object<'repo>> {
assert_eq!(mem::size_of_val(&self), mem::size_of::<T>());
if self.kind() == Some(kind) {
Ok(unsafe {
let other = ptr::read(&self as *const _ as *const T);
mem::forget(self);
other
})
} else {
Err(self)
}
}
}
pub trait CastOrPanic {
fn cast_or_panic<T>(self, kind: ObjectType) -> T;
}
impl<'repo> CastOrPanic for Object<'repo> {
fn cast_or_panic<T>(self, kind: ObjectType) -> T {
assert_eq!(mem::size_of_val(&self), mem::size_of::<T>());
if self.kind() == Some(kind) {
unsafe {
let other = ptr::read(&self as *const _ as *const T);
mem::forget(self);
other
}
} else {
let buf;
let akind = match self.kind() {
Some(akind) => akind.str(),
None => {
buf = format!("unknown ({})", unsafe { raw::git_object_type(&*self.raw) });
&buf
}
};
panic!("Expected object {} to be {} but it is {}", self.id(), kind.str(), akind)
}
}
}
impl<'repo> Clone for Object<'repo> {
fn clone(&self) -> Object<'repo> {
let mut raw = ptr::null_mut();
unsafe {
let rc = raw::git_object_dup(&mut raw, self.raw);
assert_eq!(rc, 0);
Binding::from_raw(raw)
}
}
}
impl<'repo> ::std::fmt::Debug for Object<'repo> {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
let mut ds = f.debug_struct("Object");
match self.kind() {
Some(kind) => ds.field("kind", &kind),
None => ds.field("kind", &format!("Unknow ({})", unsafe { raw::git_object_type(&*self.raw) }))
};
ds.field("id", &self.id());
ds.finish()
}
}
impl<'repo> Binding for Object<'repo> {
type Raw = *mut raw::git_object;
unsafe fn from_raw(raw: *mut raw::git_object) -> Object<'repo> {
Object { raw: raw, _marker: marker::PhantomData, }
}
fn raw(&self) -> *mut raw::git_object { self.raw }
}
impl<'repo> Drop for Object<'repo> {
fn drop(&mut self) {
unsafe { raw::git_object_free(self.raw) }
}
}