home / products / comet / documentation

l a m b d a s o f t

c o m e t

features

documentation

faq

introduction

todo

troubleshooting

forum

download

currency.h

Go to the documentation of this file.

/* Copyright © 2001 Michael Geddes, Sofus Mortensen
 *
 * This material is provided "as is", with absolutely no warranty 
 * expressed or implied. Any use is at your own risk. Permission to 
 * use or copy this software for any purpose is hereby granted without 
 * fee, provided the above notices are retained on all copies. 
 * Permission to modify the code and to distribute modified code is 
 * granted, provided the above notices are retained, and a notice that 
 * the code was modified is included with the above copyright notice. 
 *
 * This header is part of comet.
 * http://www.lambdasoft.dk/comet
 */

#ifndef COMET_CURRENCY_H
#define COMET_CURRENCY_H

#include <comet/config.h>

#include <comet/error_fwd.h>
#include <comet/assert.h>

#include <wtypes.h>

#include <iostream>
#include <algorithm>

namespace comet
{

        class bstr_t;

        // currency_t


        class currency_t
        {
                public:
                        currency_t() throw() { cy_.int64 = 0; }

                        currency_t(const CY &cy): cy_(cy) { }

                        explicit currency_t(double val)
                        {
                                VarCyFromR8(val,&cy_) | raise_exception;
                        }

#if 0
//                      //! Construct currency from CY/CURRENCY.
//                      /*!
//                              Takes ownership of specified CY value. To prevent misuse the CY must be wrapped using auto_attach.
//                              
//                              \code
//                                      currency_t cy( auto_attach( myCY ) );
//                              \endcode
//
//                              \param cyVal
//                                      Value to initialise currency_t from.
//                      */
//                      currency_t( const impl::auto_attach_t<CY> &cyVal) throw() : cy_(cyVal.get())
//                      {}
#endif  //0

                        currency_t( long val )
                        {
                                VarCyFromI4(val,&cy_) | raise_exception;
                        } 

                        currency_t( int val )
                        {
                                VarCyFromI4(val,&cy_) | raise_exception;
                        } 

                        void swap(currency_t& c) throw()
                        {
                                std::swap(cy_, c.cy_);
                        }

                        static const currency_t& create_const_reference(const CY& s) throw()
                        { return *reinterpret_cast<const currency_t*>(&s); }

                        static currency_t& create_reference(CY& s) throw()
                        { return *reinterpret_cast<currency_t*>(&s); }


