HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r12:4e36a737f884

Added true single threshold cache strategy and it behaves as expected...

jeandet -

r12:4e36a737f884

parent child

Context file:

r12:4e36a737f884

include/Variable/SingleThresholdCacheStrategy.h created 644 +22 0

@@ -0,0 +1,22
	1	#ifndef SCIQLOP_SINGLETHRESHOLDCACHESTRATEGY_H
	2	#define SCIQLOP_SINGLETHRESHOLDCACHESTRATEGY_H
	3
	4	#include "Settings/SqpSettingsDefs.h"
	5	#include "VariableCacheStrategy.h"
	6
	7	class SCIQLOP_CORE_EXPORT SingleThresholdCacheStrategy : public VariableCacheStrategy {
	8	public:
	9	SingleThresholdCacheStrategy() = default;
	10
	11	DateTimeRange computeRange(const DateTimeRange &currentCacheRange,
	12	const DateTimeRange &rangeRequested) override
	13	{
	14	Q_UNUSED(currentCacheRange);
	15	if(currentCacheRange.contains (rangeRequested*1.1))
	16	return currentCacheRange;
	17	return rangeRequested*2.;
	18	}
	19	};
	20
	21
	22	#endif // SCIQLOP_SINGLETHRESHOLDCACHESTRATEGY_H

