We've found a column that needs a entry in get() and set(). Build the case statements for this.

@param array $get
@param array $set
@param string $columnName
@param string $entity
779354
private function getSetEntity( &$get, &$set, $columnName, $entity )
    {

        foreach( array( 'get', 'set' ) as $type ) {

            // get case statement
            $caseStatement = explode( "\n", sprintf( <<<CASE
case '%s':
    \$key = '%s';
    break;\n
CASE
                ,
                $entity,
                $columnName
            ));
            $$type = array_merge( $$type, $caseStatement );

            // get callback

            $this->class->classComponents[] = new FunctionDeclaration(
                "getset.{$columnName}.{$type}",
                call_user_func( "self::generate{$type}CallbackForEntity", $columnName, $entity )
            );

        }

    }
500664
public static function getValueSet($colname)
    {
        $valueSets = RemoteAppPeer::getValueSets();

        if (!isset($valueSets[$colname])) {
            throw new PropelException(sprintf('Column "%s" has no ValueSet.', $colname));
        }

        return $valueSets[$colname];
    }
254792
public function containsSubset(Set $set)
    {
        if (count($set->getValue()) > count($this->getValue())) {
            return false;
        }

        return array_intersect($set->getValue(), $this->getValue()) == $set->getValue();
    }
265573
public function setValue($entity, $columnDescriptorId, $value, AutoTablesConfiguration $config) {
        Ensure::isNotNull($entity, 'entity musst not be null');
        $columnDescriptor = $this->getColumnDescriptor($entity, $columnDescriptorId, $config);
        if ($columnDescriptor->getType() == 'datetime') {
            $format = $this->translator->trans('php.date.format', array(), $config->getTransScope());
            $date = \DateTime::createFromFormat($format, $value);
            $columnDescriptor->setValue($entity, $date);
        } else {
            $columnDescriptor->setValue($entity, $value);
        }
    }
957559
public static function queryFilter(ItemQuery &$query, array $get)
    {
        $query->whereSearch($get['search_text']);

        $query->whereRange(['price' => [ArrayHelper::getValue($get, 'price_from', ''), ArrayHelper::getValue($get, 'price_to', '')]]);

        if(empty($query->_category) && !empty($get['category'])) $query->category(Category::findOne($get['category']));

        $query->whereProperties($get);

    }
1023312
public static function updateEntityFromArray($entity, array $data)
    {
        foreach ($data as $field => $value) {
            $method = 'set' . self::formatStringToMethodName($field);
            if (method_exists($entity, $method)) {
                $entity->$method($value);
            }
        }

        return $entity;
    }
623946
@Override
  public Map<Column, Bytes> get(Bytes row, Set<Column> columns) {
    Map<Column, Bytes> colVal = txb.get(row, columns);
    for (Map.Entry<Column, Bytes> entry : colVal.entrySet()) {
      txLog.filteredAdd(LogEntry.newGet(row, entry.getKey(), entry.getValue()), filter);
    }
    return colVal;
  }
1286047
public function refresh($entity)
    {
        $fields = $this->getFields();

        foreach ($fields as $key => $mapping) {
            $fieldType = $this->fieldManager->get($mapping['fieldtype'], $mapping);
            $getter = 'get' . ucfirst($key);
            $value = $entity->$getter();
            if ($value) {
                $fieldType->set($entity, $value);
            }
        }
    }
