← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to common/libBuffer/src/CommonBuffer.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/libBuffer/src/CommonBuffer.cpp
 
1
/*
 
2
    Copyright (c) 2009 NetAllied Systems GmbH
 
3
 
 
4
    This file is part of Common libBuffer.
 
5
        
 
6
    Licensed under the MIT Open Source License, 
 
7
    for details please see LICENSE file or the website
 
8
    http://www.opensource.org/licenses/mit-license.php
 
9
*/
 
10
 
 
11
#include "CommonBuffer.h"
 
12
#include <string.h>
 
13
 
 
14
namespace Common
 
15
{
 
16
        //--------------------------------------------------------------------
 
17
        Buffer::Buffer( size_t bufferSize, IBufferFlusher* flusher )
 
18
                : mBuffer( new char[bufferSize] )
 
19
                , mBufferSize(bufferSize)
 
20
                , mCurrentPos( mBuffer )
 
21
                , mDirectFlushSize( mBufferSize )
 
22
                , mBytesFlushed(0)
 
23
                , mFlusher(flusher)
 
24
                , mMarkSet(false)
 
25
                , mIsOverwriting(false)
 
26
        {
 
27
 
 
28
        }
 
29
 
 
30
        //--------------------------------------------------------------------
 
31
        Buffer::~Buffer()
 
32
        {
 
33
                flushFlusher();
 
34
                delete[] mBuffer;
 
35
        }
 
36
 
 
37
        //--------------------------------------------------------------------
 
38
        bool Buffer::flushBuffer()
 
39
        {
 
40
                if ( isEmpty() )
 
41
                {
 
42
                        // there is nothing to flush
 
43
                        return true;
 
44
                }
 
45
 
 
46
                // flush the buffer
 
47
                bool success = sendDataToFlusher( mBuffer, getBytesUsed() );
 
48
 
 
49
                // reset the buffer
 
50
                mCurrentPos = mBuffer;
 
51
 
 
52
                return success;
 
53
        }
 
54
 
 
55
        //--------------------------------------------------------------------
 
56
        bool Buffer::flushFlusher()
 
57
        {
 
58
                if ( !flushBuffer() )
 
59
                { 
 
60
                        return false;
 
61
                }
 
62
 
 
63
                return mFlusher->flush();
 
64
        }
 
65
 
 
66
        //--------------------------------------------------------------------
 
67
        bool Buffer::copyToBuffer( const char* text )
 
68
        {
 
69
                size_t length = strlen( text );
 
70
                return copyToBuffer( text, length);
 
71
        }
 
72
 
 
73
        //--------------------------------------------------------------------
 
74
        void Buffer::setDirectFlushSize( size_t directFlushSize )
 
75
        {
 
76
                mDirectFlushSize =  (directFlushSize > mBufferSize) ? mBufferSize : directFlushSize;
 
77
        }
 
78
 
 
79
        //------------------------------
 
80
        size_t Buffer::getBytesUsed() const
 
81
        {
 
82
                return mCurrentPos - mBuffer;
 
83
        }
 
84
 
 
85
        //------------------------------
 
86
        size_t Buffer::getBytesAvailable() const
 
87
        {
 
88
                return getBufferSize()-getBytesUsed();
 
89
        }
 
90
 
 
91
        //------------------------------
 
92
        size_t Buffer::isEmpty() const
 
93
        {
 
94
                return mBuffer == mCurrentPos;
 
95
        }
 
96
 
 
97
        //------------------------------
 
98
        size_t Buffer::getDirectFlushSize() const
 
99
        {
 
100
                return mDirectFlushSize;
 
101
        }
 
102
 
 
103
        //------------------------------
 
104
        void Buffer::increaseCurrentPosition( size_t addedBytes )
 
105
        {
 
106
                mCurrentPos += addedBytes;
 
107
        }
 
108
 
 
109
        //------------------------------
 
110
        void Buffer::increaseCurrentPosition()
 
111
        {
 
112
                mCurrentPos++;
 
113
        }
 
114
 
 
115
        //------------------------------
 
116
        bool Buffer::startMark()
 
117
        {
 
118
//              assert(!mMarkSet);
 
119
                if(mMarkSet)
 
120
                        return false; 
 
121
 
 
122
                flushBuffer();
 
123
                mMarkSet = true;
 
124
                mFlusher->startMark();
 
125
 
 
126
                return true;
 
127
        }
 
128
 
 
129
        //------------------------------
 
130
        IBufferFlusher::MarkId Buffer::endMark()
 
131
        {
 
132
//              assert(mMarkSet);
 
133
                if(!mMarkSet)
 
134
                        return IBufferFlusher::INVALID_ID;
 
135
 
 
136
                mMarkSet = false;
 
137
                flushBuffer();
 
138
                return mFlusher->endMark();
 
139
        }
 
140
 
 
141
        //------------------------------
 
142
        bool Buffer::jumpToMark( IBufferFlusher::MarkId markId, bool keepMarkId /*= false*/ )
 
143
        {
 
144
                flushBuffer();
 
145
                if ( markId == IBufferFlusher::END_OF_STREAM )
 
146
                {
 
147
                        mIsOverwriting = false;
 
148
                }
 
149
                else
 
150
                {
 
151
                        mIsOverwriting = true;
 
152
                }
 
153
                return mFlusher->jumpToMark(markId, keepMarkId);
 
154
        }
 
155
 
 
156
        //------------------------------
 
157
        size_t Buffer::getBytesCopiedToBuffer() const
 
158
        {
 
159
                return mBytesFlushed + getBytesUsed();
 
160
        }
 
161
 
 
162
        //------------------------------
 
163
        bool Buffer::sendDataToFlusher( const char* buffer, size_t length )
 
164
        {
 
165
                if ( !mIsOverwriting )
 
166
                {
 
167
                        mBytesFlushed += length;
 
168
                }
 
169
                return mFlusher->receiveData( buffer, length );
 
170
        }
 
171
 
 
172
} // namespace Common