CMakeLists.txt +1 0

             cmake_minimum_required(VERSION 3.6)
             project(SciQLOPCore CXX)
             OPTION (CPPCHECK "Analyzes the source code with cppcheck" OFF)
             OPTION (CLANG_TIDY "Analyzes the source code with Clang Tidy" OFF)
             OPTION (IWYU "Analyzes the source code with Include What You Use" OFF)
             OPTION (Catalog "builds catalog API" OFF)
             set(CMAKE_CXX_STANDARD 17)
             set(CMAKE_AUTOMOC ON)
             #https://gitlab.kitware.com/cmake/cmake/issues/15227
             #set(CMAKE_AUTOUIC ON)
             if(POLICY CMP0071)
                 cmake_policy(SET CMP0071 OLD)
             endif()
             set(CMAKE_AUTORCC ON)
             set(CMAKE_INCLUDE_CURRENT_DIR ON)
             find_package(Qt5 COMPONENTS Core Widgets Network PrintSupport Svg Test REQUIRED)
             find_package(pybind11 CONFIG QUIET)
             if (NOT pybind11_FOUND)
                 execute_process(COMMAND git submodule init external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 execute_process(COMMAND git submodule update external/pybind11 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
                 add_subdirectory(external/pybind11)
             endif()
             macro(declare_test testname testexe sources libraries)
                 add_executable(${testexe} ${sources})
                 target_link_libraries(${testexe} ${libraries})
                 add_test(NAME ${testname} COMMAND ${testexe})
             endmacro(declare_test)
             enable_testing()
             FILE (GLOB_RECURSE core_SRCS
                 ./include/DataSource/DataSourceItemMergeHelper.h
                 ./include/DataSource/DataSourceItemAction.h
                 ./include/DataSource/DataSourceItem.h
                 ./include/DataSource/DataSourceController.h
                 ./include/Common/SortUtils.h
                 ./include/Common/spimpl.h
                 ./include/Common/MimeTypesDef.h
                 ./include/Common/MetaTypes.h
                 ./include/Common/StringUtils.h
                 ./include/Common/SignalWaiter.h
                 ./include/Common/DateUtils.h
                 ./include/Common/Numeric.h
                 ./include/Common/deprecate.h
                 ./include/Common/containers.h
                 ./include/Common/debug.h
                 ./include/Plugin/IPlugin.h
                 ./include/Data/ArrayDataIterator.h
                 ./include/Data/VariableRequest.h
                 ./include/Data/VectorSeries.h
                 ./include/Data/DateTimeRange.h
                 ./include/Data/DateTimeRangeHelper.h
                 ./include/Data/ScalarSeries.h
                 ./include/Data/DataSeriesMergeHelper.h
                 ./include/Data/DataSeries.h
                 ./include/Data/AcquisitionDataPacket.h
                 ./include/Data/DataSeriesType.h
                 ./include/Data/AcquisitionRequest.h
                 ./include/Data/SqpIterator.h
                 ./include/Data/ArrayData.h
                 ./include/Data/DataSeriesIterator.h
                 ./include/Data/DataSeriesUtils.h
                 ./include/Data/SpectrogramSeries.h
                 ./include/Data/Unit.h
                 ./include/Data/DataProviderParameters.h
                 ./include/Data/OptionalAxis.h
                 ./include/Data/IDataProvider.h
                 ./include/Data/IDataSeries.h
                 ./include/Network/NetworkController.h
                 ./include/Network/Downloader.h
                 ./include/Version.h
                 ./include/CoreGlobal.h
                 ./include/Visualization/VisualizationController.h
                 ./include/PluginManager/PluginManager.h
                 ./include/Variable/VariableModel.h
                 ./include/Variable/VariableAcquisitionWorker.h
                 ./include/Variable/VariableCacheStrategy.h
                 ./include/Variable/VariableSynchronizationGroup.h
                 ./include/Variable/VariableSynchronizationGroup2.h
                 ./include/Variable/ProportionalCacheStrategy.h
+                ./include/Variable/SingleThresholdCacheStrategy.h
                 ./include/Variable/VariableCacheStrategyFactory.h
                 ./include/Variable/Variable.h
                 ./include/Variable/VariableCacheController.h
                 ./include/Variable/VariableController.h
                 ./include/Variable/VariableController2.h
                 ./include/Time/TimeController.h
                 ./include/Settings/ISqpSettingsBindable.h
                 ./include/Settings/SqpSettingsDefs.h
                 ./src/DataSource/DataSourceItem.cpp
                 ./src/DataSource/DataSourceItemAction.cpp
                 ./src/DataSource/DataSourceItemMergeHelper.cpp
                 ./src/DataSource/DataSourceController.cpp
                 ./src/Common/DateUtils.cpp
                 ./src/Common/MimeTypesDef.cpp
                 ./src/Common/StringUtils.cpp
                 ./src/Common/SignalWaiter.cpp
                 ./src/Data/ScalarSeries.cpp
                 ./src/Data/DataSeriesIterator.cpp
                 ./src/Data/OptionalAxis.cpp
                 ./src/Data/ArrayDataIterator.cpp
                 ./src/Data/SpectrogramSeries.cpp
                 ./src/Data/DataSeriesUtils.cpp
                 ./src/Data/VectorSeries.cpp
                 ./src/Network/NetworkController.cpp
                 ./src/Network/Downloader.cpp
                 ./src/Visualization/VisualizationController.cpp
                 ./src/PluginManager/PluginManager.cpp
                 ./src/Variable/VariableController.cpp
                 ./src/Variable/VariableController2.cpp
                 ./src/Variable/VariableModel.cpp
                 ./src/Variable/VariableCacheController.cpp
                 ./src/Variable/VariableSynchronizationGroup.cpp
                 ./src/Variable/VariableSynchronizationGroup2.cpp
                 ./src/Variable/Variable.cpp
                 ./src/Variable/VariableAcquisitionWorker.cpp
                 ./src/Version.cpp
                 ./src/Time/TimeController.cpp
                 ./src/Settings/SqpSettingsDefs.cpp
                     )
             IF(Catalog)
                 FILE (GLOB_RECURSE core_catalog_SRCS
                     ./src/Catalogue/CatalogueController.cpp
                     ./include/Catalogue/CatalogueController.h
                     )
             ELSE()
             FILE (GLOB_RECURSE core_catalog_SRCS
                 )
             ENDIF(Catalog)
             add_definitions(-DCORE_STATIC)
             #add_definitions(-DHIDE_DEPRECATED)
             add_definitions(-DSCIQLOP_CRASH_ON_ERROR)
             add_library(sciqlopcore ${core_SRCS} ${core_catalog_SRCS})
             SET_TARGET_PROPERTIES(sciqlopcore PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
             target_include_directories(sciqlopcore PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
                 $<INSTALL_INTERFACE:include/SciQLOP>
             )
             target_link_libraries(sciqlopcore PUBLIC
               Qt5::Core
               Qt5::Network
             )
             if(Catalog)
                 target_link_libraries(sciqlopcore PUBLIC
                   catalogs
                 )
             endif()
             pybind11_add_module(sciqlopqt src/pybind11_wrappers/QtWrappers.cpp)
             target_link_libraries(sciqlopqt PUBLIC Qt5::Core)
             pybind11_add_module(pysciqlopcore src/pybind11_wrappers/CoreWrappers.cpp)
             target_link_libraries(pysciqlopcore PUBLIC sciqlopcore)
             add_library(pysciqlop src/pybind11_wrappers/pywrappers_common.h)
             target_link_libraries(pysciqlop PUBLIC Qt5::Core)
             target_include_directories(pysciqlop PUBLIC
                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/pybind11_wrappers/>
                 $<INSTALL_INTERFACE:include/SciQLOP/py_wrappers>
             )
             SET_PROPERTY(GLOBAL PROPERTY CORE_PYTHON_PATH  ${CMAKE_CURRENT_BINARY_DIR})
             install(TARGETS sciqlopcore EXPORT SciQLOPCoreConfig
                 ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
                 RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR})
             install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SciQLOP)
             install(EXPORT SciQLOPCoreConfig DESTINATION share/SciQLOPCore/cmake)
             export(TARGETS sciqlopcore FILE SciQLOPCoreConfig.cmake)
             add_subdirectory(tests)

include/Data/DateTimeRangeHelper.h +1 0

             #ifndef SCIQLOP_DATETIMERANGEHELPER_H
             #define SCIQLOP_DATETIMERANGEHELPER_H
             #include <cmath>
+            #include <variant>
             #include <QObject>
             #include <QDebug>
             #include <opaque/numeric_typedef.hpp>
             #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             #include <Common/Numeric.h>
             #include <Data/DateTimeRange.h>
             namespace DateTimeRangeHelper {
                 bool isnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) && std::isnan(range.m_TEnd);
                 }
                 bool hasnan(const DateTimeRange& range)
                 {
                     return std::isnan(range.m_TStart) || std::isnan(range.m_TEnd);
                 }
                 bool isPureShift(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     return SciQLop::numeric::almost_equal<double>(range1.delta(), range2.delta(), 1)
                             && !SciQLop::numeric::almost_equal(range1.m_TStart, range2.m_TStart, 1);
                 }
                 bool isPureZoom(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     return !SciQLop::numeric::almost_equal<double>(range1.delta(),range2.delta(),1)&&
                             SciQLop::numeric::almost_equal<double>(range1.center(), range2.center(),1);
                 }
                 /**
                  * @brief computeTransformation such as range2 = zoom*range1 + shift
                  * @param range1
                  * @param range2
                  * @return trnaformation applied to range1 to get range2 or an object of type
                  * InvalidDateTimeRangeTransformation if the transformation has NaN or forbiden values
                  */
                 std::variant<DateTimeRangeTransformation, InvalidDateTimeRangeTransformation>
                 computeTransformation(const DateTimeRange& range1, const DateTimeRange& range2)
                 {
                     double zoom = range2.delta()/range1.delta();
                     Seconds<double> shift = range2.center() - (range1*zoom).center();
                     bool zoomValid = zoom!=0. && !std::isnan(zoom) && !std::isinf(zoom);
                     bool shiftValid = !std::isnan(shift.value) && !std::isinf(shift.value);
                     if(zoomValid && shiftValid)
                         return DateTimeRangeTransformation{zoom, shift};
                     return InvalidDateTimeRangeTransformation{};
                 }
             }
             #endif // SCIQLOP_DATETIMERANGEHELPER_H

