elseware/src/entity/gateway/entitygateway.rs/elseware/data/maps/map_ruins02_00_00e.dat/elseware/data/maps/map_ruins01_00_00_offo.dat

use std::convert::From;
use thiserror::Error;
use futures::Future;

use crate::entity::account::*;
use crate::entity::character::*;
use crate::entity::item::*;


// TODO: better granularity?
//#[derive(Error, Debug)]
#[derive(Error, Debug)]
#[error("")]
pub enum GatewayError {
    Error,
    PgError(#[from] sqlx::Error)
}


#[async_trait::async_trait]
pub trait EntityGateway: Send + Sync {
    async fn transaction<'a>(&'a mut self) -> Result<Box<dyn EntityGatewayTransaction + 'a>, GatewayError>
    {
        unimplemented!();
    }

    async fn with_transaction<'a, F, Fut, R, E>(&'a mut self, _func: F) -> Result<R, E>
    where
        Fut: Future<Output = Result<(Box<dyn EntityGatewayTransaction + 'a>, R), E>> + Send + 'a,
        F: FnOnce(Box<dyn EntityGatewayTransaction + 'a>) -> Fut + Send,
        R: Send,
        E: From<GatewayError>,
        Self: Sized
    {
        unimplemented!();
    }

    async fn create_user(&mut self, _user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
        unimplemented!()
    }

    async fn get_user_by_id(&mut self, _id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
        unimplemented!();
    }

    async fn get_user_by_name(&mut self, _username: String) -> Result<UserAccountEntity, GatewayError> {
        unimplemented!();
    }

    async fn save_user(&mut self, _user: &UserAccountEntity) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn create_user_settings(&mut self, _settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
        unimplemented!();
    }

    async fn get_user_settings_by_user(&mut self, _user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
        unimplemented!();
    }

    async fn save_user_settings(&mut self, _settings: &UserSettingsEntity) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn create_character(&mut self, _char: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
        unimplemented!();
    }

    // TODO: just make this a vec sorted by slot order?
    async fn get_characters_by_user(&mut self, _user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
        unimplemented!();
    }

    async fn save_character(&mut self, _char: &CharacterEntity) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn get_guild_card_data_by_user(&mut self, _user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
        unimplemented!();
    }

    async fn create_item(&mut self, _item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
        unimplemented!();
    }

    async fn add_item_note(&mut self, _item_id: &ItemEntityId, _item_note: ItemNote) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn feed_mag(&mut self, _mag_item_id: &ItemEntityId, _tool_item_id: &ItemEntityId) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn change_mag_owner(&mut self, _mag_item_id: &ItemEntityId, _character: &CharacterEntity) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn use_mag_cell(&mut self, _mag_item_id: &ItemEntityId, _mag_cell_id: &ItemEntityId) -> Result<(), GatewayError>  {
        unimplemented!();
    }

    async fn add_weapon_modifier(&mut self, _item_id: &ItemEntityId, _modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn get_character_inventory(&mut self, _char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
        unimplemented!();
    }

    async fn get_character_bank(&mut self, _char_id: &CharacterEntityId, _bank_name: &BankName) -> Result<BankEntity, GatewayError> {
        unimplemented!();
    }

    async fn set_character_inventory(&mut self, _char_id: &CharacterEntityId, _inventory: &InventoryEntity) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn set_character_bank(&mut self, _char_id: &CharacterEntityId, _inventory: &BankEntity, _bank_name: &BankName) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn get_character_equips(&mut self, _char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
        unimplemented!();
    }

    async fn set_character_equips(&mut self, _char_id: &CharacterEntityId, _equips: &EquippedEntity) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn get_character_meseta(&mut self, _char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
        unimplemented!();
    }

    async fn set_character_meseta(&mut self, _char_id: &CharacterEntityId, _amount: Meseta) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn get_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank: &BankName) -> Result<Meseta, GatewayError> {
        unimplemented!();
    }

    async fn set_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank: &BankName, _amount: Meseta) -> Result<(), GatewayError> {
        unimplemented!();
    }

    async fn create_trade(&mut self, _char_id1: &CharacterEntityId, _char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
        unimplemented!();
    }
}


#[async_trait::async_trait]
pub trait EntityGatewayTransaction: Send + Sync {
    fn gateway(&mut self) -> &mut dyn EntityGateway {
        unimplemented!()
    }

    async fn commit(self: Box<Self>) -> Result<(), GatewayError> {
        unimplemented!()
    }
}