BigInt.h

/*
 *
 * BigInt
 * ledger-core
 *
 * Created by Pierre Pollastri on 15/09/2016.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2016 Ledger
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */
#ifndef LEDGER_CORE_BIGINT_H
#define LEDGER_CORE_BIGINT_H

#ifndef LIBCORE_EXPORT
    #if defined(_MSC_VER)
        #include <libcore_export.h>
    #else
        #define LIBCORE_EXPORT
    #endif
#endif

#include <string>
#include <vector>
#include <bigd.h>
#include <memory>
#include "../utils/endian.h"

namespace ledger {

    namespace core {

        class BigInt {

        public:
            static LIBCORE_EXPORT const BigInt ZERO;
            static LIBCORE_EXPORT const BigInt ONE;
            static LIBCORE_EXPORT const BigInt TEN;
            typedef unsigned int SimpleInt;
            typedef unsigned long DoubleInt;
            static LIBCORE_EXPORT const std::string DIGITS;
            static LIBCORE_EXPORT const int MIN_RADIX;
            static LIBCORE_EXPORT const int MAX_RADIX;

            static LIBCORE_EXPORT BigInt* from_hex(const std::string& str);
            static LIBCORE_EXPORT BigInt fromHex(const std::string& str);
            static LIBCORE_EXPORT BigInt* from_dec(const std::string& str);
            static LIBCORE_EXPORT BigInt fromDecimal(const std::string& str);

            static LIBCORE_EXPORT BigInt fromString(const std::string& str);

            template <typename T>
            static BigInt fromScalar(T value) {
              BigInt result;
              result.assignScalar<T>(value);
              return result;
            }

        private:
            BigInt(const std::string& str, int radix);


            static bool all_digits(std::string const& s);

        public:
            BigInt();
            BigInt(const BigInt& cpy);
            BigInt(BigInt&& mov);

            BigInt(const void *data, size_t length, bool negative);
            BigInt(const std::vector<uint8_t>& data, bool negative);

            explicit BigInt(int value);
            explicit BigInt(unsigned int value);
            explicit BigInt(unsigned long long value);
            explicit BigInt(int64_t value);
            BigInt(const std::string& str);

            int toInt() const;

            unsigned toUnsignedInt() const;

            uint64_t toUint64() const;
            int64_t toInt64() const;

            std::string toString() const;
            std::string to_string() const {return toString();};

            std::string toHexString() const;

            std::vector<uint8_t> toByteArray() const;

            BigInt operator+(const BigInt& rhs) const;
            BigInt operator-(const BigInt& rhs) const;
            BigInt operator*(const BigInt& rhs) const;
            BigInt operator/(const BigInt& rhs) const;
            BigInt operator%(const BigInt& rhs) const;

            BigInt& operator++();
            BigInt  operator++(int);
            BigInt& operator--();
            BigInt  operator--(int);

            BigInt& operator=(const BigInt&);
            BigInt& operator=(BigInt&& a);

            bool operator<(const BigInt&) const;
            bool operator<=(const BigInt&) const;
            bool operator==(const BigInt&) const;
            bool operator>(const BigInt&) const;
            bool operator>=(const BigInt&) const;

            int compare(const BigInt&) const;

            BigInt pow(unsigned short p) const;

            unsigned long getBitSize() const;
            bool isNegative() const;
            bool isPositive() const;
            bool isZero() const;
            BigInt negative() const;
            BigInt positive() const;

            BigInt& assignI64(int64_t value);

            template <typename T>
            BigInt& assignScalar(T value) {
                auto bytes = endianness::scalar_type_to_array<T>(std::abs(value), endianness::Endianness::BIG);
                bdConvFromOctets(_bigd, reinterpret_cast<const unsigned char *>(bytes), sizeof(value));
                std::free(bytes);
                _negative = value < 0LL;
                return *this;
            }

            virtual ~BigInt();

        private:
            BIGD _bigd;
            bool _negative;
        };
    }

}
#endif //LEDGER_CORE_BIGINT_H