include/Variable/ProportionalCacheStrategy.h +3 -3

-            #ifndef SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
+            #ifndef SCIQLOP_PROPORTIONALCACHESTRATEGY_H
-            #define SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
+            #define SCIQLOP_PROPORTIONALCACHESTRATEGY_H
             #include "Settings/SqpSettingsDefs.h"
             #include "VariableCacheStrategy.h"
             /// This class aims to hande the cache strategy.
             class SCIQLOP_CORE_EXPORT ProportionalCacheStrategy : public VariableCacheStrategy {
             public:
                 ProportionalCacheStrategy() = default;
                 DateTimeRange computeRange(const DateTimeRange &currentCacheRange,
                                                            const DateTimeRange &rangeRequested) override
                 {
                     Q_UNUSED(currentCacheRange);
                     auto toleranceFactor = SqpSettings::toleranceValue(
                         GENERAL_TOLERANCE_AT_UPDATE_KEY, GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
                     return  rangeRequested*(1.+toleranceFactor);
                 }
             };
-            #endif // SCIQLOP_VARIABLESINGLETHRESHOLDCACHESTRATEGY_H
+            #endif // SCIQLOP_PROPORTIONALCACHESTRATEGY_H

include/Variable/VariableCacheStrategyFactory.h +3 -2

             #ifndef SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
             #define SCIQLOP_VARIABLECACHESTRATEGYFACTORY_H
             #include <memory>
             #include <stdexcept>
             #include "VariableCacheStrategy.h"
             #include "ProportionalCacheStrategy.h"
+            #include "SingleThresholdCacheStrategy.h"
             #include <Common/debug.h>
             #include <QString>
             enum class CacheStrategy { Proportional, SingleThreshold, TwoThreshold };
             class VariableCacheStrategyFactory {
                 using cacheStratPtr = std::unique_ptr<VariableCacheStrategy>;
             public:
                 static cacheStratPtr createCacheStrategy(CacheStrategy specificStrategy)
                 {
                     switch (specificStrategy) {
                     case CacheStrategy::Proportional: {
                         return std::unique_ptr<VariableCacheStrategy>{
                             new ProportionalCacheStrategy{}};
                     }
                     case CacheStrategy::SingleThreshold: {
-                        SCIQLOP_ERROR(VariableCacheStrategyFactory, "CacheStrategy::SingleThreshold not implemented yet");
+                        return std::unique_ptr<VariableCacheStrategy>{
-                        break;
+                            new SingleThresholdCacheStrategy{}};
                     }
                     case CacheStrategy::TwoThreshold: {
                         SCIQLOP_ERROR(VariableCacheStrategyFactory, "CacheStrategy::TwoThreshold not implemented yet");
                         break;
                     }
                     default:
                         SCIQLOP_ERROR(VariableCacheStrategyFactory, "Unknown cache strategy");
                         break;
                     }
                     return nullptr;
                 }
             };
             #endif // VARIABLECACHESTRATEGYFACTORY_H

include/Variable/VariableSynchronizationGroup2.h +1 -1

             #ifndef SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H
             #define SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H
             #include <QUuid>
             #include <set>
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <Common/containers.h>
             /**
              * @brief The VariableSynchronizationGroup2 class holds a list of Variables uuid which are synchronized
              * @note This class is part of SciQLop internals, as a normal user you shouldn't have to care about it
              */
             class SCIQLOP_CORE_EXPORT VariableSynchronizationGroup2
             {
             public:
                 explicit VariableSynchronizationGroup2()=default;
                 /**
                  * @brief VariableSynchronizationGroup2 is a convenience ctor to build a group with a default variable
                  * @param variable
                  */
                 explicit VariableSynchronizationGroup2(QUuid variable)
                     :_variables{{variable}}
                 {}
                 /**
                  * @brief addVariable adds the given variable to the group, does nothing if the varaible is alredy in the group
                  * @param variable
                  * @sa removeVariable
                  */
                 void addVariable(QUuid variable) noexcept
                 {
                     this->_variables.insert(variable);
                 }
                 /**
                  * @brief removeVariable removes the given variable from the group, does nothing if the varaible is not in the group
                  * @param variable
                  * @sa addVariable
                  */
                 void removeVariable(QUuid variable) noexcept
                 {
-                    this->_variables.extract(variable);
+                    this->_variables.erase(variable);
                 }
                 /**
                  * @brief contains checks if the given variable is in the group
                  * @param variable
                  * @return true if the variable is in the group
                  */
                 bool contains(QUuid variable) const noexcept
                 {
                     return SciQLop::containers::contains(this->_variables,variable);
                 }
                 /**
                  * @brief variables
                  * @return the list of synchronized variables in this group as a std::set
                  */
                 const std::set<QUuid> &variables() const noexcept
                 {
                     return this->_variables;
                 }
             private:
                 std::set<QUuid> _variables;
             };
             #endif // SCIQLOP_VARIABLESYNCHRONIZATIONGROUP2_H

src/Variable/VariableController2.cpp +2 -2

             #include "Variable/VariableController2.h"
             #include "Variable/VariableSynchronizationGroup2.h"
             #include <Common/containers.h>
             #include <Common/debug.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/DateTimeRangeHelper.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             class VariableController2::VariableController2Private
             {
                 QMap<QUuid,std::shared_ptr<Variable>> _variables;
                 QMap<QUuid,std::shared_ptr<IDataProvider>> _providers;
                 QMap<QUuid,std::shared_ptr<VariableSynchronizationGroup2>> _synchronizationGroups;
                 std::unique_ptr<VariableCacheStrategy> _cacheStrategy;
                 bool p_contains(std::shared_ptr<Variable> variable)
                 {
                     return _providers.contains(variable->ID());
                 }
                 bool v_contains(std::shared_ptr<Variable> variable)
                 {
                     return SciQLop::containers::contains(this->_variables, variable);
                 }
                 bool sg_contains(std::shared_ptr<Variable> variable)
                 {
                     return _synchronizationGroups.contains(variable->ID());
                 }
                 void _changeRange(std::shared_ptr<Variable> var, DateTimeRange r)
                 {
                     auto provider = _providers[var->ID()];
                     DateTimeRange newCacheRange;
                     std::vector<DateTimeRange> missingRanges;
                     if(DateTimeRangeHelper::hasnan(var->cacheRange()))
                     {
                         newCacheRange = _cacheStrategy->computeRange(r,r);
                         missingRanges = {newCacheRange};
                     }
                     else
                     {
                         newCacheRange = _cacheStrategy->computeRange(var->cacheRange(),r);
                         missingRanges = newCacheRange - var->cacheRange();
                     }
                     for(auto range:missingRanges)
                     {
                         auto data = provider->getData(DataProviderParameters{{range},var->metadata()});
                         var->mergeDataSeries(data);
                     }
-                    var->setCacheRange(r);
+                    var->setCacheRange(newCacheRange);
                     var->setRange(r);
                 }
             public:
                 VariableController2Private(QObject* parent=Q_NULLPTR)
-                    :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::Proportional))
+                    :_cacheStrategy(VariableCacheStrategyFactory::createCacheStrategy(CacheStrategy::SingleThreshold))
                 {
                     Q_UNUSED(parent);
                 }
                 ~VariableController2Private() = default;
                 std::shared_ptr<Variable> createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider)
                 {
                     auto newVar = std::make_shared<Variable>(name,metadata);
                     this->_variables[newVar->ID()] = newVar;
                     this->_providers[newVar->ID()] = provider;
                     this->_synchronizationGroups[newVar->ID()] = std::make_shared<VariableSynchronizationGroup2>(newVar->ID());
                     return newVar;
                 }
                 void deleteVariable(std::shared_ptr<Variable> variable)
                 {
                     /*
                      * Removing twice a var is ok but a var without provider has to be a hard error
                      * this means we got the var controller in an inconsistent state
                      */
                     if(v_contains(variable))
                         this->_variables.remove(variable->ID());
                     if(p_contains(variable))
                         this->_providers.remove(variable->ID());
                     else
                         SCIQLOP_ERROR(VariableController2Private, "No provider found for given variable");
                 }
                 void changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
                 {
                     if(p_contains(variable))
                     {
                         if(!DateTimeRangeHelper::hasnan(r))
                         {
                             auto transformation = DateTimeRangeHelper::computeTransformation(variable->range(),r);
                             auto group = _synchronizationGroups[variable->ID()];
                             if(std::holds_alternative<DateTimeRangeTransformation>(transformation))
                             {
                                 for(auto varId:group->variables())
                                 {
                                     auto var = _variables[varId];
                                     auto newRange = var->range().transform(std::get<DateTimeRangeTransformation>(transformation));
                                     _changeRange(var,newRange);
                                 }
                             }
                             else // force new range to all variables -> may be weird if more than one var in the group
                                 // @TODO ensure that there is no side effects
                             {
                                 for(auto varId:group->variables())
                                 {
                                     auto var = _variables[varId];
                                     _changeRange(var,r);
                                 }
                             }
                         }
                         else
                         {
                             SCIQLOP_ERROR(VariableController2Private, "Invalid range containing NaN");
                         }
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "No provider found for given variable");
                     }
                 }
                 void synchronize(std::shared_ptr<Variable> var, std::shared_ptr<Variable> with)
                 {
                     if(v_contains(var) && v_contains(with))
                     {
                         if(sg_contains(var) && sg_contains(with))
                         {
                             auto dest_group = this->_synchronizationGroups[with->ID()];
                             this->_synchronizationGroups[var->ID()] = dest_group;
                             dest_group->addVariable(var->ID());
                         }
                         else
                         {
                             SCIQLOP_ERROR(VariableController2Private, "At least one of the given variables isn't in a sync group");
                         }
                     }
                     else
                     {
                         SCIQLOP_ERROR(VariableController2Private, "At least one of the given variables is not found");
                     }
                 }
                 const std::set<std::shared_ptr<Variable>> variables()
                 {
                     std::set<std::shared_ptr<Variable>> vars;
                     for(auto var:_variables.values())
                     {
                         vars.insert(var);
                     }
                     return  vars;
                 }
             };
             VariableController2::VariableController2()
                 :impl{spimpl::make_unique_impl<VariableController2Private>()}
             {}
             std::shared_ptr<Variable> VariableController2::createVariable(const QString &name, const QVariantHash &metadata, std::shared_ptr<IDataProvider> provider, const DateTimeRange &range)
             {
                 auto var =  impl->createVariable(name, metadata, provider);
                 emit variableAdded(var);
                 if(!DateTimeRangeHelper::hasnan(range))
                     impl->changeRange(var,range);
                 else
                     SCIQLOP_ERROR(VariableController2, "Creating a variable with default constructed DateTimeRange is an error");
                 return var;
             }
             void VariableController2::deleteVariable(std::shared_ptr<Variable> variable)
             {
                 impl->deleteVariable(variable);
                 emit variableDeleted(variable);
             }
             void VariableController2::changeRange(std::shared_ptr<Variable> variable, DateTimeRange r)
             {
                 impl->changeRange(variable, r);
             }
             const std::set<std::shared_ptr<Variable> > VariableController2::variables()
             {
                 return impl->variables();
             }
             void VariableController2::synchronize(std::shared_ptr<Variable> var, std::shared_ptr<Variable> with)
             {
                 impl->synchronize(var, with);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages