falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Browse Source

Remove CarlaPluginPtr.hpp compat file 

Signed-off-by: falkTX <falktx@falktx.com>
pull/1961/merge
falkTX 3 months ago
parent
c2ccdc282c
commit
da31486cb6
Signed by: falkTX <falktx@falktx.com> GPG Key ID: CDBAA37ABC74FBA0
4 changed files with 11 additions and 294 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -2
      source/backend/CarlaEngine.hpp
  2. +6
    -2
      source/backend/CarlaPlugin.hpp
  3. +0
    -273
      source/backend/CarlaPluginPtr.hpp
  4. +3
    -17
      source/backend/engine/CarlaEngineOsc.hpp

+ 2
- 2
source/backend/CarlaEngine.hpp View File

@@ -1,11 +1,11 @@
// SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
// SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>
// SPDX-License-Identifier: GPL-2.0-or-later

#ifndef CARLA_ENGINE_HPP_INCLUDED
#define CARLA_ENGINE_HPP_INCLUDED

#include "CarlaBackend.h"
#include "CarlaPluginPtr.hpp"
#include "CarlaPlugin.hpp"

namespace water {
class MemoryOutputStream;


+ 6
- 2
source/backend/CarlaPlugin.hpp View File

@@ -1,11 +1,12 @@
// SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
// SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>
// SPDX-License-Identifier: GPL-2.0-or-later

#ifndef CARLA_PLUGIN_HPP_INCLUDED
#define CARLA_PLUGIN_HPP_INCLUDED

#include "CarlaBackend.h"
#include "CarlaPluginPtr.hpp"

#include <memory>

// -----------------------------------------------------------------------
// Avoid including extra libs here
@@ -37,9 +38,12 @@ class CarlaEngineCVPort;
class CarlaEngineEventPort;
class CarlaEngineCVSourcePorts;
class CarlaEngineBridge;
class CarlaPlugin;
struct CarlaStateSave;
struct EngineEvent;

typedef std::shared_ptr<CarlaPlugin> CarlaPluginPtr;

// -----------------------------------------------------------------------

/*!


+ 0
- 273
source/backend/CarlaPluginPtr.hpp View File

@@ -1,273 +0,0 @@
/*
* Carla Plugin Host
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the doc/GPL.txt file.
*/

#ifndef CARLA_CPP_COMPAT_HPP_INCLUDED
#define CARLA_CPP_COMPAT_HPP_INCLUDED

#include "CarlaDefines.h"

#ifdef CARLA_PROPER_CPP11_SUPPORT
# include <memory>
#else
# include <algorithm>
# include "CarlaUtils.hpp"
#endif

// -----------------------------------------------------------------------

#ifndef CARLA_PROPER_CPP11_SUPPORT
namespace std {

/* This code is part of shared_ptr.hpp:
* minimal implementation of smart pointer, a subset of the C++11 std::shared_ptr or boost::shared_ptr.
* Copyright (c) 2013-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
* Distributed under the MIT License (MIT)
*/
class shared_ptr_count
{
public:
shared_ptr_count() : pn(nullptr) {}
shared_ptr_count(const shared_ptr_count& count) : pn(count.pn) {}
void swap(shared_ptr_count& lhs) noexcept { std::swap(pn, lhs.pn); }

long use_count(void) const noexcept
{
long count = 0;
if (nullptr != pn)
{
count = *pn;
}
return count;
}

template<class U>
void acquire(U* p)
{
if (nullptr != p)
{
if (nullptr == pn)
{
try
{
pn = new volatile long(1);
}
catch (std::bad_alloc&)
{
delete p;
throw;
}
}
else
{
++(*pn);
}
}
}

template<class U>
void release(U* p) noexcept
{
if (nullptr != pn)
{
--(*pn);
if (0 == *pn)
{
delete p;
delete pn;
}
pn = nullptr;
}
}

public:
volatile long* pn;
};

template<class T>
class shared_ptr
{
public:
typedef T element_type;

shared_ptr(void) noexcept
: px(nullptr),
pn() {}

/*explicit*/ shared_ptr(T* p)
: px(nullptr),
pn()
{
acquire(p);
}

template <class U>
shared_ptr(const shared_ptr<U>& ptr, T* p) :
px(nullptr),
pn(ptr.pn)
{
acquire(p);
}

template <class U>
shared_ptr(const shared_ptr<U>& ptr) noexcept :
px(nullptr),
pn(ptr.pn)
{
CARLA_SAFE_ASSERT_RETURN(nullptr == ptr.px || 0 != ptr.pn.use_count(),);
acquire(static_cast<typename shared_ptr<T>::element_type*>(ptr.px));
}

shared_ptr(const shared_ptr& ptr) noexcept :
px(nullptr),
pn(ptr.pn)
{
CARLA_SAFE_ASSERT_RETURN(nullptr == ptr.px || 0 != ptr.pn.use_count(),);
acquire(ptr.px);
}

shared_ptr& operator=(shared_ptr ptr) noexcept
{
swap(ptr);
return *this;
}

~shared_ptr(void) noexcept
{
release();
}

void reset(void) noexcept
{
release();
}

void swap(shared_ptr& lhs) noexcept
{
std::swap(px, lhs.px);
pn.swap(lhs.pn);
}

operator bool() const noexcept
{
return (0 < pn.use_count());
}
long use_count(void) const noexcept
{
return pn.use_count();
}

// underlying pointer operations :
T& operator*() const noexcept
{
return *px;
}
T* operator->() const noexcept
{
return px;
}
T* get(void) const noexcept
{
return px;
}

private:
void acquire(T* p)
{
pn.acquire(p);
px = p;
}

void release(void) noexcept
{
pn.release(px);
px = nullptr;
}

private:
template<class U>
friend class shared_ptr;

private:
T* px;
shared_ptr_count pn;
};

template<class T, class U> bool operator==(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() == r.get());
}
template<class T, class U> bool operator!=(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() != r.get());
}
template<class T, class U> bool operator<=(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() <= r.get());
}
template<class T, class U> bool operator<(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() < r.get());
}
template<class T, class U> bool operator>=(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() >= r.get());
}
template<class T, class U> bool operator>(const shared_ptr<T>& l, const shared_ptr<U>& r) noexcept
{
return (l.get() > r.get());
}
template<class T, class U>
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& ptr)
{
return shared_ptr<T>(ptr, static_cast<typename shared_ptr<T>::element_type*>(ptr.get()));
}
template<class T, class U>
shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& ptr)
{
T* p = dynamic_cast<typename shared_ptr<T>::element_type*>(ptr.get());
if (nullptr != p)
{
return shared_ptr<T>(ptr, p);
}
else
{
return shared_ptr<T>();
}
}
template<class T>
bool operator==(const shared_ptr<T>& pointer1, T* const pointer2) noexcept
{
return static_cast<T*>(pointer1) == pointer2;
}
template<class T>
bool operator!=(const shared_ptr<T>& pointer1, T* const pointer2) noexcept
{
return static_cast<T*>(pointer1) != pointer2;
}

} // namespace std
#endif // CARLA_PROPER_CPP11_SUPPORT

CARLA_BACKEND_START_NAMESPACE

typedef std::shared_ptr<CarlaPlugin> CarlaPluginPtr;

CARLA_BACKEND_END_NAMESPACE

// -----------------------------------------------------------------------

#endif // CARLA_CPP_COMPAT_HPP_INCLUDED

+ 3
- 17
source/backend/engine/CarlaEngineOsc.hpp View File

@@ -1,19 +1,5 @@
/*
* Carla Plugin Host
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For a full copy of the GNU General Public License see the doc/GPL.txt file.
*/
// SPDX-FileCopyrightText: 2011-2025 Filipe Coelho <falktx@falktx.com>
// SPDX-License-Identifier: GPL-2.0-or-later

#ifndef CARLA_ENGINE_OSC_HPP_INCLUDED
#define CARLA_ENGINE_OSC_HPP_INCLUDED
@@ -24,7 +10,7 @@

#include "CarlaBackend.h"
#include "CarlaJuceUtils.hpp"
#include "CarlaPluginPtr.hpp"
#include "CarlaPlugin.hpp"
#include "CarlaOscUtils.hpp"
#include "CarlaString.hpp"



Write Preview
Loading…
Cancel
Save