This file is indexed.

/usr/include/libcmis-0.4/libcmis/allowable-actions.hxx is in libcmis-dev 0.4.1-7.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* libcmis
 * Version: MPL 1.1 / GPLv2+ / LGPLv2+
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License or as specified alternatively below. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * Major Contributor(s):
 * Copyright (C) 2011 SUSE <cbosdonnat@suse.com>
 *
 *
 * All Rights Reserved.
 *
 * For minor contributions see the git repository.
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPLv2+"), or
 * the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),
 * in which case the provisions of the GPLv2+ or the LGPLv2+ are applicable
 * instead of those above.
 */
#ifndef _ALLOWABLE_ACTIONS_HXX_
#define _ALLOWABLE_ACTIONS_HXX_

#include <map>
#include <string>

#include <boost/shared_ptr.hpp>
#include <libxml/tree.h>

#include "exception.hxx"

namespace libcmis
{
    class Object;

    class ObjectAction
    {
        public:
            enum Type
            {
                DeleteObject,
                UpdateProperties,
                GetFolderTree,
                GetProperties,
                GetObjectRelationships,
                GetObjectParents,
                GetFolderParent,
                GetDescendants,
                MoveObject,
                DeleteContentStream,
                CheckOut,
                CancelCheckOut,
                CheckIn,
                SetContentStream,
                GetAllVersions,
                AddObjectToFolder,
                RemoveObjectFromFolder,
                GetContentStream,
                ApplyPolicy,
                GetAppliedPolicies,
                RemovePolicy,
                GetChildren,
                CreateDocument,
                CreateFolder,
                CreateRelationship,
                DeleteTree,
                GetRenditions,
                GetACL,
                ApplyACL
            };

        private:
            Type m_type;
            bool m_enabled;
            bool m_valid;

        public:
            ObjectAction( xmlNodePtr node );
            virtual ~ObjectAction( ){ }

            Type getType( ) { return m_type; }
            bool isEnabled( ) { return m_enabled; }
            bool isValid( ) { return m_valid; }

            /** Parses the permission name into one of the enum values or throws
                an exception for invalid input strings.
              */
            static Type parseType( std::string type ) throw ( Exception );

    };

    /** Class providing access to the allowed actions on an object.
      */
    class AllowableActions
    {
        protected:
            std::map< ObjectAction::Type, bool > m_states;

        public:
            /** Default constructor for testing purpose
              */
            AllowableActions( );
            AllowableActions( xmlNodePtr node );
            AllowableActions( const AllowableActions& copy );
            virtual ~AllowableActions( );

            AllowableActions& operator=( const AllowableActions& copy );

            /** Returns the permissions for the corresponding actions.
              */
            bool isAllowed( ObjectAction::Type action );

            /** Returns true if the action was defined, false if the default
                value is used.
              */
            bool isDefined( ObjectAction::Type action );

            std::string toString( );
    };
    typedef boost::shared_ptr< AllowableActions > AllowableActionsPtr;
}

#endif