/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/
#ifndef TINYUTF16_H_
#define TINYUTF16_H_

#include "tinyiterator.h"

namespace analysis {

    namespace tiny {

		/**
		 * Translates given unicode character as utf16 and 
		 * stores utf16 codes in the output stream
		 */
        template <typename Stream>
        void utf16put(Stream& out, int c) {
            if ( c >= 0x00010000L ) {
                c -= 0x00010000L;
                out<<(wchar_t)(0xd800 + ((c >> 10) & 0x03ffL));
                out<<(wchar_t)(0xd800 + (c & 0x03ffL));
            } else {
                out<<(wchar_t)(c);
            }
        }

        /**
         * Writes unicode characters into the output 
         * stream as utf16 codes. 
         */
        template <typename Output> 
        struct Utf16Output {
            public:
                Utf16Output(const Output& out) : out_(out) {};
                inline Utf16Output& operator<<(int c) {
                    utf16put(out_, c);
                    return *this;
                }

                inline Utf16Output& operator<<(wchar_t c) {
                    return (*this)<<(int)c;
                }
                template <typename I>
                Utf16Output& write(I source, int length) {
                    for (int i = 0; i < length; i++) { 
                        (*this)<<source; ++source;
                    }
                    return *this;
                }
                template <typename I>
                Utf16Output& operator<<(I source) {
                     for (;*source; ++source) {
                         (*this)<<*source;
                     }
                     return *this;
                 }
            private:
                Output out_;
        };
        
        /**
         * Writes unicode characters into the given iterator as utf16 codes
         */
        template <typename Iterator> 
        struct Utf16Writer : public Utf16Output<IteratorOutput<Iterator> > {
            public:
                Utf16Writer(Iterator i) : Utf16Output<IteratorOutput<Iterator> >(IteratorOutput<Iterator>(i)) {}
            };
                
        /** 
         * Calculates the size of all characters with the iterator as utf16 
         * code points
         */
        template<typename Iterator>
        int utf16size(Iterator i) {
            int rv = 0;
            for (;*i; ++i) {
                rv += (*i >= 0x10000 ? 2 : 1);
            }
            return rv;
        }
        
        /**
         * Reads utf16 code points from given iterator and translates them 
         * as unicode characters.  
         */
        template <typename Iterator> 
        struct Utf16Iterator {
            public:
                Utf16Iterator(Iterator i) : i_(i) { 
                    operator++(); // cache first character
                }
                Utf16Iterator() : i_(), c_(0), offset_(0) {}
                inline int operator*() const {
                    return c_;
                };  
                Utf16Iterator& operator++() {
                    offset_ = i_;
                    c_ = *i_; ++i_;
                    if ( c_ >= 0xd800 && c_ <= 0xdfff ) {
                        int c2 = *i_; ++i_;
                        if ( c2 >= 0xdc00 && c2 <= 0xdfff ){
                            c_ = (((c_ & 0x03ffL) << 10) | ((c2 & 0x03ffL) << 0)) + 0x00010000L;
                        }
                    }
                    return *this;
                }
                operator int() {return offset_;}
            private:
                Iterator i_;
                int c_; // current utf cached
                int offset_; // characters read
        };
        
        /**
         * Copies the iterator content into a wstring
         */
        template<class Iterator> 
        std::wstring utf16str(Iterator i) {
            std::wostringstream ret;
            while (*i) {
                utf16put(ret, *i);
                ++i;
            }
            return ret.str();
        }
        
    }
}

#endif /* TINYUTF16_H_ */