1221576
private function generateGetSetReferenceCallback( &$get, &$set, $reference )
    {

        // we not on the ignore list?
        if( !( $property = $this->getSetAlias( $reference, 'reference' ) ) ) {
            return;
        }

        $this->additionalProperties[] = $property;

        // DEPRECIATED Symfony2 compatible getter / setter
        // $this->addSymfonyFormCompatibleGetter( $property );
        // $this->addSymfonyFormCompatibleSetter( $property );

        $this->class->addUses('Bond\\Repository');
        $this->class->addUses( 'Bond\\Entity\\StaticMethods' );

        // get
        $getCaseStatement = explode( "\n", sprintf( <<<CASE
case '%s':
    return \$this->r()->referencesGet( \$this, '%s.%s' );\n
CASE
            ,
            $property,
            $reference[0],
            $reference[1]
        ));

        $get = array_merge( $get, $getCaseStatement );

        // set
        $setCaseStatement = explode( "\n", sprintf( <<<CASE
case '%s':
    return StaticMethods::set_references( \$this, '%s.%s', \$value );\n
CASE
            ,
            $property,
            $reference[0],
            $reference[1]
        ));

        $set = array_merge( $set, $setCaseStatement );

    }
942807
public static function makeSetterGetterDoc(Entity $entity)
    {
        $properties = $entity->toArray(false);
        $entityName = $entity->calledClassName();

        echo "<pre>\n";

        foreach ($properties as $name => $value) {
            $methodName = ucfirst($name);
            $type       = $entity->typeof($name);

            echo " * @method $entityName set$methodName($type \$value)\n";
            echo " * @method $type get$methodName()\n";
        }
        echo "</pre>\n";
    }
466297
public function get($entity)
    {
        $key = $this->mapping['fieldname'];
        $valueMethod = 'get' . ucfirst($key);
        $value = $entity->$valueMethod();

        return $value;
    }
732487
@Override
  public Map<Bytes, Map<Column, Bytes>> get(Collection<Bytes> rows, Set<Column> columns) {
    Map<Bytes, Map<Column, Bytes>> rowColVal = txb.get(rows, columns);
    for (Map.Entry<Bytes, Map<Column, Bytes>> rowEntry : rowColVal.entrySet()) {
      for (Map.Entry<Column, Bytes> colEntry : rowEntry.getValue().entrySet()) {
        txLog.filteredAdd(
            LogEntry.newGet(rowEntry.getKey(), colEntry.getKey(), colEntry.getValue()), filter);
      }
    }
    return rowColVal;
  }
1115659
public function updateRows(string $table, array $set, array $where): int
    {
        $update = new Update($this->options);
        $sqlParams = $update->buildQuery($table, $set, $where);
        return $this->query($sqlParams->getSql(), $sqlParams->getParams())->getAffected();
    }
665088
public static void addColumnsToGet(Collection<String> columns, final Get get) {
    addColumnsToOperation(columns, new Operation() {
      @Override
      public void addColumn(byte[] family, byte[] column) {
        get.addColumn(family, column);
      }

      @Override
      public void addFamily(byte[] family) {
        get.addFamily(family);
      }
    });
  }
1312354
public function offsetSet($key, $entity)
    {
        $class = $this->entityClass;

        if ($entity instanceof $class) {
            if (!isset($key)) {
                $this->entities[] = $entity;
            } else {
                $this->entities[$key] = $entity;
            }
            return true;
        }

        throw new CollectionException(
            'The specified entity is not allowed for this collection.'
        );
    }
82419
public function setEntity($entity, $entityId)
    {
        //set the entity
        $method = 'set'.ucfirst($entityId);

        //set the entity
        call_user_func([$this, $method], $entity);
    }
128104
public static function collect(
        string $className,
        $objectAnnotation = null,
        string $propertyName = '',
        string $methodName = '',
        $propertyValue = null
    ) {
        if ($objectAnnotation instanceof Column) {
            self::collectColumn($objectAnnotation, $className, $propertyName, $propertyValue);
        } elseif ($objectAnnotation instanceof Entity) {
            self::collectEntity($objectAnnotation, $className);
        } elseif ($objectAnnotation instanceof Id) {
            self::collectId($className, $propertyName);
        } elseif ($objectAnnotation instanceof Required) {
            self::collectRequired($className, $propertyName);
        } elseif ($objectAnnotation instanceof Table) {
            self::collectTable($objectAnnotation, $className);
        }
    }