                        currency_t &operator=(double newVal)
                        {
                                currency_t c( newVal );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator=(long newVal)
                        {
                                currency_t c( newVal );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator=(int newVal)
                        {
                                currency_t c( newVal );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator=(const tagCY &newVal) throw()
                        {
                                cy_ = newVal;
                                return *this;
                        }


                        currency_t &operator+=(const currency_t &cy)
                        {
                                currency_t c( *this + cy );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator-=(const currency_t &cy)
                        {
                                currency_t c( *this - cy );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator*=(const currency_t &cy)
                        {
                                currency_t c( *this * cy );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator*=(long cy)
                        {
                                currency_t c( *this * cy );
                                swap(c);
                                return *this;
                        }
                        currency_t &operator*=(int val)
                        {
                                return operator*=((long)val);
                        }
                        currency_t &operator*=(double val)
                        {
                                cy_.int64 = (LONGLONG)(cy_.int64 * val);
                                return *this;
                        }

                        currency_t &operator/=(int val) const
                        {
                                return operator/=((long)val);
                        }
                        currency_t &operator/=(long val)
                        {

                                if(!valid())
                                { 
                                        // Check for invalid number
                                        return *this;
                                }

                                // Check for divide by 0
                                if (val == 0)
                                {
                                        // Set to maximum negative value
                                        cy_.Hi = 0x80000000;
                                        cy_.Lo = 0x00000000;

                                        return *this;
                                }
                                cy_.int64/=val;

                                return *this;
                        }

                        currency_t operator+(const currency_t &cy)const
                        {
                                currency_t rv;
                                VarCyAdd(cy_,cy.cy_,&rv.cy_) | raise_exception ;
                                return rv;
                        }
                        currency_t operator-(const currency_t &cy)const
                        {
                                currency_t rv;
                                VarCySub(cy_,cy.cy_,&rv.cy_) | raise_exception ;
                                return rv;
                        }
                        currency_t operator*(const currency_t &cy)const
                        {
                                currency_t rv;
                                VarCyMul(cy_,cy.cy_,&rv.cy_) | raise_exception ;
                                return rv;
                        }
                        currency_t operator*(long cy)const
                        {
                                currency_t rv;
                                VarCyMulI4(cy_,cy,&rv.cy_) | raise_exception;
                                return rv;
                        }
                        currency_t operator*(int cy)const
                        {
                                return operator *((long)cy);
                        }

                        currency_t operator*(double cy) const
                        {
                                currency_t val(*this);
                                val *=cy;
                                return val;
                        }


                        double operator/(const currency_t &cy)const
                        {
                                return ((double)cy_.int64 /(double)cy.cy_.int64);
                        }

                        currency_t operator/(int val) const
                        {
                                return operator/((long)val);
                        }
                        currency_t operator/(long val) const
                        {
                                currency_t tmp(cy_);
                                tmp/=val;
                                return tmp;
                        }

                        double operator/(double val) const
                        {
                                if(!valid())
                                { 
                                        // Check for invalid number
                                        throw std::invalid_argument("Invalid divide");
                                }

                                // Check for divide by 0
                                if (val == 0)
                                {
                                        throw std::overflow_error("Divide by 0");
                                }
                                return cy_.int64/(val*10000);
                        }

                        currency_t operator-()const
                        {
                                currency_t cy;
                                VarCyNeg(cy_,&(cy.cy_)) | raise_exception;
                                return cy;
                        }


                        currency_t &round_to(int decimals)
                        {
                                VarCyRound(cy_,decimals,&cy_) | raise_exception;
                                return *this;
                        }



                        bool operator!=(const currency_t &cy) const { return cmp(cy)!=0; }
                        bool operator!=(double val) const{ return cmp(val)!=0; }
                        bool operator==(const currency_t &cy) const { return cmp(cy)==0; }
                        bool operator==(double val) const{ return cmp(val)==0; }
                        bool operator<=(const currency_t &cy) const{ return cmp(cy)<=0; }
                        bool operator<=(double val) const{ return cmp(val)<=0; }
                        bool operator>=(const currency_t &cy) const{ return cmp(cy)>=0; }
                        bool operator>=(double val) const{ return cmp(val)>=0; }
                        bool operator<(const currency_t &cy) const{ return cmp(cy)<0; }
                        bool operator<(double val) const{ return cmp(val)<0; }
                        bool operator>(const currency_t &cy) const{ return cmp(cy)>0; }
                        bool operator>(double val) const{ return cmp(val)>0; }


                        int cmp(const currency_t &cy) const
                        {
                                return _cmpResult(VarCyCmp(cy_,cy.cy_));

                        }

                        int cmp(double cy) const
                        {
                                return _cmpResult(VarCyCmpR8(cy_,cy));
                        }

                        

                        tagCY get() const { return cy_;}
                        tagCY in() const { return cy_;}
                        tagCY *in_ptr() const { return const_cast<CY*>(&cy_);}
                        tagCY *out() { return &cy_;}
                        tagCY *inout() { return &cy_;}


#if 0
                        friend std::ostream &operator <<(std::ostream &str, const currency_t &val)
                        {
                                std::string strval=val.format( 1, str.precision(), str.width() );
                                return str<< strval.c_str();
                        }
#endif
                        
                        
                        
                        friend
                        std::basic_ostream<char> &operator<<(std::basic_ostream<char> &str, const currency_t &val)
                        {
                                std::basic_string<char> strval;
                                val.do_format(strval, 1, str.precision(), str.width() );
                                return str << strval.c_str();
                        }
                        
                        friend
                        std::basic_ostream<wchar_t> &operator<<(std::basic_ostream<wchar_t> &str, const currency_t &val)
                        {
                                std::basic_string<wchar_t> strval;
                                val.do_format(strval, 1, str.precision(), str.width() );
                                return str << strval.c_str();
                        }

                        std::basic_string<TCHAR> format(int mindigits=0,int minprecision=0, int width=0) const
                        {
                                std::basic_string<TCHAR> strval;
                                do_format(strval, mindigits, minprecision, width);
                                return strval;
                        }

                        currency_t &parse( const bstr_t &str, LCID locale =::GetThreadLocale() );
/*                      {
                                VarCyFromStr( str.in(), locale, 0, &cy_ ) | raise_exception;
                                return *this;
                        }*/

                protected:
                        template <typename CH>
                        void do_format(std::basic_string<CH> &val, int mindigits,int minprecision, int /*width*/) const
                        {
                                COMET_ASSERT(mindigits>=0 && minprecision >=0 );
                                if(minprecision> 4)  minprecision =4;

                                // Add in the 4 fixed decimal points
                                int pr=((0 <= minprecision && minprecision <=4)?(4-minprecision):0);
                                mindigits+=4;

                                val.erase();
                                val.reserve(22);
                                LONGLONG value=cy_.int64;
                                bool neg=value<0;
                                if(neg)
                                {
                                        value=-value;
                                }
                                // Put in the digits backwards 
                                int digit=0;
                                bool output=false;
                                while(value !=0 || digit < mindigits)
                                {
                                        CH dig=CH(value%10);
                                        if(output || true==(output= (dig >0 || digit>=pr))) // Once 'output' is set - output everything.
                                        {
                                                val+=(CH('0'+dig));
                                        }
                                        if(++digit == 4)
                                        {
                                                val+=CH('.');
                                                output=true;
                                        }
                                        value/=10;
                                }
                                if(neg)
                                {
                                        val+=CH('-');
                                }

                                // Now reverse the digits
                                std::reverse(val.begin(), val.end());
                        }
                public:

                        bool valid() const throw() 
                        { return !(cy_.Hi==(long)0x80000000 && cy_.Lo==0);}

                        CY detach() throw()
                        {
                                CY val = cy_;
                                cy_.int64 = 0;
                                return val;
                        }

                        static CY detach(currency_t& cy) throw()
                        {
                                return cy.detach();
                        }

                private:
                        CY cy_;

                        static int _cmpResult(HRESULT hr)
                        {
                                if(SUCCEEDED(hr))
                                {
                                        switch(hr)
                                        {
                                                case VARCMP_LT:
                                                        return -1;
                                                case VARCMP_EQ :
                                                        return 0;
                                                case VARCMP_GT:
                                                        return 1;
                                                case VARCMP_NULL:
                                                        COMET_ASSERT(!"What do we do with this?");
                                        }
                                }
                                else
                                {
                                        hr | raise_exception;
                                }
                                return 0; // shut the compiler up
                        }
        };
}

#endif // COMET_CURRENCY_H

Copyright 2002 Sofus Mortensen. All rights reserved.