Returns the attribute map for the service.

@return array Associative list of code as key and an MShop_Order_Item_Base_Service_Attribute_Interface as value
540187
protected function _getAttributeMap()
	{
		if( !isset( $this->_attributesMap ) )
		{
			$this->_attributesMap = array();

			foreach( $this->_attributes as $attribute ) {
				$this->_attributesMap[ $attribute->getCode() ] = $attribute;
			}
		}

		return $this->_attributesMap;
	}
882608
public function getItemSchema()
	{
		$attributes = $this->_getManager()->getSearchAttributes( false );
		return array(
			'name' => $this->_name,
			'properties' => $this->_getAttributeSchema( $attributes ),
		);
	}
599764
protected static function cacheAttrsMap()
    {
        $class = get_called_class();
        $attrs = $class::getAttrs();
        $private = & $class::getPrivateData();

        if (!isset($private['attrsMapCache'])) {
            $private['attrsMapCache'] = array();
        }

        $cache = & $private['attrsMapCache'];

        if (empty($cache)) {
            $cache = array(
                'db' => array(),
                'model' => array()
            );

            foreach ($attrs as $key => $value) {
                if (isset($value['field'])) {
                    $cache['db'][$key] = $value['field'];
                    $cache['model'][$value['field']] = $key;
                }
            }
        }
    }
246198
public function getAttributes()
    {
        $attributes = array(
            'id' => $this->ID(),
            'class' => $this->extraClass(),
        );

        if ($this->getStartClosed()) {
            $attributes['class'] .= ' ss-toggle ss-toggle-start-closed';
        } else {
            $attributes['class'] .= ' ss-toggle';
        }

        return array_merge(
            $this->attributes,
            $attributes
        );
    }
1082829
private function getCacheAttributes ()
	{
		
		$attributes	= array ();

		foreach (array_keys (self::$attributes) as $name)
		{
			$attributes[$name]	= $this->iget ($name);
		}
		
		return $attributes;
		
	}
859206
public function defineAttributes()
    {
        return array(
            'class' => array(AttributeType::String, 'required' => true),
            'clientId' => array(AttributeType::String, 'required' => false),
            'clientSecret' => array(AttributeType::String, 'required' => false)
        );
    }
834212
public function getMappedSecondAttributes()
    {
        $attributes = [];

        /* Only the first array in data will be examined, and map its attributes to db attributes,
           the attributes that are not present, will not be included
        */
        if (is_array($this->data[0])) {
            foreach ($this->data[0] as $attribute => $attributeValue) {
                if (array_key_exists($attribute, $this->mappingFirstEntityToSecondEntityAttributes)) {
                    $attributes[$this->mappingFirstEntityToSecondEntityAttributes[$attribute]] = $attributeValue;
                }
            }
        }

        return $attributes;
    }
230495
public function getServiceConfig()
    {
        return array(
            'aliases' => array(
                'dlccategory_doctrine_em' => 'doctrine.entitymanager.orm_default',
            ),
            
            'invokables' => array(
                'dlccategory_category_mapper'   => 'DlcCategory\Mapper\Category',
                'dlccategory_category_service'  => 'DlcCategory\Service\Category',
                'dlccategory_setup_service'     => 'DlcCategory\Service\Setup',
            ),
            
            'factories' => array(
                
                'dlccategory_category_hydrator' => function ($sm) {
                    $objectManager = $sm->get('dlccategory_doctrine_em');
                    $options       = $sm->get('dlccategory_module_options');
                    $hydrator      = new \DoctrineModule\Stdlib\Hydrator\DoctrineObject(
                            $objectManager,
                            $options->getCategoryEntityClass()
                    );
                    
                    return $hydrator;
                },
                
                'dlccategory_addcategory_form' => function ($sm) {
                    $form = new \DlcCategory\Form\AddCategory();
                    $form->setServiceLocator($sm);
                    $form->init();
                    return $form;
                },
                
                'dlccategory_editcategory_form' => function ($sm) {
                    $form = new \DlcCategory\Form\EditCategory();
                    $form->setServiceLocator($sm);
                    $form->init();
                    return $form;
                },
            
                'dlccategory_module_options' => function ($sm) {
                    $config = $sm->get('Config');
                    return new Options\ModuleOptions(isset($config['dlccategory_module_options']) ? $config['dlccategory_module_options'] : array());
                },
                
                'dlccategory_nestedset_config' => function ($sm) {
                    $em = $sm->get('dlccategory_doctrine_em');
                    $options = $sm->get('dlccategory_module_options');
                    
                    $config = new \DoctrineExtensions\NestedSet\Config($em, $options->getCategoryEntityClass());
                    return $config;
                },
                
                'dlccategory_nestedset_manager' => function ($sm) {
                    $manager = new \DoctrineExtensions\NestedSet\Manager($sm->get('dlccategory_nestedset_config'));
                    return $manager;
                },
            ),
        );
    }
