}
impl GCTransaction {
    fn headers() -> [String; 18] {
        [
            "Date".to_owned(),
            "Transaction ID".to_owned(),
            "Number".to_owned(),
            "Description".to_owned(),
            "Notes".to_owned(),
            "Commodity/Currency".to_owned(),
            "Void Reason".to_owned(),
            "Action".to_owned(),
            "Memo".to_owned(),
            "Full Account Name".to_owned(),
            "Account Name".to_owned(),
            "Amount With Sym.".to_owned(),
            "Amount Num".to_owned(),
            "Value With Sym.".to_owned(),
            "Value Num".to_owned(),
            "Reconcile".to_owned(),
            "Reconcile Date".to_owned(),
            "Rate/Price".to_owned(),
        ]
    }
    fn output(&self) -> [String; 18] {
        [
            self.date.clone(),
            self.transaction_id.clone(),
            self.number.clone(),
            self.description.clone().unwrap_or_default(),
            self.notes.clone().unwrap_or_default(),
            self.commodity_currency.clone().unwrap_or_default(),
            self.void_reason.clone().unwrap_or_default(),
            self.action.clone().unwrap_or_default(),
            self.memo.clone().unwrap_or_default(),
            self.full_account_name.clone().unwrap_or_default(),
            self.account_name.clone().unwrap_or_default(),
            self.amount_with_sym.clone().unwrap_or_default(),
            match self.amount_num {
                Some(amount_num) => amount_num.to_string().replace('.', ","),
                None => "".to_owned(),
            },
            self.value_with_sym.clone().unwrap_or_default(),
            match &self.value_num {
                Some(value_num) => value_num.to_string().replace('.', ","),
                None => "".to_owned(),
            },
            self.reconcile.clone().unwrap_or_default(),
            self.reconcile_date.clone().unwrap_or_default(),
            self.rate_price.clone().unwrap_or_default(),
        ]
    }
}
struct GCTransactionBuffer {
    transactions: VecDeque<GCTransaction>,
}
impl GCTransactionBuffer {
    fn new() -> Self {
        Self {
            transactions: VecDeque::new(),
        }
    }
    fn push_back(&mut self, gctransaction: GCTransaction) {
        self.transactions.push_back(gctransaction);
    }
    fn push_front(&mut self, gctransaction: GCTransaction) {
        self.transactions.push_front(gctransaction);
    }
    fn pop_back(&mut self) -> Option<GCTransaction> {
        self.transactions.pop_back()
    }
    fn pop_front(&mut self) -> Option<GCTransaction> {
        self.transactions.pop_front()
    }
    fn iter_mut(&mut self) -> std::collections::vec_deque::IterMut<GCTransaction> {
        self.transactions.iter_mut()
    }
    fn iter(&self) -> std::collections::vec_deque::Iter<GCTransaction> {
        self.transactions.iter()
    }

    wtr.write_record([
        "Date",
        "Transaction ID",
        "Number",
        "Description",
        "Notes",
        "Commodity/Currency",
        "Void Reason",
        "Action",
        "Memo",
        "Full Account Name",
        "Account Name",
        "Amount With Sym.",
        "Amount Num",
        "Value With Sym.",
        "Value Num",
        "Reconcile",
        "Reconcile Date",
        "Rate/Price",
    ])?;

    wtr.write_record(GCTransaction::headers())?;

    let mut transaction_buffer: VecDeque<[String; 18]> = VecDeque::new();

    let mut transaction_buffer = GCTransactionBuffer::new();

        transaction_buffer.push_back([

        transaction_buffer.push_back(GCTransaction {

            record.datum,

            date: record.datum,

            "".into(),

            transaction_id: "".into(),

            1.to_string(),

            number: 1.to_string(),

            record.text,

            description: Some(record.text.to_owned()),

            match amount_balance {
                Some(value) => value.to_string().replace('.', ","),
                None => "".into(),
            },

            notes: amount_balance.map(|value| value.to_string().replace('.', ",")),

            "CURRENCY::SEK".into(),

            commodity_currency: Some("CURRENCY::SEK".into()),

            "".into(),

            void_reason: None,

            record.typ,

            action: Some(record.typ),

            "".into(),

            memo: None,

            account_name.into(),

            full_account_name: Some(account_name.to_owned()),

            "".into(),

            account_name: None,

            "".into(),

            amount_with_sym: None,

            "".into(),

            amount_num: None,

            "".into(),

            value_with_sym: None,

            value_num.to_string().replace('.', ","),

            value_num: Some(value_num),

            "n".into(),

            reconcile: Some("n".to_owned()),

            "".into(),

            reconcile_date: None,

            "1".into(),
        ]);

            rate_price: Some("1".to_string()),
        });

    buf: &mut VecDeque<[String; 18]>,

    buf: &mut GCTransactionBuffer,

        let transaction_number = counter + 1;
        row[2] = transaction_number.to_string();

        row.number = (counter + 1).to_string();

        wtr.write_record(row)?;

        wtr.write_record(row.output())?;