// private void EnsureCapacity(int byteCount) [instance] :1355
void MemoryStream::EnsureCapacity(int byteCount)
{
    if ((Position() + (int64_t)byteCount) <= (int64_t)Capacity())
        return;
    else if ((Position() + (int64_t)byteCount) <= (int64_t)(Capacity() + _nextIncrease))
        ResizeTo(Capacity() + _nextIncrease);
    else
        ResizeTo((int)Position() + byteCount);
}

	/// <summary>オーバーフローを解決する</summary>
	void Resolve()
	{
		if (Count() < Capacity())
		{
			return;
		}
		for (Size i = 0; i < Count() - Capacity(); ++i)
		{
			m_buffer.pop_front();
		}
	}

Capacity Exword::GetCapacity()
{
    exword_capacity_t cap = {0,};
    int rsp;
    if (IsConnected()) {
        exword_setpath(m_device, (uint8_t*)GetStoragePath().utf8_str().data(), 0);
        rsp = exword_get_capacity(m_device, &cap);
        if (rsp != EXWORD_SUCCESS)
            return Capacity();
    }
    return Capacity(cap.total, cap.free);
}

 template<typename... U> void PushHead(U&&... u)
 {
     condcheck(Capacity() != 0);
     if(Empty()){
         m_Head       = 0;
         m_CircleQ[0] = T(std::forward<U>(u)...);
         m_CurrSize   = 1;
     }else{
         m_Head = ((m_Head + Capacity() - 1) % Capacity());
         m_CircleQ[m_Head] = T(std::forward<U>(u)...);
         m_CurrSize = std::min<size_t>(m_CurrSize + 1, Capacity());
     }
 }

	void NxDeviceOscOutputMessage::CheckForAvailableBundleSpace()
	{
		unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0) + 16;

		if( required > Capacity() )
			throw OutOfBufferMemoryException();
	}

void OutboundPacketStream::CheckForAvailableBundleSpace()
{
    unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0) + 16;

    if( required > Capacity() )
        throw OutOfBufferMemoryException();
}

 void PopHead()
 {
     if(!Empty()){
         m_Head = (m_Head + 1) % Capacity();
         m_CurrSize--;
     }
 }

template <class T> void Vector<T>::AutoAllocate()
{
	if(_origin == NULL)
		Allocate(2U);
	else if(_last == _end)
		Allocate(Capacity() << 1U);
}

 /** free the blob's memory */
 inline void Free()
 {
     if (Capacity() > 0) {
         RawFree(&Hdr());
         InitEmpty();
     }
 }

void VectorBase::Reserve( SizeType capacity, SizeType elementSize )
{
  SizeType oldCapacity = Capacity();
  SizeType oldCount = Count();
  if( capacity > oldCapacity )
  {
    const SizeType wholeAllocation = sizeof(SizeType) * 2 + capacity * elementSize;
    void* wholeData = (void*)malloc( wholeAllocation );
#if defined( DEBUG_ENABLED )
    // in debug build this will help identify a vector of uninitialized data
    memset( wholeData, 0xaa, wholeAllocation );
#endif
    SizeType* metaData = reinterpret_cast< SizeType* >( wholeData );
    *metaData++ = capacity;
    *metaData++ = oldCount;
    if( mData )
    {
      // copy over the old data
      memcpy( metaData, mData, oldCount * elementSize );
      // release old buffer
      Release();
    }
    mData = metaData;
  }
}

		String::String(const uint id)
		{
			if (HINSTANCE const hInstance = Application::Instance::GetLanguage().GetResourceHandle())
			{
				uint length;

				do
				{
					Reserve( Capacity() + BLOCK_SIZE );
					length = ::LoadString( hInstance, id, Ptr(), Capacity() + 1 );
				}
				while (length == Capacity());

				ShrinkTo( length );
			}
		}

// private void ResizeTo(int newSize) [instance] :1371
void MemoryStream::ResizeTo(int newSize)
{
    uArray* newBuffer = uArray::New(::TYPES[0/*byte[]*/], newSize);
    ::g::Uno::Array::Copy1(::TYPES[6/*Uno.Array.Copy<byte>*/], _buffer, newBuffer, uPtr(_buffer)->Length());
    _buffer = newBuffer;
    _nextIncrease = Capacity();
}