61991
protected function getMappedFields()
    {
        $mapping = [
            'brq_payment_method' => $this->paymentMethod->getPaymentMethod(),
            'brq_websitekey' => $this->websiteKey,
            'brq_currency' => $this->currency->getCurrencyString(),
            'brq_amount' => $this->amount,
            'brq_invoicenumber' => $this->invoiceNumber,
            'brq_ordernumber' => $this->orderNumber,
            'brq_description' => $this->description,
            'brq_return' => $this->returnURL,
            'brq_returncancel' => $this->cancelURL,
            'brq_returnerror' => $this->rejectURL,
            'brq_returnreject' => $this->errorURL
        ];

        $result = [];
        foreach ($mapping as $key => $value) {
            if (!empty($value)) {
                $result[$key] = $value;
            }
        }

        return $result;
    }
135508
public function getAttributes()
    {
        $array = [];

        if ($this->getValueSet() === null) {
            return $array;
        }

        foreach ($this->getValueSet()->getValues() as $value) {
            $array[$value->getAttribute()->getName()] = $value;
        }

        return $array;
    }
934312
public function getAttributes()
    {

        // initialize the array with the attributes
        $attributes = array();

        // prepare the pattern to filter the attributes
        $pattern = sprintf('%s-*', $this->getSerial());

        // prepare the array with the attributes
        foreach ($this as $key => $value) {
            if (fnmatch($pattern, $key)) {
                $attributes[$key] = $value;
            }
        }

        // return the attributes
        return $attributes;
    }
1068265
public function getSitemapImagesAttribute()
    {
        return $this->images->map(function ($image) {
            return [
                'url' => $image->url,
                'title' => $image->title,
            ];
        })->all();
    }
863827
public function toArray()
    {
        $array = [];

        $arrayMap = [
            // json key => property name
            'service_name' => 'serviceName',
            'service_job_id' => 'serviceJobId',
            'service_number' => 'serviceNumber',
            'service_build_url' => 'serviceBuildUrl',
            'service_branch' => 'serviceBranch',
            'service_pull_request' => 'servicePullRequest',
            'service_event_type' => 'serviceEventType',
            'repo_token' => 'repoToken',
            'git' => 'git',
            'run_at' => 'runAt',
            'source_files' => 'sourceFiles',
        ];

        foreach ($arrayMap as $jsonKey => $propName) {
            if (isset($this->$propName)) {
                $array[$jsonKey] = $this->toJsonProperty($this->$propName);
            }
        }

        $array['environment'] = [
            'packagist_version' => Version::VERSION,
        ];

        return $array;
    }
708725
public function info()
    {
        $data = [];
        foreach ($this->attributes as $key => $value) {
            switch (gettype($value)) {
                case 'boolean':
                    $data[$key] = [
                        'boolValue' => $value
                    ];
                    break;
                case 'integer':
                    $data[$key] = [
                        'intValue' => $value
                    ];
                    break;
                default:
                    $data[$key] = [
                        'stringValue' => ['value' => (string) $value]
                    ];
            }
        }
        return [
            'attributeMap' => $data
        ];
    }
545574
public function getAttributes()
    {
        return [
            Attributes\IdAttribute::make(),
            Attributes\TextAttribute::make('name')
                ->setRequired(true)
                ->setUnique(true),
            Attributes\LongTextAttribute::make('description'),
            Attributes\ClassNameAttribute::make('class_name', [PriceRuleContract::class])
                ->setRequired(true),
            Attributes\ObjectAttribute::make('payload'),
            Attributes\CreatedAtAttribute::make(),
            Attributes\UpdatedAtAttribute::make(),
            Attributes\DeletedAtAttribute::make(),
        ];
    }
1369134
public static function getMappings()
    {
        $basePath = self::getBasePath();

        return array(
            realpath($basePath.'Address/Resources/config/doctrine/model') => 'LMammino\EFoundation\Address\Model',
            realpath($basePath.'Attribute/Resources/config/doctrine/model') =>
                'LMammino\EFoundation\Attribute\Model',
            realpath($basePath.'Cart/Resources/config/doctrine/model') => 'LMammino\EFoundation\Cart\Model',
            realpath($basePath.'Order/Resources/config/doctrine/model') => 'LMammino\EFoundation\Order\Model',
            realpath($basePath.'Price/Resources/config/doctrine/model') => 'LMammino\EFoundation\Price\Model',
            realpath($basePath.'Product/Resources/config/doctrine/model') => 'LMammino\EFoundation\Product\Model',
            realpath($basePath.'Variation/Resources/config/doctrine/model') =>
                'LMammino\EFoundation\Variation\Model',
        );
    }
178158
public function getServiceRoutingMap()
    {
        $ret = [];
        $optionRoutes = $this->getOptionRoutes();

        foreach ($optionRoutes as $routeName => $optionRoute) {
            // get base name from options action
            $routeParts = explode('.', $routeName);
            if (count($routeParts) < 3) {
                continue;
            }
            array_pop($routeParts); // get rid of last part
            $baseName = implode('.', $routeParts);

            // get routes from same controller
            foreach ($this->getRoutesByBasename($baseName) as $routeName => $route) {
                // don't put schema stuff
                if (strpos('schema', strtolower($routeName)) === false) {
                    $ret[$baseName][$routeName] = $route;
                }
            }
        }

        return $ret;
    }