DZRawData __fastcall DZRawData::operator-(WORD tag)
{
    DZRawData res(Capacity());
    if (imp)
    {
        const unsigned char *p = begin();
        const unsigned char *e = end();
        XWord tg, sz;
        while (p + 3 < e)
        {
            tg.b[0] = *p++;
            tg.b[1] = *p++;
            sz.b[0] = *p++;
            sz.b[1] = *p++;

            if (tg.w != tag)
            {
                res += tg.w;
                res += sz.w;

                while (p < e && sz.w-- > 0)
                    res += *p++;
            }
            else
                p += sz.w;
        }

        while (p < e)
            res += *p++;
    }
    return res;
}

				inline size_t Compact(size_t leastLength)
				{
					uint32_t writableBytes = WriteableBytes();
					if (writableBytes < leastLength)
					{
						return 0;
					}
					uint32_t readableBytes = ReadableBytes();
					uint32_t total = Capacity();
					char* newSpace = NULL;
					if (readableBytes > 0)
					{
						newSpace = (char*) malloc(readableBytes);
						if (NULL == newSpace)
						{
							return 0;
						}
						memcpy(newSpace, m_buffer + m_read_idx, readableBytes);
					}
					if (NULL != m_buffer)
					{
						free(m_buffer);
					}
					m_read_idx = 0;
					m_write_idx = readableBytes;
					m_buffer_len = readableBytes;
					m_buffer = newSpace;
					return total - readableBytes;
				}

	/** free the blob's memory */
	FORCEINLINE void Free()
	{
		if (Capacity() > 0) {
			RawFree(&Hdr());
			InitEmpty();
		}
	}

int NDOStreamMsg::WriteBin(void *data, size_t size)
{
	if (_end <= _op_addr || size >= Capacity()){
		return -1;
	}

	if (size ==0){
		if (-1 == _writeMarker(ENDSTREAM_MARKER_BIN, 0)) {
			return -1;
		}
		return 0;
	}
	else {
		if (-1 == _writeMarker(ENDSTREAM_MARKER_BIN, 1)) {
			return -1;
		}
	}

	size_t free_size = _end - _op_addr;
	if (size + 2 <= free_size) {
		_WriteOrg((NDUINT16)size);
		if (size > 0)
			memcpy(_op_addr, data, size);
		MsgLength() += (NDUINT16)size;
		_op_addr += size;
		return 0;
	}
	return -1;
}

void OutboundPacketStream::CheckForAvailableMessageSpace( const char *addressPattern )
{
    // plus 4 for at least four bytes of type tag
    unsigned long required = Size() + ((ElementSizeSlotRequired()) ? 4 : 0) + RoundUp4(static_cast<unsigned long>(strlen(addressPattern)) + 1) + 4;

    if( required > Capacity() )
        throw OutOfBufferMemoryException();
}

//============================================================
void TNetMessageBuffer::Update(){
   TInt capacity = Capacity();
   TNetSerial messageSerial = _messageHead.Serial();
   TNetTick messageTick = _messageHead.Tick();
   TNetHash hash = CalculateHash(messageSerial, messageTick, _pData, _dataLength);
   _netHead.SetLength((TNetLength)capacity);
   _netHead.SetHash(hash);
}

Errors OutboundPacketStream::CheckForAvailableMessageSpace( const char *addressPattern )
{
    // plus 4 for at least four bytes of type tag
    std::size_t required = Size() + ((ElementSizeSlotRequired())?4:0)
            + RoundUp4(std::strlen(addressPattern) + 1) + 4;

    return (required > Capacity()) ? OUT_OF_BUFFER_MEMORY_ERROR : SUCCESS;
}

void OutboundPacketStream::CheckForAvailableArgumentSpace( long argumentLength )
{
    // plus three for extra type tag, comma and null terminator
     unsigned long required = static_cast<unsigned long>((argumentCurrent_ - data_) + argumentLength + RoundUp4( (end_ - typeTagsCurrent_) + 3 ));

    if( required > Capacity() )
        throw OutOfBufferMemoryException();
}